Flutter SDK

flutter pub add seenn_flutter

dependencies:
  seenn_flutter: ^0.3.0

import 'package:seenn_flutter/seenn_flutter.dart';

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

  // Initialize Seenn SDK
  await Seenn.init(
    apiKey: 'pk_live_xxx',  // Your public API key
    userId: 'user_123',     // Your user ID
  );

  runApp(const MyApp());
}

await Seenn.init(
  apiKey: 'pk_live_xxx',
  userId: 'user_123',
  config: SeennConfig(
    apiUrl: 'https://api.seenn.io',
    timeout: Duration(seconds: 30),
    debug: true,
  ),
);

// Or use development config for local testing
await Seenn.init(
  apiKey: 'pk_test_xxx',
  userId: 'test_user',
  config: SeennConfig.development(
    apiUrl: 'http://localhost:3001',
  ),
);

import 'package:seenn_flutter/seenn_flutter.dart';

await Seenn.init(
  apiKey: 'your-api-key',
  userId: 'user_123',
  config: SeennConfig.selfHosted(
    apiUrl: 'https://api.yourcompany.com',
    basePath: '/v1',
    pollInterval: Duration(seconds: 5),
  ),
);

// Subscribe to job updates (starts polling)
Seenn.instance.subscribeJob('job_123');

// Listen to updates
Seenn.instance.jobs.stream('job_123').listen((job) {
  print('Progress: \${job?.progress}%');
});

// Unsubscribe when done
Seenn.instance.unsubscribeJob('job_123');

final tracker = Seenn.instance.jobs.subscribe('job_123');

// Listen to all updates
tracker.onUpdate.listen((job) {
  print('Job updated: \${job.status}');
});

// Listen to progress changes only
tracker.onProgress.listen((update) {
  print('Progress: \${update.progress}%');
  print('Message: \${update.message}');
  if (update.stage != null) {
    print('Stage: \${update.stage.current}/\${update.stage.total}');
  }
});

// Listen to completion
tracker.onComplete.listen((job) {
  print('Completed! URL: \${job.resultUrl}');
});

// Listen to failures
tracker.onFailed.listen((job) {
  print('Failed: \${job.errorMessage}');
});

// Listen to terminal state (completed or failed)
tracker.onTerminal.listen((job) {
  print('Job finished with status: \${job.status}');
});

class JobProgressWidget extends StatelessWidget {
  final String jobId;

  const JobProgressWidget({required this.jobId});

  @override
  Widget build(BuildContext context) {
    return StreamBuilder<SeennJob?>(
      stream: Seenn.instance.jobs.stream(jobId),
      builder: (context, snapshot) {
        final job = snapshot.data;

        if (job == null) {
          return const CircularProgressIndicator();
        }

        return Column(
          children: [
            Text(job.title),
            LinearProgressIndicator(value: job.progress / 100),
            Text('\${job.progress}%'),
            if (job.message != null)
              Text(job.message!),
            if (job.status == JobStatus.completed)
              ElevatedButton(
                onPressed: () => openUrl(job.resultUrl!),
                child: const Text('Download'),
              ),
          ],
        );
      },
    );
  }
}

StreamBuilder<Map<String, SeennJob>>(
  stream: Seenn.instance.jobs.all$,
  builder: (context, snapshot) {
    final jobs = snapshot.data?.values.toList() ?? [];

    return ListView.builder(
      itemCount: jobs.length,
      itemBuilder: (context, index) {
        final job = jobs[index];
        return ListTile(
          title: Text(job.title),
          subtitle: Text('\${job.progress}% - \${job.status}'),
        );
      },
    );
  },
);

import 'package:seenn_flutter/seenn_flutter.dart';

// No Seenn.init() needed!

// Start a Live Activity when job begins
final result = await LiveActivity.start(
  jobId: 'job_123',
  title: 'Processing your video...',
  jobType: 'video-processing',
  initialProgress: 0,
);

if (result.success) {
  print('Activity started: ${result.activityId}');
}

// Update from your own state management
await LiveActivity.update(
  jobId: 'job_123',
  progress: 50,
  status: 'running',
  message: 'Encoding frames...',
);

// End with CTA button
await LiveActivity.end(
  jobId: 'job_123',
  finalProgress: 100,
  finalStatus: 'completed',
  message: 'Video ready!',
  ctaButton: LiveActivityCTAButton(
    text: 'Watch Now',
    deepLink: 'myapp://videos/job_123',
  ),
);

import 'package:seenn_flutter/seenn_flutter.dart';

