Debian 10下WebRTC视频通话全栈搭建：从Kamailio配置到RTPEngine避坑指南

如果你正在为移动应用或Web应用寻找一个稳定、可控的实时音视频通话解决方案，那么自建SIP服务器配合WebRTC技术栈，可能是你绕不开的一环。市面上现成的云服务固然方便，但当你需要深度定制通话逻辑、控制数据流向、对接自有业务系统，或者单纯想摆脱月租费用时，自己动手搭建一套完整的信令与媒体服务器，就成了一种极具吸引力的选择。

这篇文章就是为那些有类似想法的全栈工程师准备的。我们将以Debian 10为舞台，从零开始，构建一套支持WebSocket信令、能够完美处理公网NAT穿透、并能与Flutter等移动端框架无缝集成的WebRTC视频通话系统。核心组件是Kamailio（高性能SIP信令服务器）和RTPEngine（媒体代理与NAT穿透引擎）。整个过程不仅仅是复制粘贴命令，我会结合我实际部署中踩过的坑，深入讲解每个关键配置背后的原理，特别是如何让WebRTC的媒体流在复杂的网络环境下畅通无阻。无论你是想为你的Flutter应用增加视频通话功能，还是希望构建一个独立的音视频通信平台，这篇文章都将提供一条清晰的路径。

1. 环境准备与核心组件解析

在开始敲命令之前，我们需要对这套架构的各个角色有一个清晰的认识。很多人一上来就安装，结果遇到问题完全不知道从何排查。理解每个组件的作用，是后续顺利配置和调试的基础。

我们的目标架构可以这样概括：客户端（Web或Flutter应用）通过WebSocket协议与Kamailio服务器建立信令连接，进行注册、呼叫建立等SIP信令交互。当通话建立后，音视频媒体流（RTP/RTCP包）并不直接在对等设备间传输，而是通过RTPEngine进行中转和NAT穿透处理。Kamailio负责指挥RTPEngine，告诉它该为哪一路通话创建媒体转发通道。

为什么需要RTPEngine？这是WebRTC在公网环境下的关键。大多数设备都位于路由器或防火墙之后，拥有私有IP地址（如192.168.1.x）。设备A无法直接将媒体流发送到设备B的私有地址。RTPEngine扮演了一个“媒体中继”的角色，它拥有公网IP，两端设备都将媒体流发送给它，再由它转发给对端，从而解决了“看不见对方”的问题。同时，RTPEngine还能在WebRTC使用的SRTP/SRTCP（加密媒体流）和传统SIP电话常用的RTP/RTCP（非加密媒体流）之间进行转换，实现Web端与传统SIP话机等异构终端的互通。

准备工作清单：

• 一台Debian 10服务器：建议拥有一个公网IP地址。如果使用云服务器，请确保安全组/防火墙放行了后续需要用到的端口（如SIP的5060 TCP/UDP，WebSocket的8880，RTP媒体端口范围30000-60000等）。
• 基础工具：确保sudo、vim（或你喜欢的编辑器）、wget、curl已安装。
• MySQL数据库：Kamailio默认使用MySQL存储用户、联系人等信息。我们将使用MariaDB（MySQL的一个流行分支）。

首先，更新系统并安装MariaDB服务器：

sudo apt update
sudo apt upgrade -y
sudo apt install -y mariadb-server mariadb-client

安装完成后，运行安全安装脚本并设置root密码：

sudo mysql_secure_installation

你会被问到一系列问题，通常可以这样选择：

• 设置root密码？ Y
• 移除匿名用户？ Y
• 禁止root远程登录？ Y (通常建议，除非你需要远程管理)
• 移除测试数据库？ Y
• 立即重载权限表？ Y

接下来，我们需要为Kamailio创建一个专用的数据库和用户。登录MySQL：

sudo mysql -u root -p

在MySQL提示符下，执行以下命令：

CREATE DATABASE kamailio CHARACTER SET utf8 COLLATE utf8_general_ci;
CREATE USER 'kamailio'@'localhost' IDENTIFIED BY '你的强密码';
GRANT ALL PRIVILEGES ON kamailio.* TO 'kamailio'@'localhost';
FLUSH PRIVILEGES;
EXIT;

