/// <summary> /// Send a request to listen to multiple topics /// </summary> /// <param name="accessToken">Access token with the required scopes to listen for the desired topics</param> /// <param name="topics">Topics to handle</param> /// <returns></returns> public static async Task Listen(string accessToken, string[] topics) { ListenRequest listenRequest = new ListenRequest(accessToken, topics); s_ListenNonce = listenRequest.nonce; await SendAsync(JObject.FromObject(listenRequest)); }
/// <summary>Snippet for Listen</summary> public async Task Listen() { // Snippet: Listen(CallSettings, BidirectionalStreamingSettings) // Create client FirestoreClient firestoreClient = FirestoreClient.Create(); // Initialize streaming call, retrieving the stream object FirestoreClient.ListenStream response = firestoreClient.Listen(); // Sending requests and retrieving responses can be arbitrarily interleaved // Exact sequence will depend on client/server behavior // Create task to do something with responses from server Task responseHandlerTask = Task.Run(async() => { // Note that C# 8 code can use await foreach AsyncResponseStream <ListenResponse> responseStream = response.GetResponseStream(); while (await responseStream.MoveNextAsync()) { ListenResponse responseItem = responseStream.Current; // Do something with streamed response } // The response stream has completed }); // Send requests to the server bool done = false; while (!done) { // Initialize a request ListenRequest request = new ListenRequest { Database = "", AddTarget = new Target(), RemoveTarget = 0, Labels = { { "", "" }, }, }; // Stream a request to the server await response.WriteAsync(request); // Set "done" to true when sending requests is complete } // Complete writing requests to the stream await response.WriteCompleteAsync(); // Await the response handler // This will complete once all server responses have been processed await responseHandlerTask; // End snippet }
// Visible for testing internal ListenRequest CreateRequest(ByteString resumeToken) { var request = new ListenRequest { AddTarget = _target.Clone(), Database = _db.RootPath }; if (resumeToken != null) { request.AddTarget.ResumeToken = resumeToken; } return(request); }
/// <summary>Snippet for Listen</summary> public async Task Listen() { // Snippet: Listen(CallSettings,BidirectionalStreamingSettings) // Create client FirestoreClient firestoreClient = FirestoreClient.Create(); // Initialize streaming call, retrieving the stream object FirestoreClient.ListenStream duplexStream = firestoreClient.Listen(); // Sending requests and retrieving responses can be arbitrarily interleaved. // Exact sequence will depend on client/server behavior. // Create task to do something with responses from server Task responseHandlerTask = Task.Run(async() => { IAsyncEnumerator <ListenResponse> responseStream = duplexStream.ResponseStream; while (await responseStream.MoveNext()) { ListenResponse response = responseStream.Current; // Do something with streamed response } // The response stream has completed }); // Send requests to the server bool done = false; while (!done) { // Initialize a request ListenRequest request = new ListenRequest { Database = new DatabaseRootName("[PROJECT]", "[DATABASE]").ToString(), }; // Stream a request to the server await duplexStream.WriteAsync(request); // Set "done" to true when sending requests is complete } // Complete writing requests to the stream await duplexStream.WriteCompleteAsync(); // Await the response handler. // This will complete once all server responses have been processed. await responseHandlerTask; // End snippet }
// // ListenToDocument(string documentPath) // // Listen to changes in a specific document public void ListenToDocument(string documentPath) { // Initialize a request var dt = new DocumentsTarget { }; dt.Documents.Add(documentPath); ListenRequest request = new ListenRequest { Database = new DatabaseRootName(ProjectId, DatabaseId).ToString(), AddTarget = new Target { Documents = dt } }; PendingRequests.Add(request); }
// // ListenToQuery(StructuredQuery query) // // Start listening to a query. I've not tried listening to multiple quries, your mileage may vary with that. public void ListenToQuery(StructuredQuery query) { var qt = new QueryTarget { }; qt.StructuredQuery = query; qt.Parent = string.Format("projects/{0}/databases/{1}/documents", ProjectId, DatabaseId); ListenRequest request = new ListenRequest { Database = new DatabaseRootName(ProjectId, DatabaseId).ToString(), AddTarget = new Target { Query = qt, } }; PendingRequests.Add(request); }
public override async Task Listen(ListenRequest request, IServerStreamWriter <ListenResponse> responseStream, ServerCallContext context) { var channel = _chatter.Listen(request.RoomId); var userName = request.UserName; while (await channel.WaitToReadAsync()) { while (channel.TryRead(out var message)) { if (message.UserName.Equals(userName, StringComparison.OrdinalIgnoreCase)) { continue; } await responseStream.WriteAsync(new ListenResponse { UserName = message.UserName, Message = message.Text }); } } }
public override async Task Listen(ListenRequest request, IServerStreamWriter <ListenResponse> responseStream, ServerCallContext context) { var client = new Client(); client.Session = request.SessionToken; clients.TryAdd(client.Session, client); var connected = true; do { try { await client.Trigger.WaitAsync(); while (client.Queue.TryDequeue(out var message)) { var messageProto = new ChatMessage { Message = message.Text, Channel = " ", }; await responseStream.WriteAsync(new ListenResponse { Message = messageProto }); } client.Trigger.Reset(); } catch (Exception e) { connected = false; } }while (connected); clients.TryRemove(client.Session, out client); }
public IAsyncResult BeginListen(CIPMask service, AsyncCallback callback, object state) { try { ListenRequest request = new ListenRequest(_id); request.CIPMask = service; MessageAsyncResult result = new MessageAsyncResult(this, request, callback, state); _application.SendRequestMessage(result); return result; } catch (Exception e) { Trace.TraceError("Controller#{0}::BeginListen, Exception = {1}", ValidationHelper.HashString(this), e); throw; } }
/// <summary> /// Pull data from item and create ListenRequest instance with them. /// </summary> /// <param name="item">Audio item containing data.</param> /// <param name="includeTimestamp">If timestamp should be included. Defaults to true.</param> /// <returns>ListenRequest instace with data.</returns> private ListenRequest BuildListenRequest(Audio item, bool includeTimestamp = true) { var listenRequest = new ListenRequest(); if (includeTimestamp) { listenRequest.ListenedAt = Helpers.GetCurrentTimestamp(); } if (item.ProviderIds.ContainsKey("MusicBrainzArtist")) { var artistIds = item.ProviderIds["MusicBrainzArtist"].Split(';'); listenRequest.ArtistMbIds = new List <string>(artistIds); } else { listenRequest.ArtistMbIds = new List <string>(); } if (item.ProviderIds.ContainsKey("MusicBrainzAlbum")) { listenRequest.AlbumMbId = item.ProviderIds["MusicBrainzAlbum"]; } if (item.ProviderIds.ContainsKey("MusicBrainzTrack")) { listenRequest.TrackMbId = item.ProviderIds["MusicBrainzTrack"]; } if (item.ProviderIds.ContainsKey("MusicBrainzRecording")) { listenRequest.RecordingMbId = item.ProviderIds["MusicBrainzRecording"]; } else if (!string.IsNullOrEmpty(listenRequest.TrackMbId)) { var recordingId = GetRecordingId(item.Name, listenRequest.TrackMbId); if (recordingId != null) { listenRequest.RecordingMbId = recordingId; } else { listenRequest.TrackMbId = null; } } if (!string.IsNullOrEmpty(item.Artists[0])) { listenRequest.Artist = item.Artists[0]; } if (!string.IsNullOrEmpty(item.Album)) { listenRequest.Album = item.Album; } if (!string.IsNullOrEmpty(item.Name)) { listenRequest.Track = item.Name; } return(listenRequest); }
private void SendFakeListenRequest() { ListenRequest request = new ListenRequest(0); request.CIPMask = CIPMask.None; SendMessage(request); }