private void ApplyToSpeakCallback(IntPtr pData)
{
AsynCallResult applyResult = (AsynCallResult)Marshal.PtrToStructure(pData, typeof(AsynCallResult));
ReturnMessage applyMessage;
if (applyResult.m_rc == 0)
{
applyMessage = ReturnMessage.GenerateMessage(applyResult.m_message);
}
else
{
applyMessage = ReturnMessage.GenerateError(applyResult.m_message, applyResult.m_rc.ToString());
}
SetResult("ApplyToSpeak", applyMessage);
}
private void InviteCallback(IntPtr pData)
{
AsynCallResult result = (AsynCallResult)Marshal.PtrToStructure(pData, typeof(AsynCallResult));
ReturnMessage inviteReturnMessage;
if (result.m_rc == 0)
{
inviteReturnMessage = ReturnMessage.GenerateMessage(result.m_message);
}
else
{
inviteReturnMessage = ReturnMessage.GenerateError(result.m_message, result.ToString());
}
SetResult("InviteParticipants", inviteReturnMessage);
}
private void StartShareDocCallback(IntPtr pData)
{
AsynCallResult asynCallRulst = (AsynCallResult)Marshal.PtrToStructure(pData, typeof(AsynCallResult));
ReturnMessage startDocMessage;
if (asynCallRulst.m_rc == 0)
{
startDocMessage = ReturnMessage.GenerateMessage(asynCallRulst.m_message);
}
else
{
startDocMessage = ReturnMessage.GenerateError(asynCallRulst.m_message, asynCallRulst.m_rc.ToString());
}
SetResult("StartShareDoc", startDocMessage);
}
public async Task <AsynCallResult> StopPushLiveStream()
{
if (LiveId != 0)
{
Log.Logger.Debug($"【server push live stop begins】：liveId={LiveId}");
AsynCallResult stopAsynCallResult = await _sdkService.StopLiveStream(LiveId);
LiveId = 0;
Log.Logger.Debug($"【server push live stop result】：result={stopAsynCallResult.m_rc}, msg={stopAsynCallResult.m_message}");
return(stopAsynCallResult);
}
return(new AsynCallResult()
{
m_rc = -1, m_message = Messages.WarningNoLiveToStop
});
}
public async Task <AsynCallResult> StopRecord()
{
if (RecordId != 0)
{
Log.Logger.Debug($"【local record live stop begins】：liveId={RecordId}");
AsynCallResult stopAsynCallResult = await _sdkService.StopRecord();
RecordId = 0;
Log.Logger.Debug(
$"【local record live stop result】：result={stopAsynCallResult.m_rc}, msg={stopAsynCallResult.m_message}");
return(stopAsynCallResult);
}
return(new AsynCallResult()
{
m_rc = -1, m_message = Messages.WarningNoLiveToStop
});
}
public async Task ExitAsync()
{
IsDialogOpen = false;
UnRegisterMeetingEvents();
await _meetingView.Dispatcher.BeginInvoke(new Action(() =>
{
_meetingView.Close();
_exitMeetingCallbackEvent(true, "");
}));
await StopAllLives();
AsynCallResult exitResult = await _sdkService.ExitMeeting();
Log.Logger.Debug($"【exit meeting】：result={exitResult.m_rc}, msg={exitResult.m_message}");
HasErrorMsg(exitResult.m_rc.ToString(), exitResult.m_message);
}
private void OpenCameraCallback(IntPtr pData)
{
AsynCallResult openCameraResult = Marshal.PtrToStructure <AsynCallResult>(pData);
ReturnMessage openCameraMessage;
if (openCameraResult.m_rc == 0)
{
openCameraMessage = ReturnMessage.GenerateData(openCameraResult.m_message);
}
else
{
openCameraMessage = ReturnMessage.GenerateError(openCameraResult.m_message,
openCameraResult.m_rc.ToString());
}
OpenCameraEvent?.Invoke(openCameraMessage);
}
private async Task SetMicStateAsync()
{
if (MicState == "静音")
{
AsynCallResult result = await _sdkService.SetMicMuteState(1);
if (!HasErrorMsg(result.m_rc.ToString(), result.m_message))
{
MicState = "取消静音";
}
}
else
{
AsynCallResult result = await _sdkService.SetMicMuteState(0);
if (!HasErrorMsg(result.m_rc.ToString(), result.m_message))
{
MicState = "静音";
}
}
}
private async Task ScreenShareAsync()
{
if (ScreenShareState == "共享屏幕")
{
AsynCallResult result = await _sdkService.StartScreenSharing();
if (!HasErrorMsg(result.m_rc.ToString(), result.m_message))
{
ScreenShareState = "取消屏幕共享";
}
}
else
{
AsynCallResult result = await _sdkService.StopScreenSharing();
if (!HasErrorMsg(result.m_rc.ToString(), result.m_message))
{
ScreenShareState = "共享屏幕";
}
}
}
private async Task OpenCloseCameraAsync()
{
if (OpenCloseCameraOperation == "open camera")
{
AsynCallResult result = await _sdkService.OpenCamera(SelectedCamera);
if (!HasErrorMsg(result.m_rc.ToString(), result.m_message))
{
OpenCloseCameraOperation = "close camera";
}
}
else
{
AsynCallResult result = await _sdkService.CloseCamera();
if (!HasErrorMsg(result.m_rc.ToString(), result.m_message))
{
OpenCloseCameraOperation = "open camera";
}
}
}
public async Task <AsynCallResult> RefreshLiveStream(List <LiveVideoStreamInfo> openedStreamInfos)
{
if (LiveId != 0)
{
Log.Logger.Debug($"【server refresh live begins】：liveId={LiveId}, videos={openedStreamInfos.Count}");
for (int i = 0; i < openedStreamInfos.Count; i++)
{
Log.Logger.Debug(
$"video{i + 1}：x={openedStreamInfos[i].XLocation}, y={openedStreamInfos[i].YLocation}, width={openedStreamInfos[i].Width}, height={openedStreamInfos[i].Height}");
}
AsynCallResult updateAsynCallResult =
await
_sdkService.UpdateLiveVideoStreams(LiveId, openedStreamInfos.ToArray(), openedStreamInfos.Count);
Log.Logger.Debug(
$"【server refresh live result】：result={updateAsynCallResult.m_rc}, msg={updateAsynCallResult.m_message}");
return(updateAsynCallResult);
}
return(new AsynCallResult()
{
m_rc = -1, m_message = Messages.WarningNoLiveToRefresh
});
}
private async Task SpeakingStatusChangedAsync()
{
if (SpeakingStatus == IsSpeaking)
{
bool stopSucceeded = await _sdkService.StopSpeak();
if (!stopSucceeded)
{
//
}
//will change SpeakStatus in StopSpeakCallbackEventHandler.
}
if (SpeakingStatus == IsNotSpeaking)
{
AsynCallResult result = await _sdkService.ApplyToSpeak();
if (!HasErrorMsg(result.m_rc.ToString(), result.m_message))
{
// will change SpeakStatus in callback???
SpeakingStatus = IsSpeaking;
}
}
}
private async Task StopSpeakAsync(string userPhoneId)
{
AsynCallResult result = await _sdkService.RequireUserStopSpeak(userPhoneId);
HasErrorMsg(result.m_rc.ToString(), result.m_message);
}
private async Task SetDefaultDataCameraAsync(string cameraName)
{
AsynCallResult result = await _sdkService.SetDefaultCamera(2, cameraName);
HasErrorMsg(result.m_rc.ToString(), result.m_message);
}
private void ErrorMsgReceivedEventHandler(AsynCallResult error)
{
HasErrorMsg("-1", error.m_message);
}
private void DiskSpaceNotEnoughEventHandler(AsynCallResult msg)
{
HasErrorMsg(msg.m_rc.ToString(), msg.m_message);
}
