// build.gradle (app level)
dependencies {
    implementation 'co.amity:amity-sdk-android:6.0.0'
    implementation 'co.amity:amity-video-sdk-android:1.0.0'
}

npm install @amityco/ts-sdk
# or
<script src="https://sdk.amity.co/web/v6/amity-web-sdk.js"></script>

npm install @amityco/ts-sdk-react-native \
  @amityco/video-broadcaster-react-native \
  @amityco/video-player-react-native

dependencies:
  amity_sdk: ^6.0.0
  amity_video_player: ^0.0.1

import co.amity.sdk.AmitySDK

// Initialize SDK
AmitySDK.setup(
    context = this,
    apiKey = "your-api-key",
    httpUrl = "https://api.amity.co",
    socketUrl = "wss://api.amity.co"
)

// Login user
AmitySDK.login("user-123")
    .displayName("John Doe")
    .build()
    .login { result ->
        when (result) {
            is AmityResult.Success -> println("Login successful")
            is AmityResult.Error -> println("Login failed: ${result.error}")
        }
    }

import { Client } from '@amityco/ts-sdk';

// Initialize and login
const client = Client.createClient({
  apiKey: 'your-api-key',
  httpUrl: 'https://api.amity.co',
  socketUrl: 'wss://api.amity.co'
});

await client.login({
  userId: 'user-123',
  displayName: 'John Doe'
});

import { Client } from '@amityco/ts-sdk-react-native';

// Initialize SDK
const loginParams = {
  userId: 'user-123',
  displayName: 'John Doe'
};

const sessionHandler = {
  sessionWillRenewAccessToken: (renewal) => {
    renewal.renew();
  }
};

const response = await Client.login(loginParams, sessionHandler);

import 'package:amity_sdk/amity_sdk.dart';

// Initialize SDK
final sdk = AmitySDK();
await sdk.setup(
  option: AmitySDKSetupOption(
    apiKey: 'your-api-key',
    httpEndpoint: 'https://api.amity.co',
    socketEndpoint: 'wss://api.amity.co',
  ),
);

// Login user
final user = await sdk.login('user-123')
    .displayName('John Doe')
    .submit();

class BroadcastActivity : AppCompatActivity() {
    private lateinit var broadcaster: AmityLiveBroadcaster
    private lateinit var previewView: TextureView
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        broadcaster = AmityLiveBroadcaster.Builder(this)
            .setPreviewView(previewView)
            .setStreamingStateListener { state ->
                handleStreamingState(state)
            }
            .build()
    }
    
    private fun startBroadcast() {
        broadcaster.startStreaming("stream-id")
    }
}

import { StreamBroadcaster } from '@amityco/ts-sdk';

class WebBroadcaster {
  private broadcaster: StreamBroadcaster;
  
  constructor(videoElement: HTMLVideoElement) {
    this.broadcaster = new StreamBroadcaster({
      videoElement,
      constraints: {
        video: {
          width: { ideal: 1280 },
          height: { ideal: 720 },
          frameRate: { ideal: 30 }
        },
        audio: true
      }
    });
  }
  
  async startBroadcast(streamId: string) {
    await this.broadcaster.start(streamId);
  }
}

import { AmityVideoBroadcaster } from '@amityco/video-broadcaster-react-native';

const BroadcastScreen = () => {
  const broadcasterRef = useRef(null);
  
  const startBroadcast = async () => {
    const { data: stream } = await StreamRepository.createStream({
      title: 'My Live Stream'
    });
    
    broadcasterRef.current?.startPublish(stream.streamId);
  };
  
  return (
    <AmityVideoBroadcaster
      ref={broadcasterRef}
      style={{ flex: 1 }}
      resolution={{ width: 1280, height: 720 }}
      bitrate={2000000}
    />
  );
};

import 'package:camera/camera.dart';

class BroadcastScreen extends StatefulWidget {
  @override
  _BroadcastScreenState createState() => _BroadcastScreenState();
}

class _BroadcastScreenState extends State<BroadcastScreen> {
  CameraController? _controller;
  
  @override
  void initState() {
    super.initState();
    _initializeCamera();
  }
  
