/// <summary>
/// Select method to simplify searching.
/// </summary>
/// <param name="deviceId">The device id of the device being searched.</param>
/// <param name="type">The type of the device being searched.</param>
/// <returns>Returns the DeviceDataModel if found otherwise returns null.</returns>
public DeviceDataModel SelectByDeviceIdAndType(string deviceId, string type)
{
try
{
DeviceDataModel device = this.serviceContext.DeviceTable.Where(s => s.DeviceId == deviceId && s.DeviceType == type).FirstOrDefault();
return(device);
}
catch (DataServiceQueryException)
{
return(null);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Delete the device record.
/// </summary>
/// Deletes subscription records before deleting device details.
/// <param name="ddm">The device to be delete.</param>
public void DeleteDeviceSubscriptions(DeviceDataModel ddm)
{
IEnumerable <SubscriptionDataModel> sdmList = this.serviceContext.SubscriptionsTable.Where(s => (s.DeviceId == ddm.DeviceId));
foreach (SubscriptionDataModel sdm in sdmList)
{
this.serviceContext.DeleteObject(sdm);
}
IEnumerable <DeviceDataModel> ddmList = this.serviceContext.DeviceTable.Where(d => d.DeviceId == ddm.DeviceId);
foreach (DeviceDataModel tddm in ddmList)
{
this.serviceContext.DeleteObject(tddm);
}
this.serviceContext.SaveChanges();
}
/// <summary>
/// Adds the device or updates it. For WP7, the URI will be updated frequently.
/// deviceID is maintained as the index into the d/b
/// </summary>
/// <param name="devTypeName">The type of the device being added or updated.</param>
/// <param name="deviceId">The device id of the device being added or updated.</param>
/// <param name="deviceUri">The device uri. Used only for WP7 and empty string for others.</param>
/// <returns>Returns success or an error.</returns>
public PushMessageError AddOrUpdateDevice(string devTypeName, string deviceId, string deviceUri)
{
DeviceDataModel ddm = this.dds.SelectByDeviceIdAndType(deviceId, devTypeName);
if (ddm == null)
{
// No such device, create it
ddm = new DeviceDataModel(devTypeName, deviceId);
ddm.Address = deviceUri;
this.dds.Insert(ddm);
return PushMessageError.Success;
}
else
{
// For WP7, we will update the URI with the new value
ddm.Address = deviceUri;
this.dds.Update(ddm);
return PushMessageError.Success;
}
}
/// <summary>
/// Select device by DeviceID.
/// </summary>
/// <param name="deviceId">The device id being searched.</param>
/// <returns>Returns the DeviceDataModel if found otherwise returns null.</returns>
public DeviceDataModel SelectByDeviceId(string deviceId)
{
try
{
DeviceDataModel device = this.serviceContext.DeviceTable.Where(s => s.DeviceId == deviceId).First();
return(device);
}
catch (DataServiceQueryException)
{
return(null);
}
catch (ArgumentNullException)
{
return(null);
}
//catch (Exception)
//{
// return null;
//}
}
/// <summary>
/// enques all types of WP7 message to each device URI in the subscription.
/// </summary>
/// <param name="subscription"></param>
/// <param name="messageBytes"></param>
/// <param name="type"></param>
private void EnqueAndroidNotification(DeviceDataModel ddm, byte[] msgBytes)
{
try
{
// get the all devices that have signed up for the subscription
// send the message to each device addrress or URI
this.SendAndroidMessage(msgBytes);
}
catch (ObjectDisposedException e)
{
if (this.NotificationFailed != null)
{
this.NotificationFailed(this, new NotificationEventArgs(e));
}
}
catch (System.IO.IOException e)
{
if (this.NotificationFailed != null)
{
this.NotificationFailed(this, new NotificationEventArgs(e));
}
}
}
/// <summary>
/// Enque either a common or WP7 message to be sent to MPNS. Get message components and send it to the device
/// </summary>
/// <param name="device">Device to send the message to</param>
/// <param name="msg">Message to send</param>
public override void EnqueMessage(DeviceDataModel device, PushMessage msg)
{
if (msg.MessageType == (short)PushMessageType.Toast)
{
this.EnqueAndroidToastNotification(device, msg.Message["toast"]);
}
else if (msg.MessageType == (short)PushMessageType.Raw)
{
this.EnqueAndroidRawNotification(device, msg.Message["raw"]);
}
else if (msg.MessageType == (short)PushMessageType.Common)
{
this.EnqueAndroidCommonNotification(device, msg.Message["title"], int.Parse(msg.Message["count"], CultureInfo.InvariantCulture), msg.Message["sound"]);
}
else if (msg.MessageType == (short)PushMessageType.Iphone)
{
this.EnqueAndroidCommonNotification(device, msg.Message["title"], int.Parse(msg.Message["count"], CultureInfo.InvariantCulture), msg.Message["sound"]);
}
else
{
return;
}
}
/// <summary>
/// Enque message for a particular device. For iPhone, we have to pack each message separately as the device ID is put in the message
/// </summary>
/// <param name="device"></param>
/// <param name="msg"></param>
private void EnqueiOSMessage(DeviceDataModel device, iPhoneMessage msg)
{
byte[] apnsNotificationBytes;
int numberOfRetries = 0;
if (device.DeviceType == "iOS")
{
if (!CheckDeviceId(device.DeviceId))
{
return;
}
// compose the message
apnsNotificationBytes = this.ComposeAPNSMessage(device.DeviceId, msg as iPhoneMessage);
while (numberOfRetries < this.SendRetries)
{
try
{
// and send the notification
this.SendiPhoneDeviceNotification(apnsNotificationBytes);
return;
}
catch (DeviceIdFormatException e)
{
// device ID was wrong. Send an error to listener
if (this.DeviceIdFormatError != null)
{
this.DeviceIdFormatError(this, new NotificationEventArgs(e));
}
}
catch (NotificationFormatException e)
{
// notification format was wrong. send error to listner
if (this.NotificationFormatError != null)
{
this.NotificationFormatError(this, new NotificationEventArgs(e));
}
}
catch (ObjectDisposedException e)
{
if (this.NotificationFailed != null)
{
this.NotificationFailed(this, new NotificationEventArgs(e));
}
this.DisconnectTCPClient();
}
catch (System.IO.IOException e)
{
if (this.NotificationFailed != null)
{
this.NotificationFailed(this, new NotificationEventArgs(e));
}
this.DisconnectTCPClient();
}
numberOfRetries++;
}
}
}
/// <summary>
/// Remove a device from the table
/// </summary>
/// <param name="item">The DeviceDataModel item to be deleted.</param>
public void Delete(DeviceDataModel item)
{
this.serviceContext.DeleteObject(item);
this.serviceContext.SaveChanges();
}
/// <summary>
/// Update a device. For WP7 device, URI will get updated often.
/// </summary>
/// <param name="updatedItem">The item to be updated.</param>
public void Update(DeviceDataModel updatedItem)
{
// We only need to update WP7 devices.
this.serviceContext.UpdateObject(updatedItem);
this.serviceContext.SaveChanges();
}
/// <summary>
/// Add a device to the table
/// </summary>
/// <param name="newItem">The DeviceDataModel item to be added.</param>
public void Insert(DeviceDataModel newItem)
{
this.serviceContext.AddObject(MessageServiceContext.DeviceTableName, newItem);
this.serviceContext.SaveChanges();
}
/// <summary>
/// Enques all types of WP7 message to each device URI in the subscription.
/// </summary>
/// <param name="ddm">Device to send message to.</param>
/// <param name="messageBytes">Message bytes of the message to send.</param>
/// <param name="type">Type of message to send.</param>
private void EnqueWP7Notification(DeviceDataModel ddm, byte[] messageBytes, WP7NotificationType type)
{
// Get the all devices that have signed up for the subscription
// Send the message to each device addrress or URI
if (Uri.IsWellFormedUriString(ddm.Address, UriKind.Absolute))
{
this.SendWP7Message(new Uri(ddm.Address), messageBytes, type);
}
else
{
if (this.DeviceIdFormatError != null)
{
this.DeviceIdFormatError(this, new NotificationEventArgs(new DeviceIdFormatException(ddm.Address)));
}
}
}
/// <summary>
/// Formats a toast message and enques it for sending it out a device.
/// </summary>
/// <param name="ddm">The device to send the message to.</param>
/// <param name="message">The message to send.</param>
private void EnqueWP7ToastNotification(DeviceDataModel ddm, string message)
{
Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "WCF Worker role: Enque Toast for deviceID : {0}", ddm.DeviceId));
byte[] messageBytes = PackageToastNotification(message);
this.EnqueWP7Notification(ddm, messageBytes, WP7NotificationType.Toast);
}
/// <summary>
/// Enque either a common or WP7 message to be sent to MPNS. Get message components and send it to the device
/// </summary>
/// <param name="device">Device to send the message to</param>
/// <param name="msg">Message to send</param>
public override void EnqueMessage(DeviceDataModel device, PushMessage msg)
{
if (msg.MessageType == (short)PushMessageType.Toast)
{
this.EnqueWP7ToastNotification(device, msg.Message["toast"]);
}
else if (msg.MessageType == (short)PushMessageType.Raw)
{
this.EnqueWP7RawNotification(device, msg.Message["message"]);
}
else if (msg.MessageType == (short)PushMessageType.Tile || msg.MessageType == (short)PushMessageType.Common)
{
this.EnqueWP7TileNotification(device, msg.Message["title"], int.Parse(msg.Message["count"], CultureInfo.InvariantCulture), msg.Message["url"]);
}
else
{
return;
}
}
/// <summary>
/// Update a device. For WP7 device, URI will get updated often.
/// </summary>
/// <param name="updatedItem">The item to be updated.</param>
public void Update(DeviceDataModel updatedItem)
{
// We only need to update WP7 devices.
this.serviceContext.UpdateObject(updatedItem);
this.serviceContext.SaveChanges();
}
/// <summary>
/// formats a raw message and enques it for sending it out to all devices in the subscription.
/// </summary>
/// <param name="subscription"></param>
/// <param name="message"></param>
private void EnqueAndroidRawNotification(DeviceDataModel ddm, string message)
{
Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "WCF Worker role: Enque Raw for deviceID : {0}", ddm.DeviceId));
byte[] formattedMsgBytes = PackageRawNotification(ddm.DeviceId, message);
this.EnqueAndroidNotification(ddm, formattedMsgBytes);
}
/// <summary>
/// formats a file message and enques it for sending it out to all devices in the subscription.
/// </summary>
/// <param name="subscription"></param>
/// <param name="title"></param>
/// <param name="count"></param>
/// <param name="image"></param>
private void EnqueAndroidCommonNotification(DeviceDataModel ddm, string title, int count, string sound)
{
Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "WCF Worker role: Enque Raw for deviceID : {0}", ddm.DeviceId));
byte[] formattedMsgBytes = this.PackageCommonNotification(ddm.DeviceId, title, count, sound);
this.EnqueAndroidNotification(ddm, formattedMsgBytes);
}
/// <summary>
/// Formats a raw message and enques it for sending it out to all devices in the subscription.
/// </summary>
/// <param name="ddm">Device to send a raw message.</param>
/// <param name="message">Message to send.</param>
private void EnqueWP7RawNotification(DeviceDataModel ddm, string message)
{
byte[] messageBytes = Encoding.UTF8.GetBytes(message);
this.EnqueWP7Notification(ddm, messageBytes, WP7NotificationType.Raw);
}
/// <summary>
/// Remove a device from the table
/// </summary>
/// <param name="item">The DeviceDataModel item to be deleted.</param>
public void Delete(DeviceDataModel item)
{
this.serviceContext.DeleteObject(item);
this.serviceContext.SaveChanges();
}
/// <summary>
/// Formats a file message and enques it for sending it out to dtheevices in the subscription.
/// </summary>
/// <param name="ddm">Devices to send the message to.</param>
/// <param name="title">Title of the push notification.</param>
/// <param name="count">Count to be shown on the tile.</param>
/// <param name="image">Image to show on the tile.</param>
private void EnqueWP7TileNotification(DeviceDataModel ddm, string title, int count, string image)
{
byte[] messageBytes = PackageTileNotification(title, count, image);
this.EnqueWP7Notification(ddm, messageBytes, WP7NotificationType.Tile);
}
/// <summary>
/// Enque and send the message to the appropriate notification service
/// </summary>
/// <param name="device">Device to send the message to</param>
/// <param name="msg">The push message to send to the device</param>
public virtual void EnqueMessage(DeviceDataModel device, PushMessage msg)
{
return;
}
/// <summary>
/// Enque either a common or iPhone message type to be sent to APNS. Get message components and enque it for the device
/// </summary>
/// <param name="device">Device to send the message to</param>
/// <param name="msg">Message to send</param>
public override void EnqueMessage(DeviceDataModel device, PushMessage msg)
{
if (msg.MessageType == (short)PushMessageType.Iphone)
{
string msgStr = ToString(msg);
iPhoneMessage iPhoneMsg = FromString(msgStr, typeof(iPhoneMessage)) as iPhoneMessage;
this.EnqueiOSMessage(device, iPhoneMsg);
}
else if (msg.MessageType == (short)PushMessageType.Common)
{
string msgStr = ToString(msg);
iPhoneMessage iPhoneMsg = FromString(msgStr, typeof(iPhoneMessage)) as iPhoneMessage;
this.EnqueiOSMessage(device, iPhoneMsg);
}
}
/// <summary>
/// Delete the device record.
/// </summary>
/// Deletes subscription records before deleting device details.
/// <param name="ddm">The device to be delete.</param>
public void DeleteDeviceSubscriptions(DeviceDataModel ddm)
{
IEnumerable<SubscriptionDataModel> sdmList = this.serviceContext.SubscriptionsTable.Where(s => (s.DeviceId == ddm.DeviceId));
foreach (SubscriptionDataModel sdm in sdmList)
{
this.serviceContext.DeleteObject(sdm);
}
IEnumerable<DeviceDataModel> ddmList = this.serviceContext.DeviceTable.Where(d => d.DeviceId == ddm.DeviceId);
foreach (DeviceDataModel tddm in ddmList)
{
this.serviceContext.DeleteObject(tddm);
}
this.serviceContext.SaveChanges();
}
/// <summary>
/// Add a device to the table
/// </summary>
/// <param name="newItem">The DeviceDataModel item to be added.</param>
public void Insert(DeviceDataModel newItem)
{
this.serviceContext.AddObject(MessageServiceContext.DeviceTableName, newItem);
this.serviceContext.SaveChanges();
}
