A/B Testing — Feature Flags add-on

dependencies:
  abrova_ab_testing:
    hosted: https://center.abrova.ir/api/packages/abrova/pub
    version: ^0.2.3

flutter pub get

<uses-permission android:name="android.permission.INTERNET" />

import 'package:abrova_ab_testing/abrova_ab_testing.dart';

// Initialize
final flags = await AbrovaFeatureFlags.init(
  AbrovaFeatureFlagsConfig(
    apiKey: 'YOUR_API_KEY',
    tokenProvider: fetchAbrovaToken, // returns a user token from your backend (step 3)
  ),
);

// Set the signed-in user
await flags.setUserId('user-123');

// Check a flag
if (await flags.isEnabled('dark-mode')) {
  // Feature is enabled
}

curl -X POST https://auth.abrova.ir/users/token \
  -H "x-api-key: $ABROVA_API_KEY" \
  -H "x-server-secret: $ABROVA_SERVER_SECRET" \
  -H "Content-Type: application/json" \
  -d '{"userId": "user-123", "expiresIn": 3600}'

# → { "token": "eyJhbGciOi…", "userId": "user-123", "expiresIn": 3600, "expiresAt": "…" }

import 'dart:convert';
import 'package:http/http.dart' as http;

Future<String?> fetchAbrovaToken() async {
  if (sessionToken == null) return null; // no one signed in: the SDK waits
  // Call YOUR backend, authenticated as the signed-in user
  final res = await http.post(
    Uri.parse('https://your-api.example.com/abrova-token'),
    headers: {'Authorization': 'Bearer $sessionToken'}, // your app's own session
  );
  if (res.statusCode != 200) throw Exception('Could not get an Abrova token');
  return jsonDecode(res.body)['token'] as String;
}

final flags = AbrovaFeatureFlags.instance;

flags.isAwaitingUserToken;            // true while there is no user token
flags.onAwaitingUserToken(() { });    // called each time the SDK starts waiting

// After sign-in
await flags.refreshUserToken();       // with a tokenProvider: asks it again now
await flags.setUserToken(token);      // without one: hand the token over

// After sign-out
await flags.clearUserId();            // or setUserToken(null)

import 'package:flutter/material.dart';
import 'package:abrova_ab_testing/abrova_ab_testing.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  // Initialize with full config
  await AbrovaFeatureFlags.init(
    AbrovaFeatureFlagsConfig(
      apiKey: 'YOUR_API_KEY',
      tokenProvider: fetchAbrovaToken, // User token from your backend
      debug: true,              // Enable debug logging
      enableOfflineCache: true, // Cache flags for offline use (default: true)
    ),
    callback: (event, data) {
      print('FeatureFlags event: $event, data: $data');
    },
  );

  runApp(const MyApp());
}

// Access the instance anywhere after init
final flags = AbrovaFeatureFlags.instance;

final flags = AbrovaFeatureFlags.instance;

// Set user ID (persisted across sessions)
await flags.setUserId('user-123');

// Forget the user at sign-out
await flags.clearUserId();

// Get current user ID
final userId = flags.getUserId();

// Set user attributes for targeting rules
flags.setUserAttributes({
  'plan': 'premium',
  'country': 'US',
  'age': 25,
  'is_beta_user': true,
});

final flags = AbrovaFeatureFlags.instance;

// Simple check
if (await flags.isEnabled('dark-mode')) {
  enableDarkMode();
}

// With default value (returned if flag not found)
final showBanner = await flags.isEnabled('promo-banner', defaultValue: false);

final flags = AbrovaFeatureFlags.instance;

// Get a string value
final buttonColor = await flags.getValue('button-color', defaultValue: 'blue');

// Get a numeric value
final maxRetries = await flags.getValue('max-retries', defaultValue: 3);

// Get a JSON config value
final config = await flags.getValue('onboarding-config', defaultValue: {});

// Fetch all flags (server call with cache fallback; API key only)
final allFlags = await AbrovaFeatureFlags.instance.getAll();

for (final flag in allFlags) {
  print('${flag.key}: enabled=${flag.enabled}, value=${flag.defaultValue}');
  if (flag.variants != null) {
    for (final variant in flag.variants!) {
      print('  variant ${variant.key}: ${variant.value} (weight: ${variant.weight})');
    }
  }
}