  Future<void> _initializeCamera() async {
    final cameras = await availableCameras();
    _controller = CameraController(
      cameras[0],
      ResolutionPreset.high,
      enableAudio: true,
    );
    await _controller!.initialize();
    setState(() {});
  }
  
  Widget build(BuildContext context) {
    return _controller?.value.isInitialized == true
        ? CameraPreview(_controller!)
        : CircularProgressIndicator();
  }
}

import com.google.firebase.messaging.FirebaseMessagingService

class AmityMessagingService : FirebaseMessagingService() {
    override fun onMessageReceived(remoteMessage: RemoteMessage) {
        super.onMessageReceived(remoteMessage)
        
        if (remoteMessage.data["type"] == "stream_started") {
            showStreamNotification(remoteMessage)
        }
    }
    
    private fun showStreamNotification(message: RemoteMessage) {
        val notificationBuilder = NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle(message.notification?.title)
            .setContentText(message.notification?.body)
            .setSmallIcon(R.drawable.ic_notification)
            .setAutoCancel(true)
        
        NotificationManagerCompat.from(this)
            .notify(notificationId, notificationBuilder.build())
    }
}

// Service worker registration
navigator.serviceWorker.register('/sw.js');

// Request notification permission
Notification.requestPermission().then(permission => {
  if (permission === 'granted') {
    console.log('Notification permission granted');
  }
});

// Handle push events in service worker
self.addEventListener('push', event => {
  const data = event.data.json();
  
  if (data.type === 'stream_started') {
    self.registration.showNotification(data.title, {
      body: data.body,
      icon: '/icon.png',
      data: { streamId: data.streamId }
    });
  }
});

import PushNotification from 'react-native-push-notification';

// Configure notifications
PushNotification.configure({
  onNotification: function(notification) {
    if (notification.data?.streamId) {
      navigateToStream(notification.data.streamId);
    }
  },
  requestPermissions: Platform.OS === 'ios',
});

// Handle stream notifications
const handleStreamNotification = (notification) => {
  const { streamId, type } = notification.data;
  
  switch (type) {
    case 'stream_started':
      // Navigate to live stream
      break;
    case 'stream_ended':
      // Show stream ended notification
      break;
  }
};

import 'package:flutter_local_notifications/flutter_local_notifications.dart';
import 'package:firebase_messaging/firebase_messaging.dart';

class NotificationService {
  final FlutterLocalNotificationsPlugin _localNotifications = 
      FlutterLocalNotificationsPlugin();
  final FirebaseMessaging _firebaseMessaging = FirebaseMessaging.instance;

  Future<void> initialize() async {
    // Initialize local notifications
    const androidSettings = AndroidInitializationSettings('@mipmap/ic_launcher');
    const iosSettings = DarwinInitializationSettings();
    
    await _localNotifications.initialize(
      InitializationSettings(
        android: androidSettings,
        iOS: iosSettings,
      ),
      onDidReceiveNotificationResponse: _onNotificationTapped,
    );

    // Setup Firebase Messaging
    FirebaseMessaging.onMessage.listen(_handleForegroundMessage);
  }
}

// Shared business logic
export class StreamManager {
  async createStream(params: CreateStreamParams): Promise<Stream> {
    // Platform-agnostic implementation
    return this.apiClient.createStream(params);
  }
}

// Platform-specific UI components
// Web version
const WebStreamPlayer = ({ stream }: { stream: Stream }) => {
  return <video src={stream.playbackUrl} controls />;
};

// React Native version
const MobileStreamPlayer = ({ stream }: { stream: Stream }) => {
  return <AmityStreamPlayer stream={stream} />;
};

// Flutter approach to consolidate platforms
abstract class PlatformVideoService {
  Future<void> startBroadcast(String streamId);
  Future<void> stopBroadcast();
  Stream<VideoPlayerState> get playerState;
}

class IOSVideoService extends PlatformVideoService {
  @override
  Future<void> startBroadcast(String streamId) {
    // iOS-specific implementation using method channels
  }
}

class AndroidVideoService extends PlatformVideoService {
  @override
  Future<void> startBroadcast(String streamId) {
    // Android-specific implementation using method channels
  }
}