/// <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);
}
