private void _WebSocket_OnMessage(object sender, MessageEventArgs e)
{
_lastReceivedTime = DateTime.UtcNow;
string data = "";
if (e.IsBinary)
{
data = GZipDecompresser.Decompress(e.RawData);
}
else
{
data = System.Text.Encoding.Default.GetString(e.RawData);
}
var pingMessage = JsonConvert.DeserializeObject <PingMessage>(data);
if (pingMessage != null && pingMessage.ping != 0)
{
_logger.Log(Log.LogLevel.Trace, $"WebSocekt received data, ping={pingMessage.ping}");
string pongData = $"{{\"pong\":{pingMessage.ping}}}";
_WebSocket.Send(pongData);
_logger.Log(Log.LogLevel.Trace, $"WebSocket replied data, pong={pingMessage.ping}");
}
else
{
OnResponseReceived?.Invoke(data);
}
}
/// <summary>
/// Handles the login as a coroutine.
/// </summary>
/// <param name="username">The username that is used.</param>
/// <param name="password">The password that is used.</param>
/// <param name="onResponseReceived">The handler to call on success.</param>
/// <param name="onErrorReceived">The handler to call on error.</param>
/// <returns>An enumerator.</returns>
private IEnumerator _LoginCoroutine(string username, string password, OnResponseReceived onResponseReceived, OnErrorReceived onErrorReceived)
{
var form = new WWWForm();
form.AddField("grant_type", "password");
form.AddField("username", username);
form.AddField("password", password);
using (var req = UnityWebRequest.Post(BaseUrl + "token", form))
{
req.SetRequestHeader("grant_type", "application/x-www-form-urlencoded");
req.downloadHandler = new DownloadHandlerBuffer();
yield return(req.SendWebRequest());
if (req.isNetworkError || req.isHttpError)
{
onErrorReceived(req.error);
}
else
{
onResponseReceived(req.downloadHandler.text);
}
}
}
private static async void WebSocketClient_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
if (args.MessageType == SocketMessageType.Utf8)
{
string jsonOutput = null;
using (var dataReader = args.GetDataReader())
{
dataReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
jsonOutput = dataReader.ReadString(dataReader.UnconsumedBufferLength);
}
// Occasionally, the Direct Line service sends an empty message as a liveness ping. Ignore these messages.
if (string.IsNullOrWhiteSpace(jsonOutput))
{
return;
}
var activitySet = JsonConvert.DeserializeObject <ActivitySet>(jsonOutput);
var activities = activitySet.Activities.Where(a => a.From.Id == Settings.Instance.BotId);
foreach (var activity in activities)
{
Debug.WriteLine(activity.Text);
OnResponseReceived?.Invoke(null, new BotEventArgs(activity.Text));
// If there is an audio attached to the response, automatically speaks it.
var audioResponseUrl = activity.Attachments?.FirstOrDefault(a => a.ContentType == "audio/mp3")?.ContentUrl;
if (audioResponseUrl != null)
{
await TextToSpeech.SpeakAsync(activity.Speak ?? activity.Text, Settings.Instance.Culture, audioResponseUrl);
}
}
}
}
public async Task GetResponse()
{
var responseRestService = Container.Instance.Resolve <ResponseRestService>();
var responsesViewModel = Container.Instance.Resolve <ResponsesViewModel>();
var response = await responseRestService.GetResponse(ResponseId);
Response = response;
OnResponseReceived?.Invoke();
responsesViewModel.HandleResponseModelReceived(response);
}
private async Task Listen()
{
var bytesReceived = new byte[256];
Debug.WriteLine("Blackmagic listener started!");
while (true)
{
try
{
var readTask = _stream.ReadAsync(bytesReceived, 0, bytesReceived.Length, _cancellationTokenSource.Token);
await Task.WhenAny(readTask, Task.Delay(-1, _cancellationTokenSource.Token)).ConfigureAwait(false);
if (_cancellationTokenSource.IsCancellationRequested)
{
throw new OperationCanceledException(_cancellationTokenSource.Token);
}
if (!readTask.IsCompleted)
{
continue;
}
int bytes;
if ((bytes = readTask.Result) == 0)
{
continue;
}
var response = System.Text.Encoding.ASCII.GetString(bytesReceived, 0, bytes);
OnResponseReceived?.Invoke(this, new EventArgs <string>(response));
}
catch (OperationCanceledException)
{
Debug.WriteLine("Listener canceled");
break;
}
catch (System.IO.IOException ioException)
{
if (_tcpClient.Connected)
{
Debug.WriteLine($"Blackmagic listener encountered error: {ioException}");
continue;
}
Logger.Error(ioException, "Blackmagic listener was closed forcibly, attempting to reconnect to Blackmagic.");
Debug.WriteLine($"Blackmagic listener was closed forcibly: {ioException}\n Attempting to reconnect to Blackmagic...");
Disconnect();
break;
}
catch (Exception ex)
{
Logger.Error(ex, "Unknown Blackmagic listener error");
Debug.WriteLine($"Blackmagic listener error. {ex.Message}");
}
}
}
public void ReceivedCommandResponse(ZToolPacket packet)
{
_logger.Trace(" {} received as synchronous command.", packet.GetType().Name);
lock (packet) {
OnResponseReceived?.Invoke(this, packet);
// Do not set response[0] again.
//response[0] = packet;
//response.notify();
}
}
public R Request(S obj)
{
using (var client = new NamedPipeClientStream(ServerName, PipeName))
{
client.Connect();
Formatter.Serialize(client, obj);
OnRequestSended?.Invoke(this, obj);
var response = Formatter.Deserialize <R>(client);
OnResponseReceived?.Invoke(this, response);
return(response);
}
}
public async Task <R> RequestAsync(S obj, CancellationToken cancellationToken)
{
using (var client = new NamedPipeClientStream(ServerName, PipeName))
{
await client.ConnectAsync(cancellationToken);
Formatter.Serialize(client, obj);
OnRequestSended?.Invoke(this, obj);
var response = Formatter.Deserialize <R>(client);
OnResponseReceived?.Invoke(this, response);
return(response);
}
}
public void ClearEventHandlers()
{
if (OnResponseReceived == null)
{
return;
}
Delegate[] handlers = OnResponseReceived.GetInvocationList();
foreach (var handler in handlers)
{
OnResponseReceived -= (handler as ResponseReceivedHandler);
}
}
// Send a command asynchronously, and perform the appropriate callback when a response is received,
// or the request times out.
public void SendCommandAsync(Command command, OnResponseReceived OnReceived, OnResponseTimeout OnTimeout, TimeSpan timeout)
{
connection.SendMessage(
0,
command.ID,
"",
(string answer) => {
OnReceived(new List <string>(answer.Split('\n')));
},
() => {
OnTimeout();
},
timeout
);
}
private void EmitResponseReceived(string name, IPEndPoint serviceEndPoint, EndPoint remoteEndPoint, byte[] payload)
{
if (ForwardResponse(serviceEndPoint, remoteEndPoint))
{
OnResponseReceived?.Invoke(new Service(name,
serviceEndPoint,
_localAddress,
_networkInterfaceId,
payload));
}
else
{
Log.DebugFormat("Ignoring local service '{0}' from '{1}', we can't possibly connect to it",
serviceEndPoint,
remoteEndPoint);
}
}
protected override void PostRequest(ResponseContainer response)
{
Logger.Instance.Log(LogLevel.Debug, $"Got {response.StatusCode} to {response.RequestMessage.RequestUri}, ({response.ParsedObjects.Count:N0} parsed objects)");
Debug.WriteLine($"Response to {response.RequestMessage.RequestUri}, ({response.ParsedObjects.Count:N0} parsed objects)");
foreach (DataObject dataObject in response.ParsedObjects)
{
Debug.WriteLine($"Parsed object by {dataObject.ParserType}: {dataObject}");
}
// Save to DB
foreach (SaverBase saver in _savers)
{
saver.Run(response.ParsedObjects);
}
// Execute other interests
OnResponseReceived?.Invoke(response);
}
/// <summary>
/// Handles the getting of a profile as a coroutine.
/// </summary>
/// <param name="id">The profile's id</param>
/// <param name="onResponseReceived">The handler to call on success.</param>
/// <param name="onErrorReceived">The handler to call on error.</param>
/// <returns>An enumerator.</returns>
private IEnumerator _GetProfileCoroutine(string id, OnResponseReceived onResponseReceived, OnErrorReceived onErrorReceived)
{
using (var req = UnityWebRequest.Get(BaseUrl + "api/user-contexts/" + id))
{
req.SetRequestHeader("content-type", "application/json");
req.SetRequestHeader("authorization", _loginResponse.Token);
req.downloadHandler = new DownloadHandlerBuffer();
yield return(req.SendWebRequest());
if (req.isNetworkError || req.isHttpError)
{
onErrorReceived(req.error);
}
else
{
onResponseReceived(req.downloadHandler.text);
}
}
}
/*
* The Listen method.
* The method works as long as the connection
* to the remote host is alive. It gets a buffer
* from the stream, and if it's not null - it writes
* it to the console (When we will have a GUI, it will
* be shown as a responsive design).
*/
private void Listen()
{
try
{
// As long as the connection is alive...
while (_connected)
{
try
{
Nullable <char> c = null;
string response = string.Empty;
// Read a buffer from the stream
while ((c = (char)(_streamReader.Read())) != '|' && !_streamReader.EndOfStream)
{
response += c;
}
// If it is null, raise an exception.
if (response == null || string.IsNullOrWhiteSpace(response))
{
_connected = false;
continue;
}
// Otherwise, write the data to the console.
if (!string.IsNullOrWhiteSpace(response))
{
OnResponseReceived?.Invoke(response);
_streamReader.BaseStream.Flush();
}
}
catch (Exception)
{
_connected = false;
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public void Receive(Response response)
{
if (response.GetType() == typeof(FailureDetectionResponse))
{
(response as FailureDetectionResponse).DeadEdges.ForEach(edge => comms.Node.Router.DeleteEdge(edge.Item1, edge.Item2));
}
new Thread(() =>
{
Thread.Sleep(Constants.SEND_DURATION_TIME / Constants.TimeScale);
if (response.DestinationID == comms.Node.Id)
{
OnResponseReceived?.Invoke(this, new ResponseEventArgs(response));
}
else
{
uint?nextHop = comms.Node.Router.NextHop(comms.Node.Id, response.DestinationID);
Send(nextHop, response);
}
}).Start();
}
public void Start(string[] ips, int count = 4)
{
var goal = ips.Length * count;
var local = LocalIp;
OnResponseReceived?.Invoke($"Current IP: {local} ({GetIpLocation(local)})");
new Thread(new ThreadStart(() =>
{
foreach (var ip in ips.Select((value, index) => new { value, index }))
{
var roundTrip = new List <int>();
var head = $">>>>>>>>>>>>>>>>> Started to ping [{ip.value}]: ";
OnResponseReceived?.Invoke(head);
for (int i = 0; i < count; i++)
{
OnResponseReceived(DoPing(ip.value));
OnProgressUpdated(ip.index * 4 + i + 1, goal);
Thread.Sleep(1000);
}
}
OnResponseReceived?.Invoke("================== Done ===================");
})).Start();
}
private void _WebSocket_OnMessage(object sender, MessageEventArgs e)
{
_lastReceivedTime = DateTime.UtcNow;
if (e.IsBinary)
{
string data = GZipDecompresser.Decompress(e.RawData);
var pingMessage = JsonConvert.DeserializeObject <PingMessage>(data);
if (pingMessage != null && pingMessage.ping != 0)
{
//Console.WriteLine($"received ping:{pingMessage.ping}");
string pongData = $"{{\"pong\":{pingMessage.ping}}}";
_WebSocket.Send(pongData);
//Console.WriteLine($"replied pong:{pingMessage.ping}");
}
else
{
var response = JsonConvert.DeserializeObject <DataResponseType>(data);
OnResponseReceived?.Invoke(response);
}
}
}
/// <summary>
/// Method implements initial request. Returned result sets to Atomics.UnitDescription property and
/// to internal this._xmlDescription variable.
/// </summary>
/// <param name="hostNameorAddress">Host name or IP address of the AV receiver</param>
public bool RequestUnitDescription(string hostNameorAddress)
{
Atomics.HostNameOrIPAddress = hostNameorAddress;
bool result = false;
try
{
if (PingIpAddress(3, hostNameorAddress) == true)
{
string ynccmd = YNCCommand.CreateCommand(MethodType.NONE);
Atomics.UnitDescription = Http.Send(hostNameorAddress, Atomics.UnitDescriptionPath, HttpMethod.Get, ynccmd);
UnitDescription = Atomics.UnitDescription;
OnResponseReceived?.Invoke(this, new CommEventArgs()
{
Success = true, UnitDescription = Atomics.UnitDescription, YNCFunction = CommandListFunctionType.UnitDescription
});
result = true;
}
else
{
throw new Exception("Receiver is not accessible.");
}
}
catch (Exception ex)
{
OnResponseReceived?.Invoke(this, new CommEventArgs()
{
Success = false, ErrorMessage = ex.Message, YNCFunction = CommandListFunctionType.UnitDescription
});
}
return(result);
}
public void ReceivedCommandResponse(ZToolPacket packet)
{
Log.Verbose(" {Packet} received as synchronous command.", packet.GetType().Name);
OnResponseReceived?.Invoke(this, packet);
}
private static void CallHandler(object obj, HttpResponseMessage response)
{
var args = new ResponseEventArguments(DateTime.Now, response.StatusCode);
OnResponseReceived.Invoke(obj, args);
}
private void sender_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
inUse = false;
OnResponseReceived?.Invoke(this, new ResponseReceivedEventArgs(asyncResponse));
}
private void SocketOnResponseReceived(Service service)
{
OnResponseReceived?.Invoke(service);
}
private Task HandleResponse(JsonObject data)
{
OnResponseReceived?.Invoke(this, data);
return(Task.CompletedTask);
}
public AppServiceResponseListener(OnResponseReceived onReceived)
{
this.onResponseReceived = onReceived;
}
public static async void StartService()
{
try
{
if (isRunning)
{
// If the service is already running, exits.
return;
}
isRunning = true;
var isConnected = false;
while (!isConnected)
{
// Be sure to be connected to the Internet.
var profile = NetworkInformation.GetInternetConnectionProfile();
isConnected = profile?.GetNetworkConnectivityLevel() == NetworkConnectivityLevel.InternetAccess;
await Task.Delay(200);
}
if (Settings.Instance == null)
{
await LoadSettingsAsync();
}
if (directLineClient == null)
{
// Obtain a token using the Direct Line secret
var tokenResponse = await new DirectLineClient(Settings.Instance.DirectLineSecret).Tokens.GenerateTokenForNewConversationAsync();
// Use token to create conversation
directLineClient = new DirectLineClient(tokenResponse.Token);
conversation = await directLineClient.Conversations.StartConversationAsync();
// Connect using a WebSocket.
webSocketClient = new MessageWebSocket();
webSocketClient.MessageReceived += WebSocketClient_MessageReceived;
await webSocketClient.ConnectAsync(new Uri(conversation.StreamUrl));
}
if (assistantInvokerSpeechRecognizer == null)
{
// Create an instance of SpeechRecognizer.
assistantInvokerSpeechRecognizer = new SpeechRecognizer(new Language(Settings.Instance.Culture));
assistantInvokerSpeechRecognizer.Timeouts.InitialSilenceTimeout = TimeSpan.MaxValue;
assistantInvokerSpeechRecognizer.Timeouts.BabbleTimeout = TimeSpan.MaxValue;
// Add a list constraint to the recognizer.
var listConstraint = new SpeechRecognitionListConstraint(new string[] { Settings.Instance.AssistantName }, "assistant");
assistantInvokerSpeechRecognizer.Constraints.Add(listConstraint);
await assistantInvokerSpeechRecognizer.CompileConstraintsAsync();
}
if (commandSpeechRecognizer == null)
{
commandSpeechRecognizer = new SpeechRecognizer(new Language(Settings.Instance.Culture));
// Apply the dictation topic constraint to optimize for dictated freeform speech.
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "dictation");
commandSpeechRecognizer.Constraints.Add(dictationConstraint);
await commandSpeechRecognizer.CompileConstraintsAsync();
}
// The assistant is ready to receive input.
SoundPlayer.Instance.Play(Sounds.SpeechActive);
while (isRunning)
{
try
{
var assistantInvocationResult = await assistantInvokerSpeechRecognizer.RecognizeAsync();
if (assistantInvocationResult.Status == SpeechRecognitionResultStatus.Success && assistantInvocationResult.Confidence != SpeechRecognitionConfidence.Rejected)
{
OnStartRecognition?.Invoke(null, EventArgs.Empty);
SoundPlayer.Instance.Play(Sounds.Ready);
// Starts command recognition. It returns when the first utterance has been recognized.
var commandResult = await commandSpeechRecognizer.RecognizeAsync();
if (commandResult.Status == SpeechRecognitionResultStatus.Success && commandResult.Confidence != SpeechRecognitionConfidence.Rejected)
{
var command = commandResult.NormalizeText();
Debug.WriteLine(command);
OnCommandReceived?.Invoke(null, EventArgs.Empty);
// Sends the activity to the Bot. The answer will be received in the WebSocket received event handler.
var userMessage = new Activity
{
From = new ChannelAccount(Settings.Instance.UserName),
Text = command,
Type = ActivityTypes.Message
};
await directLineClient.Conversations.PostActivityAsync(conversation.ConversationId, userMessage);
}
}
}
catch (Exception ex)
{
OnResponseReceived?.Invoke(null, new BotEventArgs(ex.Message));
}
}
// Clean up used resources.
SoundPlayer.Instance.Play(Sounds.SpeechStopped);
}
catch (Exception ex)
{
OnResponseReceived?.Invoke(null, new BotEventArgs(ex.Message));
SoundPlayer.Instance.Play(Sounds.SpeechStopped);
}
assistantInvokerSpeechRecognizer?.Dispose();
commandSpeechRecognizer?.Dispose();
webSocketClient?.Dispose();
directLineClient?.Dispose();
assistantInvokerSpeechRecognizer = null;
commandSpeechRecognizer = null;
webSocketClient = null;
conversation = null;
directLineClient = null;
isRunning = false;
}