注意：请务必将 你的强密码 替换为一个复杂的密码，并记录下来，后续配置会用到。

2. Kamailio SIP服务器的安装与基础配置

Kamailio是一个功能极其强大的SIP服务器，其配置文件kamailio.cfg的灵活性既是优点也是难点。我们将采用从官方仓库安装的方式，确保获得稳定且兼容的版本。

第一步，添加Kamailio官方仓库并安装：

# 导入仓库GPG密钥
wget -O- http://deb.kamailio.org/kamailiodebkey.gpg | sudo apt-key add -

# 添加仓库源（针对Debian 10 Buster）
echo "deb http://deb.kamailio.org/kamailio55 buster main" | sudo tee /etc/apt/sources.list.d/kamailio.list
echo "deb-src http://deb.kamailio.org/kamailio55 buster main" | sudo tee -a /etc/apt/sources.list.d/kamailio.list

# 更新包列表并安装Kamailio及必要模块
sudo apt update
sudo apt install -y kamailio kamailio-mysql-modules kamailio-websocket-modules kamailio-tls-modules

这里我们安装了四个核心包：

• kamailio: 主程序
• kamailio-mysql-modules: MySQL数据库支持
• kamailio-websocket-modules: WebSocket支持（WebRTC信令必需）
• kamailio-tls-modules: TLS支持（用于WSS，可选但推荐）

第二步，配置数据库连接 (/etc/kamailio/kamctlrc)：

这个文件控制着kamctl管理工具的行为，主要是数据库连接信息。

sudo vim /etc/kamailio/kamctlrc

找到并修改以下关键参数，其他保持默认即可：

# SIP域名，可以是你的公网IP或域名
SIP_DOMAIN=你的公网IP或域名
# 数据库引擎
DBENGINE=MYSQL
# 数据库主机
DBHOST=localhost
# 数据库端口
DBPORT=3306
# 数据库名
DBNAME=kamailio
# 数据库读写用户（我们之前创建的）
DBRWUSER=kamailio
# 数据库读写用户密码
DBRWPW=你的强密码
# 数据库超级用户（用于初始化表结构）
DBROOTUSER=root
DBROOTPW=你的MariaDB root密码
# 数据库字符集
CHARSET="utf8"

保存退出后，使用kamdbctl工具创建Kamailio所需的数据库表结构：

sudo kamdbctl create

这个脚本会询问你使用哪个数据库引擎、root用户密码等，因为我们已经在kamctlrc里配置了，所以它会自动读取并创建所有表。看到 INFO: database tables for Kamailio were created successfully 即表示成功。

第三步，创建测试用户：

现在我们可以用kamctl命令添加一个SIP用户了，例如用户1001，密码123456：

sudo kamctl add 1001 123456

你可以用 sudo kamctl showdb 查看subscriber表，确认用户已添加。

3. 深度定制Kamailio核心配置文件

这是整个搭建过程中最核心也最具挑战性的一步。原始的/etc/kamailio/kamailio.cfg文件超过1500行，包含大量注释和可选功能。我们将对其进行精简和定制，重点关注WebSocket支持和与RTPEngine的集成。

重要提示：在修改前，请务必备份原文件：sudo cp /etc/kamailio/kamailio.cfg /etc/kamailio/kamailio.cfg.bak

我们将采用“定义驱动”的方式。Kamailio的配置文件支持使用 #!define 宏来开启或关闭特定功能。我们首先在文件头部区域（通常在 ####### Defined Values ######### 部分附近）设置我们的核心参数和功能开关。

找到类似以下的行并进行修改和添加：

sudo vim /etc/kamailio/kamailio.cfg

A. 定义网络参数和功能宏：

####### Defined Values #########

#!substdef "!MY_IP_ADDR!你的公网IP地址!g"
#!substdef "!MY_DOMAIN!你的公网IP地址或域名!g"
#!substdef "!MY_WS_PORT!8880!g" # WebSocket监听端口
#!substdef "!MY_WSS_PORT!8443!g" # 安全的WebSocket监听端口（需TLS证书）
#!substdef "!MY_WS_ADDR!tcp:MY_IP_ADDR:MY_WS_PORT!g"
#!substdef "!MY_WSS_ADDR!tls:MY_IP_ADDR:MY_WSS_PORT!g"