// Initialize push token listener (call once at app startup)
LiveActivity.initialize();

// Listen for Live Activity push tokens
final subscription = LiveActivity.onPushToken.listen((token) {
  // Send token to your backend
  myApi.registerLiveActivityToken(
    jobId: token.jobId,
    token: token.token,
  );
});

// Don't forget to cancel when done
subscription.cancel();
LiveActivity.dispose();

// Check if connected (sync)
if (Seenn.instance.isConnected) {
  print('Connected to Seenn');
}

// Stream of connection state changes
StreamBuilder<SeennConnectionState>(
  stream: Seenn.instance.connectionState$,
  builder: (context, snapshot) {
    final state = snapshot.data ?? SeennConnectionState.disconnected;

    return Icon(
      state.isConnected ? Icons.cloud_done : Icons.cloud_off,
      color: state.isConnected ? Colors.green : Colors.red,
    );
  },
);

<key>NSSupportsLiveActivities</key>
<true/>

import seenn_flutter

@main
class AppDelegate: FlutterAppDelegate {
  override func application(_ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    GeneratedPluginRegistrant.register(with: self)

    // Register Live Activity bridge
    if #available(iOS 16.2, *) {
      SeennLiveActivityRegistry.shared.register(SeennLiveActivityBridgeImpl.shared)
    }

    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
  }
}

// Start Live Activity
final result = await Seenn.instance.liveActivity.startActivity(
  jobId: 'job_123',
  title: 'Processing video...',
  jobType: 'video_render',
);

if (result.success) {
  print('Activity started: \${result.activityId}');
}

// Update Live Activity
await Seenn.instance.liveActivity.updateActivity(
  jobId: 'job_123',
  progress: 50,
  status: 'running',
  message: 'Encoding frames...',
);

// End Live Activity
await Seenn.instance.liveActivity.endActivity(
  jobId: 'job_123',
  finalProgress: 100,
  finalStatus: 'completed',
  message: 'Your video is ready!',
);

await Seenn.instance.liveActivity.endActivity(
  jobId: 'job_123',
  finalProgress: 100,
  finalStatus: 'completed',
  message: 'Your Photos are Ready!',
  ctaButton: LiveActivityCTAButton(
    text: 'See Your Photos ✨',
    deepLink: 'myapp://jobs/job_123/results',
    style: LiveActivityCTAButtonStyle.primary,
    backgroundColor: '#FFFFFF',
    textColor: '#000000',
    cornerRadius: 20,
  ),
);

// Start and auto-track Live Activity
final job = Seenn.instance.jobs.get('job_123');
await Seenn.instance.startLiveActivityForJob(job!);

// The SDK will automatically update/end the Live Activity
// when job state changes via polling

import UserNotifications

class NotificationService: UNNotificationServiceExtension {
    var contentHandler: ((UNNotificationContent) -> Void)?
    var bestAttemptContent: UNMutableNotificationContent?

    override func didReceive(
        _ request: UNNotificationRequest,
        withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void
    ) {
        self.contentHandler = contentHandler
        bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)

        guard let bestAttemptContent = bestAttemptContent else {
            contentHandler(request.content)
            return
        }

        // Look for image URL in payload
        let userInfo = request.content.userInfo
        let imageUrlString = userInfo["senderAvatar"] as? String
            ?? userInfo["imageUrl"] as? String
            ?? userInfo["image"] as? String

        guard let urlString = imageUrlString,
              let imageUrl = URL(string: urlString) else {
            contentHandler(bestAttemptContent)
            return
        }

        // Download and attach image
        downloadImage(from: imageUrl) { attachment in
            if let attachment = attachment {
                bestAttemptContent.attachments = [attachment]
            }
            contentHandler(bestAttemptContent)
        }
    }

    override func serviceExtensionTimeWillExpire() {
        if let contentHandler = contentHandler,
           let bestAttemptContent = bestAttemptContent {
            contentHandler(bestAttemptContent)
        }
    }

    private func downloadImage(
        from url: URL,
        completion: @escaping (UNNotificationAttachment?) -> Void
    ) {
        let task = URLSession.shared.downloadTask(with: url) { localUrl, response, error in
            guard let localUrl = localUrl, error == nil else {
                completion(nil)
                return
            }

            let fileManager = FileManager.default
            let tempDir = fileManager.temporaryDirectory
            let fileName = url.lastPathComponent
            let destUrl = tempDir.appendingPathComponent(fileName)

            try? fileManager.removeItem(at: destUrl)
            do {
                try fileManager.moveItem(at: localUrl, to: destUrl)
                let attachment = try UNNotificationAttachment(
                    identifier: "image",
                    url: destUrl,
                    options: nil
                )
                completion(attachment)
            } catch {
                completion(nil)
            }
        }
        task.resume()
    }
}

