React Native SDK

npm install @seenn/react-native
# or
yarn add @seenn/react-native

cd ios && pod install

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

import SeennReactNative

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
  func application(_ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    // Register Live Activity bridge
    if #available(iOS 16.2, *) {
      SeennLiveActivityRegistry.shared.register(SeennLiveActivityBridgeImpl.shared)
    }
    return true
  }
}

import { Seenn } from '@seenn/react-native';
import { useEffect } from 'react';

export default function App() {
  useEffect(() => {
    // Initialize once on mount
    Seenn.init({
      apiKey: 'pk_live_xxx',  // Your public API key
      userId: 'user_123',     // Your user ID
    });

    return () => {
      // Cleanup on unmount
      Seenn.dispose();
    };
  }, []);

  return <AppContent />;
}

Seenn.init({
  apiKey: 'pk_live_xxx',
  userId: 'user_123',
  config: {
    apiUrl: 'https://api.seenn.io',
    pollInterval: 5000,  // 5 seconds
    debug: __DEV__,  // Enable debug logs in development
  },
});

import { Seenn } from '@seenn/react-native';

// Initialize with polling mode
Seenn.init({
  apiKey: 'your-api-key',
  userId: 'user_123',
  config: {
    baseUrl: 'https://api.yourcompany.com',
    basePath: '/v1',
    mode: 'polling',           // ← Explicit polling mode
    pollInterval: 5000,       // 5 seconds (default)
  },
});

// Subscribe to job updates (starts polling)
seenn.subscribeJobForPolling('job_123');

// Or subscribe to multiple jobs
seenn.subscribeJobsForPolling(['job_456', 'job_789']);

// Unsubscribe when done
seenn.unsubscribeJobFromPolling('job_123');

import { useSeennJob } from '@seenn/react-native';
import { View, Text, ActivityIndicator } from 'react-native';

function JobProgress({ jobId }: { jobId: string }) {
  const { job, isLoading, error } = useSeennJob(jobId);

  if (isLoading) {
    return <ActivityIndicator />;
  }

  if (error) {
    return <Text>Error: {error.message}</Text>;
  }

  return (
    <View>
      <Text>{job.title}</Text>
      <Text>Progress: {job.progress}%</Text>
      {job.message && <Text>{job.message}</Text>}

      {job.stage && (
        <Text>
          Stage: {job.stage.label} ({job.stage.index}/{job.stage.total})
        </Text>
      )}

      {job.eta && (
        <Text>ETA: {job.eta}s</Text>
      )}

      {job.status === 'completed' && (
        <Button title="Download" onPress={() => openUrl(job.resultUrl)} />
      )}
    </View>
  );
}

import { useSeennJobs } from '@seenn/react-native';
import { FlatList, Text } from 'react-native';

function JobsList() {
  const { jobs, isLoading, refetch } = useSeennJobs({
    status: ['running', 'queued'],
    limit: 20,
  });

  if (isLoading) {
    return <ActivityIndicator />;
  }

  return (
    <FlatList
      data={jobs}
      keyExtractor={(item) => item.jobId}
      onRefresh={refetch}
      refreshing={isLoading}
      renderItem={({ item }) => (
        <View>
          <Text>{item.title}</Text>
          <Text>{item.progress}% - {item.status}</Text>
        </View>
      )}
    />
  );
}

import { useEffect } from 'react';
import { AppState } from 'react-native';

// Reconnect when app comes to foreground
useEffect(() => {
  const subscription = AppState.addEventListener('change', (state) => {
    if (state === 'active') {
      seenn.reconnect();
    }
  });
  return () => subscription.remove();
}, []);

// Manually update job state from external source
const fetchJobManually = async (jobId: string) => {
  const response = await fetch(`https://api.seenn.io/v1/jobs/${jobId}`, {
    headers: { 'Authorization': `Bearer ${publicKey}` }
  });
  const job = await response.json();
  seenn.updateJob(job);
};

// Connection state based polling
const connectionState = useSeennConnectionState(seenn);