# 启用核心功能
#!define WITH_MYSQL
#!define WITH_AUTH          # 启用用户认证
#!define WITH_USRLOCDB      # 将用户位置信息持久化到数据库
#!define WITH_NAT           # 启用NAT穿透支持
#!define WITH_RTPENGINE     # **关键：使用RTPEngine而非旧的RTPProxy**
#!define WITH_WEBSOCKETS    # **关键：启用WebSocket支持**
#!define WITH_DEBUG         # 调试阶段建议开启，生产环境可关闭

# 数据库连接URL，格式为：mysql://用户名:密码@服务器地址/数据库名
#!trydef DBURL "mysql://kamailio:你的强密码@localhost/kamailio"

B. 配置监听端口：

在 ####### Global Parameters ######### 部分的 listen 指令中，确保包含了我们定义的WebSocket地址：

listen=udp:MY_IP_ADDR:5060
listen=tcp:MY_IP_ADDR:5060
#!ifdef WITH_WEBSOCKETS
listen=MY_WS_ADDR
#!endif

这样Kamailio就会在5060端口监听传统的UDP/TCP SIP，同时在8880端口监听WebSocket连接。

C. 加载必要的模块：

在 ####### Modules Section ######## 部分，确保以下模块被加载。Kamailio会根据 #!define 宏自动加载相关模块，但我们可以检查一下关键模块是否存在：

# 确保以下行存在（通常由宏控制自动添加）
loadmodule "websocket.so"
loadmodule "rtpengine.so"
loadmodule "nathelper.so"
loadmodule "auth_db.so"
loadmodule "usrloc.so"

D. 配置模块参数：

这是连接Kamailio和RTPEngine的桥梁，至关重要。

# ----- rtpengine params -----
# 告诉Kamailio RTPEngine的ng控制接口在哪里
modparam("rtpengine", "rtpengine_sock", "udp:127.0.0.1:2223")
# 用于在多个呼叫分支中标识唯一的媒体会话
modparam("rtpengine", "extra_id_pv", "$avp(extra_id)")

# ----- nathelper params -----
# 这些参数帮助Kamailio处理NAT后的客户端
modparam("nathelper", "natping_interval", 30)
modparam("nathelper", "ping_nated_only", 1)
modparam("nathelper|registrar", "received_avp", "$avp(RECEIVED)")
modparam("usrloc", "nat_bflag", 6) # 注意：FLB_NATB的值需要与前面定义的flag对应

E. 修改路由逻辑以集成WebSocket和RTPEngine：

原始配置文件的路由逻辑 request_route 已经相当复杂。我们需要确保它正确处理WebSocket连接和触发RTPEngine管理。关键点在于 route[NATMANAGE] 和新增的 route[BRIDGING]。

我强烈建议在 route[BRIDGING] 部分（如果不存在则添加）和 route[NATMANAGE] 部分，加入详细的日志输出，这在调试时能救命。例如：

route[BRIDGING] {
    xlog("L_INFO", "BRIDGING: proto=$proto, ru=$ru\n");
    if (!has_totag()) {
        if ($proto =~ "ws" && !($ru =~ "transport=ws")) {
            xlog("L_INFO", "需要桥接：WebRTC客户端呼叫传统SIP终端\n");
            setbflag(8); # 设置FLB_RTPWS标志，值需与前面定义一致
        } else if (!($proto =~ "ws") && $ru =~ "transport=ws") {
            xlog("L_INFO", "需要桥接：传统SIP终端呼叫WebRTC客户端\n");
            setbflag(8);
        }
    }
}

在 route[NATMANAGE] 中，找到处理RTPEngine的部分（通常由 #!ifdef WITH_RTPENGINE 包裹），确保它根据我们设置的标志（如FLB_RTPWS）来向RTPEngine发送正确的指令。这部分指令非常关键，它决定了RTPEngine如何处理媒体流（例如，是否进行SRTP到RTP的转换，是否处理ICE等）。