// Set attributes that match your targeting rules
AbrovaFeatureFlags.instance.setUserAttributes({
  'country': 'US',
  'plan': 'premium',
  'age': 25,
  'email': 'user@company.com',
});

// Flag with targeting rule {"country": {"in": ["US", "CA"]}}
// will be enabled for this user
final enabled = await AbrovaFeatureFlags.instance.isEnabled('us-feature');

// User ID is required for rollout percentage to work
await AbrovaFeatureFlags.instance.setUserId('user-123');

// A flag with 25% rollout will be enabled for ~25% of users
// The same user always gets the same result
final enabled = await AbrovaFeatureFlags.instance.isEnabled('new-feature');

// A flag with variants: blue (50%), green (30%), red (20%)
final buttonColor = await AbrovaFeatureFlags.instance.getValue(
  'button-color',
  defaultValue: 'blue',
);

// Use the value
switch (buttonColor) {
  case 'green':
    return Colors.green;
  case 'red':
    return Colors.red;
  default:
    return Colors.blue;
}

final flags = AbrovaFeatureFlags.instance;

// Check connectivity status
print('Online: ${flags.isOnline}');

// Access cached flags directly (no server call)
final cached = flags.cachedFlags;
print('Cached flags: ${cached.length}');

// Force refresh from server
await flags.refresh();

await AbrovaFeatureFlags.init(
  AbrovaFeatureFlagsConfig(
    apiKey: 'YOUR_API_KEY',
    tokenProvider: fetchAbrovaToken,
  ),
  callback: (event, data) {
    switch (event) {
      case 'initialized':
        print('SDK ready, offline: ${data?['offline']}');
        break;
      case 'featureFlagsRefreshed':
        print('Fetched ${data?['count']} flags');
        break;
      case 'awaitingUserToken':
        print('Waiting for a user token');
        break;
      case 'error':
        print('Error: ${data?['message']}');
        break;
    }
  },
);

// Manually refresh flags from server
await AbrovaFeatureFlags.instance.refresh();

// Clear cached flags, user and token, and reset the SDK.
// Call AbrovaFeatureFlags.init() again before using it afterwards.
// To sign a user out, call clearUserId() instead.
await AbrovaFeatureFlags.instance.reset();

// Clean up resources when done (currently a no-op: nothing to release)
AbrovaFeatureFlags.instance.dispose();

import 'package:flutter/material.dart';
import 'package:abrova_ab_testing/abrova_ab_testing.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  await AbrovaFeatureFlags.init(
    AbrovaFeatureFlagsConfig(
      apiKey: 'YOUR_API_KEY',
      tokenProvider: fetchAbrovaToken, // see step 3
      debug: true,
    ),
  );

  runApp(const MyApp());
}

class HomePage extends StatefulWidget {
  const HomePage({super.key});

  @override
  State<HomePage> createState() => _HomePageState();
}

class _HomePageState extends State<HomePage> {
  bool _darkMode = false;
  String _bannerText = 'Welcome!';
  bool _loading = true;

  @override
  void initState() {
    super.initState();
    _loadFlags();
  }

  Future<void> _loadFlags() async {
    final flags = AbrovaFeatureFlags.instance;

    // Set user for targeting
    await flags.setUserId('user-123');
    flags.setUserAttributes({
      'plan': 'premium',
      'country': 'US',
    });

    // Check flags
    final darkMode = await flags.isEnabled('dark-mode');
    final bannerText = await flags.getValue(
      'banner-text',
      defaultValue: 'Welcome!',
    ) as String;

    setState(() {
      _darkMode = darkMode;
      _bannerText = bannerText;
      _loading = false;
    });
  }

  @override
  Widget build(BuildContext context) {
    if (_loading) {
      return const Scaffold(
        body: Center(child: CircularProgressIndicator()),
      );
    }

    return Theme(
      data: _darkMode ? ThemeData.dark() : ThemeData.light(),
      child: Scaffold(
        appBar: AppBar(title: const Text('My App')),
        body: Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              Text(
                _bannerText,
                style: const TextStyle(fontSize: 24, fontWeight: FontWeight.bold),
              ),
              const SizedBox(height: 16),
              Text('Dark mode: ${_darkMode ? "ON" : "OFF"}'),
            ],
          ),
        ),
      ),
    );
  }
}