Cross-Platform Comparison Guide

This guide provides a comprehensive comparison of social.plus Video SDK implementation across all supported platforms, helping you choose the right approach for your application.

Platform Overview

Quick Comparison
Technical Specs

Feature	iOS	Android	Web	React Native	Flutter
Native Performance	✅ Excellent	✅ Excellent	⚠️ Good	⚠️ Good	⚠️ Good
Development Speed	⚠️ Moderate	⚠️ Moderate	✅ Fast	✅ Fast	✅ Fast
Code Sharing	❌ Platform-specific	❌ Platform-specific	❌ Web-only	✅ Cross-platform	✅ Cross-platform
Live Streaming	✅ Full support	✅ Full support	✅ Full support	✅ Full support	✅ Full support
Video Playback	✅ Full support	✅ Full support	✅ Full support	✅ Full support	✅ Full support
Push Notifications	✅ APNs	✅ FCM	✅ Web Push	✅ Multi-platform	✅ Multi-platform
Real-time Events	✅ WebSocket	✅ WebSocket	✅ WebSocket	✅ WebSocket	✅ WebSocket
Background Processing	✅ Full	✅ Full	⚠️ Limited	✅ Full	✅ Full
Hardware Access	✅ Full	✅ Full	⚠️ Limited	✅ Full	✅ Full

Specification	iOS	Android	Web	React Native	Flutter
Min Version	iOS 12+	API 21+	Modern browsers	RN 0.64+	Flutter 3.0+
Language	Swift/Objective-C	Kotlin/Java	JavaScript/TypeScript	JavaScript/TypeScript	Dart
Package Manager	CocoaPods/SPM	Gradle/Maven	npm/yarn	npm/yarn	pub.dev
SDK Size	~15MB	~20MB	~5MB (gzipped)	~25MB	~30MB
Memory Usage	Low	Low	Medium	Medium	Medium
Battery Impact	Low	Low	N/A	Medium	Medium
Hot Reload	❌	❌	✅	✅	✅

Installation & Setup Comparison

iOS
Android
Web
React Native
Flutter

// Podfile
platform :ios, '12.0'

target 'YourApp' do
  pod 'AmitySDK'
  pod 'AmityVideoSDK'
end

Pros:

Native performance and integration
Full access to iOS-specific features
Excellent debugging tools

Cons:

iOS-only, requires separate Android development
Longer development cycle
Requires macOS for development

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

Pros:

Native performance and integration
Full access to Android-specific features
Rich development tools

Cons:

Android-only, requires separate iOS development
Device fragmentation challenges
Complex permission handling

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

Pros:

Fastest deployment and updates
No app store approval required
Cross-platform by nature

Cons:

Limited hardware access
Browser compatibility issues
Network-dependent performance

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

Pros:

Single codebase for iOS and Android
Large developer community
Hot reload for fast development

Cons:

Bridge overhead affects performance
Native module dependencies
Requires platform-specific configurations

dependencies:
  amity_sdk: ^6.0.0
  amity_video_player: ^0.0.1

Pros:

Single codebase for all platforms
Excellent performance
Rich UI framework

Cons:

Smaller community than React Native
Dart learning curve
Larger app size

SDK Initialization Comparison

iOS (Swift)
Android (Kotlin)
Web (TypeScript)
React Native
Flutter (Dart)

import AmitySDK

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

// Login user
AmitySDKManager.login(
    userId: "user-123",
    displayName: "John Doe"
) { result in
    switch result {
    case .success(let user):
        print("Login successful: \(user.userId)")
    case .failure(let error):
        print("Login failed: \(error)")
    }
}

Best for: iOS-native apps requiring maximum performance

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

Best for: Web applications, PWAs, quick prototypes

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);

Best for: Cross-platform mobile apps with React expertise

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();

Best for: Cross-platform apps with custom UI requirements

Live Streaming Implementation

import AmityVideoSDK

class BroadcastViewController: UIViewController {
    @IBOutlet weak var previewView: UIView!
    private var broadcaster: AmityLiveBroadcaster?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupBroadcaster()
    }
    
    private func setupBroadcaster() {
        broadcaster = AmityLiveBroadcaster(
            previewView: previewView,
            delegate: self
        )
    }
    
    @IBAction func startBroadcast(_ sender: UIButton) {
        broadcaster?.startBroadcast(streamId: "stream-id")
    }
}