一个典型的 rtpengine_manage 指令可能如下：

if (isbflagset(8)) { # FLB_RTPWS
    if ($proto =~ "ws") {
        # WebRTC to SIP: 移除WebRTC特性，转换为普通RTP
        $xavp(r=>$T_branch_idx) = "replace-origin replace-session-connection ICE=remove RTP/SAVPF";
    } else {
        # SIP to WebRTC: 添加WebRTC特性
        $xavp(r=>$T_branch_idx) = "replace-origin replace-session-connection ICE=force RTP/SAVPF";
    }
}
rtpengine_manage($xavp(r=>$T_branch_idx));

F. 启动与测试：

完成配置后，先检查配置文件语法：

sudo kamailio -c

如果输出 INFO: configuration file successfully parsed，则语法正确。现在启动Kamailio服务：

sudo systemctl start kamailio
sudo systemctl enable kamailio # 设置开机自启
sudo systemctl status kamailio # 查看状态

查看实时日志，监控启动过程和后续的注册、呼叫事件：

sudo tail -f /var/log/syslog | grep kamailio
# 或者如果你配置了单独的日志文件
sudo tail -f /var/log/kamailio.log

此时，你的SIP信令服务器（支持WebSocket）应该已经运行起来了。你可以尝试用支持WebSocket SIP的软电话（如MicroSIP，需在高级设置中启用WS）或者我们后面会写的Flutter测试客户端，用 1001@你的服务器IP:8880 进行注册测试。在日志中看到 REGISTER 成功的消息，就说明信令通道的第一步走通了。

4. RTPEngine的部署与媒体流转发配置

信令通了，接下来要解决媒体流。RTPEngine的安装相比Kamailio要简单一些，但配置同样需要精细调整。我们将使用Sipwise维护的Debian仓库进行安装，这是目前最方便的方式。

第一步，安装RTPEngine：

# 添加Sipwise RTPEngine仓库密钥
wget -O- https://deb.sipwise.com/spce/rtpengine/rtpengine.gpg.key | sudo apt-key add -

# 添加仓库源（针对Debian 10 Buster）
echo "deb https://deb.sipwise.com/spce/rtpengine/ buster main" | sudo tee /etc/apt/sources.list.d/rtpengine.list

# 更新并安装
sudo apt update
sudo apt install -y ngcp-rtpengine-daemon ngcp-rtpengine-iptables ngcp-rtpengine-kernel-dkms

注意：ngcp-rtpengine-kernel-dkms 包会尝试编译内核模块以实现最高性能的“内核转发”模式。如果安装失败或你的服务器不支持DKMS，可以只安装 ngcp-rtpengine-daemon，它将使用纯用户空间的转发模式，性能稍差但兼容性更好。

第二步，配置RTPEngine：

主要配置文件是 /etc/rtpengine/rtpengine.conf。我们需要创建一个适配我们环境的配置。

sudo cp /etc/rtpengine/rtpengine.conf.sample /etc/rtpengine/rtpengine.conf
sudo vim /etc/rtpengine/rtpengine.conf

以下是一个最简化的有效配置，重点关注与Kamailio的对接和公网接口：

[rtpengine]
# 接口绑定：指定RTPEngine在哪个IP地址上监听和发送媒体流。
# 格式：内部接口名/公网IP
# 如果你只有一个公网网卡，通常是 eth0/你的公网IP
interface = eth0/你的公网IP

# 监听Kamailio控制指令的地址和端口（必须与Kamailio配置中的rtpengine_sock一致）
listen-ng = 127.0.0.1:2223

# RTP/RTCP端口范围。确保这个范围在防火墙/安全组中是开放的。
port-min = 30000
port-max = 60000

# 日志级别：6为info，7为debug（调试时有用）
log-level = 6
log-facility = local5

# 转发模式：kernel（内核，高性能）或 userspace（用户空间，兼容性好）
# 如果安装了内核模块且启动成功，默认就是kernel
# forwarding-mode = kernel

# 超时设置（秒）
timeout = 60
silent-timeout = 3600

# 对于WebRTC的支持，确保以下选项开启（通常是默认值）
# 这些选项允许处理DTLS-SRTP、ICE等
dtls-passive = false
ice-demo = false

