LiveKit移动端开发：iOS/Android/Flutter SDK实战教程

【免费下载链接】livekit End-to-end stack for WebRTC. SFU media server and SDKs. 项目地址: https://gitcode.com/GitHub_Trending/li/livekit

概述

LiveKit是一个开源的WebRTC SFU（Selective Forwarding Unit）媒体服务器，为开发者提供构建实时音视频应用的完整解决方案。本文将深入探讨LiveKit在移动端的开发实践，涵盖iOS、Android和Flutter三大主流移动平台。

移动端SDK生态

LiveKit提供完整的移动端SDK支持：

平台	SDK仓库	声明式UI支持	官方示例
iOS/macOS/visionOS	client-sdk-swift	SwiftUI	示例应用
Android	client-sdk-android	Compose	示例应用
Flutter	client-sdk-flutter	原生组件	示例应用

环境准备与服务器配置

LiveKit服务器部署

首先需要部署LiveKit服务器，支持多种部署方式：

# config-sample.yaml 基础配置
port: 7880
rtc:
  port_range_start: 50000
  port_range_end: 60000
  tcp_port: 7881
  use_external_ip: true

keys:
  key1: secret1
  key2: secret2

快速启动开发服务器

# 使用开发模式启动
livekit-server --dev

# 生成访问令牌
lk token create \
    --api-key devkey --api-secret secret \
    --join --room test-room --identity mobile-user \
    --valid-for 24h

iOS开发实战

集成Swift SDK

// Package.swift
dependencies: [
    .package(url: "https://github.com/livekit/client-sdk-swift", from: "1.0.0")
]

// 在SwiftUI中集成
import LiveKit
import SwiftUI

struct VideoCallView: View {
    @StateObject private var room = Room()
    
    var body: some View {
        VStack {
            if let localVideoTrack = room.localParticipant?.videoTracks.first {
                VideoView(track: localVideoTrack)
                    .frame(width: 120, height: 160)
            }
            
            ForEach(room.remoteParticipants, id: \.sid) { participant in
                if let videoTrack = participant.videoTracks.first {
                    VideoView(track: videoTrack)
                        .aspectRatio(contentMode: .fit)
                }
            }
        }
        .onAppear(perform: connectToRoom)
    }
    
    private func connectToRoom() {
        Task {
            do {
                let url = "wss://your-livekit-server.com"
                let token = "your-jwt-token"
                try await room.connect(url: url, token: token)
                
                // 发布本地音视频
                try await room.localParticipant?.setCamera(enabled: true)
                try await room.localParticipant?.setMicrophone(enabled: true)
            } catch {
                print("连接失败: \(error)")
            }
        }
    }
}

高级功能实现

// 屏幕共享
extension VideoCallView {
    private func startScreenShare() {
        Task {
            guard let screenShareCapture = try? await ScreenShareCapture(options: ScreenShareCaptureOptions(
                dimensions: .h1080_169,
                fps: 30
            )) else { return }
            
            let track = LocalVideoTrack.createVideoTrack(
                name: "screen-share",
                source: .screenShareVideo,
                capture: screenShareCapture
            )
            
            try await room.localParticipant?.publishVideoTrack(track)
        }
    }
}

// 音频处理
extension VideoCallView {
    private func configureAudio() {
        // 设置音频质量
        room.audioOutput = .default
        
        // 启用噪声抑制
        room.audioConfiguration.noiseSuppressionLevel = .high
        
        // 启用回声消除
        room.audioConfiguration.echoCancellation = true
    }
}

Android开发实战

集成Kotlin SDK

// build.gradle.kts
dependencies {
    implementation("io.livekit:livekit-android:1.0.0")
}

// MainActivity.kt
class VideoCallActivity : AppCompatActivity() {
    private lateinit var room: Room
    private lateinit var binding: ActivityVideoCallBinding
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityVideoCallBinding.inflate(layoutInflater)
        setContentView(binding.root)
        
