Flutter SDK

flutter pub add seenn_flutter

dependencies:
  seenn_flutter: ^0.2.0

import 'package:seenn_flutter/seenn_flutter.dart';

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

  // Initialize Seenn SDK
  await Seenn.init(
    appId: 'app_xxx',
    userToken: userToken,  // From your backend
  );

  runApp(const MyApp());
}

await Seenn.init(
  appId: 'app_xxx',
  userToken: userToken,
  config: SeennConfig(
    apiUrl: 'https://api.seenn.io',
    sseUrl: 'https://sse.seenn.io',
    timeout: Duration(seconds: 30),
    debug: true,
  ),
);

// Or use development config for local testing
await Seenn.init(
  appId: 'test_app',
  userToken: 'test_token',
  config: SeennConfig.development(
    apiUrl: 'http://localhost:3001',
    sseUrl: 'http://localhost:3000',
  ),
);

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}'),
        );
      },
    );
  },
);

await Seenn.init(
  appId: 'app_xxx',
  userToken: 'user_token_xxx',
  config: SeennConfig.selfHosted(
    apiUrl: 'https://my-backend.com',
    pollInterval: Duration(seconds: 5), // default: 5s
  ),
);

// Subscribe to specific jobs (required in polling mode)
Seenn.instance.subscribeJob('job_123');
Seenn.instance.subscribeJobs(['job_456', 'job_789']);

// Jobs auto-unsubscribe when they reach terminal state
// Manual unsubscribe:
Seenn.instance.unsubscribeJob('job_123');

// Check connection mode
if (Seenn.instance.isPollingMode) {
  print('Using polling mode');
}

// 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/>

// 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!',
);

// 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 SSE

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 token (e.g., after token refresh)
await Seenn.setUserToken(newToken);

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