第三步，处理内核模块与防火墙（关键步骤）：

如果你成功安装了内核模块并希望使用kernel转发模式，RTPEngine需要iptables规则来将收到的RTP包重定向到内核模块。安装包应该提供了一个服务来管理这个，但有时需要手动处理。

检查内核模块是否加载：

lsmod | grep xt_RTPENGINE

如果没有，尝试手动加载并设置iptables规则（假设你的公网网卡是eth0）：

# 加载内核模块
sudo modprobe xt_RTPENGINE

# 添加iptables规则，将目的端口在30000-60000之间的UDP包重定向到RTPEngine
sudo iptables -I INPUT -i eth0 -p udp --dport 30000:60000 -j RTPENGINE --id 0
sudo iptables -I FORWARD -i eth0 -p udp --dport 30000:60000 -j RTPENGINE --id 0

# 为了使规则持久化，安装iptables-persistent
sudo apt install -y iptables-persistent
# 保存当前规则
sudo netfilter-persistent save

第四步，启动RTPEngine并测试：

sudo systemctl start ngcp-rtpengine-daemon
sudo systemctl enable ngcp-rtpengine-daemon
sudo systemctl status ngcp-rtpengine-daemon

查看RTPEngine日志，确认它成功绑定了接口并监听控制端口：

sudo tail -f /var/log/syslog | grep rtpengine
# 或查看指定facility的日志
sudo tail -f /var/log/rtpengine.log

你应该能看到类似 listening on NG 127.0.0.1:2223 和 interface bound to eth0/公网IP 的日志。

第五步，联动测试：

重启Kamailio以使新的RTPEngine配置生效：

sudo systemctl restart kamailio

现在，进行一个完整的测试呼叫。当Kamailio处理一个INVITE请求时，它会在日志中调用rtpengine_manage。如果配置正确，你会在RTPEngine的日志中看到类似 created new session 和 added stream 的条目，这表明媒体通道已被成功创建。

如果RTPEngine没有反应，请检查：

1. Kamailio配置中 rtpengine_sock 的地址端口是否与RTPEngine的 listen-ng 完全一致。
2. Kamailio的 route[NATMANAGE] 逻辑是否被触发（查看Kamailio的info级别日志）。
3. RTPEngine服务是否真的在运行并监听2223端口：sudo ss -ulnp | grep 2223

5. Flutter客户端集成与实战调试

服务器端搭建完毕，最后一步是客户端。我们将使用Flutter的sip_ua库来实现一个基本的SIP注册和呼叫功能。这个库封装了Dart版本的SIP协议栈和WebRTC。

第一步，项目配置与依赖：

在你的Flutter项目的pubspec.yaml中添加依赖：

dependencies:
  flutter:
    sdk: flutter
  sip_ua: ^0.4.0 # 请检查最新版本
  flutter_webrtc: ^0.9.0 # 用于获取摄像头和麦克风权限，处理媒体流
  permission_handler: ^10.0.0 # 权限处理

然后运行 flutter pub get。

第二步，实现一个简单的SIP管理类：

这个类将封装注册、呼叫等核心逻辑。我们创建一个sip_manager.dart文件。

import 'package:sip_ua/sip_ua.dart';
import 'package:flutter_webrtc/flutter_webrtc.dart';

class SipManager {
  late SIPUAHelper _helper;
  RegistrationState? _registrationState;
  Call? _activeCall;
  MediaStream? _localStream;
  RTCVideoRenderer _localRenderer = RTCVideoRenderer();
  RTCVideoRenderer _remoteRenderer = RTCVideoRenderer();

  final String _server = '你的公网IP或域名';
  final String _wsPort = '8880';

  // 初始化WebRTC渲染器
  Future<void> initializeRenderers() async {
    await _localRenderer.initialize();
    await _remoteRenderer.initialize();
  }