Advantages:

Native camera and microphone integration
Optimal battery usage
Full control over UI/UX

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")
    }
}

Advantages:

Excellent hardware optimization
Advanced camera controls
Background streaming support

TypeScript SDK gap: StreamBroadcaster is not available in the TypeScript SDK. Android exposes AmityStreamBroadcaster for RTMP broadcasting. In TS/Web, streaming uses WebRTC browser APIs via StreamRepository.createStream. Tracking: see .docs-ops/evals/sdk-tickets-to-file.md.

// StreamBroadcaster not in TS SDK — use StreamRepository.createStream + WebRTC MediaRecorder

Advantages:

No app installation required
Instant deployment
WebRTC optimization

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}
    />
  );
};

Advantages:

Single codebase for iOS and Android
React ecosystem integration
Hot reload development

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();
  }
}

Advantages:

Single codebase for all platforms
Excellent UI customization
Strong performance

Push Notifications Comparison

iOS
Android
Web
React Native
Flutter

import UserNotifications

// Request permissions
UNUserNotificationCenter.current().requestAuthorization(
    options: [.alert, .badge, .sound]
) { granted, error in
    if granted {
        DispatchQueue.main.async {
            UIApplication.shared.registerForRemoteNotifications()
        }
    }
}

// Handle notifications
func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    didReceive response: UNNotificationResponse
) {
    let userInfo = response.notification.request.content.userInfo
    if let streamId = userInfo["streamId"] as? String {
        navigateToStream(streamId)
    }
}

Features:

Native APNs integration
Rich notifications with media
Background processing

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())
    }
}

Features:

FCM integration
Rich media notifications
Background processing

// 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 }
    });
  }
});

Features:

Web Push API
Service worker integration
Cross-browser support

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;
  }
};

Features:

Unified API for iOS and Android
Background processing
Deep linking support

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

Features:

Cross-platform notification handling
Firebase Messaging integration
Rich notification support

Performance Comparison

Memory Usage

Memory Footprint
Performance Metrics

Platform	Base SDK	Video Components	Total Runtime
iOS	~5MB	~10MB	~15-20MB
Android	~8MB	~12MB	~20-25MB
Web	~2MB	~3MB	~5-8MB
React Native	~10MB	~15MB	~25-30MB
Flutter	~12MB	~18MB	~30-35MB

Note: Actual memory usage varies based on features used and device capabilities

Metric	iOS	Android	Web	React Native	Flutter
App Launch Time	500ms	800ms	200ms	1200ms	1000ms
Video Start Time	800ms	1000ms	1200ms	1500ms	1400ms
Frame Rate (1080p)	60fps	60fps	30fps	45fps	50fps
Battery Drain (1h streaming)	15%	18%	N/A	22%	20%
CPU Usage (streaming)	25%	30%	40%	35%	32%

Development Experience

Learning Curve
Development Speed

Aspect	iOS	Android	Web	React Native	Flutter
Language Complexity	Medium	Medium	Low	Low	Medium
SDK Documentation	✅ Excellent	✅ Excellent	✅ Excellent	✅ Excellent	✅ Excellent
Community Support	✅ Large	✅ Large	✅ Very Large	✅ Very Large	⚠️ Growing
Debugging Tools	✅ Excellent	✅ Excellent	✅ Good	⚠️ Good	⚠️ Good
Testing Support	✅ Excellent	✅ Excellent	✅ Good	⚠️ Good	✅ Excellent
CI/CD Integration	✅ Excellent	✅ Excellent	✅ Excellent	✅ Good	✅ Good

Phase	iOS	Android	Web	React Native	Flutter
Initial Setup	2-4 hours	2-4 hours	30 minutes	1-2 hours	1-2 hours
Basic Implementation	2-3 days	2-3 days	1 day	1-2 days	1-2 days
Advanced Features	1-2 weeks	1-2 weeks	3-5 days	5-7 days	5-7 days
Platform Polish	3-5 days	3-5 days	2-3 days	2-3 days	2-3 days
Testing & QA	3-5 days	3-5 days	2-3 days	4-6 days	4-6 days

