devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

iOS 基于LinPhone的语音通话_ios. 与服务器语音通话

作者：Monodyee | 2024-02-22 05:35:16

赞

踩

ios. 与服务器语音通话

语音通话涉及到的概念介绍：

VoIP（Voice over Internet Protocol）即首先数字化语音信号并压缩成帧，转换为IP数据包在网络上传输，以此完成语音通话的业务，是一种利用IP协议传输语音数据的通信技术，VoIP通话中媒体流是走的UDP，一旦网络质量不好，语音的质量就会有延时或者断续，但是速度快。

Linphone是一款基于标准SIP的开源VoIP电话工具，是一款遵循GPL的开源的网络电话系统。它能够让你通过internet来查询朋友的IP，并通过IP给他打电话的软件，功能非常强大，既支持桌面系统，也支持移动终端，还能支持WEB浏览器。使用linphone，我们可以在互联网上随意的通信，通过语音、视频、即时文本消息。

Linphone基于ilbc的编解码；ilbc的编解码压缩比率还是比较大的，大概在1/10至1/9之间。也就是说假如每秒20kb的语音数据，编码后就2kb/s，非常小，非常利于网络传输。它使用了一个C库speex, 来实现回声消除模块。Linphone的最大优势在于全平台支持，android，ios，winphone，windows，linux，mac osx，web 全都支持

语音通话开发流程：

1）Cocoapods集成

Cocoapods 需要引入的开源三方库及版本：'linphone-sdk', ‘4.2’   'CocoaAsyncSocket', '7.6.5'

linphone-sdk：用于实际的语音通话功能

CocoaAsyncSocket：用于与后台建立链接，分配网络座席和通话状态改变监听(开通多少个座席要注意，这会涉及到不菲的价格...)

2）后台的简单介绍

因为不是我做的后台，我只能做简要的介绍，我们后台使用的语言是C++，如果不想付出太高的成本，又有比较高的效率, C++无疑是很好的选择。在语音通话过程中，客户端与后台会进行三大类型的交互:

1.向主管账号信息的服务器发送请求交互，获取与第二个服务器进行第二类和第三类交互要使用的数据模型

2.根据第一类与服务器交互获取的数据模型，LinPhoneSDK与服务器进行第二类交互，建立UDP链接，用于语音通话

3.根据第一类与后台交互获取的数据模型，使用客户端基于TCP/IP协议的socket网络库GCDAsyncSocket与后台进行第三类交互，建立链接，保持长链接，用于获取网络坐席和更改通话状态

3）客户端语音通话的各状态搭建分析

1.登录

I. 向主管账号信息的服务器发送请求, 传入对应的URL，账号和密码，使用AES加密(key和偏移量与后台协商一致)，获取接下来要使用的数据模型

  1. //向主管账号信息的服务器发送请求，建立链接，获取接下来要用到的数据模型
  2. YGCallManager *manager = [YGCallManager instance];
  3. [manager initSdk:model success:^(NSDictionary * _Nullable responseObject) {
  4.       NSLog(@"initSdk:%@", responseObject);
  5.       //与socket服务器和LinPhone服务器建立链接
  6.      [[YGCallManager instance] login];
  7.    } failure:^(NSError * _Nullable error) {
  8.       NSLog(@"initSdk:%@", error);
  9. }];

II. LinPhoneSDK与服务器建立第二类交互，建立UDP连接，为语音通话服务

  1. ESSipManager *sipManager = [ESSipManager instance];
  2. [sipManager login:@"你的LoginNum" password:@"你的pwd" displayName:@"" domain:@"你的sipIP:sipPort" port:@"你的sipPort" withTransport:@"UDP"];

