public void SendNotification(string userID, string title, string body, Dictionary <string, string> data = null)
{
var registrationTokens = GetManyByUserID(userID)
.Select(m => m.Token)
.ToList();
if (registrationTokens.Count == 0)
{
return;
}
var message = new MulticastMessage()
{
Tokens = registrationTokens,
Data = new Dictionary <string, string>()
{
["title"] = title,
["body"] = body,
},
};
if (data != null && data.Count > 0)
{
foreach (var item in data)
{
if (!message.Data.ContainsKey(item.Key))
{
message.Data.Append(item);
}
}
}
var response = FirebaseMessaging.DefaultInstance.SendMulticastAsync(message).ConfigureAwait(true);
}
public static async Task <int> SendNotificationAsync(List <string> deviceTokens, string title, string body)
{
BatchResponse response = null;
if (deviceTokens.Count() > 0)
{
var content = new MulticastMessage
{
Tokens = deviceTokens,
Data = new Dictionary <string, string>()
{
{ "title", title },
{ "text", body },
},
};
response = await FirebaseMessaging.DefaultInstance.SendMulticastAsync(content);
if (response.FailureCount > 0)
{
var failedTokens = new List <string>();
for (var i = 0; i < response.Responses.Count; i++)
{
if (!response.Responses[i].IsSuccess)
{
failedTokens.Add(deviceTokens[i]);
}
}
}
}
return(response.SuccessCount);
}
public async void Post()
{
var app = fireBaseAppProvider.Get();
var firebaseMessaging = FirebaseMessaging.GetMessaging(app);
var to = mobileDevicesService.GetAll().ToList();
logger.LogInformation("Sending to {0} devices", to.Count);
var message = new MulticastMessage
{
Notification = new Notification
{
Title = "Hello from api",
Body = "Test message"
},
Android = new AndroidConfig
{
TimeToLive = TimeSpan.FromMinutes(1)
},
Tokens = to
};
var result = await firebaseMessaging.SendMulticastAsync(message);
logger.LogInformation("responce: {0}", JsonConvert.SerializeObject(result));
}
internal static async Task SendMulticastAsync()
{
// [START send_multicast]
// Create a list containing up to 500 registration tokens.
// These registration tokens come from the client FCM SDKs.
var registrationTokens = new List <string>()
{
"YOUR_REGISTRATION_TOKEN_1",
// ...
"YOUR_REGISTRATION_TOKEN_n",
};
var message = new MulticastMessage()
{
Tokens = registrationTokens,
Data = new Dictionary <string, string>()
{
{ "score", "850" },
{ "time", "2:45" },
},
};
var response = await FirebaseMessaging.DefaultInstance.SendMulticastAsync(message);
// See the BatchResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} messages were sent successfully");
// [END send_multicast]
}
public static async Task <BatchResponse> SendMessageFirebaseChatViaTokken(FCMMessageChatDTO model)
{
if (FirebaseApp.DefaultInstance == null)
{
var defaultApp = FirebaseApp.Create(new AppOptions()
{
Credential = GoogleCredential.FromFile(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "FBkey.json")),
});
}
//Convert Data to List Dictionnary
var jsonData = JsonConvert.SerializeObject(model.Data);
var dictionaryData = JsonConvert.DeserializeObject <Dictionary <string, string> >(jsonData);
var message = new MulticastMessage()
{
Data = dictionaryData,
Notification = new FirebaseAdmin.Messaging.Notification
{
Title = model.Notification.Title,
Body = model.Notification.Body
},
Tokens = model.Token
};
var messaging = FirebaseMessaging.DefaultInstance;
var result = await messaging.SendMulticastAsync(message);
return(result);
}
private async Task SendPushNotificationMessages(List <string> tokens, string title, string body, Dictionary <string, string> data, CancellationToken cancellationToken)
{
int tokenCount = tokens.Count <= 100 ? tokens.Count : 100;
if (tokenCount == 0)
{
return;
}
MulticastMessage message = new MulticastMessage
{
Tokens = tokens.Take(tokenCount).ToList(),
Notification = new Notification
{
Title = title,
Body = body,
},
Data = data,
};
BatchResponse response = await FirebaseMessaging.GetMessaging(_firebaseApp)
.SendMulticastAsync(message, cancellationToken);
// TODO: handle response
if (tokens.Count > 100)
{
await SendPushNotificationMessages(tokens.Skip(100).ToList(), title, body, data, cancellationToken);
}
}
public async Task <MessageSendResponse> SendMulticast(MessageSendRequest request)
{
var message = new MulticastMessage()
{
Notification = new Notification()
{
Title = request.NotificationTitle,
Body = request.NotificationBody,
},
Tokens = request.Tokens,
};
var response = await _firebaseService.SendMulticastAsync(message);
var returnResponse = new MessageSendResponse()
{
Responses = response.Responses.Select(x => new ResponseItem
{
IsSuccess = x.IsSuccess,
MessageId = x.MessageId,
Exception = x.IsSuccess ? null : new ExceptionItem
{
Message = x.Exception.Message,
MessagingErrorCode = x.Exception.MessagingErrorCode.HasValue ? (int)x.Exception.MessagingErrorCode : 0
}
}),
FailureCount = response.FailureCount,
SuccessCount = response.SuccessCount
};
return(returnResponse);
}
public virtual async Task <string> SendNotification(List <string> clientToken, string title, string body)
{
var registrationTokens = clientToken;
var message = new MulticastMessage()
{
Tokens = registrationTokens,
Data = new Dictionary <string, string>()
{
{ "title", title },
{ "body", body },
},
};
var firebaseApp = FirebaseApp.Create(new AppOptions()
{
Credential = GoogleCredential.FromFile(path_to_private_key),
}, "My_Sexy_App");
//FirebaseMessaging.GetMessaging(firebaseApp);
//var response = await FirebaseMessaging.DefaultInstance.SendMulticastAsync(message).ConfigureAwait(true);
var response = await FirebaseMessaging.GetMessaging(firebaseApp).SendMulticastAsync(message).ConfigureAwait(true);
var nresp = response.FailureCount + response.SuccessCount;
var eachResp = response.Responses;
return("");
}
public async Task SendMulticast()
{
var multicastMessage = new MulticastMessage
{
Notification = new Notification()
{
Title = "Title",
Body = "Body",
},
Android = new AndroidConfig()
{
Priority = Priority.Normal,
TimeToLive = TimeSpan.FromHours(1),
RestrictedPackageName = "com.google.firebase.testing",
},
Tokens = new[]
{
"token1",
"token2",
},
};
var response = await FirebaseMessaging.DefaultInstance.SendMulticastAsync(multicastMessage, dryRun : true);
Assert.NotNull(response);
Assert.Equal(2, response.FailureCount);
Assert.NotNull(response.Responses[0].Exception);
Assert.NotNull(response.Responses[1].Exception);
}
public async Task SendAsync(MulticastMessage message, CancellationToken ct)
{
if (_client == null)
{
_client = new TcpClient();
}
if (!_client.Connected)
{
if (!await Connect())
{
return;
}
}
try
{
using (var ms = new MemoryStream())
{
var binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(ms, message);
byte[] msgLength = BitConverter.GetBytes(ms.Length);
_stream.Write(msgLength, 0, msgLength.Length);
ms.Position = 0;
ms.CopyTo(_stream);
}
await _stream.FlushAsync(ct);
}
catch (Exception ex)
{
Log.Error("Exception rised in SendAsync", ex);
Disconnect();
}
}
private void MessageReceived(object sender, MulticastMsgEventArgs mMsg)
{
Log.Info($"Receved message from {mMsg.RemoteEndpoint.Address}:{mMsg.RemoteEndpoint.Port}. Message length is {mMsg.Data.Length}");
var message = new MulticastMessage(mMsg.Data, mMsg.MCastEndpoint);
_mcastQueue.Post(message);
}
private void Vibrate(MulticastService arg1, MulticastMessage msg)
{
if (!Selbsttest && DeviceInfo.Name == msg.Sender)
{
return;
}
Vibration.Vibrate();
}
private void Text2Speech(MulticastService arg1, MulticastMessage msg)
{
if (!Selbsttest && DeviceInfo.Name == msg.Sender)
{
return;
}
TextToSpeech.SpeakAsync(msg.Data);
}
public void SendJSON(IShakeAction sender, MulticastMessage data)
{
if (IsRunning)
{
var json = JsonConvert.SerializeObject(data);
var bytes = Encoding.Default.GetBytes(json);
client.Send(bytes, bytes.Length, remoteep);
}
}
public void GetMessageListTooManyTokens()
{
var message = new MulticastMessage
{
Tokens = Enumerable.Range(0, 501).Select(x => x.ToString()).ToList(),
};
Assert.Throws <ArgumentException>(() => message.GetMessageList());
}
private void SendMessage(object sender, MulticastMessage msg)
{
if (!IsRunning)
{
return;
}
var bytes = Encoding.Default.GetBytes(JsonConvert.SerializeObject(msg));
client.Send(bytes, bytes.Length, remoteEndpoint);
}
public Task SendAsync(IEnumerable <string> clientTokens, string title, string body, Uri imageUri = null)
{
var notification = new Notification {
Body = body, Title = title, ImageUrl = imageUri?.AbsoluteUri
};
var message = new MulticastMessage {
Tokens = clientTokens.ToList(), Notification = notification
};
return(_firebaseMessaging.SendMulticastAsync(message));
}
/// <summary>傳送訊息給多位使用者</summary>
/// <param name="ToId"></param>
/// <param name="message"></param>
/// <returns></returns>
public Task <string> SendMuticastMessageAsync(List <string> ToId, params Message[] message)
{
MulticastMessage oModel = new MulticastMessage()
{
to = ToId
};
oModel.messages.AddRange(message);
return(MessageApi.SendMessageActionAsync(this.channelAccessToken, PostMessageType.Multicast, oModel));
}
public void SendMessage(Squiggle.Core.Presence.Transport.Message message)
{
var msg = new MulticastMessage()
{
Sender = localEndpoint, Data = SerializationHelper.Serialize(message)
};
if (mcastHost != null)
{
mcastHost.Send(serverEndpoint, msg);
}
}
public void GetMessageList()
{
var message = new MulticastMessage
{
Tokens = new[] { "test-token1", "test-token2" },
};
var messages = message.GetMessageList();
Assert.Equal(2, messages.Count);
Assert.Equal("test-token1", messages[0].Token);
Assert.Equal("test-token2", messages[1].Token);
}
/*
* Sends notifications with firebase.
* @param devicesToSendNotificationTo - Needs to be provided by a client device (web, app)
*/
public static async Task SendNotification(string title, string description, IList <FirebaseDevice> devicesToSendNotificationTo)
{
IEnumerable <string> deviceKeys = devicesToSendNotificationTo.Select(d => d.DeviceKey);
var message = new MulticastMessage()
{
Tokens = new List <string>(deviceKeys),
Notification = new FirebaseAdmin.Messaging.Notification()
{
Title = title,
Body = description
},
};
await FirebaseMessaging.DefaultInstance.SendMulticastAsync(message).ConfigureAwait(true);
}
private async Task <IReadOnlyList <SendResponse> > SendFcmNotification(IReadOnlyCollection <Device> devices,
string notificationTitle, string notificationMessage, bool dataOnly,
IReadOnlyDictionary <string, string> data)
{
if (devices.Count > 0)
{
var tokens = devices.Select(d => d.DeviceToken).ToList();
var allData = new Dictionary <string, string> {
{ "messageText", notificationMessage }
}
.Concat(data)
.ToDictionary(x => x.Key, x => x.Value);
var firebaseMessage = new MulticastMessage
{
Tokens = tokens,
Data = allData
};
if (!dataOnly)
{
firebaseMessage.Apns = new ApnsConfig {
Aps = new Aps {
Sound = "seagulls"
}
}; // This sound does not work on Android
firebaseMessage.Android = new AndroidConfig
{
TimeToLive = new TimeSpan(12, 0, 0),
Notification = new AndroidNotification
{
ChannelId = "RequestedItemsChannel",
Sound = "seagulls"
}
};
firebaseMessage.Notification = new FirebaseAdmin.Messaging.Notification
{
Title = notificationTitle,
Body = notificationMessage
};
}
var response = await FirebaseMessaging.DefaultInstance.SendMulticastAsync(firebaseMessage);
return(response.Responses);
}
return(new List <SendResponse>());
}
public async Task <BatchResponse> SendMessage(Dictionary <string, string> data, params string[] deviceTokens)
{
var message = new MulticastMessage
{
Notification = new Notification
{
Title = "Title Notification",
Body = "Message Notification",
},
Data = data,
Tokens = deviceTokens,
};
return(await FirebaseMessaging.DefaultInstance.SendMulticastAsync(message));
}
private MulticastMessage CreateMessage(SendMessageData messageData, IReadOnlyList <string> tokens)
{
var message = new MulticastMessage
{
Tokens = tokens,
Notification = new Notification
{
Title = messageData.Title,
Body = messageData.Body,
},
Data = messageData.CustomData,
};
return(message);
}
private void Listen()
{
while (true)
{
if (cts.Token.IsCancellationRequested)
{
break;
}
byte[] data = client.Receive(ref localEp);
string json = Encoding.Default.GetString(data, 0, data.Length);
MulticastMessage msg = JsonConvert.DeserializeObject <MulticastMessage>(json);
MessagingCenter.Send(this, msg.Type.ToString(), msg);
}
}
private void Light(MulticastService arg1, MulticastMessage msg)
{
if (!Selbsttest && DeviceInfo.Name == msg.Sender)
{
return;
}
if (msg.Data == "On")
{
Flashlight.TurnOnAsync();
}
else
{
Flashlight.TurnOffAsync();
}
}
/// <summary>
/// https://devdocs.line.me/en/#multicast
/// Send messages to multiple users at any time
/// </summary>
/// <param name="to">IDs of the receivers. Max: 150 users. Use IDs returned via the webhook event of source users. IDs of groups or rooms cannot be used. Do not use the LINE ID found on the LINE app. </param>
/// <param name="messages"> Messages Max: 5 </param>
public async Task MulticastAsync(List <string> to, List <Message> messages)
{
if (to.Count > 150)
{
throw new Exception("Max: 150 users");
}
if (messages.Count > 5)
{
throw new Exception("Max: 5 Messages");
}
using (HttpClient client = GetClient())
{
JsonSerializerSettings settings = new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
NullValueHandling = NullValueHandling.Ignore
};
settings.Converters.Add(new StringEnumConverter(true));
MulticastMessage message = new MulticastMessage()
{
To = to,
Messages = messages
};
StringContent content = new StringContent(
JsonConvert.SerializeObject(message, settings),
Encoding.UTF8, "application/json");
var result = await client.PostAsync(multicastEndpoint, content);
if (result.IsSuccessStatusCode)
{
return;
}
else
{
throw new Exception(await result.Content.ReadAsStringAsync());
}
//200 OK Request successful
//400 Bad Request Problem with the request
//401 Unauthorized Valid Channel access token is not specified
//403 Forbidden Not authorized to use the API.Confirm that your account or plan is authorized to used the API.
//429 Too Many Requests Exceeded the rate limit for API calls
//500 Internal Server Error Error on the internal server
}
}
void ForwardMessage(MulticastMessage message)
{
AddClient(message.Sender);
IEnumerable <IPEndPoint> clientsList;
lock (clients)
clientsList = clients.ToList();
clients.ForEach(client =>
{
if (!client.Equals(message.Sender))
{
mcastHost.Send(client, message);
}
});
}
public Task SendAsync(IEnumerable <string> clientTokens, string alert, IDictionary <string, string> data)
{
var message = new MulticastMessage
{
Tokens = clientTokens.ToList(),
Apns = new ApnsConfig {
Aps = new Aps {
Alert = new ApsAlert {
Title = alert
}
}
},
Data = new ReadOnlyDictionary <string, string>(data),
};
return(_firebaseMessaging.SendMulticastAsync(message));
}
public static void SendToMulti(List <string> tokens, string title, string body, string link = "")
{
try
{
var defaultApp = FirebaseApp.Create(new AppOptions()
{
Credential = GoogleCredential.FromFile(HostingEnvironment.ApplicationPhysicalPath + @"\assets\anbarii-firebase-adminsdk-rh9du-ab014d04e2.json"),
});
Console.WriteLine(defaultApp.Name); // "[DEFAULT]"
// Retrieve services by passing the defaultApp variable...
var defaultAuth = FirebaseAuth.GetAuth(defaultApp);
// ... or use the equivalent shorthand notation
defaultAuth = FirebaseAuth.DefaultInstance;
}
catch { }
var message = new MulticastMessage()
{
Notification = new Notification()
{
Title = title,
Body = body,
},
Webpush = new WebpushConfig()
{
Headers = new Dictionary <string, string>()
{
{ "Urgency", "high" },
},
Notification = new WebpushNotification()
{
Title = title,
Body = body,
},
FcmOptions = new WebpushFcmOptions()
{
Link = link
},
},
Tokens = tokens,
};
FirebaseMessaging.DefaultInstance.SendMulticastAsync(message);
// Response is a message ID string.
}