useEffect(() => {
  if (connectionState === 'disconnected') {
    const interval = setInterval(() => {
      fetchJobManually(activeJobId);
    }, 30000); // Poll every 30s
    return () => clearInterval(interval);
  }
}, [connectionState]);

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

cd ios && pod install

import { useSeennJob, useLiveActivity } from '@seenn/react-native';

function JobScreen({ jobId }: { jobId: string }) {
  const job = useSeennJob(seenn, jobId);

  // Auto-sync job state with Live Activity
  const { isActive, isSupported } = useLiveActivity(job, {
    autoStart: true,   // Start when job begins running
    autoEnd: true,     // End when job completes/fails
    dismissAfter: 300, // Keep on screen 5 min after completion
  });

  return (
    <View>
      <Text>{job?.title}</Text>
      <Text>Progress: {job?.progress}%</Text>
      {isSupported && <Text>Live Activity: {isActive ? 'On' : 'Off'}</Text>}
    </View>
  );
}

import { LiveActivity } from '@seenn/react-native';

// Check support
const supported = await LiveActivity.isSupported();

// Start activity
const result = await LiveActivity.start({
  jobId: 'job_123',
  title: 'Generating video...',
  jobType: 'video-generation',
  initialProgress: 0,
});

// Update progress
await LiveActivity.update({
  jobId: 'job_123',
  progress: 50,
  status: 'running',
  message: 'Encoding frames...',
  stageName: 'Encoding',
  stageIndex: 2,
  stageTotal: 3,
});

// End activity
await LiveActivity.end({
  jobId: 'job_123',
  finalStatus: 'completed',
  message: 'Video ready!',
  resultUrl: 'https://example.com/video.mp4',
  dismissAfter: 300,
});

// Get active activities
const activeIds = await LiveActivity.getActiveIds();
// ['job_123', 'job_456']

// Cancel all
await LiveActivity.cancelAll();

// Start multiple activities
await LiveActivity.start({ jobId: 'job_1', title: 'Video 1', ... });
await LiveActivity.start({ jobId: 'job_2', title: 'Video 2', ... });
await LiveActivity.start({ jobId: 'job_3', title: 'Image Pack', ... });

// Each updates independently
await LiveActivity.update({ jobId: 'job_1', progress: 50, ... });
await LiveActivity.update({ jobId: 'job_2', progress: 75, ... });

// Check which are active
const activeIds = await LiveActivity.getActiveIds();
console.log(activeIds); // ['job_1', 'job_2', 'job_3']

import { LiveActivity } from '@seenn/react-native';

// Listen for push tokens
const unsubscribe = LiveActivity.onPushToken((event) => {
  console.log(`Token for ${event.jobId}: ${event.token}`);
  // Send to your backend for APNs push updates
  sendTokenToBackend(event.jobId, event.token);
});

// Later: unsubscribe()

import { useLiveActivity } from '@seenn/react-native';

const { isActive } = useLiveActivity(job, {
  autoStart: true,
  autoEnd: true,

  // CTA button on completion
  completionCTA: {
    text: 'See Your Photos ✨',
    deepLink: (job) => `myapp://jobs/${job.jobId}/results`,
  },

  // Or different buttons for completed vs failed
  ctaButtons: {
    completed: {
      text: 'View Results',
      deepLink: (job) => `myapp://results/${job.jobId}`,
    },
    failed: {
      text: 'Try Again',
      deepLink: (job) => `myapp://retry/${job.jobId}`,
    },
  },
});

await LiveActivity.end({
  jobId: 'job_123',
  finalStatus: 'completed',
  message: 'Your Photos are Ready!',
  ctaButton: {
    text: 'See Your Photos ✨',
    deepLink: 'myapp://jobs/job_123/results',
    style: 'primary', // 'primary' | 'secondary' | 'outline'
    backgroundColor: '#FFFFFF',
    textColor: '#000000',
    cornerRadius: 20,
  },
});

# Install the CLI
npm install @seenn/setup-widget --save-dev

# Initialize widget configuration
npx @seenn/setup-widget init

# After editing seenn.config.js, regenerate Swift files
npx @seenn/setup-widget update

