### ARCallPlus 簡介
ARCallPlus 是 anyRTC 開源的音視訊通話專案，同時支援iOS、Android、Web等平臺。本文主要介紹音視訊通話 ARUICalling 模組 iOS 本地庫的封裝。

#### 原始碼下載

三行程式碼、二十分鐘應用內構建，實現音視訊通話。本專案已上架App Store，歡迎下載體驗。

- [GitHub 開源地址](https://github.com/anyRTC-UseCase/ARCallPlus)
- [App Store 下載地址](https://apps.apple.com/cn/app/arcallplus/id1613852992)

### 開發環境

- 開發工具：Xcode13 真機執行

- 開發語言：Objective-C、Swift

### 專案結構

![arcallplus_structure](https://img-blog.csdnimg.cn/c8866ae4dea64e2aac825f50eb4bb9e8.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5L2Z55Sf5Li2OTE=,size_20,color_FFFFFF,t_70,g_se,x_16)

**核心 API:**
- ARUILogin（登入 API）
- ARUICalling（通話 API）
- ARUICallingListerner（通話回撥）

**內部核心 API:**

- ARTCCalling（音影片）
- ARTCCallingDelegate（音影片回撥）
- ARTCCalling+Signal（實時訊息）

### 核心 API 和回撥

```
@interface ARUICalling : NSObject

+ (instancetype)shareInstance;

/// 通話介面
/// @param users 使用者資訊
/// @param type 呼叫型別：影片/語音
- (void)call:(NSArray<arcalluser> *)users type:(ARUICallingType)type;

/// 通話回撥
/// @param listener 回撥
- (void)setCallingListener:(id<aruicallinglisterner>)listener;

/// 設定鈴聲，建議在30s以內，只支援本地音訊檔案
/// @param filePath 音訊檔案路徑
- (void)setCallingBell:(NSString *)filePath;

/// 開啟靜音模式（預設關）
- (void)enableMuteMode:(BOOL)enable;

/// 開啟自定義路由（預設關）
/// @param enable 開啟後，在onStart回撥中，會收到對應的ViewController物件，可以自行決定檢視展示方式
- (void)enableCustomViewRoute:(BOOL)enable;

@end

@protocol ARUICallingListerner <nsobject>

// 收到呼叫時，先透過此方法詢問是否可以喚起被叫UI.
// 返回為true，直接喚起UI。返回為false，內部返回忙線
// 不實現預設直接可以喚起UI
- (BOOL)shouldShowOnCallView NS_SWIFT_NAME(shouldShowOnCallView());

/// 呼叫開始回撥。主叫、被叫均會觸發；
/// 被叫觸發時，會將控制器透過監聽回撥出來，由接入方決定顯示方案。
/// @param userIDs 本次通話使用者id（自己除外）
/// @param type 通話型別:影片\音訊
/// @param role 通話角色:主叫\被叫
/// @param viewController 提供Calling功能頁面給呼叫方，可以讓使用者在此基礎上自定義
- (void)callStart:(NSArray<nsstring> *)userIDs type:(ARUICallingType)type role:(ARUICallingRole)role viewController:(UIViewController * _Nullable)viewController NS_SWIFT_NAME(callStart(userIDs:type:role:viewController:));

/// 通話結束回撥
/// @param userIDs 本次通話使用者id（自己除外）
/// @param type 通話型別:影片\音訊
/// @param role 通話角色:主叫\被叫
/// @param totalTime 通話時長
- (void)callEnd:(NSArray<nsstring> *)userIDs type:(ARUICallingType)type role:(ARUICallingRole)role totalTime:(float)totalTime NS_SWIFT_NAME(callEnd(userIDs:type:role:totalTime:));

/// 通話事件回撥
/// @param event 回撥事件型別
/// @param type 通話型別:影片\音訊
/// @param role 通話角色:主叫\被叫
/// @param message 事件
- (void)onCallEvent:(ARUICallingEvent)event type:(ARUICallingType)type role:(ARUICallingRole)role message:(NSString *)message NS_SWIFT_NAME(onCallEvent(event:type:role:message:));

/// 推送事件回撥
/// @param userIDs 不線上的使用者id
/// @param type 通話型別:影片\音訊
- (void)onPushToOfflineUser:(NSArray<nsstring> *)userIDs type:(ARUICallingType)type;

@end
```

### 示例程式碼

##### 效果展示（點對點音訊通話）
![arcallplus_audio](https://img-blog.csdnimg.cn/93a34e38c23d4329aa15c320f82094d1.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5L2Z55Sf5Li2OTE=,size_20,color_FFFFFF,t_70,g_se,x_16)

##### 程式碼實現

```
- (ARtcEngineKit *)rtcEngine {
    if (!_rtcEngine) {
        /// 例項化音影片引擎物件
        _rtcEngine = [ARtcEngineKit sharedEngineWithAppId:[ARUILogin getSdkAppID] delegate:self];
        /// 直播模式
        [_rtcEngine setChannelProfile: ARChannelProfileLiveBroadcasting];
        [_rtcEngine setClientRole: ARClientRoleBroadcaster];
        /// 編碼配置
        ARVideoEncoderConfiguration *configuration = [[ARVideoEncoderConfiguration alloc] init];
        configuration.dimensions = CGSizeMake(960, 540);
        configuration.frameRate = 15;
        configuration.bitrate = 500;
        [_rtcEngine setVideoEncoderConfiguration:configuration];
        /// 啟用說話者音量提示
        [_rtcEngine enableAudioVolumeIndication:2000 smooth:3 report_vad: YES];
        /// 開啟美顏
        [_rtcEngine setBeautyEffectOptions:YES options:[[ARBeautyOptions alloc]init]];
    }
    return _rtcEngine;
}

//MARK: - Publish Method

- (void)call:(NSArray *)userIDs type:(CallType)type {
    /// 發起通話
    if (!self.isOnCalling) {
        self.curLastModel.inviter = [ARUILogin getUserID];
        self.curLastModel.action = CallAction_Call;
        self.curLastModel.calltype = type;
        self.curRoomID = [NSString stringWithFormat:@"%d", [ARTCCallingUtils generateRoomID]];
        self.isMembers = userIDs.count >= 2 ? YES : NO;
        self.calleeUserIDs = [@[] mutableCopy];
        
        self.curType = type;
        self.isOnCalling = YES;
        self.isBeingCalled = NO;
        [self joinRoom];
        [self createMemberChannel];
    }
    
    // 如果不在當前邀請列表，則新增
    NSMutableArray *newInviteList = [NSMutableArray array];
    for (NSString *userID in userIDs) {
        if (![self.curInvitingList containsObject:userID]) {
            [newInviteList addObject:userID];
        }
    }
    
    [self.curInvitingList addObjectsFromArray:newInviteList];
    [self.calleeUserIDs addObjectsFromArray:newInviteList];
    
    if (!(self.curInvitingList && self.curInvitingList.count > 0)) return;
    self.currentCallingUserID = newInviteList.firstObject;
    for (NSString *userID in self.curInvitingList) {
        [self invite:userID action:CallAction_Call];
    }
}

- (void)accept:(BOOL)isVideo {
    /// 接受當前通話
    ARLog(@"Calling - accept Call");
    if (!isVideo) {
        [self.rtcEngine disableVideo];
        self.curType = CallType_Audio;
        if ([self canDelegateRespondMethod:@selector(onSwitchToAudio:message:)]) {
            [self.delegate onSwitchToAudio:YES message:@""];
        }
    }
    
    [self joinRoom];
    self.currentCallingUserID = self.curSponsorForMe;
    [self invite:self.curSponsorForMe action:CallAction_Accept];
    self.isCallSucess = YES;
    [self dealWithException:10];
}

- (void)reject {
    /// 拒絕當前通話
    ARLog(@"Calling - reject Call");
    [self invite:self.curSponsorForMe action:CallAction_Reject];
    self.isOnCalling = NO;
    [self.rtcEngine disableVideo];
}

- (void)hangup {
    /// 主動結束通話通話
    __block BOOL hasCallUser = NO;
    [self.curRoomList enumerateObjectsUsingBlock:^(NSString *user, NSUInteger idx, BOOL * _Nonnull stop) {
        if ((user && user.length > 0) && ![self.curInvitingList containsObject:user]) {
            // 還有正在通話的使用者
            hasCallUser = YES;
            [self invite:user action:CallAction_End];
            *stop = YES;
        }
    }];
    
    /// 主叫需要取消未接通的通話
    if (hasCallUser == NO) {
        ARLog(@"Calling - GroupHangup Send CallAction_Cancel");
        [self.curInvitingList enumerateObjectsUsingBlock:^(NSString *invitedId, NSUInteger idx, BOOL * _Nonnull stop) {
            [self invite:invitedId action:CallAction_Cancel];
        }];
    }

[self leaveRoom];
    self.isOnCalling = NO;
}

- (void)switchToAudio {
    /// 切換到語音通話（通話中）
    self.curType = CallType_Audio;
    [self.rtcEngine disableVideo];
    [self invite:self.currentCallingUserID action:CallAction_SwitchToAudio];
    
    if ([self canDelegateRespondMethod:@selector(onSwitchToAudio:message:)]) {
        [self.delegate onSwitchToAudio:YES message:@""];
    }
}

- (void)startRemoteView:(NSString *)userID view:(UIView *)view {
    /// 開啟遠端使用者影片渲染
    ARLog(@"Calling - startRemoteView userID = %@", userID);
    if (userID.length != 0) {
        ARtcVideoCanvas *canvas = [[ARtcVideoCanvas alloc] init];
        canvas.uid = userID;
        canvas.view = view;
        [self.rtcEngine setupRemoteVideo:canvas];
    }
}

- (void)stopRemoteView:(NSString *)userID {
    /// 關閉遠端使用者影片渲染
    ARLog(@"Calling - stopRemoteView userID = %@", userID);
    ARtcVideoCanvas *canvas = [[ARtcVideoCanvas alloc] init];
    canvas.uid = userID;
    canvas.view = nil;
    [self.rtcEngine setupRemoteVideo:canvas];
}

- (void)openCamera:(BOOL)frontCamera view:(UIView *)view {
    /// 開啟攝像頭
    ARLog(@"Calling - openCamera");
    if (self.curType == CallType_Video) {
        [self.rtcEngine enableVideo];
    }
    ARtcVideoCanvas *canvas = [[ARtcVideoCanvas alloc] init];
    canvas.uid = [ARUILogin getUserID];
    canvas.view = view;
    [self.rtcEngine setupLocalVideo:canvas];
    [self.rtcEngine startPreview];
    self.isFrontCamera = frontCamera;
}

```

##### 效果展示（點對點視訊通話）
![arcallplus_video](https://img-blog.csdnimg.cn/ac0ddf2f6f9d490fa8f22c6948bcfd1c.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5L2Z55Sf5Li2OTE=,size_20,color_FFFFFF,t_70,g_se,x_16)

##### 程式碼實現

```
//MARK: - ARtcEngineDelegate

- (void)rtcEngine:(ARtcEngineKit *)engine didOccurError:(ARErrorCode)errorCode {
    /// 發生錯誤回撥
    ARLog(@"Calling - didOccurError = %ld", (long)errorCode);
}

- (void)rtcEngine:(ARtcEngineKit *)engine firstRemoteVideoDecodedOfUid:(NSString *)uid size:(CGSize)size elapsed:(NSInteger)elapsed {
    ARLog(@"Calling - firstRemoteVideoDecodedOfUid = %@", uid);
}

- (void)rtcEngine:(ARtcEngineKit *)engine didJoinedOfUid:(NSString *)uid elapsed:(NSInteger)elapsed {
    /// 遠端使用者/主播加入回撥
    ARLog(@"Calling - didJoinedOfUid = %@", uid);
    // C2C curInvitingList 不要移除 userID，如果是自己邀請的對方，這裡移除後，最後髮結束信令的時候找不到人
    [self dealWithException:0];
    [self removeTimer:uid];
    if ([self.curInvitingList containsObject:uid]) {
        [self.curInvitingList removeObject:uid];
    }
    if (![self.curRoomList containsObject:uid]) {
        [self.curRoomList addObject:uid];
    }
    // C2C 通話要計算通話時長
    if ([self canDelegateRespondMethod:@selector(onUserEnter:)]) {
        [self.delegate onUserEnter:uid];
    }
}

- (void)rtcEngine:(ARtcEngineKit *)engine didOfflineOfUid:(NSString *)uid reason:(ARUserOfflineReason)reason {
    /// 遠端使用者（通訊場景）/主播（直播場景）離開當前頻道回撥
    ARLog(@"Calling - didOfflineOfUid = %@", uid);
    // C2C curInvitingList 不要移除 userID，如果是自己邀請的對方，這裡移除後，最後髮結束信令的時候找不到人
    if (self.isMembers || (!self.isMembers && reason == ARUserOfflineReasonQuit)) {
        if ([self.curInvitingList containsObject:uid]) {
            [self.curInvitingList removeObject:uid];
        }
        if ([self.curRoomList containsObject:uid]) {
            [self.curRoomList removeObject:uid];
        }
        if ([self canDelegateRespondMethod:@selector(onUserLeave:)]) {
            [self.delegate onUserLeave:uid];
        }
        [self preExitRoom];
    } else if (reason == ARUserOfflineReasonDropped) {
        [self dealWithException:10];
    }
}

- (void)rtcEngine:(ARtcEngineKit *)engine remoteVideoStateChangedOfUid:(NSString *)uid state:(ARVideoRemoteState)state reason:(ARVideoRemoteStateReason)reason elapsed:(NSInteger)elapsed {
    /// 遠端影片狀態發生改變回撥
    if (reason == ARVideoRemoteStateReasonRemoteMuted || reason == ARVideoRemoteStateReasonRemoteUnmuted) {
        if ([self canDelegateRespondMethod:@selector(onUserVideoAvailable:available:)]) {
            [self.delegate onUserVideoAvailable:uid available:(reason == ARVideoRemoteStateReasonRemoteMuted) ? NO : YES];
        }
    }
}

- (void)rtcEngine:(ARtcEngineKit *)engine remoteAudioStateChangedOfUid:(NSString *)uid state:(ARAudioRemoteState)state reason:(ARAudioRemoteStateReason)reason elapsed:(NSInteger)elapsed {
    /// 遠端音訊狀態發生改變回撥
    if (reason == ARAudioRemoteReasonRemoteMuted || reason == ARAudioRemoteReasonRemoteUnmuted) {
        if ([self canDelegateRespondMethod:@selector(onUserAudioAvailable:available:)]) {
            [self.delegate onUserAudioAvailable:uid available:(reason == ARAudioRemoteReasonRemoteMuted) ? NO : YES];
        }
    }
}

- (void)rtcEngine:(ARtcEngineKit *)engine reportAudioVolumeIndicationOfSpeakers:(NSArray<artcaudiovolumeinfo> *)speakers totalVolume:(NSInteger)totalVolume {
    /// 提示頻道內誰正在說話、說話者音量及本地使用者是否在說話的回撥
    if ([self canDelegateRespondMethod:@selector(onUserVoiceVolume:volume:)]) {
        for (ARtcAudioVolumeInfo *info in speakers) {
            if ([info.uid isEqualToString:@"0"]) {
                [self.delegate onUserVoiceVolume:[ARUILogin getUserID] volume:(UInt32)info.volume];
            } else {
                [self.delegate onUserVoiceVolume:info.uid volume:(UInt32)info.volume];
            }
        }
    }
}

- (void)rtcEngine:(ARtcEngineKit *)engine connectionChangedToState:(ARConnectionStateType)state reason:(ARConnectionChangedReason)reason {
    //ARLog(@"Calling - rtc connectionStateChanged state = %ld reason = %ld", (long)state, (long)reason);
}

- (void)rtcEngine:(ARtcEngineKit *)engine didVideoSubscribeStateChange:(NSString *)channel withUid:(NSString *)uid oldState:(ARStreamSubscribeState)oldState newState:(ARStreamSubscribeState)newState elapseSinceLastState:(NSInteger)elapseSinceLastState {
    ARLog(@"Calling - didVideoSubscribeStateChange = %@ %@ %lu %lu", channel, uid, (unsigned long)oldState, (unsigned long)newState);
}

```

##### 效果展示（多人視訊通話）
![arcallplus_videos](https://img-blog.csdnimg.cn/dde11c1783ca462aaff5b9b1fd44fa08.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5L2Z55Sf5Li2OTE=,size_20,color_FFFFFF,t_70,g_se,x_16)

##### 程式碼實現

```

- (void)addSignalListener {
    ARUILogin.kit.aRtmDelegate = self;
    self.callEngine.callDelegate = self;
    /// 使用者進入後臺推送問題
    [NSNotificationCenter.defaultCenter addObserver:self selector:@selector(enterBackground:) name:UIApplicationWillResignActiveNotification object:nil];
    [NSNotificationCenter.defaultCenter addObserver:self selector:@selector(becomeActive:) name:UIApplicationWillEnterForegroundNotification object:nil];
}

- (void)removeSignalListener {
    self.callEngine.callDelegate = nil;
    self.callEngine = nil;
    [NSNotificationCenter.defaultCenter removeObserver:self name:UIApplicationWillResignActiveNotification object:nil];
    [NSNotificationCenter.defaultCenter removeObserver:self name:UIApplicationWillEnterForegroundNotification object:nil];
}

- (void)invite:(NSString *)receiver action:(CallAction)action {
    if (action == CallAction_Call) {
        /// 發起呼叫邀請
        NSMutableArray *arr = [[NSMutableArray alloc] initWithObjects:[ARUILogin getUserID], nil];
        [arr addObjectsFromArray:self.calleeUserIDs];
        
        NSMutableArray *infoArr = [NSMutableArray array];
        for (NSInteger i = 0; i < arr.count; i++) {
            ARCallUser *user = [ARUILogin getCallUserInfo:arr[i]];
            [infoArr addObject:[NSObject ar_dictionaryWithObject: user]];
        }
        
        NSDictionary *dic = @{@"Mode": @(self.curType == CallType_Video ? 0 : 1),
                             @"Conference": [NSNumber numberWithBool:self.isMembers],
                             @"ChanId": self.curRoomID,
                             @"UserData": arr,
                             @"UserInfo": infoArr
        };
        ARtmLocalInvitation *localInvitation = [[ARtmLocalInvitation alloc] initWithCalleeId:receiver];
        localInvitation.content = [ARTCCallingUtils dictionary2JsonStr:dic];
        [self.callEngine sendLocalInvitation:localInvitation completion:^(ARtmInvitationApiCallErrorCode errorCode) {
            ARLog(@"sendLocalInvitation code = %ld", (long)errorCode);
        }];
        [self.callingDic setObject:localInvitation forKey:receiver];
    } else if (action == CallAction_Cancel) {
        /// 取消呼叫邀請
        id invitation = [self.callingDic objectForKey:receiver];
        if (invitation) {
            ARtmLocalInvitation *localInvitation = (ARtmLocalInvitation *)invitation;
            [self.callEngine cancelLocalInvitation:localInvitation completion:^(ARtmInvitationApiCallErrorCode errorCode) {
                ARLog(@"cancelLocalInvitation code = %ld", (long)errorCode);
            }];
        }
    } else if (action == CallAction_Accept) {
        /// 接受呼叫邀請
        id invitation = [self.calledDic objectForKey:receiver];
        if (invitation) {
            ARtmRemoteInvitation *remoteInvitation = (ARtmRemoteInvitation *)invitation;
            NSDictionary *dic = @{@"Mode": @(self.curType == CallType_Video ? 0: 1), @"Conference": [NSNumber numberWithBool:self.isMembers]};
            remoteInvitation.response = [ARTCCallingUtils dictionary2JsonStr:dic];
            [self.callEngine acceptRemoteInvitation:remoteInvitation completion:^(ARtmInvitationApiCallErrorCode errorCode) {
                ARLog(@"acceptRemoteInvitation code = %ld", (long)errorCode);
            }];
        }
    } else if (action == CallAction_Reject) {
        /// 拒絕呼叫邀請
        id invitation = [self.calledDic objectForKey:receiver];
        if (invitation) {
            ARtmRemoteInvitation *remoteInvitation = (ARtmRemoteInvitation *)invitation;
            [self.callEngine refuseRemoteInvitation:remoteInvitation completion:^(ARtmInvitationApiCallErrorCode errorCode) {
                ARLog(@"refuseRemoteInvitation code = %ld", (long)errorCode);
            }];
        }
    } else if (action == CallAction_SwitchToAudio) {
        /// 切換成語音通話
        NSDictionary *dic = [[NSDictionary alloc] initWithObjectsAndKeys:@"SwitchAudio", @"Cmd",nil];
        ARtmMessage *message = [[ARtmMessage alloc] initWithText:[ARTCCallingUtils dictionary2JsonStr:dic]];
        [self sendPeerMessage:message user:receiver];
    } else if (action == CallAction_End) {
        /// 通話中斷
        if (!self.isMembers) {
            NSDictionary *dic = [[NSDictionary alloc] initWithObjectsAndKeys:@"EndCall", @"Cmd",nil];
            ARtmMessage *message = [[ARtmMessage alloc] initWithText:[ARTCCallingUtils dictionary2JsonStr:dic]];
            [self sendPeerMessage:message user:receiver];
        }
    }
}

- (void)preExitRoom {
    /// 當前房間中存在成員，不能自動退房
    if (self.curRoomList.count > 0) return;
    
    /// 存在正在呼叫的通話
    if (self.curInvitingList.count >= 1) {
        return;
    }
    
    [self exitRoom];
}

- (void)exitRoom {
    ARLog(@"Calling - exitRoom");
    if ([self canDelegateRespondMethod:@selector(onCallEnd)]) {
        [self.delegate onCallEnd];
    }
    
    for (NSString *uid in self.timerDic.allKeys) {
        [self removeTimer:uid];
    }
    
    [self dealWithException:0];
    [self leaveRoom];
    self.isOnCalling = NO;
    
    if(UIApplication.sharedApplication.applicationState == UIApplicationStateBackground) {
        [self logout];
    }
}

// MARK: - privite

- (ARtmCallKit *)callEngine {
    return [ARUILogin.kit getRtmCallKit];
}

- (void)sendPeerMessage:(ARtmMessage *)message user:(NSString *)uid {
    ARLog(@"Calling - sendPeerMessage = %@", message.text);
    ARtmSendMessageOptions *options = [[ARtmSendMessageOptions alloc] init];
    [[ARUILogin kit] sendMessage:message toPeer:uid sendMessageOptions:options completion:^(ARtmSendPeerMessageErrorCode errorCode) {
        ARLog(@"Calling - SendPeerMessage code = %ld", (long)errorCode);
    }];
}

- (void)logout {
    if (!self.isOnCalling && ARUILogin.kit != nil) {
        [ARUILogin.kit logoutWithCompletion:nil];
        self.interrupt = YES;
    }
}

- (void)enterBackground:(NSNotification *)notification {
    [self logout];
}

- (void)becomeActive:(NSNotification *)notification {
    if (!self.isOnCalling && self.interrupt) {
        [ARUILogin.kit loginByToken:nil user:ARUILogin.getUserID completion:nil];
        self.interrupt = NO;
    }
}

//MARK: - ARtmDelegate

- (void)rtmKit:(ARtmKit *)kit connectionStateChanged:(ARtmConnectionState)state reason:(ARtmConnectionChangeReason)reason {
    ARLog(@"Calling - rtm connectionStateChanged state = %ld reason = %ld", (long)state, (long)reason);
    if (reason == ARtmConnectionChangeReasonRemoteLogin) {
        [self.delegate onError:401 msg:@"RemoteLogin"];
        [self exitRoom];
        return;
    }
    
    if (!self.isMembers) {
        if (state == ARtmConnectionStateDisconnected || state == ARtmConnectionStateReconnecting) {
            self.isReconnection = YES;
            [self dealWithException: 30];
            
        } else if (state == ARtmConnectionStateConnected) {
            [self dealWithException:0];
            
            if (self.isReconnection && self.isOnCalling && self.currentCallingUserID) {
                /// 相容異常
                [self dealWithException:10];
                self.isReconnection = NO;
                NSDictionary *dic = [[NSDictionary alloc] initWithObjectsAndKeys:@"CallState", @"Cmd",nil];
                ARtmMessage *message = [[ARtmMessage alloc] initWithText:[ARTCCallingUtils dictionary2JsonStr:dic]];
                [self sendPeerMessage:message user:self.currentCallingUserID];
            }
        }
    }
}

- (void)rtmKit:(ARtmKit *)kit messageReceived:(ARtmMessage *)message fromPeer:(NSString *)peerId {
    /// 收到點對點訊息回撥
    ARLog(@"Calling - messageReceived text = %@ ", message.text);
    if (message.text.length != 0) {
        NSDictionary *dic = [ARTCCallingUtils jsonSring2Dictionary:message.text];
        NSString *value = [dic objectForKey:@"Cmd"];
        if ([value isEqualToString:@"SwitchAudio"]) {
            /// 切換成語音通話
            if ([self canDelegateRespondMethod:@selector(onSwitchToAudio:message:)]) {
                [self.delegate onSwitchToAudio:YES message:@""];
            }
            self.curType = CallType_Audio;
            
        } else if ([value isEqualToString:@"EndCall"]) {
            /// 結束通話
            if (!self.isMembers) {
                if ([self canDelegateRespondMethod:@selector(onUserLeave:)]) {
                    [self.delegate onUserLeave:peerId];
                }
                [self exitRoom];
            }
        } else if ([value isEqualToString:@"CallState"]) {
            /// 確認通話狀態
            NSDictionary *dic;
            if (self.isCallSucess) {
                dic = @{@"Cmd": @"CallStateResult", @"state": @(2), @"Mode": (self.curType == CallType_Video ? @(0) : @(1))};
            } else {
                dic= @{@"Cmd": @"CallStateResult", @"state": @(1)};
            }
            ARtmMessage *message = [[ARtmMessage alloc] initWithText:[ARTCCallingUtils dictionary2JsonStr:dic]];
            [self sendPeerMessage:message user:peerId];
            
        } else if ([value isEqualToString:@"CallStateResult"]) {
            /// 對方通話狀態回覆結果
            [self dealWithException:0];
            
            int state = [[dic objectForKey:@"state"] intValue];
            if (state == 0) {
                /// 已結束通話
                [self exitRoom];
            } else if (state == 1) {
                /// 呼叫等待
            } else {
                /// 已同意
                int mode = [[dic objectForKey:@"Mode"] intValue];
                if (self.curType == CallType_Video && mode == 1) {
                    self.curType = CallType_Audio;
                    [self switchToAudio];
                }
            }
        }
    }
}

// MARK: - ARtmCallDelegate

- (void)rtmCallKit:(ARtmCallKit * _Nonnull)callKit localInvitationReceivedByPeer:(ARtmLocalInvitation * _Nonnull)localInvitation {
    /// 被叫已收到呼叫邀請
    ARLog(@"Calling - localInvitationReceivedByPeer");
}

- (void)rtmCallKit:(ARtmCallKit * _Nonnull)callKit localInvitationAccepted:(ARtmLocalInvitation * _Nonnull)localInvitation withResponse:(NSString * _Nullable) response {
    /// 被叫已接受呼叫邀請
    ARLog(@"Calling - localInvitationAccepted response = %@", response);
    [self.callingDic removeObjectForKey:localInvitation.calleeId];
    if (response != nil) {
        NSDictionary * dic = [ARTCCallingUtils jsonSring2Dictionary:response];
        if (self.curType == CallType_Video && [[dic objectForKey:@"Mode"] intValue] == 1) {
            if ([self canDelegateRespondMethod:@selector(onSwitchToAudio:message:)]) {
                [self.delegate onSwitchToAudio:YES message:@""];
            }
            self.curType = CallType_Audio;
        }
    }
    
    self.isCallSucess = YES;
}

- (void)rtmCallKit:(ARtmCallKit * _Nonnull)callKit localInvitationRefused:(ARtmLocalInvitation * _Nonnull)localInvitation withResponse:(NSString * _Nullable) response {
    /// 被叫已拒絕呼叫邀請
    ARLog(@"Calling - localInvitationRefused");
    [self.callingDic removeObjectForKey:localInvitation.calleeId];
    
    BOOL isBusy = NO;
    if (localInvitation.response.length != 0) {
        NSDictionary * dic = [ARTCCallingUtils jsonSring2Dictionary:localInvitation.response];
        if ([dic.allValues containsObject:@"Calling"]) {
            isBusy = YES;
        }
    }
    
    if (self.delegate) {
        NSString *uid = localInvitation.calleeId;
        if ([self.curInvitingList containsObject:uid]) {
            [self.curInvitingList removeObject:uid];
        }
        if (isBusy) {
            if ([self canDelegateRespondMethod:@selector(onLineBusy:)]) {
                [self.delegate onLineBusy:localInvitation.calleeId];
            }
        } else {
            if ([self canDelegateRespondMethod:@selector(onReject:)]) {
                [self.delegate onReject:uid];
            }
        }
        [self preExitRoom];
    }
}

- (void)rtmCallKit:(ARtmCallKit * _Nonnull)callKit localInvitationCanceled:(ARtmLocalInvitation * _Nonnull)localInvitation {
    /// 呼叫邀請已被取消
    ARLog(@"Calling - localInvitationCanceled");
    [self.callingDic removeObjectForKey:localInvitation.calleeId];
}

- (void)rtmCallKit:(ARtmCallKit * _Nonnull)callKit localInvitationFailure:(ARtmLocalInvitation * _Nonnull)localInvitation errorCode:(ARtmLocalInvitationErrorCode)errorCode {
    /// 呼叫邀請傳送失敗
    ARLog(@"Calling - localInvitationFailure");
    NSString *calleeId = localInvitation.calleeId;
    [self.callingDic removeObjectForKey:calleeId];
    
    if ([self canDelegateRespondMethod:@selector(onNoResp:)]) {
        [self.delegate onNoResp:calleeId];
    }
    if ([self.curInvitingList containsObject:calleeId]) {
        [self.curInvitingList removeObject:calleeId];
    }
    [self preExitRoom];
}

- (void)rtmCallKit:(ARtmCallKit * _Nonnull)callKit remoteInvitationReceived:(ARtmRemoteInvitation * _Nonnull)remoteInvitation {
    /// 收到一個呼叫邀請
    ARLog(@"Calling - remoteInvitationReceived");
    [self.calledDic setObject:remoteInvitation forKey:remoteInvitation.callerId];
    if (!self.isOnCalling) {
        self.isOnCalling = YES;
        self.curSponsorForMe = remoteInvitation.callerId;
        self.currentCallingUserID = remoteInvitation.callerId;
        
        NSDictionary *dic = [ARTCCallingUtils jsonSring2Dictionary:remoteInvitation.content];
        self.isMembers = [[dic objectForKey:@"Conference"] boolValue];
        self.curRoomID = [dic objectForKey:@"ChanId"];
        CallType type = ([[dic objectForKey:@"Mode"] intValue] == 0) ? CallType_Video : CallType_Audio;
        self.curType = type;
        if ([dic.allKeys containsObject:@"UserInfo"]) {
            NSArray *infoArr = [dic objectForKey:@"UserInfo"];
            for (NSInteger i = 0; i < infoArr.count; i++) {
                ARCallUser *user = [ARCallUser ar_objectWithDictionary: infoArr[i]];
                [ARUILogin setCallUserInfo:user];
            }
        }
        
        if (self.isMembers) {
            /// 多人通話
            NSArray *arr = [dic objectForKey:@"UserData"];
            [self.delegate onInvited:remoteInvitation.callerId userIds:arr isFromGroup:NO callType:type];
            [self createMemberChannel];
            
            /// 30s
            for (NSInteger i = 0; i < arr.count; i++) {
                NSString *uid = arr[i];
                /// 被叫對其他受邀者倒數計時 -- 異常處理
                if (![uid isEqualToString:[ARUILogin getUserID]] && ![uid isEqualToString:self.curSponsorForMe]) {
                    __block NSInteger totalTime = 0;
                    NSTimeInterval interval = 1.0;
                    __weak typeof(self) weakSelf = self;
                    NSString *timerName = [ARTCGCDTimer timerTask:^{
                        totalTime += (NSInteger)interval;
                        if (totalTime == 30) {
                            if ([weakSelf canDelegateRespondMethod:@selector(onNoResp:)]) {
                                [weakSelf.delegate onNoResp:uid];
                                [weakSelf removeTimer: uid];
                            }
                        }
                        ARLog(@"%@ ==> %ld \n", uid, (long)totalTime);
                    } start:0 interval:interval repeats:YES async:NO];
                    [self.timerDic setObject:timerName forKey:uid];
                }
            }
        } else {
            /// 單人通話
            [self.delegate onInvited:remoteInvitation.callerId userIds:@[[ARUILogin getUserID]] isFromGroup:NO callType:type];
        }
    } else {
        NSDictionary *dic = [[NSDictionary alloc] initWithObjectsAndKeys:@"Calling", @"Cmd",nil];
        remoteInvitation.response = [ARTCCallingUtils dictionary2JsonStr:dic];
        [self invite:remoteInvitation.callerId action:CallAction_Reject];
    }
}

- (void)rtmCallKit:(ARtmCallKit * _Nonnull)callKit remoteInvitationRefused:(ARtmRemoteInvitation * _Nonnull)remoteInvitation {
    /// 拒絕呼叫邀請成功
    ARLog(@"Calling - remoteInvitationRefused");
    [self.calledDic removeObjectForKey:remoteInvitation.callerId];
}

- (void)rtmCallKit:(ARtmCallKit * _Nonnull)callKit remoteInvitationAccepted:(ARtmRemoteInvitation * _Nonnull)remoteInvitation {
    /// 接受呼叫邀請成功
    ARLog(@"Calling - remoteInvitationAccepted");
    [self.calledDic removeObjectForKey:remoteInvitation.callerId];
}

- (void)rtmCallKit:(ARtmCallKit * _Nonnull)callKit remoteInvitationCanceled:(ARtmRemoteInvitation * _Nonnull)remoteInvitation {
    /// 主叫已取消呼叫邀請
    ARLog(@"Calling - remoteInvitationCanceled");
    [self.calledDic removeObjectForKey:remoteInvitation.callerId];
    
    if ([self.curSponsorForMe isEqualToString:remoteInvitation.callerId]) {
        [self exitRoom];
        if ([self canDelegateRespondMethod:@selector(onCallingCancel:)]) {
            [self.delegate onCallingCancel:remoteInvitation.callerId];
        }
    }
}

```

### 結束語

最後，ARCallPlus開源專案中還存在一些bug和待完善的功能點。有不足之處歡迎大家指出issues。</artcaudiovolumeinfo></nsstring></nsstring></nsstring></nsobject></aruicallinglisterner></arcalluser>

IOS技術分享| ARCallPlus 開源專案（一）

相關文章