III. 当Linphone登录成功，会调用成功的回调，这时socket与服务器建立第三类链接，为开通网络坐席和切换通话状态服务

  1. sipManager.linphoneBlock = ^(NSInteger registrationState) {
  2.    if (self.linphoneRegistrationState != registrationState) {
  3.          self.linphoneRegistrationState = registrationState;
  4.            if (registrationState == 2) {
  5.                //2.socket连接
  6.                self.clientSocket = [[GCDAsyncSocket alloc] initWithDelegate:self delegateQueue:dispatch_get_main_queue()];
  7.                NSError *socketError = nil;
  8.                if (![self.clientSocket connectToHost:self.tcpModel.TransferIP onPort:self.tcpModel.TransferPort withTimeout:-1 error:&socketError]) {
  9.                    if (socketError) {
  10.                        NSLog(@"连接服务器失败:%@", socketError.localizedDescription);
  11.                        return;
  12.                 }
  13.       }

这里说的切换通话状态服务，也就是说接通和挂断等需要让客户端知道，以做到相应的处理，客户端接受状态的变化主要是通过socket的代理来实现

主要功能代码：

  1. - (void)socket:(GCDAsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag {
  2.     //接收登录服务消息
  3.     if ([lastString containsString:@"LOGIN_SUCCEED"]) {
  4.         //向app端推送EventLogin成功消息
  5.         if (self.eventBlock) {
  6.             NSDictionary *dic = @{@"msg":@"登录成功"};
  7.             self.eventBlock(EVENTLogin, YES, dic);
  8.         }
  9.    //通知服务器当前账号的通道已经被占用
  10.         NSData *data4 = [self sendMsgWithName:@"" type:@"" targetType:@"" msg:[NSString stringWithFormat:@"与后台协商好的信令服务"]];
  11.         [self.clientSocket writeData:data4 withTimeout:-1 tag:4];
  12.     }
  13. }

IV. 做登录功能遇到的问题: 在一开始实现登录的时候发现多次登录会经常报用户正忙，无法登录。后来与后台联调，发现单点登录功能(也就是这次登录会把之前的登录踢下去)还不完善，针对socket接口进行了优化升级.流程修改为： 发送准备状态给语音通话的服务器 => 发送初始化消息给分配座席服务器 => 发送清理通道消息给服务器 =》 发送登录消息给服务器

实现功能的部分代码(主要是发送与后台协商好的socket)：

  1. //登录
  2. - (void)ygTcpLogin {
  3.     //发送准备状态给服务器
  4.     NSData *data = [self sendMsgWithName:@"" type:@"" targetType:@"" msg:@"与后台约定好的信令服务"];
  5.     [self.clientSocket writeData:data withTimeout:-1 tag:0];
  6.     //发送初始化消息给转发服务器
  7.     NSData *data1 = [self sendMsgWithName:@"" type:@"" targetType:@"" msg:@"与后台约定好的信令服务"];
  8.     [self.clientSocket writeData:data1 withTimeout:-1 tag:1];
  9.     //发送清理通道消息给服务器
  10.     NSData *data2 = [self sendMsgWithName:@"" type:@"" targetType:@"" msg:@"与后台约定好的信令服务"];
  11.     [self.clientSocket writeData:data2 withTimeout:-1 tag:2];
  12.     //发送登录消息给服务器
  13.     NSData *data3 = [self sendMsgWithName:@"" type:@"" targetType:@"" msg:@"与后台约定好的信令服务"];
  14.     [self.clientSocket writeData:data3 withTimeout:-1 tag:3];
  15. }

V.  做登陆功能遇到的问题2: iOS16以上的版本Linphone与语音通话后台无法建立链接，原因是端口存在被占用的可能。解决方式是每次链接时，给LinPhone分配未被占用的随机端口

实现的功能的部分代码：

  1.     [LinphoneManager.instance resetLinphoneCore];
  2.  
  3.     LinphoneProxyConfig *config = linphone_core_create_proxy_config(LC);
  4.     LinphoneAddress *addr = linphone_address_new([NSString stringWithFormat:@"sip:%@@%@",username, domain].UTF8String);
  5.     LinphoneAddress *tmpAddr = linphone_address_new([NSString stringWithFormat:@"sip:%@",domain].UTF8String);
  6.     linphone_address_set_username(addr, username.UTF8String);
  7.     linphone_address_set_port(addr, linphone_address_get_port(tmpAddr));
  8.     linphone_address_set_domain(addr, linphone_address_get_domain(tmpAddr));
  9.     if (displayName && ![displayName isEqualToString:@""]) {
  10.         linphone_address_set_display_name(addr, displayName.UTF8String);
  11.     }
  12.     linphone_proxy_config_set_identity_address(config, addr);
  13.     if (transport) {
  14.         linphone_proxy_config_set_route(
  15.                                         config,
  16.                                         [NSString stringWithFormat:@"%s;transport=%s", domain.UTF8String, transport.lowercaseString.UTF8String]
  17.                                         .UTF8String);
  18.         linphone_proxy_config_set_server_addr(
  19.                                               config,
  20.                                               [NSString stringWithFormat:@"%s;transport=%s", domain.UTF8String, transport.lowercaseString.UTF8String]
  21.                                               .UTF8String);
  22.     }
  23.     
  24.     linphone_proxy_config_enable_publish(config, FALSE);
  25.     linphone_proxy_config_enable_register(config, TRUE);
  26.     
  27.     LinphoneAuthInfo *info =
  28.     linphone_auth_info_new(linphone_address_get_username(addr), // username
  29.                            NULL,                                // user id
  30.                            password.UTF8String,                        // passwd
  31.                            NULL,                                // ha1
  32.                            linphone_address_get_domain(addr),   // realm - assumed to be domain
  33.                            linphone_address_get_domain(addr)    // domain
  34.                            );
  35.     linphone_core_add_auth_info(LC, info);
  36.     linphone_address_unref(addr);
  37.     linphone_address_unref(tmpAddr);
  38.     //分配随机端口
  39.     LCSipTransports transportValue = {-1,-1,-1,-1};
  40.     
  41.     if (linphone_core_set_sip_transports(LC, &transportValue)) {
  42.         NSLog(@"cannot set transport");
  43.     }

2.外呼

I. 外呼功能流程：客户端拨打 => 通知服务器将当前账号置于繁忙状态并分配座席 => 客户端收到转座席是否成功的socket回调并做相应的处理， 同时服务器(语音后台)发送虚拟号码和被呼叫的号码等相关信息给Lin Phone，通知Linphone拨打网络电话 

实现外呼功能的部分代码(客户端主要是把自己和被呼叫者的信息发给后台，LinPhone拨打电话实际是由后台触发的)：

  1. //当前账号置为繁忙
  2. NSData *data8 = [self sendMsgWithName:@"" type:@"" targetType:@"" msg:@"繁忙信令"];
  3. [self.clientSocket writeData:data8 withTimeout:-1 tag:8];
  4.  
  5. //分配座席，并建立语音通话链接
  6. NSData *data9 = [self sendMsgWithName:@"" type:@"" targetType:@"" msg:@"座席建立链接信令"];
  7. [self.clientSocket writeData:data9 withTimeout:-1 tag:9];

II.外呼动作完成后，就需要等待被呼叫者，看其是否接听，这就需要监听通话状态的改变，这里是由LinPhone提供的状态变化的宏来实现的，我们需要对这个后果进行通知监听，一旦监听到状态变化，调用LinPhone相关的API来进行接听或挂断。

实现功能的部分代码：

  1. //监听通话状态变化
  2. [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(onCallUpdate:) name:kLinphoneCallUpdate object:nil];
  3.  
  4. - (void) onCallUpdate: (NSNotification*) notification {
  5.     NSDictionary* userInfo = [notification userInfo];
  6.     NSValue* c = [userInfo valueForKey:@"call"];
  7.     //    int state = (int)[userInfo valueForKey:@"state"];
  8.     LinphoneCallState state = [[userInfo objectForKey:@"state"] intValue];
  9.     NSString* message = [userInfo valueForKey:@"message"];
  10.     NSLog(@"========== state: %d, message: %@", state, message);
  11.     LinphoneCall* call = c.pointerValue;
  12.     
  13.     NSDictionary *dict = @{@"call" : [NSValue valueWithPointer:call],
  14.                            @"state" : [NSNumber numberWithInt:state],
  15.                            @"message" : message};
  16.     
  17.     switch (state) {
  18.         //接听
  19.         case LinphoneCallIncomingReceived: {
  20.             [NSNotificationCenter.defaultCenter postNotificationName:ES_ON_CALL_COMMING object: self userInfo:dict];
  21.             if (self.callBlock) {
  22.                 self.callBlock((NSInteger)state, dict);
  23.             }
  24.             break;
  25.         }
  26.             case LinphoneCallOutgoingInit:
  27.             case LinphoneCallConnected:
  28.             case LinphoneCallStreamsRunning: {
  29.                 // check video
  30.                 if (![self isVideoEnabled:call]) {
  31.                     const LinphoneCallParams *param = linphone_call_get_current_params(call);
  32.                     const LinphoneCallAppData *callAppData =
  33.                     (__bridge const LinphoneCallAppData *)(linphone_call_get_user_data(call));
  34.                     if (state == LinphoneCallStreamsRunning && callAppData->videoRequested &&
  35.                         linphone_call_params_low_bandwidth_enabled(param)) {
  36.                         // too bad video was not enabled because low bandwidth
  37.                         
  38.                         NSLog(@"带宽太低，无法开启视频通话");
  39.                         
  40.                         callAppData->videoRequested = FALSE; /*reset field*/
  41.                     }
  42.                 }
  43.                 [NSNotificationCenter.defaultCenter postNotificationName:ES_ON_CALL_STREAM_UPDATE object:self userInfo:dict];
  44.                 break;
  45.             }
  46.             case LinphoneCallUpdatedByRemote: {
  47.                 const LinphoneCallParams *current = linphone_call_get_current_params(call);
  48.                 const LinphoneCallParams *remote = linphone_call_get_remote_params(call);
  49.                 
  50.                 /* remote wants to add video */
  51.                 if ((linphone_core_video_display_enabled([LinphoneManager getLc]) && !linphone_call_params_video_enabled(current) &&
  52.                      linphone_call_params_video_enabled(remote)) &&
  53.                     (!linphone_core_get_video_policy([LinphoneManager getLc])->automatically_accept ||
  54.                      (([UIApplication sharedApplication].applicationState != UIApplicationStateActive) &&
  55.                       floor(NSFoundationVersionNumber) > NSFoundationVersionNumber_iOS_9_x_Max))) {
  56.                          linphone_core_defer_call_update([LinphoneManager getLc], call);
  57.                          
  58.                          
  59.                          [NSNotificationCenter.defaultCenter postNotificationName:ES_ON_REMOTE_OPEN_CEMERA object: self userInfo:dict];
  60.                          
  61.                          //                     [self allowToOpenCameraByRemote:call];
  62.                          
  63.                      } else if (linphone_call_params_video_enabled(current) && !linphone_call_params_video_enabled(remote)) {
  64.                          
  65.                      }
  66.                 break;
  67.             }
  68.             case LinphoneCallUpdating:
  69.             break;
  70.             case LinphoneCallPausing:
  71.             case LinphoneCallPaused:
  72.             break;
  73.             case LinphoneCallPausedByRemote:
  74.             break;
  75.         //挂断
  76.         case LinphoneCallEnd: {//LinphoneCallEnd
  77.             [NSNotificationCenter.defaultCenter postNotificationName:ES_ON_CALL_END object: self userInfo:NULL];
  78.             if (self.callBlock) {
  79.                 self.callBlock((NSInteger)state, dict);
  80.             }
  81.             break;
  82.         }
  83.         case LinphoneCallReleased: {
  84.             if (self.callBlock) {
  85.                 self.callBlock((NSInteger)state, dict);
  86.             }
  87.             break;
  88.         }
  89.         case LinphoneCallError:
  90.         default:
  91.             break;
  92.     }
  93. }

当触发callBlock后，就会调用LinPhone相应的接听的方法：

  1. - (void)acceptCall:(LinphoneCall *)call evenWithVideo:(BOOL)video {
  2. 	LinphoneCallParams *lcallParams = linphone_core_create_call_params(theLinphoneCore, call);
  3. 	if (!lcallParams) {
  4. 		LOGW(@"Could not create call parameters for %p, call has probably already ended.", call);
  5. 		return;
  6. 	}
  7.  
  8. 	if ([self lpConfigBoolForKey:@"edge_opt_preference"]) {
  9. 		bool low_bandwidth = self.network == network_2g;
  10. 		if (low_bandwidth) {
  11. 			LOGI(@"Low bandwidth mode");
  12. 		}
  13. 		linphone_call_params_enable_low_bandwidth(lcallParams, low_bandwidth);
  14. 	}
  15. 	linphone_call_params_enable_video(lcallParams, video);
  16.  
  17. 	linphone_call_accept_with_params(call, lcallParams);
  18.     linphone_call_params_unref(lcallParams);
  19. }

此时，一个呼叫-接听的流程就已经建立，接下来就要说到挂断了，因为有接听，必然就有挂断

3.挂断

挂断分为两类，一类是己方主动挂断，另一类是对方挂断，这是两种不同的处理方式

I. 己方挂断

流程: 己方点击挂断 => 通知后台己方挂断，即将执行挂断流程 => 通知LinPhone执行挂断 => LinPhone执行挂断后通知语音服务器执行挂断处理 => 语音服务器通知与socket进行长链接的服务器进行挂断处理 => 与socket进行长链接的服务器会给客户端回调，设置完全通话结束socket信令给socket服务器，并设置己方处于空闲状态 => 语音服务器会给Linphone发送通话完全结束，Linphone清理本次通话数据并通知客户端，进行本地通话数据清理

开始通知后台执行己方挂断，并且通知Linphone结束通话的部分代码：

  1.  NSData *data20 = [self sendMsgWithName:self.tcpModel.PhoneNo type:@"" targetType:@"" msg:[NSString stringWithFormat:@"开始结束通话信令服务"];
  2.  
  3.   LinphoneCore* lc = [LinphoneManager getLc];
  4.     LinphoneCall* currentcall = linphone_core_get_current_call(lc);
  5.     if (linphone_core_is_in_conference(lc) || // In conference
  6.         (linphone_core_get_conference_size(lc) > 0) // Only one conf
  7.         ) {
  8.         linphone_core_terminate_conference(lc);
  9.     } else if(currentcall != NULL) { // In a call
  10. //        linphone_core_terminate_call(lc, currentcall);
  11.         linphone_call_terminate(currentcall);
  12.     } else {
  13.         const MSList* calls = linphone_core_get_calls(lc);
  14.         if (ms_list_size(calls) == 1) { // Only one call
  15. //            linphone_core_terminate_call(lc,(LinphoneCall*)(calls->data));
  16.             linphone_call_terminate((LinphoneCall *)(calls->data));
  17.         }
  18.     }

后台收到结束通话信令，并且通知客户端传送结束的socket信息，客户端向后台发送己方置为空闲的部分代码:

  1. //设置话后
  2.         NSData *data11 = [self sendMsgWithName:@"" type:@"" targetType:@"FlyCcs" msg:[NSString stringWithFormat:@"话后信令"]];
  3.         [self.clientSocket writeData:data11 withTimeout:-1 tag:11];
  4.      //设置话后提交
  5.         NSData *data12 = [self sendMsgWithName:@"" type:@"" targetType:@"FlyCcs" msg:[NSString stringWithFormat:@"话后提交信令"]];
  6.         [self.clientSocket writeData:data12 withTimeout:-1 tag:12];
  7.     //空闲
  8.         NSData *data19 = [self sendMsgWithName:self.tcpModel.PhoneNo type:@"FlyCcs" targetType:@"FlyCcs" msg:[NSString stringWithFormat:@"空闲信令"]];
  9.         [self.clientSocket writeData:data19 withTimeout:-1 tag:19];

LinPhone发送彻底消除通话的通知，客户端执行本地通话的数据清理的部分代码：

  1. case LinphoneCallReleased: {
  2.             if (self.callBlock) {
  3.                 self.callBlock((NSInteger)state, dict);
  4.             }
  5.             break;
  6.  }
  7.  
  8.  
  9. sipManager.callBlock = ^(NSInteger callState, NSDictionary *dict) {
  10.         if (self->_ISDIALOUT == 0) {
  11.             return;
  12.         }
  13.         if (callState == 1) {
  14.             NSLog(@"接听--callState == 1");
  15.             LinphoneCall *call = [dict[@"call"] pointerValue];
  16.             [weakManager acceptCall:(ESCall *)call];
  17.         } else if (callState == 18) {
  18.             NSLog(@"挂断--callState == 18");
  19.             //向app端推送EventHangup
  20. //            if (self.eventBlock) {
  21. //                NSDictionary *dic = @{@"CallId":@"",
  22. //                                      @"CallTime":@"",
  23. //                                      @"CodeCause":@"",
  24. //                                      @"ConnectTime":@"",
  25. //                                      @"EndTime":@"",
  26. //                                      @"Rebark":self.Rebark ? self.Rebark : @"",
  27. //                                      @"SignalIng":@"",
  28. //                                      @"WavFile":self.WavFile ? self.WavFile : @""
  29. //                };
  30. //                self.eventBlock(EVENTHangup, YES, dic);
  31. //            }
  32.             //清空本地数据
  33.             self->_callModel = nil;
  34.             self->_CallId = nil;
  35.             self->_ConnectTime = nil;
  36.             self->_Rebark = nil;
  37.             self->_WavFile = nil;
  38.             self->_ISDIALOUT = 10;
  39.    }

II. 对方挂断 

流程；对方挂断 => LinPhone通知客户端挂断 => LinPhone通知服务器通话挂断 => 服务器通知客户端发动结束通话，置为空闲的信令 => 服务器通知LinPhone消除本次通话数据 => LinPhone通知客户端消除本次通话数据

实现功能的关键代码与己方挂断代码是相同的，所以就不列举了

4.来电

流程: LinPhone收到来电通知 => 通知服务器和客户端回调收到来电 => 服务器通过socket代理通知客户端来电和相关来电消息 => 客户端发送繁忙信令和转发分配座席信令 =>通话信道建立完毕

实现功能的部分代码(与上面重复的部分省略)：

  1.  
  2. //繁忙信令
  3. NSData *data13 = [self sendMsgWithName:@"" type:@"" targetType:@"" msg:[NSString stringWithFormat:@"当前账号置为繁忙的信令"]]; //与data10一样;
  4.         [self.clientSocket writeData:data13 withTimeout:-1 tag:13];
  5.  
  6. //分配座席信令        
  7. NSData *data14 = [self sendMsgWithName:@"" type:@"" targetType:@"FlyCn" msg:[NSString stringWithFormat:@"转发分配座席的信令"]; //与data10一样
  8.         [self.clientSocket writeData:data14 withTimeout:-1 tag:14];

4.接听

 实现主要功能的部分代码:

  1. LinphoneCallParams *lcallParams = linphone_core_create_call_params(theLinphoneCore, call);
  2. 	if (!lcallParams) {
  3. 		LOGW(@"Could not create call parameters for %p, call has probably already ended.", call);
  4. 		return;
  5. 	}
  6.  
  7. 	if ([self lpConfigBoolForKey:@"edge_opt_preference"]) {
  8. 		bool low_bandwidth = self.network == network_2g;
  9. 		if (low_bandwidth) {
  10. 			LOGI(@"Low bandwidth mode");
  11. 		}
  12. 		linphone_call_params_enable_low_bandwidth(lcallParams, low_bandwidth);
  13. 	}
  14. 	linphone_call_params_enable_video(lcallParams, video);
  15.  
  16. 	linphone_call_accept_with_params(call, lcallParams);
  17.     linphone_call_params_unref(lcallParams);

听筒/扬声器切换 静音切换 保持通话

还有就是一些比较细小的功能，比如听筒/扬声器切换，静音切换

  1. //听筒/扬声器切换
  2. - (void)speakerToggle {
  3.     //true:开启扬声器； false:关闭扬声器
  4.     [LinphoneManager.instance setSpeakerEnabled:self->speaker];
  5.     self->speaker = !self->speaker;
  6. }
  7.  
  8. //静音切换
  9. - (void)muteToggle {
  10.     //true:开启静音； false:关闭静音
  11.     linphone_core_enable_mic(LC, self->mute);
  12.     self->mute = !self->mute;
  13. }

还有就是先忙其他事，保持当前通话，对方听不到声音：

流程：客户端向服务器发送保持当前通话信令 => 客户端向服务器发送保持繁忙状态信令 => 语音服务区通知LinPhone进入保持当前通话状态

  1. //保持
  2. - (void)holdCall {
  3.     NSData *data30 = [self sendMsgWithName:@"" type:@"" targetType:@"" msg:[NSString stringWithFormat:@"保持通话信令"];
  4.     [self.clientSocket writeData:data30 withTimeout:-1 tag:30];
  5.     
  6.     NSData *data31 = [self sendMsgWithName:@"" type:@"" targetType:@"" msg:[NSString stringWithFormat:@"保持繁忙状态信令"];
  7.     [self.clientSocket writeData:data31 withTimeout:-1 tag:31];
  8.     
  9.     //向app端推送状态事件EventAgentState
  10.     if (self.eventBlock) {
  11.  
  12.     }
  13.     
  14.     self.flag = ([self.flag isEqualToString:@"HOLDCALL"]) ? @"REHOLDCALL" : @"HOLDCALL";
  15. }

语音通话后台保活的实现

 通话过程中的保活已经由LinPhone底层实现，但是没有通话还处于后台模式，怎么保活来保证收到来电和播放响铃呢，这里的响铃不是微信里的通知短暂响铃，而是长时间的响铃，我这边的实现方式主要是基于播放无声音乐

I. LinPhone给客户端状态回调，通知来电，在来电的回调里调用播放长时间响铃 ，挂断电话时，在回调里通知挂断，然后结束播放铃声

  1. manager.eventBlock = ^(EVENT event, BOOL result, NSDictionary * _Nonnull resultMsg) {
  2.         switch (event) {
  3.             case EVENTAgentState: {
  4.                 //状态变化事件，下一行注释均为回调具体参数
  5.                 [[NSNotificationCenter defaultCenter] postNotificationName:kEVENTAgentState object:nil userInfo:resultMsg];
  6.             }
  7.                 break;
  8.             case EVENTLogin: {
  9.                 //登录成功事件
  10.                 if (result) {
  11.                     ViewController *vc = [[ViewController alloc] init];
  12.                     [self.navigationController pushViewController:vc animated:YES];
  13.                 } else {
  14.                     sender.enabled = YES;
  15.                     [self alertWithMessage:@"登录失败，请重新登录"];
  16.                 }
  17.             }
  18.                 break;
  19.             case EVENTQuitLogin: {
  20.                 //退出登录或工号异处登录事件
  21.                 [[NSNotificationCenter defaultCenter] postNotificationName:kEVENTQuitLogin object:nil userInfo:resultMsg];
  22.             }
  23.                 break;
  24.             case EVENTMakeCall: {
  25.                 //外呼事件
  26.             }
  27.                 break;
  28.             case EVENTComeCall: {
  29.                 //来电事件
  30.                 [[NSNotificationCenter defaultCenter] postNotificationName:kComeCallUpdate object:nil userInfo:resultMsg];
  31.                 AVAudioSession *audioSession = [AVAudioSession sharedInstance];
  32.                 // 设置多声道播放
  33.                 NSError *error = nil;
  34.                 [audioSession setCategory:AVAudioSessionCategoryMultiRoute withOptions:AVAudioSessionCategoryOptionMixWithOthers error:&error];
  35.                 [[ZSAVPlayerInstance sharedInstance] start];
  36.             }
  37.                 break;
  38.             case EVENTCalling: {
  39.                 //通话中事件
  40.                 [[ZSAVPlayerInstance sharedInstance] stop];
  41.                 AVAudioSession *audioSession = [AVAudioSession sharedInstance];
  42.                 // 设置后台播放
  43.                 NSError *error = nil;
  44.                 [audioSession setCategory:AVAudioSessionCategoryPlayAndRecord withOptions:AVAudioSessionCategoryOptionMixWithOthers error:&error];
  45.             }
  46.                 break;
  47.             case EVENTHangup: {
  48.                 //挂机事件
  49.                 [[NSNotificationCenter defaultCenter] postNotificationName:kEVENTHangup object:nil userInfo:resultMsg];
  50.                 [[ZSAVPlayerInstance sharedInstance] stop];
  51.                 AVAudioSession *audioSession = [AVAudioSession sharedInstance];
  52.                 // 设置后台播放
  53.                 NSError *error = nil;
  54.                 [audioSession setCategory:AVAudioSessionCategoryPlayback withOptions:AVAudioSessionCategoryOptionMixWithOthers error:&error];
  55.             }
  56.                 break;
  57.             default:
  58.                 break;
  59.         }
  60.         [resultMsg enumerateKeysAndObjectsUsingBlock:^(id key,id obj, BOOL *stop) {
  61.              NSLog(@"event:%d key:%@ value:%@", (int)event, key, obj);
  62.           }];
  63.     };

II.问题：

在这个过程中，遇到的问题是后台保活音乐和铃声播放存在冲突，后台保活音乐要设置AVAudioSession为AVAudioSessionCategoryPlayback后台播放模式，铃声在这种模式下无法播放，播放铃声要设置为AVAudioSessionCategoryMultiRoute多声道模式, 等到接听铃声播放结束再设置为AVAudioSessionCategoryPlayback后台播放模式，

播放器部分代码：

  1. static ZSAVPlayerInstance *instance;
  2. static dispatch_once_t onceToken;
  3. + (instancetype)sharedInstance {
  4.     dispatch_once(&onceToken, ^{
  5.         instance = [ZSAVPlayerInstance new];
  6.     });
  7.     return instance;
  8. }
  9.  
  10.  
  11. - (void)setup {
  12.     [self setupAudioSession];
  13.     [self setupAudioPlayer];
  14. }
  15.  
  16. - (void)setupAudioSession {
  17.     // 新建AudioSession会话
  18.     AVAudioSession *audioSession = [AVAudioSession sharedInstance];
  19.     // 设置多声道混合播放
  20.     NSError *error = nil;
  21.     [audioSession setCategory:AVAudioSessionCategoryMultiRoute withOptions:AVAudioSessionCategoryOptionMixWithOthers error:&error];
  22.     if (error) {
  23.         NSLog(@"Error setCategory AVAudioSession: %@", error);
  24.     }
  25.     NSLog(@"%d", audioSession.isOtherAudioPlaying);
  26.     NSError *activeSetError = nil;
  27.     // 启动AudioSession，如果一个前台app正在播放音频则可能会启动失败
  28.     [audioSession setActive:YES error:&activeSetError];
  29.     if (activeSetError) {
  30.         NSLog(@"Error activating AVAudioSession: %@", activeSetError);
  31.     }
  32. }
  33.  
  34. - (void)setupAudioPlayer {
  35.     //铃声文件
  36.     self.audioPlayer = [[AVAudioPlayer alloc] initWithContentsOfURL:[[NSBundle mainBundle] URLForResource:@"notes_of_the_optimistic" withExtension:@"caf"] error:nil];
  37.     //音量
  38.     self.audioPlayer.volume = 1.0;
  39.     //播放多次
  40.     self.audioPlayer.numberOfLoops = -1;
  41.     [self.audioPlayer prepareToPlay];
  42. }
  43.  
  44. #pragma mark - public method
  45.  
  46. - (void)start {
  47.     NSLog(@"--ringUrl:%@", self.ringUrl.absoluteString);
  48.     [self setupAudioSession];
  49.     [self setupAudioPlayer];
  50.     if (!self.audioPlayer.isPlaying) {
  51.         [self.audioPlayer play];
  52.     }
  53. }
  54.  
  55. - (void)stop {
  56.     [self.audioPlayer stop];
  57. }

结语

语音通话的主要知识点就是这些，还有一些其他的就需要结合具体业务流程就不方便说了，视频通话也可以使用LinPhone，有时间再写吧，感觉有帮助的话给个star吧!

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/128734
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号