// seenn.config.js
module.exports = {
  theme: {
    preset: 'gradient-sunset', // or 'default', 'gradient-ocean', etc.
    colors: {
      progressBar: '#FFFFFF',
    },
    layout: {
      showIcon: true,
      showEta: true,
      showStage: true,
    },
    cta: {
      style: { backgroundColor: '#FFFFFF', textColor: '#000000' },
    },
  },
  jobTypes: {
    'video-generation': { icon: 'video.fill', color: '#9B59B6' },
    'image-generation': { icon: 'photo.fill', color: '#3498DB' },
  },
};

Media Attachment (thumbnail RIGHT):
┌────────────────────────────────────┬────┐
│ Remix Complete!                   │ 🖼️ │  ← imageUrl
│ Summer Vibes is ready to play    │    │
└────────────────────────────────────┴────┘

Communication Notification (avatar LEFT):
┌────────────────────────────────────────┐
│ 👤 DJ Mix                              │  ← senderAvatar
│    Check out this remix I made!        │
└────────────────────────────────────────┘

# Creates Widget Extension + Notification Service Extension
npx @seenn/setup-widget init

# Skip if you only need Live Activities
npx @seenn/setup-widget init --skip-rich-push

// Backend: Alert notification with media attachment
await job.complete({
  push: {
    alert: {
      title: 'Remix Complete!',
      body: 'Summer Vibes is ready to play',
    },
    // Media attachment - thumbnail on RIGHT side
    media: {
      imageUrl: 'https://example.com/album-art.jpg',
    },
  },
});

// Also works with silent/passive push!
await job.setProgress(50, {
  push: {
    silent: true,
    media: { imageUrl: 'https://example.com/preview.jpg' },
  },
});

// Backend: Send communication notification
await job.complete({
  push: {
    // Communication notification - avatar on LEFT side
    communication: {
      senderName: 'DJ Mix',
      senderAvatar: 'https://example.com/avatar.jpg',
      conversationId: 'conv-123',  // Optional: for grouping
    },
    // Optional: break through Focus mode
    timeSensitive: true,
  },
});

<!-- Add to ios/YourApp/Info.plist -->
<key>NSUserActivityTypes</key>
<array>
    <string>INSendMessageIntent</string>
</array>

// Backend: Communication + Media (avatar LEFT, thumbnail RIGHT)
await job.complete({
  push: {
    communication: {
      senderName: 'Sarah',
      senderAvatar: 'https://example.com/sarah.jpg',
    },
    media: {
      imageUrl: 'https://example.com/shared-photo.jpg',
    },
  },
});

Combined: Avatar LEFT + Thumbnail RIGHT
┌────────────────────────────────────┬────┐
│ 👤 Sarah                          │ 🖼️ │
│    Check out this photo!          │    │
└────────────────────────────────────┴────┘
  ↑ senderAvatar                      ↑ imageUrl

import { LiveActivity } from '@seenn/react-native';

// Check current authorization status
const status = await LiveActivity.getPushAuthorizationStatus();
console.log(status.status);       // 'provisional', 'authorized', etc.
console.log(status.isProvisional); // true if quiet notifications

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

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

import { LiveActivity } from '@seenn/react-native';

