697 lines
30 KiB
C#
697 lines
30 KiB
C#
/*
|
|
* Copyright (c) 2006-2014, openmetaverse.org
|
|
* All rights reserved.
|
|
*
|
|
* - Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* - Redistributions of source code must retain the above copyright notice, this
|
|
* list of conditions and the following disclaimer.
|
|
* - Neither the name of the openmetaverse.org nor the names
|
|
* of its contributors may be used to endorse or promote products derived from
|
|
* this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Net.Sockets;
|
|
using System.Diagnostics;
|
|
using System.Threading;
|
|
using System.Text;
|
|
|
|
namespace OpenMetaverse.Voice
|
|
{
|
|
public partial class VoiceGateway
|
|
{
|
|
public delegate void DaemonRunningCallback();
|
|
public delegate void DaemonExitedCallback();
|
|
public delegate void DaemonCouldntRunCallback();
|
|
public delegate void DaemonConnectedCallback();
|
|
public delegate void DaemonDisconnectedCallback();
|
|
public delegate void DaemonCouldntConnectCallback();
|
|
|
|
public event DaemonRunningCallback OnDaemonRunning;
|
|
public event DaemonExitedCallback OnDaemonExited;
|
|
public event DaemonCouldntRunCallback OnDaemonCouldntRun;
|
|
public event DaemonConnectedCallback OnDaemonConnected;
|
|
public event DaemonDisconnectedCallback OnDaemonDisconnected;
|
|
public event DaemonCouldntConnectCallback OnDaemonCouldntConnect;
|
|
|
|
public bool DaemonIsRunning { get { return daemonIsRunning; } }
|
|
public bool DaemonIsConnected { get { return daemonIsConnected; } }
|
|
public int RequestId { get { return requestId; } }
|
|
|
|
protected Process daemonProcess;
|
|
protected ManualResetEvent daemonLoopSignal = new ManualResetEvent(false);
|
|
protected TCPPipe daemonPipe;
|
|
protected bool daemonIsRunning = false;
|
|
protected bool daemonIsConnected = false;
|
|
protected int requestId = 0;
|
|
|
|
#region Daemon Management
|
|
|
|
/// <summary>
|
|
/// Starts a thread that keeps the daemon running
|
|
/// </summary>
|
|
/// <param name="path"></param>
|
|
/// <param name="args"></param>
|
|
public void StartDaemon(string path, string args)
|
|
{
|
|
StopDaemon();
|
|
daemonLoopSignal.Set();
|
|
|
|
Thread thread = new Thread(new ThreadStart(delegate()
|
|
{
|
|
while (daemonLoopSignal.WaitOne(500, false))
|
|
{
|
|
daemonProcess = new Process();
|
|
daemonProcess.StartInfo.FileName = path;
|
|
daemonProcess.StartInfo.WorkingDirectory = Path.GetDirectoryName(path);
|
|
daemonProcess.StartInfo.Arguments = args;
|
|
daemonProcess.StartInfo.UseShellExecute = false;
|
|
|
|
if (Environment.OSVersion.Platform == PlatformID.Unix)
|
|
{
|
|
string ldPath = string.Empty;
|
|
try
|
|
{
|
|
ldPath = Environment.GetEnvironmentVariable("LD_LIBRARY_PATH");
|
|
}
|
|
catch { }
|
|
string newLdPath = daemonProcess.StartInfo.WorkingDirectory;
|
|
if (!string.IsNullOrEmpty(ldPath))
|
|
newLdPath += ":" + ldPath;
|
|
daemonProcess.StartInfo.EnvironmentVariables.Add("LD_LIBRARY_PATH", newLdPath);
|
|
}
|
|
|
|
Logger.DebugLog("Voice folder: " + daemonProcess.StartInfo.WorkingDirectory);
|
|
Logger.DebugLog(path + " " + args);
|
|
bool ok = true;
|
|
|
|
if (!File.Exists(path))
|
|
ok = false;
|
|
|
|
if (ok)
|
|
{
|
|
// Attempt to start the process
|
|
if (!daemonProcess.Start())
|
|
ok = false;
|
|
}
|
|
|
|
if (!ok)
|
|
{
|
|
daemonIsRunning = false;
|
|
daemonLoopSignal.Reset();
|
|
|
|
if (OnDaemonCouldntRun != null)
|
|
{
|
|
try { OnDaemonCouldntRun(); }
|
|
catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, null, e); }
|
|
}
|
|
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
Thread.Sleep(2000);
|
|
daemonIsRunning = true;
|
|
if (OnDaemonRunning != null)
|
|
{
|
|
try { OnDaemonRunning(); }
|
|
catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, null, e); }
|
|
}
|
|
|
|
Logger.DebugLog("Started voice daemon, waiting for exit...");
|
|
daemonProcess.WaitForExit();
|
|
Logger.DebugLog("Voice daemon exited");
|
|
daemonIsRunning = false;
|
|
|
|
if (OnDaemonExited != null)
|
|
{
|
|
try { OnDaemonExited(); }
|
|
catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, null, e); }
|
|
}
|
|
}
|
|
}
|
|
}));
|
|
|
|
thread.Name = "VoiceDaemonController";
|
|
thread.IsBackground = true;
|
|
thread.Start();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stops the daemon and the thread keeping it running
|
|
/// </summary>
|
|
public void StopDaemon()
|
|
{
|
|
daemonLoopSignal.Reset();
|
|
if (daemonProcess != null)
|
|
{
|
|
try
|
|
{
|
|
daemonProcess.Kill();
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
Logger.Log("Failed to stop the voice daemon", Helpers.LogLevel.Error, ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="address"></param>
|
|
/// <param name="port"></param>
|
|
/// <returns></returns>
|
|
public bool ConnectToDaemon(string address, int port)
|
|
{
|
|
daemonIsConnected = false;
|
|
|
|
daemonPipe = new TCPPipe();
|
|
daemonPipe.OnDisconnected +=
|
|
delegate(SocketException e)
|
|
{
|
|
if (OnDaemonDisconnected != null)
|
|
{
|
|
try { OnDaemonDisconnected(); }
|
|
catch (Exception ex) { Logger.Log(ex.Message, Helpers.LogLevel.Error, null, ex); }
|
|
}
|
|
};
|
|
daemonPipe.OnReceiveLine += new TCPPipe.OnReceiveLineCallback(daemonPipe_OnReceiveLine);
|
|
|
|
SocketException se = daemonPipe.Connect(address, port);
|
|
if (se == null)
|
|
{
|
|
daemonIsConnected = true;
|
|
|
|
if (OnDaemonConnected != null)
|
|
{
|
|
try { OnDaemonConnected(); }
|
|
catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, null, e); }
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
daemonIsConnected = false;
|
|
|
|
if (OnDaemonCouldntConnect != null)
|
|
{
|
|
try { OnDaemonCouldntConnect(); }
|
|
catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, null, e); }
|
|
}
|
|
|
|
Logger.Log("Voice daemon connection failed: " + se.Message, Helpers.LogLevel.Error);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#endregion Daemon Management
|
|
|
|
public int Request(string action)
|
|
{
|
|
return Request(action, null);
|
|
}
|
|
|
|
public int Request(string action, string requestXML)
|
|
{
|
|
int returnId = requestId;
|
|
if (daemonIsConnected)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append(String.Format("<Request requestId=\"{0}\" action=\"{1}\"", requestId++, action));
|
|
if (string.IsNullOrEmpty(requestXML))
|
|
{
|
|
sb.Append(" />");
|
|
}
|
|
else
|
|
{
|
|
sb.Append(">");
|
|
sb.Append(requestXML);
|
|
sb.Append("</Request>");
|
|
}
|
|
sb.Append("\n\n\n");
|
|
|
|
#if DEBUG
|
|
Logger.Log("Request: " + sb.ToString(), Helpers.LogLevel.Debug);
|
|
#endif
|
|
try
|
|
{
|
|
daemonPipe.SendData(Encoding.ASCII.GetBytes(sb.ToString()));
|
|
}
|
|
catch
|
|
{
|
|
returnId = -1;
|
|
}
|
|
|
|
return returnId;
|
|
}
|
|
else
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
public static string MakeXML(string name, string text)
|
|
{
|
|
if (string.IsNullOrEmpty(text))
|
|
return string.Format("<{0} />", name);
|
|
else
|
|
return string.Format("<{0}>{1}</{0}>", name, text);
|
|
}
|
|
|
|
private void daemonPipe_OnReceiveLine(string line)
|
|
{
|
|
#if DEBUG
|
|
Logger.Log(line, Helpers.LogLevel.Debug);
|
|
#endif
|
|
|
|
if (line.Substring(0, 10) == "<Response ")
|
|
{
|
|
VoiceResponse rsp = null;
|
|
try
|
|
{
|
|
rsp = (VoiceResponse)ResponseSerializer.Deserialize(new StringReader(line));
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logger.Log("Failed to deserialize voice daemon response", Helpers.LogLevel.Error, e);
|
|
return;
|
|
}
|
|
|
|
ResponseType genericResponse = ResponseType.None;
|
|
|
|
switch (rsp.Action)
|
|
{
|
|
// These first responses carry useful information beyond simple status,
|
|
// so they each have a specific Event.
|
|
case "Connector.Create.1":
|
|
if (OnConnectorCreateResponse != null)
|
|
{
|
|
OnConnectorCreateResponse(
|
|
rsp.InputXml.Request,
|
|
new VoiceConnectorEventArgs(
|
|
int.Parse(rsp.ReturnCode),
|
|
int.Parse(rsp.Results.StatusCode),
|
|
rsp.Results.StatusString,
|
|
rsp.Results.VersionID,
|
|
rsp.Results.ConnectorHandle));
|
|
}
|
|
break;
|
|
case "Aux.GetCaptureDevices.1":
|
|
inputDevices = new List<string>();
|
|
|
|
if (rsp.Results.CaptureDevices.Count == 0 || rsp.Results.CurrentCaptureDevice == null)
|
|
break;
|
|
|
|
foreach (CaptureDevice device in rsp.Results.CaptureDevices)
|
|
inputDevices.Add(device.Device);
|
|
currentCaptureDevice = rsp.Results.CurrentCaptureDevice.Device;
|
|
|
|
if (OnAuxGetCaptureDevicesResponse != null && rsp.Results.CaptureDevices.Count > 0)
|
|
{
|
|
OnAuxGetCaptureDevicesResponse(
|
|
rsp.InputXml.Request,
|
|
new VoiceDevicesEventArgs(
|
|
ResponseType.GetCaptureDevices,
|
|
int.Parse(rsp.ReturnCode),
|
|
int.Parse(rsp.Results.StatusCode),
|
|
rsp.Results.StatusString,
|
|
rsp.Results.CurrentCaptureDevice.Device,
|
|
inputDevices));
|
|
}
|
|
break;
|
|
case "Aux.GetRenderDevices.1":
|
|
outputDevices = new List<string>();
|
|
|
|
if (rsp.Results.RenderDevices.Count == 0 || rsp.Results.CurrentRenderDevice == null)
|
|
break;
|
|
|
|
foreach (RenderDevice device in rsp.Results.RenderDevices)
|
|
outputDevices.Add(device.Device);
|
|
|
|
|
|
currentPlaybackDevice = rsp.Results.CurrentRenderDevice.Device;
|
|
|
|
if (OnAuxGetRenderDevicesResponse != null)
|
|
{
|
|
OnAuxGetRenderDevicesResponse(
|
|
rsp.InputXml.Request,
|
|
new VoiceDevicesEventArgs(
|
|
ResponseType.GetCaptureDevices,
|
|
int.Parse(rsp.ReturnCode),
|
|
int.Parse(rsp.Results.StatusCode),
|
|
rsp.Results.StatusString,
|
|
rsp.Results.CurrentRenderDevice.Device,
|
|
outputDevices));
|
|
}
|
|
break;
|
|
|
|
case "Account.Login.1":
|
|
if (OnAccountLoginResponse != null)
|
|
{
|
|
OnAccountLoginResponse(rsp.InputXml.Request,
|
|
new VoiceAccountEventArgs(
|
|
int.Parse(rsp.ReturnCode),
|
|
int.Parse(rsp.Results.StatusCode),
|
|
rsp.Results.StatusString,
|
|
rsp.Results.AccountHandle));
|
|
}
|
|
break;
|
|
|
|
case "Session.Create.1":
|
|
if (OnSessionCreateResponse != null)
|
|
{
|
|
OnSessionCreateResponse(
|
|
rsp.InputXml.Request,
|
|
new VoiceSessionEventArgs(
|
|
int.Parse(rsp.ReturnCode),
|
|
int.Parse(rsp.Results.StatusCode),
|
|
rsp.Results.StatusString,
|
|
rsp.Results.SessionHandle));
|
|
}
|
|
break;
|
|
|
|
// All the remaining responses below this point just report status,
|
|
// so they all share the same Event. Most are useful only for
|
|
// detecting coding errors.
|
|
case "Connector.InitiateShutdown.1":
|
|
genericResponse = ResponseType.ConnectorInitiateShutdown;
|
|
break;
|
|
case "Aux.SetRenderDevice.1":
|
|
genericResponse = ResponseType.SetRenderDevice;
|
|
break;
|
|
case "Connector.MuteLocalMic.1":
|
|
genericResponse = ResponseType.MuteLocalMic;
|
|
break;
|
|
case "Connector.MuteLocalSpeaker.1":
|
|
genericResponse = ResponseType.MuteLocalSpeaker;
|
|
break;
|
|
case "Connector.SetLocalMicVolume.1":
|
|
genericResponse = ResponseType.SetLocalMicVolume;
|
|
break;
|
|
case "Connector.SetLocalSpeakerVolume.1":
|
|
genericResponse = ResponseType.SetLocalSpeakerVolume;
|
|
break;
|
|
case "Aux.SetCaptureDevice.1":
|
|
genericResponse = ResponseType.SetCaptureDevice;
|
|
break;
|
|
case "Session.RenderAudioStart.1":
|
|
genericResponse = ResponseType.RenderAudioStart;
|
|
break;
|
|
case "Session.RenderAudioStop.1":
|
|
genericResponse = ResponseType.RenderAudioStop;
|
|
break;
|
|
case "Aux.CaptureAudioStart.1":
|
|
genericResponse = ResponseType.CaptureAudioStart;
|
|
break;
|
|
case "Aux.CaptureAudioStop.1":
|
|
genericResponse = ResponseType.CaptureAudioStop;
|
|
break;
|
|
case "Aux.SetMicLevel.1":
|
|
genericResponse = ResponseType.SetMicLevel;
|
|
break;
|
|
case "Aux.SetSpeakerLevel.1":
|
|
genericResponse = ResponseType.SetSpeakerLevel;
|
|
break;
|
|
case "Account.Logout.1":
|
|
genericResponse = ResponseType.AccountLogout;
|
|
break;
|
|
case "Session.Connect.1":
|
|
genericResponse = ResponseType.SessionConnect;
|
|
break;
|
|
case "Session.Terminate.1":
|
|
genericResponse = ResponseType.SessionTerminate;
|
|
break;
|
|
case "Session.SetParticipantVolumeForMe.1":
|
|
genericResponse = ResponseType.SetParticipantVolumeForMe;
|
|
break;
|
|
case "Session.SetParticipantMuteForMe.1":
|
|
genericResponse = ResponseType.SetParticipantMuteForMe;
|
|
break;
|
|
case "Session.Set3DPosition.1":
|
|
genericResponse = ResponseType.Set3DPosition;
|
|
break;
|
|
default:
|
|
Logger.Log("Unimplemented response from the voice daemon: " + line, Helpers.LogLevel.Error);
|
|
break;
|
|
}
|
|
|
|
// Send the Response Event for all the simple cases.
|
|
if (genericResponse != ResponseType.None && OnVoiceResponse != null)
|
|
{
|
|
OnVoiceResponse(rsp.InputXml.Request,
|
|
new VoiceResponseEventArgs(
|
|
genericResponse,
|
|
int.Parse(rsp.ReturnCode),
|
|
int.Parse(rsp.Results.StatusCode),
|
|
rsp.Results.StatusString));
|
|
}
|
|
}
|
|
else if (line.Substring(0, 7) == "<Event ")
|
|
{
|
|
VoiceEvent evt = null;
|
|
try
|
|
{
|
|
evt = (VoiceEvent)EventSerializer.Deserialize(new StringReader(line));
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logger.Log("Failed to deserialize voice daemon event", Helpers.LogLevel.Error, e);
|
|
return;
|
|
}
|
|
|
|
switch (evt.Type)
|
|
{
|
|
case "LoginStateChangeEvent":
|
|
case "AccountLoginStateChangeEvent":
|
|
if (OnAccountLoginStateChangeEvent != null)
|
|
{
|
|
OnAccountLoginStateChangeEvent(this,
|
|
new AccountLoginStateChangeEventArgs(
|
|
evt.AccountHandle,
|
|
int.Parse(evt.StatusCode),
|
|
evt.StatusString,
|
|
(LoginState)int.Parse(evt.State)));
|
|
}
|
|
break;
|
|
|
|
case "SessionNewEvent":
|
|
if (OnSessionNewEvent != null)
|
|
{
|
|
OnSessionNewEvent(this,
|
|
new NewSessionEventArgs(
|
|
evt.AccountHandle,
|
|
evt.SessionHandle,
|
|
evt.URI,
|
|
bool.Parse(evt.IsChannel),
|
|
evt.Name,
|
|
evt.AudioMedia));
|
|
}
|
|
break;
|
|
|
|
case "SessionStateChangeEvent":
|
|
if (OnSessionStateChangeEvent != null)
|
|
{
|
|
OnSessionStateChangeEvent(this,
|
|
new SessionStateChangeEventArgs(
|
|
evt.SessionHandle,
|
|
int.Parse(evt.StatusCode),
|
|
evt.StatusString,
|
|
(SessionState)int.Parse(evt.State),
|
|
evt.URI,
|
|
bool.Parse(evt.IsChannel),
|
|
evt.ChannelName));
|
|
}
|
|
break;
|
|
|
|
case "ParticipantAddedEvent":
|
|
Logger.Log("Add participant " + evt.ParticipantUri, Helpers.LogLevel.Debug);
|
|
if (OnSessionParticipantAddedEvent != null)
|
|
{
|
|
OnSessionParticipantAddedEvent(this,
|
|
new ParticipantAddedEventArgs(
|
|
evt.SessionGroupHandle,
|
|
evt.SessionHandle,
|
|
evt.ParticipantUri,
|
|
evt.AccountName,
|
|
evt.DisplayName,
|
|
(ParticipantType)int.Parse(evt.ParticipantType),
|
|
evt.Application));
|
|
}
|
|
break;
|
|
|
|
case "ParticipantRemovedEvent":
|
|
if (OnSessionParticipantRemovedEvent != null)
|
|
{
|
|
OnSessionParticipantRemovedEvent(this,
|
|
new ParticipantRemovedEventArgs(
|
|
evt.SessionGroupHandle,
|
|
evt.SessionHandle,
|
|
evt.ParticipantUri,
|
|
evt.AccountName,
|
|
evt.Reason));
|
|
}
|
|
break;
|
|
|
|
case "ParticipantStateChangeEvent":
|
|
// Useful in person-to-person calls
|
|
if (OnSessionParticipantStateChangeEvent != null)
|
|
{
|
|
OnSessionParticipantStateChangeEvent(this,
|
|
new ParticipantStateChangeEventArgs(
|
|
evt.SessionHandle,
|
|
int.Parse(evt.StatusCode),
|
|
evt.StatusString,
|
|
(ParticipantState)int.Parse(evt.State), // Ringing, Connected, etc
|
|
evt.ParticipantUri,
|
|
evt.AccountName,
|
|
evt.DisplayName,
|
|
(ParticipantType)int.Parse(evt.ParticipantType)));
|
|
}
|
|
break;
|
|
|
|
case "ParticipantPropertiesEvent":
|
|
if (OnSessionParticipantPropertiesEvent != null)
|
|
{
|
|
OnSessionParticipantPropertiesEvent(this,
|
|
new ParticipantPropertiesEventArgs(
|
|
evt.SessionHandle,
|
|
evt.ParticipantUri,
|
|
bool.Parse(evt.IsLocallyMuted),
|
|
bool.Parse(evt.IsModeratorMuted),
|
|
bool.Parse(evt.IsSpeaking),
|
|
int.Parse(evt.Volume),
|
|
float.Parse(evt.Energy)));
|
|
}
|
|
break;
|
|
|
|
case "ParticipantUpdatedEvent":
|
|
if (OnSessionParticipantUpdatedEvent != null)
|
|
{
|
|
OnSessionParticipantUpdatedEvent(this,
|
|
new ParticipantUpdatedEventArgs(
|
|
evt.SessionHandle,
|
|
evt.ParticipantUri,
|
|
bool.Parse(evt.IsModeratorMuted),
|
|
bool.Parse(evt.IsSpeaking),
|
|
int.Parse(evt.Volume),
|
|
float.Parse(evt.Energy)));
|
|
}
|
|
break;
|
|
|
|
case "SessionGroupAddedEvent":
|
|
if (OnSessionGroupAddedEvent != null)
|
|
{
|
|
OnSessionGroupAddedEvent(this,
|
|
new SessionGroupAddedEventArgs(
|
|
evt.AccountHandle,
|
|
evt.SessionGroupHandle,
|
|
evt.Type));
|
|
}
|
|
break;
|
|
|
|
case "SessionAddedEvent":
|
|
if (OnSessionAddedEvent != null)
|
|
{
|
|
OnSessionAddedEvent(this,
|
|
new SessionAddedEventArgs(
|
|
evt.SessionGroupHandle,
|
|
evt.SessionHandle,
|
|
evt.Uri,
|
|
bool.Parse(evt.IsChannel),
|
|
bool.Parse(evt.Incoming)));
|
|
}
|
|
break;
|
|
|
|
case "SessionRemovedEvent":
|
|
if (OnSessionRemovedEvent != null)
|
|
{
|
|
OnSessionRemovedEvent(this,
|
|
new SessionRemovedEventArgs(
|
|
evt.SessionGroupHandle,
|
|
evt.SessionHandle,
|
|
evt.Uri));
|
|
}
|
|
break;
|
|
|
|
case "SessionUpdatedEvent":
|
|
if (OnSessionRemovedEvent != null)
|
|
{
|
|
OnSessionUpdatedEvent(this,
|
|
new SessionUpdatedEventArgs(
|
|
evt.SessionGroupHandle,
|
|
evt.SessionHandle,
|
|
evt.Uri,
|
|
int.Parse(evt.IsMuted) != 0,
|
|
int.Parse(evt.Volume),
|
|
int.Parse(evt.TransmitEnabled) != 0,
|
|
+ int.Parse(evt.IsFocused) != 0));
|
|
}
|
|
break;
|
|
|
|
case "AuxAudioPropertiesEvent":
|
|
if (OnAuxAudioPropertiesEvent != null)
|
|
{
|
|
OnAuxAudioPropertiesEvent(this,
|
|
new AudioPropertiesEventArgs(
|
|
bool.Parse(evt.MicIsActive),
|
|
float.Parse(evt.MicEnergy),
|
|
int.Parse(evt.MicVolume),
|
|
int.Parse(evt.SpeakerVolume)));
|
|
}
|
|
break;
|
|
|
|
case "SessionMediaEvent":
|
|
if (OnSessionMediaEvent != null)
|
|
{
|
|
OnSessionMediaEvent(this,
|
|
new SessionMediaEventArgs(
|
|
evt.SessionHandle,
|
|
bool.Parse(evt.HasText),
|
|
bool.Parse(evt.HasAudio),
|
|
bool.Parse(evt.HasVideo),
|
|
bool.Parse(evt.Terminated)));
|
|
}
|
|
break;
|
|
|
|
case "BuddyAndGroupListChangedEvent":
|
|
// TODO * <AccountHandle>c1_m1000xrjiQgi95QhCzH_D6ZJ8c5A==</AccountHandle><Buddies /><Groups />
|
|
break;
|
|
|
|
case "MediaStreamUpdatedEvent":
|
|
// TODO <SessionGroupHandle>c1_m1000xrjiQgi95QhCzH_D6ZJ8c5A==_sg0</SessionGroupHandle>
|
|
// <SessionHandle>c1_m1000xrjiQgi95QhCzH_D6ZJ8c5A==0</SessionHandle>
|
|
//<StatusCode>0</StatusCode><StatusString /><State>1</State><Incoming>false</Incoming>
|
|
|
|
break;
|
|
|
|
default:
|
|
Logger.Log("Unimplemented event from the voice daemon: " + line, Helpers.LogLevel.Error);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.Log("Unrecognized data from the voice daemon: " + line, Helpers.LogLevel.Error);
|
|
}
|
|
}
|
|
}
|
|
}
|