  // 初始化SIP UA并注册
  Future<void> register(String username, String password, String displayName) async {
    _helper = SIPUAHelper();

    var settings = UaSettings();
    // WebSocket连接地址，注意是ws://
    settings.webSocketUrl = 'ws://$_server:$_wsPort';
    settings.webSocketSettings.allowBadCertificate = true; // 仅测试用，生产环境应使用WSS和有效证书

    settings.uri = 'sip:$username@$_server';
    settings.authorizationUser = username;
    settings.password = password;
    settings.displayName = displayName;
    settings.userAgent = 'Flutter WebRTC Client';
    settings.dtmfMode = DtmfMode.RFC2833;

    // 设置事件监听器
    _helper.addSipUaHelperListener(SipUaHelperListener(
      registrationStateChanged: _onRegistrationStateChanged,
      callStateChanged: _onCallStateChanged,
      transportStateChanged: _onTransportStateChanged,
      onNewMessage: _onNewMessage,
    ));

    await _helper.start(settings);
  }

  void _onRegistrationStateChanged(RegistrationState state) {
    _registrationState = state;
    print('注册状态变更: ${state.state}');
    // 这里可以通知UI更新，例如使用Provider或Stream
  }

  void _onCallStateChanged(Call call, CallState state) {
    print('呼叫状态变更: ${state.state} - 方向: ${call.direction}');
    
    switch (state.state) {
      case CallStateEnum.CALL_INITIATION:
        // 来电或去电初始化
        _activeCall = call;
        if (call.direction == 'INCOMING') {
          // 弹出接听界面
          _showIncomingCallDialog(call);
        }
        break;
      case CallStateEnum.CONNECTING:
        // 呼叫连接中
        break;
      case CallStateEnum.ACCEPTED:
        // 呼叫被接受
        _handleCallAccepted(state);
        break;
      case CallStateEnum.STREAM:
        // 媒体流就绪
        if (state.originator == 'remote') {
          _remoteRenderer.srcObject = state.stream;
        }
        break;
      case CallStateEnum.ENDED:
      case CallStateEnum.FAILED:
        // 呼叫结束或失败
        _cleanupCall();
        break;
      default:
        break;
    }
  }

  Future<void> makeCall(String target, {bool withVideo = false}) async {
    if (_registrationState?.state != RegistrationStateEnum.REGISTERED) {
      print('未注册，无法呼叫');
      return;
    }
    if (_activeCall != null) {
      print('已有活跃呼叫');
      return;
    }

    // 获取本地媒体流
    final mediaConstraints = <String, dynamic>{
      'audio': true,
      'video': withVideo ? {
        'mandatory': {
          'minWidth': '640',
          'minHeight': '480',
          'minFrameRate': '30',
        },
        'facingMode': 'user',
        'optional': [],
      } : false,
    };

    try {
      _localStream = await navigator.mediaDevices.getUserMedia(mediaConstraints);
      _localRenderer.srcObject = _localStream;
      
      bool success = await _helper.call(target,
          voiceonly: !withVideo, mediaStream: _localStream);
      if (!success) {
        print('发起呼叫失败');
        _localStream?.dispose();
        _localRenderer.srcObject = null;
      }
    } catch (e) {
      print('获取媒体设备失败: $e');
    }
  }

  Future<void> answerCall(Call call) async {
    // 同样需要获取本地流（如果是视频通话）
    final mediaConstraints = <String, dynamic>{'audio': true, 'video': call.remote_has_video};
    _localStream = await navigator.mediaDevices.getUserMedia(mediaConstraints);
    _localRenderer.srcObject = _localStream;
    
    await call.answer(mediaConstraints: mediaConstraints, mediaStream: _localStream);
  }

  void hangup() {
    _activeCall?.hangup();
    _cleanupCall();
  }

  void _handleCallAccepted(CallState state) async {
    // 这里可以开始播放振铃停止音等
    print('通话已连接');
  }

  void _cleanupCall() {
    _activeCall = null;
    _localStream?.dispose();
    _localStream = null;
    _localRenderer.srcObject = null;
    _remoteRenderer.srcObject = null;
  }

  void _showIncomingCallDialog(Call call) {
    // 使用你喜欢的对话框方式，例如showDialog
    // 显示来电者信息，并提供接听/拒接按钮
  }

  // 其他监听器方法...
  void _onTransportStateChanged(TransportState state) {}
  void _onNewMessage(SIPMessageRequest msg) {}

