Flutter SDK

# 1. pubspec.yaml: install from Abrova Center
dependencies:
  abrova_storage:
    hosted: https://center.abrova.ir/api/packages/abrova/pub
    version: ^0.2.1

# 2. Install
flutter pub get

import 'package:abrova_storage/abrova_storage.dart';

final storage = AbrovaStorage(
  apiKey: 'ab_live_xxxxxxxxxxxx',
  // The signed-in user's Abrova user token, see "Sign users in" below.
  // Return null when no one is signed in.
  tokenProvider: () => myBackend.fetchAbrovaToken(),
);

// Dispose when done (e.g., in your State's dispose())
@override
void dispose() {
  storage.dispose(); // calls still waiting for a user fail with code 'disposed'
  super.dispose();
}

final auth = AbrovaAuth.instance;
final storage = AbrovaStorage(
  apiKey: 'ab_live_xxxxxxxxxxxx',
  tokenProvider: auth.tokenProvider,
);

// After sign-in or sign-out
auth.authStateChanges.listen((_) => storage.refreshUserToken());

// When the user signs in or out
await storage.refreshUserToken();

// Or pass a token you already hold (null signs out)
await storage.setUserToken(token);

// Or set / replace the provider later
await storage.setTokenProvider(() => myBackend.fetchAbrovaToken());

final storage = AbrovaStorage(
  apiKey: 'ab_live_xxxxxxxxxxxx',
  tokenProvider: auth.tokenProvider,
);
storage.onAwaitingUserToken(() => showSignIn()); // once per wait
storage.isAwaitingUserToken; // true while file calls wait for a user

final storage = AbrovaStorage(
  apiKey: 'ab_live_xxxxxxxxxxxx',
  tokenProvider: auth.tokenProvider,
  userTokenWaitTimeout: const Duration(seconds: 30), // throws token_required after 30 s
);

import 'dart:io';
import 'dart:typed_data';
import 'package:abrova_storage/abrova_storage.dart';

// Upload from Uint8List (bytes)
final Uint8List imageBytes = await File('path/to/image.jpg').readAsBytes();

final file = await storage.upload(
  'my-bucket',
  'images/photo.jpg',
  imageBytes,
  options: UploadOptions(
    contentType: 'image/jpeg',
    metadata: {'source': 'camera'},
  ),
  // Optional: about every 50 ms or 1%; the last call has sent == total
  onProgress: (sent, total) => setState(() => _progress = sent / total),
);

print('Uploaded: ${file.id}');
print('Size: ${file.size} bytes');

// Download file content as Uint8List
final Uint8List bytes = await storage.download(fileId);

// Save to local file
final file = File('${directory.path}/downloaded.jpg');
await file.writeAsBytes(bytes);

// Or display directly
Image.memory(bytes);

// List files in a bucket
final result = await storage.listFiles(
  'my-bucket',
  options: ListFilesOptions(
    prefix: 'images/',
    limit: 50,
  ),
);

for (final file in result.files) {
  print('${file.path}: ${file.size} bytes');
}

// Pagination: nextCursor is null on the last page
if (result.nextCursor != null) {
  final nextPage = await storage.listFiles(
    'my-bucket',
    options: ListFilesOptions(cursor: result.nextCursor),
  );
}

// Deletes follow the bucket's delete rules
// Delete a file by ID
await storage.delete(fileId);

// Delete a file by path
await storage.deleteByPath('my-bucket', 'images/photo.jpg');

// Delete multiple files at once
final result = await storage.deleteMany([
  'file_id_1',
  'file_id_2',
  'file_id_3',
]);
print('Deleted ${result.deleted} files');

// A 600 px wide WebP, straight into Image.network
final url = await storage.getPublicUrl(file.id,
    transforms: const ImageTransforms(width: 600, format: 'webp'));
Image.network(url);

// A public link you stored earlier: the same URL, no request
final thumb = AbrovaStorage.publicImageUrl(savedLink,
    transforms: const ImageTransforms(width: 200, height: 200, fit: 'cover', format: 'webp'));

// The transform address needs the key and user token headers
final thumbnailUrl = storage.getTransformUrl(
  fileId,
  transforms: const ImageTransforms(width: 200, height: 200, fit: 'cover', format: 'webp'),
);
Image.network(
  thumbnailUrl,
  headers: {
    'x-api-key': 'ab_live_xxxxxxxxxxxx',
    'x-user-token': userToken, // the signed-in user's token
  },
);

// All available options
const options = ImageTransforms(
  width: 800,      // 1 or more (above 4096 sent as 4096)
  height: 600,
  fit: 'contain',  // cover, contain, fill, inside, outside
  format: 'webp',  // jpeg (default), png, webp, avif
  quality: 85,     // 1-100
  blur: 5,         // 0-20
  sharpen: 2,      // 0-10
  rotate: 90,      // degrees (multiples of 90 recommended)
);

import 'package:flutter/material.dart';
import 'package:image_picker/image_picker.dart';
import 'package:abrova_storage/abrova_storage.dart';

class ProfileService {
  final AbrovaStorage _storage;

  ProfileService(String apiKey, AbrovaStorageTokenProvider tokenProvider)
      : _storage = AbrovaStorage(apiKey: apiKey, tokenProvider: tokenProvider);

  // Uploads to the public "avatars" bucket and returns a 200 px thumbnail link
  Future<String?> uploadProfileImage(String userId) async {
    final picker = ImagePicker();
    final pickedFile = await picker.pickImage(
      source: ImageSource.gallery,
      maxWidth: 1024,
      maxHeight: 1024,
      imageQuality: 85,
    );
    if (pickedFile == null) return null;

    final bytes = await pickedFile.readAsBytes();
    final file = await _storage.upload(
      'avatars',
      'users/$userId/avatar.jpg',
      bytes,
      options: UploadOptions(contentType: 'image/jpeg'),
    );

    return _storage.getPublicUrl(
      file.id,
      transforms: const ImageTransforms(width: 200, height: 200, fit: 'cover', format: 'webp'),
    );
  }

  // No headers needed for a public link
  Widget avatar(String url) => Image.network(url);

  void dispose() {
    _storage.dispose();
  }
}

try {
  await storage.upload('photos', 'clips/a.mov', bytes);
} on AbrovaStorageTokenException catch (e) {
  // token_required / token_expired / token_invalid: send the user to sign in
  print('Sign-in needed: ${e.code}');
} on AbrovaStorageException catch (e) {
  if (e.isTypeNotAllowed) {
    showError("This bucket doesn't take this file type");
  } else if (e.isFileTooLarge) {
    showError('The file is too big');
  } else if (e.code == StorageErrorCode.pathTaken) {
    showError('A file with this name already exists');
  } else if (e.code == StorageErrorCode.accessDenied) {
    showError("You can't write here");
  } else {
    showError(e.message);
  }
}