Use Case Recommendations

Choose iOS Native When:

Building premium iOS-only applications
Maximum performance is critical
Deep iOS ecosystem integration needed
Advanced camera/media features required
Long-term iOS-specific development

Choose Android Native When:

Building premium Android-only applications
Maximum performance on Android is critical
Complex Android-specific integrations needed
Advanced hardware access required
Long-term Android-specific development

Choose Web When:

Rapid prototyping and deployment
No app store distribution needed
Desktop and mobile web access
Limited development resources
Frequent updates required

Choose React Native When:

Team has React/JavaScript expertise
Cross-platform mobile development
Rapid development cycles needed
Existing React ecosystem integration
Budget constraints for separate native development

Choose Flutter When:

Building for multiple platforms (iOS, Android, Web)
Custom UI/UX requirements
Team comfortable with Dart
Long-term cross-platform strategy
Performance-critical cross-platform apps

Migration Strategies

Native to Cross-Platform
Web to Mobile
Cross-Platform Consolidation

// Gradual migration approach
// 1. Start with shared business logic
interface StreamService {
  createStream(params: CreateStreamParams): Promise<Stream>;
  getStream(id: string): Promise<Stream>;
}

// 2. Implement platform-specific adapters
class IOSStreamService implements StreamService {
  // iOS-specific implementation
}

class AndroidStreamService implements StreamService {
  // Android-specific implementation
}

class CrossPlatformStreamService implements StreamService {
  // React Native/Flutter implementation
}

// 3. Migrate screen by screen
// Start with less complex screens
// Gradually move to core features

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

Cost Analysis

Development Costs

Factor	iOS	Android	Web	React Native	Flutter
Initial Development	High	High	Low	Medium	Medium
Maintenance	High	High	Low	Medium	Medium
Testing	Medium	High	Low	Medium	Medium
Platform Updates	Medium	High	Low	Medium	Medium
Team Size Required	2-3	2-3	1-2	1-2	1-2

Operational Costs

Factor	iOS	Android	Web	React Native	Flutter
App Store Fees	$99/year	$25 one-time	None	$124/year	$124/year
Distribution	App Store	Google Play	CDN/Hosting	App Stores	App Stores
Updates	Review process	Instant	Instant	Review process	Review process
Analytics	Built-in	Built-in	Third-party	Third-party	Third-party

Conclusion

The choice of platform depends on your specific requirements:

For maximum performance: Choose native iOS/Android
For rapid development: Choose Web or React Native
For cross-platform consistency: Choose Flutter
For existing team expertise: Leverage current skills (React → React Native, etc.)
For budget constraints: Consider cross-platform solutions

Each platform has its strengths, and the social.plus Video SDK provides consistent functionality across all platforms while optimizing for each platform’s specific capabilities.

Next Steps

Sample Applications

We provide sample applications for each platform to help you get started quickly:

iOS: GitHub Repository
Android: GitHub Repository
Web: GitHub Repository
React Native: GitHub Repository
Flutter: GitHub Repository

Documentation Index

​Cross-Platform Comparison Guide

​Platform Overview

​Installation & Setup Comparison

​SDK Initialization Comparison

​Live Streaming Implementation

​Push Notifications Comparison

​Performance Comparison

​Memory Usage

​Development Experience

​Use Case Recommendations

​Choose iOS Native When:

​Choose Android Native When:

​Choose Web When:

​Choose React Native When:

​Choose Flutter When:

​Migration Strategies

​Cost Analysis

​Development Costs

​Operational Costs

​Conclusion

​Next Steps

​Sample Applications

Cross-Platform Comparison Guide

Platform Overview

Installation & Setup Comparison

SDK Initialization Comparison

Live Streaming Implementation

Push Notifications Comparison

Performance Comparison

Memory Usage

Development Experience

Use Case Recommendations

Choose iOS Native When:

Choose Android Native When:

Choose Web When:

Choose React Native When:

Choose Flutter When:

Migration Strategies

Cost Analysis

Development Costs

Operational Costs

Conclusion

Next Steps

Sample Applications