  // 清理资源
  void dispose() {
    _helper.removeSipUaHelperListener(...);
    _helper.stop();
    _localRenderer.dispose();
    _remoteRenderer.dispose();
    _cleanupCall();
  }
}

第三步，在UI中集成：

在Flutter的页面中，初始化SipManager，并提供注册表单和呼叫控制按钮。关键点在于正确处理生命周期（在initState中初始化，在dispose中清理），以及将媒体流的RTCVideoRenderer与Video widget绑定。

// 在StatefulWidget的State中
late SipManager _sipManager;
final RTCVideoRenderer _localRenderer = RTCVideoRenderer();
final RTCVideoRenderer _remoteRenderer = RTCVideoRenderer();

@override
void initState() {
  super.initState();
  _initRenderers();
  _sipManager = SipManager();
}

Future<void> _initRenderers() async {
  await _localRenderer.initialize();
  await _remoteRenderer.initialize();
}

// 在UI中显示视频
Column(
  children: [
    // 本地预览（画中画）
    SizedBox(
      height: 120,
      width: 90,
      child: RTCVideoView(_localRenderer),
    ),
    // 远程视频（全屏）
    Expanded(
      child: RTCVideoView(_remoteRenderer),
    ),
    // 控制按钮行
    Row(
      mainAxisAlignment: MainAxisAlignment.spaceEvenly,
      children: [
        IconButton(onPressed: _makeCall, icon: Icon(Icons.call)),
        IconButton(onPressed: _hangup, icon: Icon(Icons.call_end)),
        IconButton(onPressed: _toggleMute, icon: Icon(Icons.mic_off)),
        IconButton(onPressed: _toggleVideo, icon: Icon(Icons.videocam_off)),
      ],
    )
  ],
)

第四步，实战调试与常见问题：

1. 注册失败：检查Flutter客户端中的webSocketUrl是否正确（ws://IP:8880），检查Kamailio日志看是否收到REGISTER请求，以及认证是否通过。常见错误是数据库密码不对或kamctlrc配置有误。
2. 呼叫无声音/无视频：
   • 首先检查信令：在Kamailio日志中，是否完整走完了INVITE -> 100 Trying -> 180 Ringing -> 200 OK -> ACK的流程？呼叫是否成功建立？
   • 检查RTPEngine：在呼叫建立时，Kamailio日志是否打印了rtpengine_manage的调用？RTPEngine日志是否显示创建了新的session和stream？
   • 检查端口开放：确保服务器防火墙和安全组开放了RTPEngine使用的UDP端口范围（如30000-60000）。可以用tcpdump在服务器上抓包：sudo tcpdump -i eth0 udp portrange 30000-60000 -vv，看是否有RTP包进出。
   • 检查ICE候选：在复杂的NAT环境下（如对称型NAT），STUN服务器可能无法提供有效的公网候选地址。此时，RTPEngine的媒体中继是唯一的解决方案。确保Kamailio正确地将ICE=force或ICE=remove指令传递给了RTPEngine。
3. 一端有声音另一端没有：这通常是单向NAT或防火墙规则导致。确保RTPEngine的interface配置正确绑定到了公网IP，并且服务器本身没有阻止UDP包的iptables规则。
4. Flutter端获取媒体设备失败：确保在AndroidManifest.xml和Info.plist中声明了相机和麦克风权限，并且在运行时通过permission_handler库动态请求。

调试是一个迭代的过程。我的经验是，严格按照日志来。开启Kamailio和RTPEngine的debug级别日志（log-level = 7），从客户端发起一个呼叫，然后一步步追踪信令和媒体控制指令在服务器端的处理流程。每当解决一个问题，你对整个WebRTC通信体系的理解就会加深一层。

这套自建方案给了你完全的控制权，从用户管理、呼叫路由到媒体处理策略都可以深度定制。虽然初始搭建有一定复杂度，但一旦跑通，其稳定性和灵活性是很多黑盒云服务无法比拟的。希望这篇从服务器配置到客户端集成的全栈指南，能帮你扫清障碍，成功搭建起属于自己的实时音视频通信系统。