{
  "aps": {
    "alert": {
      "title": "New message from Sarah",
      "body": "Hey! Check out this photo"
    },
    "sound": "default",
    "mutable-content": 1  // Required for extension to run
  },
  "senderAvatar": "https://example.com/avatar.jpg"  // Image URL
}

import 'package:seenn_flutter/seenn_flutter.dart';

// Check current authorization status
final status = await LiveActivity.getPushAuthorizationStatus();
print(status.status);       // PushAuthorizationStatus.provisional
print(status.isProvisional); // true if quiet notifications

// Request provisional push — no prompt shown!
final granted = await LiveActivity.requestProvisionalPushAuthorization();
if (granted) {
  print('Provisional push enabled');
}

// Later: upgrade to full push (shows prompt)
if (status.canRequestFullAuthorization) {
  final upgraded = await LiveActivity.upgradeToStandardPush();
  if (upgraded) {
    print('Full push access granted');
  }
}

import 'package:seenn_flutter/seenn_flutter.dart';

// Initialize push token listener
LiveActivity.initialize();

// Listen for both Live Activity and device push tokens
final subscription = LiveActivity.onPushToken.listen((event) {
  if (event.isLiveActivity) {
    // Live Activity token - for updating a specific Live Activity via APNs
    print('Live Activity token for \${event.jobId}: \${event.token}');
    myBackend.registerLiveActivityToken(event.jobId!, event.token);
  } else if (event.isDevice) {
    // Device token - for regular push notifications
    print('Device push token: \${event.token}');
    myBackend.registerDevicePushToken(event.token);
  }
});

// Request provisional push - token will be emitted via onPushToken
await LiveActivity.requestProvisionalPushAuthorization();

// Don't forget to cancel when done
subscription.cancel();

final notificationService = OngoingNotificationService();

// Start notification
final result = await notificationService.startNotification(
  jobId: 'job_123',
  title: 'Processing',
  jobType: 'video_render',
  initialMessage: 'Starting...',
);

// Update progress
await notificationService.updateNotification(
  jobId: 'job_123',
  progress: 50,
  status: 'running',
  message: 'Halfway there...',
);

// End notification
await notificationService.endNotification(
  jobId: 'job_123',
  finalProgress: 100,
  finalStatus: 'completed',
  message: 'Your video is ready!',
);

final jobNotification = JobNotificationService();

// Automatically uses Live Activity on iOS, Ongoing Notification on Android
await jobNotification.start(
  jobId: 'job_123',
  title: 'Processing',
  jobType: 'video_render',
);

// Sync with job updates
tracker.onUpdate.listen((job) async {
  await jobNotification.syncWithJob(job);
});

import 'package:seenn_flutter/seenn_flutter.dart';

// Using convenience function
final countdown = etaCountdownStream(job);

countdown.listen((state) {
  print('Remaining: \${state.formatted}');   // "2m 30s"
  print('Past due: \${state.isPastDue}');    // false
  print('Confidence: \${state.confidence}'); // 0.85
  print('Based on: \${state.basedOn} jobs'); // 42
});

final etaService = EtaCountdownService();

// Start countdown
etaService.startCountdown(job);

// Listen to updates
etaService.stream.listen((state) {
  print('ETA: \${state.formatted}');
});

// Update when job changes from server
tracker.onUpdate.listen((job) {
  etaService.updateJob(job);
});

// Clean up
etaService.dispose();

// Get parent jobs
final parents = Seenn.instance.jobs.parents;

// Get children of a specific parent
final children = Seenn.instance.jobs.childrenOf('parent_job_id');

// Stream of parent jobs
Seenn.instance.jobs.parents$.listen((parents) {
  print('Parent jobs: \${parents.length}');
});

// Track child progress on a parent job
final tracker = Seenn.instance.jobs.subscribe('parent_job_id');

tracker.onChildProgress.listen((update) {
  print('Children: \${update.completed}/\${update.total}');
  print('Failed: \${update.failed}');
  print('Running: \${update.running}');
  print('Percent: \${update.percentComplete}%');
});

// Call when user logs out or app closes
await Seenn.dispose();

// Update user ID (e.g., after user switch or login)
await Seenn.setUserToken(newUserId);

// Force reconnect
await Seenn.instance.reconnect();