        initializeRoom()
    }
    
    private fun initializeRoom() {
        room = Room(
            context = this,
            options = RoomOptions(
                adaptiveStream = true,
                dynacast = true
            )
        )
        
        room.addListener(object : Room.Listener() {
            override fun onParticipantConnected(participant: RemoteParticipant) {
                // 处理新参与者加入
            }
            
            override fun onTrackSubscribed(
                track: Track,
                publication: TrackPublication,
                participant: RemoteParticipant
            ) {
                if (track is VideoTrack) {
                    addRemoteVideoView(track)
                }
            }
        })
        
        connectToRoom()
    }
    
    private fun connectToRoom() {
        val url = "wss://your-livekit-server.com"
        val token = "your-jwt-token"
        
        CoroutineScope(Dispatchers.IO).launch {
            try {
                room.connect(url, token)
                
                // 启用本地媒体
                room.localParticipant?.setCameraEnabled(true)
                room.localParticipant?.setMicrophoneEnabled(true)
                
                // 获取本地视频轨道并显示
                room.localParticipant?.getVideoTracks()?.firstOrNull()?.let { track ->
                    runOnUiThread {
                        addLocalVideoView(track)
                    }
                }
            } catch (e: Exception) {
                Log.e("LiveKit", "连接失败", e)
            }
        }
    }
    
    private fun addLocalVideoView(track: VideoTrack) {
        val videoView = VideoView(this)
        videoView.setTrack(track)
        binding.localVideoContainer.addView(videoView)
    }
    
    private fun addRemoteVideoView(track: VideoTrack) {
        runOnUiThread {
            val videoView = VideoView(this)
            videoView.setTrack(track)
            binding.remoteVideoContainer.addView(videoView)
        }
    }
}

Compose集成示例

@Composable
fun VideoCallScreen() {
    val room = remember { Room(context = LocalContext.current) }
    var connected by remember { mutableStateOf(false) }
    
    LaunchedEffect(Unit) {
        try {
            room.connect("wss://your-server.com", "your-token")
            connected = true
        } catch (e: Exception) {
            // 处理错误
        }
    }
    
    Column {
        if (connected) {
            // 本地视频预览
            room.localParticipant?.videoTracks?.firstOrNull()?.let { track ->
                VideoRenderer(track = track, modifier = Modifier.size(120.dp))
            }
            
            // 远程参与者视频
            LazyVerticalGrid(columns = Adaptive(2)) {
                items(room.remoteParticipants) { participant ->
                    participant.videoTracks.firstOrNull()?.let { track ->
                        VideoRenderer(track = track, modifier = Modifier.aspectRatio(9f / 16f))
                    }
                }
            }
        }
    }
}

Flutter开发实战

集成Flutter SDK

# pubspec.yaml
dependencies:
  livekit_client: ^1.0.0
  permission_handler: ^11.0.0

// main.dart
import 'package:flutter/material.dart';
import 'package:livekit_client/livekit_client.dart';
import 'package:permission_handler/permission_handler.dart';

class VideoCallPage extends StatefulWidget {
  @override
  _VideoCallPageState createState() => _VideoCallPageState();
}

class _VideoCallPageState extends State<VideoCallPage> {
  late Room room;
  bool isConnected = false;
  List<RemoteParticipant> remoteParticipants = [];

  @override
  void initState() {
    super.initState();
    initializeRoom();
  }

  Future<void> initializeRoom() async {
    // 请求权限
    await [Permission.camera, Permission.microphone].request();
    
    room = Room();
    
    // 添加事件监听器
    room.addListener(_onRoomUpdate);
    
    await connectToRoom();
  }

  Future<void> connectToRoom() async {
    try {
      await room.connect(
        'wss://your-livekit-server.com',
        'your-jwt-token',
        roomOptions: RoomOptions(
          adaptiveStream: true,
          dynacast: true,
        ),
      );
      
      // 发布本地音视频
      await room.localParticipant?.setCameraEnabled(true);
      await room.localParticipant?.setMicrophoneEnabled(true);
      
      setState(() => isConnected = true);
    } catch (e) {
      print('连接失败: $e');
    }
  }

  void _onRoomUpdate() {
    setState(() {
      remoteParticipants = room.remoteParticipants.values.toList();
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('视频通话')),
      body: Column(
        children: [
          // 本地视频预览
          if (room.localParticipant?.videoTracks.isNotEmpty == true)
            VideoTrackRenderer(
              room.localParticipant!.videoTracks.first!,
              height: 120,
            ),
          
          // 远程视频网格
          Expanded(
            child: GridView.builder(
              gridDelegate: SliverGridDelegateWithFixedCrossAxisCount(
                crossAxisCount: 2,
                crossAxisSpacing: 8,
                mainAxisSpacing: 8,
              ),
              itemCount: remoteParticipants.length,
              itemBuilder: (context, index) {
                final participant = remoteParticipants[index];
                final videoTracks = participant.videoTracks;
                
                return videoTracks.isNotEmpty
                    ? VideoTrackRenderer(videoTracks.first!)
                    : Placeholder();
              },
            ),
          ),
          
          // 控制按钮
          ControlBar(room: room),
        ],
      ),
    );
  }

