public async Task VolumeMuteMessageAsync(bool muted)
{
if (connection.ConnectionState == DeviceConnectionState.Connected)
{
await SendMessageAsync(ChromeCastMessages.GetVolumeMuteMessage(muted, GetNextRequestId()));
}
}
public async Task ConnectAsync(string sourceId = null, string destinationId = null, Action connectedCallback = null)
{
await SendMessageAsync(ChromeCastMessages.GetConnectMessage(sourceId, destinationId));
var listener = new StreamingRequestsListener();
listener.Connected += async(Socket socket, string http) =>
{
var remoteAddress = ((IPEndPoint)socket.RemoteEndPoint).Address.ToString();
if (remoteAddress != connection.Host)
{
Debug.WriteLine("Address didn't match");
}
else
{
await ConnectRecordingDataAsync(socket);
}
if (connectedCallback != null)
{
connectedCallback();
}
};
var endpoint = listener.StartListening(Network.GetIp4Address());
if (endpoint == null)
{
throw new Exception("Can't listen ...");
}
streamingUrl = string.Format("http://{0}:{1}/", endpoint.Address.ToString(), endpoint.Port);
}
public void Write(CastMessage message, DeviceState state)
{
if (Disposed)
{
return;
}
logger.Log($"out [{DateTime.Now.ToLongTimeString()}] [{state}] [{ipAddress}:{port}] {message.PayloadUtf8}");
var byteArray = ChromeCastMessages.MessageToByteArray(message);
sslStream.BeginWrite(byteArray, 0, byteArray.Length, WriteAsyncCallback, sslStream);
}
public void ProcessMessage(DeviceListener deviceListener, CastMessage castMessage)
{
var options = new JsonSerializerOptions {
IncludeFields = true
};
var message = JsonSerializer.Deserialize <PayloadMessageBase>(castMessage.PayloadUtf8, options);
switch (message.type)
{
case "SET_VOLUME":
if (castMessage.PayloadUtf8.Contains("muted", System.StringComparison.CurrentCulture))
{
var volumeMuteMessage = JsonSerializer.Deserialize <MessageVolumeMute>(castMessage.PayloadUtf8, options);
SystemCalls.SetMute(volumeMuteMessage.volume.muted);
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(volumeMuteMessage.requestId, state, SecondsPlaying()), state);
deviceListener.Write(ChromeCastMessages.ReceiverStatusMessage(volumeMuteMessage.requestId), state);
}
else
{
var volumeMessage = JsonSerializer.Deserialize <MessageVolume>(castMessage.PayloadUtf8, options);
SystemCalls.SetVolume(volumeMessage.volume.level);
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(volumeMessage.requestId, state, SecondsPlaying()), state);
deviceListener.Write(ChromeCastMessages.ReceiverStatusMessage(volumeMessage.requestId), state);
}
break;
case "CONNECT":
state = DeviceState.Connected;
break;
case "CLOSE":
state = DeviceState.Closed;
var closeMessage = JsonSerializer.Deserialize <MessageStop>(castMessage.PayloadUtf8, options);
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(closeMessage.requestId, state, 0), state);
break;
case "LAUNCH":
state = DeviceState.Launching;
var launchMessage = JsonSerializer.Deserialize <MessageLaunch>(castMessage.PayloadUtf8, options);
deviceListener.Write(ChromeCastMessages.ReceiverStatusMessage(launchMessage.requestId), state);
break;
case "LOAD":
state = DeviceState.Loading;
var loadMessage = JsonSerializer.Deserialize <MessageLoad>(castMessage.PayloadUtf8, options);
logger.Log($"[{state}] Start playing: {loadMessage?.media?.contentId}");
SystemCalls.StartPlaying(loadMessage.media.contentId);
playerPlayTime = DateTime.Now;
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(loadMessage.requestId, state, SecondsPlaying()), state);
state = DeviceState.Buffering;
Task.Delay(2000).Wait();
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(loadMessage.requestId, state, SecondsPlaying()), state);
break;
case "PAUSE":
state = DeviceState.Paused;
var pauseMessage = JsonSerializer.Deserialize <MessagePause>(castMessage.PayloadUtf8, options);
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(pauseMessage.requestId, state, SecondsPlaying()), state);
break;
case "PLAY":
break;
case "STOP":
state = DeviceState.Idle;
var stopMessage = JsonSerializer.Deserialize <MessageStop>(castMessage.PayloadUtf8, options);
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(stopMessage.requestId, state, 0), state);
SystemCalls.StopPlaying();
break;
case "PING":
break;
case "PONG":
break;
case "GET_STATUS":
var getstatusMessage = JsonSerializer.Deserialize <MessageStatus>(castMessage.PayloadUtf8, options);
if (state == DeviceState.Buffering)
{
state = DeviceState.Playing;
}
switch (state)
{
case DeviceState.Idle:
case DeviceState.Closed:
case DeviceState.Connected:
deviceListener.Write(ChromeCastMessages.ReceiverStatusMessage(getstatusMessage.requestId), state);
break;
case DeviceState.Playing:
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(getstatusMessage.requestId, state, SecondsPlaying()), state);
break;
default:
deviceListener.Write(ChromeCastMessages.ReceiverStatusMessage(getstatusMessage.requestId), state);
break;
}
break;
default:
logger.Log($"in default [{DateTime.Now.ToLongTimeString()}] {message.type} {castMessage.PayloadUtf8}");
break;
}
}
public void SendNewVolume(float level, DeviceListener deviceListener)
{
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(0, state, SecondsPlaying()), state);
}
public async Task SendMessageAsync(CastMessage castMessage)
{
var byteMessage = ChromeCastMessages.MessageToByteArray(castMessage);
await connection.SendMessageAsync(new ArraySegment <byte>(byteMessage));
}
public async Task StopAsync()
{
await SendMessageAsync(ChromeCastMessages.GetStopMessage(chromeCastApplicationSessionNr, chromeCastMediaSessionId, GetNextRequestId(), chromeCastSource, chromeCastDestination));
}
public async Task GetMediaStatusAsync()
{
await SendMessageAsync(ChromeCastMessages.GetMediaStatusMessage(GetNextRequestId(), chromeCastSource, chromeCastDestination));
}
public async Task GetReceiverStatusAsync()
{
await SendMessageAsync(ChromeCastMessages.GetReceiverStatusMessage(GetNextRequestId()));
}
public async Task PongAsync()
{
await SendMessageAsync(ChromeCastMessages.GetPongMessage());
}
public async Task SetVolumeMessageAsync(Volume newVolume)
{
await SendMessageAsync(ChromeCastMessages.GetVolumeSetMessage(newVolume, GetNextRequestId()));
}
public async Task PauseMediaMessageAsync()
{
DeviceState = DeviceState.Paused;
await SendMessageAsync(ChromeCastMessages.GetPauseMessage(chromeCastApplicationSessionNr, chromeCastMediaSessionId, GetNextRequestId(), chromeCastSource, chromeCastDestination));
}
public async Task LoadMediaMessageAsync()
{
DeviceState = DeviceState.LoadingMedia;
await SendMessageAsync(ChromeCastMessages.GetLoadMessage(streamingUrl, chromeCastSource, chromeCastDestination));
}
public async Task LaunchMessageAsyncM()
{
await SendMessageAsync(ChromeCastMessages.GetLaunchMessage(GetNextRequestId()));
}