// Listen for both Live Activity and device push tokens
const unsubscribe = LiveActivity.onPushToken((event) => {
  if (event.type === 'liveActivity') {
    // Live Activity token - for updating a specific Live Activity via APNs
    console.log(`Live Activity token for ${event.jobId}: ${event.token}`);
    myBackend.registerLiveActivityToken(event.jobId, event.token);
  } else if (event.type === 'device') {
    // Device token - for regular push notifications
    console.log(`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 unsubscribe when done
unsubscribe();

# If you already have @seenn/react-native installed:
npx expo install expo-live-activity

# Fresh installation (both packages):
npx expo install expo-live-activity @seenn/react-native

{
  "expo": {
    "plugins": ["expo-live-activity"]
  }
}

npx expo prebuild --clean

import { useSeennJob, useExpoLiveActivity } from '@seenn/react-native';

function JobScreen({ jobId }: { jobId: string }) {
  const job = useSeennJob(seenn, jobId);

  // Auto-sync with Expo Live Activity
  const { isActive, isSupported } = useExpoLiveActivity(job, {
    autoStart: true,
    autoEnd: true,
    colors: {
      backgroundColor: '#1c1c1e',
      progressTint: '#3b82f6',
    },
    deepLinkUrl: 'myapp://jobs/job_123',
  });

  return (
    <View>
      <Text>{job?.title}</Text>
      <Text>Progress: {job?.progress}%</Text>
    </View>
  );
}

import { ExpoLiveActivity } from '@seenn/react-native';

// Check if available
const isAvailable = ExpoLiveActivity.isAvailable();

// Start activity
const activityId = await ExpoLiveActivity.start(job, {
  backgroundColor: '#1c1c1e',
  progressViewTint: '#3b82f6',
});

// Update activity
await ExpoLiveActivity.update(activityId, job);

// Stop activity
await ExpoLiveActivity.stop(activityId, job);

import { useSeennJob, useJobNotification } from '@seenn/react-native';

function JobScreen({ jobId }: { jobId: string }) {
  const job = useSeennJob(seenn, jobId);

  // Auto-sync job state with notification (iOS + Android)
  const { isActive, isSupported, platform } = useJobNotification(job);

  return (
    <View>
      <Text>{job?.title}</Text>
      <Text>Progress: {job?.progress}%</Text>
      {isSupported && <Text>Notification: {isActive ? 'Active' : 'Off'} ({platform})</Text>}
    </View>
  );
}

import { OngoingNotification } from '@seenn/react-native';

// Check support (Android 8.0+)
const supported = await OngoingNotification.isSupported();

// Check permission (Android 13+)
const hasPermission = await OngoingNotification.hasPermission();

// Start notification
const result = await OngoingNotification.start({
  jobId: 'job_123',
  title: 'Generating video...',
  initialProgress: 0,
});

// Update progress
await OngoingNotification.update({
  jobId: 'job_123',
  progress: 50,
  status: 'running',
  message: 'Encoding frames...',
  stageName: 'Encoding',
  stageIndex: 2,
  stageTotal: 3,
});

// End notification
await OngoingNotification.end({
  jobId: 'job_123',
  finalStatus: 'completed',
  message: 'Video ready!',
  dismissAfter: 5000, // 5 seconds (milliseconds)
});

// Cancel all notifications
await OngoingNotification.cancelAll();

import { JobNotification } from '@seenn/react-native';

// Works on iOS (Live Activity) and Android (Ongoing Notification)
await JobNotification.start({ jobId, title, initialProgress: 0 });
await JobNotification.update({ jobId, progress: 50, status: 'running' });
await JobNotification.end({ jobId, finalStatus: 'completed' });

// Check current platform
console.log(JobNotification.platform); // 'ios' | 'android' | 'other'

function BatchJobProgress({ jobId }: { jobId: string }) {
  const { job } = useSeennJob(jobId);

  return (
    <View>
      <Text style={styles.title}>{job.title}</Text>

      {/* Progress bar */}
      <View style={styles.progressBar}>
        <View style={[styles.progressFill, { width: `${job.progress}%` }]} />
      </View>

      {/* Batch counter: "3/5 images completed" */}
      {job.childrenTotal && (
        <Text style={styles.counter}>
          {job.childrenCompleted}/{job.childrenTotal} images completed
        </Text>
      )}

      {/* Individual child status */}
      {job.children?.map((child) => (
        <View key={child.childId} style={styles.childRow}>
          <StatusIcon status={child.status} />
          <Text>{child.title}</Text>
          {child.status === 'running' && <Text>{child.progress}%</Text>}
        </View>
      ))}
    </View>
  );
}

import { Seenn, useSeennJob } from '@seenn/react-native';

function BatchWithLiveActivity({ parentJobId }: { parentJobId: string }) {
  const { job } = useSeennJob(parentJobId);

  // Start Live Activity when job begins
  useEffect(() => {
    const startActivity = async () => {
      if (job?.status === 'running') {
        await Seenn.liveActivity.start({
          jobId: parentJobId,
          title: job.title,
          // Pass batch info for custom UI
          metadata: {
            childrenTotal: job.childrenTotal,
            childrenCompleted: job.childrenCompleted,
          },
        });
      }
    };
    startActivity();
  }, [job?.status]);

  // Live Activity auto-updates via polling!
  // When job.childrenCompleted changes, widget refreshes

  return (
    <View>
      <Text>{job.childrenCompleted}/{job.childrenTotal} completed</Text>
    </View>
  );
}

import { useParentJob } from '@seenn/react-native';

function BatchProgress({ seenn, batchJobId }) {
  const {
    job,              // The parent job
    isParent,         // true if this is a parent job
    childStats,       // { total, completed, failed, running, pending }
    progress,         // 0-100
    allChildrenDone,  // true when all children finished
    allChildrenSuccess, // true when all completed successfully
    hasFailedChildren, // true if any child failed
  } = useParentJob(seenn, batchJobId);

  if (!job) return <Text>Loading...</Text>;

  return (
    <View>
      <Text>{job.title}</Text>
      <ProgressBar progress={progress} />

      {childStats && (
        <Text>{childStats.completed}/{childStats.total} completed</Text>
      )}

      {hasFailedChildren && (
        <Text style={{ color: 'red' }}>{childStats.failed} failed</Text>
      )}

      {allChildrenSuccess && <Text>All done!</Text>}
    </View>
  );
}

import { useChildJob } from '@seenn/react-native';

function ChildJobCard({ seenn, childJobId }) {
  const {
    job,         // The child job
    isChild,     // true if this is a child job
    parentJobId, // Parent job ID
    childIndex,  // 0-based index within parent
    isComplete,  // true if completed
    isFailed,    // true if failed
  } = useChildJob(seenn, childJobId);

  if (!job) return null;

  return (
    <View style={styles.card}>
      <Text>#{childIndex + 1}: {job.title}</Text>
      <ProgressBar progress={job.progress} />
      {isComplete && <Icon name="check" color="green" />}
      {isFailed && <Icon name="x" color="red" />}
    </View>
  );
}

import { useJobsByIds } from '@seenn/react-native';

function ChildrenList({ seenn, childJobIds }) {
  // Subscribe to all children by their IDs
  const childJobs = useJobsByIds(seenn, childJobIds);

  return (
    <View>
      {childJobs.map((job) => (
        <View key={job.jobId} style={styles.row}>
          <StatusIcon status={job.status} />
          <Text>{job.title}</Text>
          <Text>{job.progress}%</Text>
        </View>
      ))}
    </View>
  );
}

interface SeennJob {
  jobId: string;
  userId: string;
  status: JobStatus;  // 'pending' | 'queued' | 'running' | 'completed' | 'failed'
  title: string;
  progress: number;  // 0-100
  message?: string;
  stage?: StageInfo;
  queue?: QueueInfo;
  eta?: number;  // Seconds to completion
  resultUrl?: string;
  errorMessage?: string;
  createdAt: string;
  updatedAt: string;

  // Parent-child fields
  parentJobId?: string;
  childProgressMode?: 'average' | 'weighted' | 'sequential';
  children?: ChildJob[];
  childrenCompleted?: number;
  childrenTotal?: number;
}

interface StageInfo {
  id: string;
  label: string;
  index: number;
  total: number;
}

interface QueueInfo {
  position: number;
  total: number;
  estimatedWaitSeconds?: number;
}

import { useSeennJob, useEtaCountdown } from '@seenn/react-native';

function JobProgress({ seenn, jobId }) {
  const job = useSeennJob(seenn, jobId);
  const eta = useEtaCountdown(job);

  return (
    <View>
      <ProgressBar progress={job?.progress || 0} />

      {eta.remaining !== null && (
        <Text>~{eta.formatted} remaining</Text>
      )}

      {eta.isPastDue && (
        <Text style={{ color: '#f59e0b' }}>
          Taking longer than expected...
        </Text>
      )}

      {eta.confidence !== null && eta.confidence < 0.5 && (
        <Text style={{ opacity: 0.6 }}>
          (estimate may vary)
        </Text>
      )}
    </View>
  );
}

Seenn.init({
  apiKey: 'pk_live_xxx',
  userId: 'user_123',
  config: {
    // Point to your own backend
    apiUrl: 'https://api.yourcompany.com',
    pollInterval: 5000,  // 5 seconds
  },
});

import { LiveActivity } from '@seenn/react-native';

// No Seenn.init() needed!

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

// 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',
  finalStatus: 'completed',
  message: 'Video ready!',
  ctaButton: {
    text: 'Watch Now',
    deepLink: 'myapp://videos/job_123',
  },
});

import { LiveActivity } from '@seenn/react-native';
import { useEffect } from 'react';

function App() {
  useEffect(() => {
    // Listen for Live Activity push tokens
    const unsubscribe = LiveActivity.onPushToken((event) => {
      // Send token to your backend
      myApi.registerLiveActivityToken({
        jobId: event.jobId,
        token: event.token,
      });
    });

    return () => unsubscribe();
  }, []);

  return <YourApp />;
}

// Progress update
{
  "aps": {
    "timestamp": 1706500000,
    "event": "update",
    "content-state": {
      "progress": 75,
      "status": "running",
      "message": "Processing 3/4...",
      "stageName": "Encoding",
      "stageIndex": 3,
      "stageTotal": 4
    }
  }
}

// Completion with CTA button
{
  "aps": {
    "timestamp": 1706500120,
    "event": "end",
    "dismissal-date": 1706500420,
    "content-state": {
      "progress": 100,
      "status": "completed",
      "message": "Your video is ready!",
      "ctaButtonText": "Watch Now",
      "ctaDeepLink": "myapp://videos/123"
    }
  }
}

import { useSeennJob, SeennError } from '@seenn/react-native';

function JobProgress({ jobId }: { jobId: string }) {
  const { job, error } = useSeennJob(jobId);

  if (error) {
    if (error instanceof SeennError) {
      switch (error.code) {
        case 'JOB_NOT_FOUND':
          return <Text>Job not found</Text>;
        case 'UNAUTHORIZED':
          // Refresh user token
          refreshToken();
          break;
        case 'RATE_LIMITED':
          return <Text>Too many requests, please wait</Text>;
      }
    }
    return <Text>Error: {error.message}</Text>;
  }

  // Render job...
}

import { LiveActivity, SeennErrorCode, SDK_VERSION } from '@seenn/react-native';

console.log('SDK Version:', SDK_VERSION); // '0.9.10'

const result = await LiveActivity.start({
  jobId: 'job_123',
  title: 'Processing...',
});

if (!result.success) {
  switch (result.code) {
    case SeennErrorCode.PLATFORM_NOT_SUPPORTED:
      console.log('Not on iOS');
      break;
    case SeennErrorCode.INVALID_JOB_ID:
      console.log('Invalid job ID');
      break;
    case SeennErrorCode.NATIVE_MODULE_NOT_FOUND:
      console.log('Native setup incomplete');
      break;
    default:
      console.log(`Error [${result.code}]: ${result.error}`);
  }
}

import { useSeennPush } from '@seenn/react-native';

function App() {
  const {
    token,
    authorizationStatus,
    isLoading,
    requestProvisional,
    requestStandard,
    refreshToken,
  } = useSeennPush({
    debug: true,     // Enable detailed logging in __DEV__
    autoRefresh: true, // Auto-refresh token on mount
    onTokenReceived: async (token) => {
      await api.registerDevice({ userId, deviceToken: token });
    },
    onAuthorizationStatus: (status) => {
      console.log('Auth status:', status);
    },
    onError: (error) => {
      console.error('Push error:', error);
    },
  });

  useEffect(() => {
    if (authorizationStatus === 'notDetermined') {
      requestProvisional();
    }
  }, [authorizationStatus]);

  return <YourApp />;
}

// When token expires, update it
await Seenn.setUserToken(newToken);

// Force reconnect
await Seenn.reconnect();

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