  @override
  void dispose() {
    room.dispose();
    super.dispose();
  }
}

class ControlBar extends StatelessWidget {
  final Room room;
  
  ControlBar({required this.room});
  
  @override
  Widget build(BuildContext context) {
    return Row(
      mainAxisAlignment: MainAxisAlignment.spaceEvenly,
      children: [
        IconButton(
          icon: Icon(Icons.mic_off),
          onPressed: () => room.localParticipant?.setMicrophoneEnabled(false),
        ),
        IconButton(
          icon: Icon(Icons.videocam_off),
          onPressed: () => room.localParticipant?.setCameraEnabled(false),
        ),
        IconButton(
          icon: Icon(Icons.call_end),
          onPressed: () => Navigator.pop(context),
        ),
      ],
    );
  }
}

高级功能与最佳实践

1. 自适应码流与网络优化

// Flutter示例 - 网络状态监听
room.addListener(() {
  final stats = room.engine?.connectionQuality;
  if (stats != null) {
    print('网络质量: ${stats.quality}');
    print('丢包率: ${stats.packetLoss}%');
    print('延迟: ${stats.latency}ms');
  }
});

// 手动调整视频质量
void adjustVideoQuality(ConnectionQuality quality) {
  switch (quality) {
    case ConnectionQuality.excellent:
      room.localParticipant?.setVideoEncoding('h1080_169');
      break;
    case ConnectionQuality.good:
      room.localParticipant?.setVideoEncoding('h720_169');
      break;
    case ConnectionQuality.poor:
      room.localParticipant?.setVideoEncoding('h360_169');
      break;
  }
}

2. 屏幕共享实现

// Android屏幕共享
private fun startScreenSharing() {
    val mediaProjectionManager = getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
    val intent = mediaProjectionManager.createScreenCaptureIntent()
    startActivityForResult(intent, SCREEN_SHARE_REQUEST_CODE)
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode == SCREEN_SHARE_REQUEST_CODE && resultCode == Activity.RESULT_OK) {
        data?.let { 
            val screenShareCapture = ScreenShareCapture(this, resultCode, it)
            val screenTrack = LocalVideoTrack.createVideoTrack(
                "screen-share",
                screenShareCapture
            )
            room.localParticipant?.publishTrack(screenTrack)
        }
    }
}

3. 音频处理与优化

// iOS音频配置
func configureAudioSession() {
    let audioSession = AVAudioSession.sharedInstance()
    do {
        try audioSession.setCategory(.playAndRecord, mode: .videoChat, options: [.duckOthers, .allowBluetooth])
        try audioSession.setActive(true)
    } catch {
        print("音频会话配置失败: \(error)")
    }
}

// 音频路由处理
func setupAudioRouteObserver() {
    NotificationCenter.default.addObserver(
        self,
        selector: #selector(handleRouteChange),
        name: AVAudioSession.routeChangeNotification,
        object: nil
    )
}

@objc func handleRouteChange(notification: Notification) {
    guard let reasonValue = notification.userInfo?[AVAudioSessionRouteChangeReasonKey] as? UInt,
          let reason = AVAudioSession.RouteChangeReason(rawValue: reasonValue) else { return }
    
    switch reason {
    case .newDeviceAvailable:
        print("新音频设备可用")
    case .oldDeviceUnavailable:
        print("音频设备不可用")
    default:
        break
    }
}

性能优化与调试

1. 内存管理最佳实践

// Android内存优化
class VideoCallActivity : AppCompatActivity() {
    override fun onTrimMemory(level: Int) {
        super.onTrimMemory(level)
        when (level) {
            ComponentCallbacks2.TRIM_MEMORY_MODERATE,
            ComponentCallbacks2.TRIM_MEMORY_COMPLETE -> {
                // 降低视频质量或暂停非关键轨道
                room.remoteParticipants.forEach { participant ->
                    participant.videoTracks.forEach { track ->
                        if (!track.isPrimary) {
                            track.setEnabled(false)
                        }
                    }
                }
            }
        }
    }
}

2. 电池优化策略

// iOS电池优化
func optimizeBatteryUsage() {
    // 启用低功耗模式
    room.options.adaptiveStream = true
    room.options.dynacast = true
    
    // 配置视频编码参数
    let videoEncoding = VideoEncoding(
        maxBitrate: 1_500_000,  // 1.5 Mbps
        maxFps: 30,

【免费下载链接】livekit End-to-end stack for WebRTC. SFU media server and SDKs. 项目地址: https://gitcode.com/GitHub_Trending/li/livekit