public void ParseListenerAttributes( INotificationListener Instance )
{
Type instanceType = Instance.GetType();
Type listenerAttributeType = typeof( NotificationListenerAttribute );
INotifier notifier = Notifier.getInstance( Instance.Context );
foreach( MethodInfo method in instanceType.GetMethods( BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance ) )
{
foreach( Attribute attribute in method.GetCustomAttributes( listenerAttributeType, false ) )
{
Console.WriteLine( "\t" + this + ".ParseListenerAttributes()\n\tAdding InterestListener: " + ( attribute as NotificationListenerAttribute ).Name );
MethodInfo scopeMethod = method;
notifier.Add(
new NotificationInterestListener(
( attribute as NotificationListenerAttribute ).Type,
Instance.Context,
delegate( Object Sender, INotification Notification )
{
scopeMethod.Invoke( Instance, new Object[]{ Sender, Notification } );
}
)
);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NotificationHostViewModel" /> class.
/// </summary>
/// <param name="notificationListener">Object which is listening for occuring notifications.</param>
public NotificationHostViewModel(INotificationListener notificationListener = null)
{
_notificationListener = notificationListener ?? Locator.Current.GetService <INotificationListener>();
var notificationSource = new SourceList <Notification>();
var notificationChanges = notificationSource.Connect();
this.WhenActivated(d =>
{
_notificationListener.Notifications
.ObserveOn(RxApp.TaskpoolScheduler)
.Subscribe(x => notificationSource.Add(x))
.DisposeWith(d);
// Add new received notifications as viewmodels to our internal collection.
notificationChanges
.Transform(x => new NotificationViewModel(x))
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out _notifications)
.Subscribe()
.DisposeWith(d);
// Listen for notification close requests.
notificationChanges
.Throttle(TimeSpan.FromMilliseconds(100), RxApp.TaskpoolScheduler)
.Select(_ => Notifications.Select(x => x.Close).Merge())
.Switch()
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(x => notificationSource.Remove(x.Notification))
.DisposeWith(d);
});
}
public void Init(NotificationsSettings settings, INotificationListener listener)
{
// Store the settings for later references.
mSettings = settings;
// Convert category groups to JSON. Invalid groups (empty name or ID) will be
// automatically ignored in native side.
var categoryGroupJson = AndroidNotificationHelper.ToJson(settings.CategoryGroups);
// Convert categories to JSON.
var categories = new List <NotificationCategory>();
categories.Add(settings.DefaultCategory);
if (settings.UserCategories != null)
{
categories.AddRange(settings.UserCategories);
}
var categoriesJson = AndroidNotificationHelper.ToJson(categories.ToArray());
// Listener info
var name = listener.Name;
var backgroundNotificationMethod = Helper.GetMethodName(listener.NativeNotificationFromBackgroundHandler);
var foregroundNotificationMethod = Helper.GetMethodName(listener.NativeNotificationFromForegroundHandler);
// Initialize native Android client, which may send some launch notification data during the process.
AndroidNotificationNative._InitNativeClient(categoryGroupJson, categoriesJson, name, backgroundNotificationMethod, foregroundNotificationMethod);
mIsInitialized = true;
}
public void RedeliverTo_WhenNotificationWasNotDelivered_DoesNotTouchDecreasesDeliveryCount(
INotificationListener listener,
EventStreamUpdated notification,
EventStreamReaderId consumerId)
{
Assert.Equal(0, notification.RedeliverTo(listener).DeliveryCount);
}
public void IsAddressedTo_WhenNotificationWasNotAddressed_Throws(
INotificationListener listener,
EventStreamUpdated notification,
EventStreamReaderId consumerId)
{
Assert.Throws <InvalidOperationException>(() => notification.IsAddressedTo(listener));
}
// TODO: onDispose remove logic integrieren
public void ParseDelegateInterestAttributes( INotificationListener Instance )
{
Type InstanceType = Instance.GetType();
Type ListenerAttributeType = typeof( NotificationDelegateAttribute );
foreach( MethodInfo method in InstanceType.GetMethods( BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance ) )
{
foreach( Attribute attribute in method.GetCustomAttributes( ListenerAttributeType, false ) )
{
#if DEBUG
Debug.WriteLine( this + ".ParseDelegateInterestAttributes()\n\tNoteType: " + ( attribute as NotificationDelegateAttribute ).NoteType + "\n\tNotificationDelegateInterest: " + ( attribute as NotificationDelegateAttribute ).Name + "\n---" );
#endif
MethodInfo scopeMethod = method;
// adding handler methods to the NotificationListenerList
Instance.NotificationListenerList.Add(
new NotificationDelegateInterest(
( attribute as NotificationDelegateAttribute ).NoteType,
Instance.Context,
delegate( Object Sender, INotification Notification )
{
scopeMethod.Invoke( Instance, new Object[]{ Sender, Notification } );
}
)
);
}
}
}
public NotifyControl(INotificationListener notificationService, IUserSession userSession)
{
InitializeComponent();
notificationService.NotificationRecieved += notificationService_OnNotification;
ApplicationCommands.LoginSucceeded.RegisterCommand(new DelegateCommand <object>(Update));
ApplicationCommands.UserLoggedOut.RegisterCommand(new DelegateCommand <object>(Update));
_userSession = userSession;
}
public void NotificationsSubscriber_WhenProcessingIsNotEnabled_AddsListenerToCollection(
INotificationListener listener,
EventStoreConnectionConfiguration connectionConfiguration)
{
connectionConfiguration.Notifications.Subscribe(listener);
Assert.DoesNotContain(listener, connectionConfiguration.NotificationListeners);
}
public bool IsAddressedTo(INotificationListener listener)
{
Require.NotNull(listener, "listener");
Ensure.True(m_recipient != null, "Notification was not addressed.");
return(m_recipient.Equals(listener.GetType().FullName));
}
public StandardMBean(object impl, Type intfType)
{
_internalInfo = MBeanInternalInfo.GetCached(intfType);
_info = _internalInfo.MBeanInfo;//CreateMBeanInfo(impl, intfType);
_impl = impl;
_registration = impl as IMBeanRegistration;
_notifListener = impl as INotificationListener;
_notifEmitter = impl as INotificationEmitter;
}
/// <summary>
/// Remove Notification listener.
/// </summary>
/// <param name="listener"></param>
public void RemoveListener(INotificationListener listener)
{
_listeners.Remove(listener);
if (_config.EnableConsoleLogging)
{
Debug.Log("[Countly NotificationsCallbackService] RemoveListener: " + listener);
}
}
public StandardMBean(object impl, Type intfType)
{
_internalInfo = MBeanInternalInfo.GetCached(intfType);
_info = _internalInfo.MBeanInfo;//CreateMBeanInfo(impl, intfType);
_impl = impl;
_registration = impl as IMBeanRegistration;
_notifListener = impl as INotificationListener;
_notifEmitter = impl as INotificationEmitter;
}
public void RedeliverTo_DecreasesDeliveryCount(
INotificationListener listener,
EventStreamUpdated notification,
EventStreamReaderId consumerId)
{
SaveAndRestore(notification);
Assert.Equal(0, notification.RedeliverTo(listener).DeliveryCount);
}
public void IsAddressedTo_WhenRecipientSpecifiedDirectly_ReturnsTrue(
INotificationListener listener,
EventStreamUpdated notification,
EventStreamReaderId consumerId)
{
Assert.True(notification
.SendTo(listener)
.IsAddressedTo(listener));
}
public void SendTo_WhenMessagHasBeenAddressedToTheSameConsumer_ReturnsItself(
INotificationListener listener,
EventStreamUpdated notification,
EventStreamReaderId consumerId)
{
var addressedNotification = notification.SendTo(listener);
Assert.Same(addressedNotification, addressedNotification.SendTo(listener));
}
public void SendTo_ChangesNotificationId(
INotificationListener listener,
EventStreamUpdated notification,
EventStreamReaderId consumerId)
{
var addressedNotification = notification.SendTo(listener);
Assert.NotEqual(notification.NotificationId, addressedNotification.NotificationId);
}
internal static iOSNotificationListenerInfo ToIOSNotificationListenerInfo(INotificationListener listener)
{
var iOSListenerInfo = new iOSNotificationListenerInfo();
iOSListenerInfo.name = listener.Name;
iOSListenerInfo.backgroundNotificationMethod = Helper.GetMethodName(listener.NativeNotificationFromBackgroundHandler);
iOSListenerInfo.foregroundNotificationMethod = Helper.GetMethodName(listener.NativeNotificationFromForegroundHandler);
return(iOSListenerInfo);
}
public NotificationListenerSubscription(
INotificationsChannel notificationsChannel,
INotificationListener listener)
{
Require.NotNull(notificationsChannel, "notificationsChannel");
Require.NotNull(listener, "listener");
m_notificationsChannel = notificationsChannel;
m_listener = listener;
m_processingCountdown = new CountdownEvent(0);
}
private INotificationListener GetListenerMBean(ObjectName name, out IDynamicMBean bean)
{
bean = GetMBean(name);
INotificationListener listner = bean as INotificationListener;
if (listner != null)
{
return(listner);
}
throw new OperationsException(string.Format("Bean \"{0}\" is not a notification listener.", name));
}
public void SendTo_WhenMessagHasBeenAddressedToTheSameConsumer_SavesId(
INotificationListener listener,
EventStreamUpdated notification,
EventStreamReaderId consumerId)
{
var addressedNotification = notification.SendTo(listener);
Assert.Equal(
addressedNotification.NotificationId,
addressedNotification.SendTo(listener).NotificationId);
}
public IEventStoreConnectionConfiguration Subscribe(INotificationListener listener)
{
Require.NotNull(listener, "listener");
if (m_enabled)
{
m_listeners.Add(listener);
}
return(m_connection);
}
// PUBLIC METHODS
// -------------------------------------------------------------------------
public void Subscribe(Notification.Type type, INotificationListener listener)
{
if (!m_types.ContainsKey(type))
{
m_types[type] = new List <INotificationListener>();
}
if (!m_types[type].Contains(listener))
{
m_types[type].Add(listener);
}
}
public void RemoveNotificationListener(ObjectName name, ObjectName listener)
{
name = GetNameWithDomain(name);
listener = GetNameWithDomain(listener);
IDynamicMBean bean;
INotificationEmitter emitter = GetEmitterMBean(name, out bean);
TestPermissions(bean.GetMBeanInfo().ClassName, null, name, MBeanPermissionAction.RemoveNotificationListener);
INotificationListener listenerBean = GetListenerMBean(listener, out bean);
NotificationCallback callback = new NotificationCallback(listenerBean.HandleNotification);
emitter.RemoveNotificationListener(callback);
}
public void HandleNotification(ApplicationSettingsBase settings, string pathToNotificationFile, INotificationListener listener)
{
Settings = settings;
PathToNotificationFile = pathToNotificationFile;
Listener = listener;
// Setup a worker to process the notification in the background to avoid locking up the
// application
var notificationWorker = new BackgroundWorker();
notificationWorker.DoWork += new DoWorkEventHandler(FetchNotifications);
notificationWorker.RunWorkerAsync(this);
}
public void SendTo_PreservesNotificationPropertiesValues(
INotificationListener listener,
EventStreamUpdated notification,
EventStreamReaderId consumerId)
{
var addressedNotification = (EventStreamUpdated)notification.SendTo(listener);
Assert.Equal(notification.StreamName, addressedNotification.StreamName);
Assert.Equal(notification.FromVersion, addressedNotification.FromVersion);
Assert.Equal(notification.ToVersion, addressedNotification.ToVersion);
Assert.Equal(notification.NotificationType, addressedNotification.NotificationType);
Assert.Equal(notification.DeliveryCount, addressedNotification.DeliveryCount);
}
/// <summary>
/// Add Notification listener.
/// </summary>
/// <param name="listener"></param>
public void AddListener(INotificationListener listener)
{
if (_listeners.Contains(listener))
{
return;
}
_listeners.Add(listener);
if (_config.EnableConsoleLogging)
{
Debug.Log("[Countly NotificationsCallbackService] AddListener: " + listener);
}
}
public void Unsubscribe(Notification.Type type, INotificationListener listener)
{
if (!m_types.ContainsKey(type))
{
return;
}
if (!m_types[type].Contains(listener))
{
return;
}
m_types[type].Remove(listener);
}
public INotification SendTo(INotificationListener listener)
{
Require.NotNull(listener, "listener");
if (IsAddressed && IsAddressedTo(listener))
{
return(this);
}
return(CopyAndUpdate(properties =>
{
properties[NotificationPropertyKeys.Common.NOTIFICATION_ID] = NotificationId.Create().ToString();
properties[NotificationPropertyKeys.Common.RECIPIENT] = listener.GetType().FullName;
}));
}
public INotification RedeliverTo(INotificationListener listener)
{
Require.NotNull(listener, "listener");
return(CopyAndUpdate(properties =>
{
properties[NotificationPropertyKeys.Common.NOTIFICATION_ID] = Guid.NewGuid().ToString("N");
properties[NotificationPropertyKeys.Common.RECIPIENT] = listener.GetType().FullName;
if (m_deliveryCount > 0)
{
properties[NotificationPropertyKeys.Common.DELIVERY_COUNT] = (m_deliveryCount - 1).ToInvariantString();
}
}));
}
public void AddNotificationListener(INotificationListener listener)
{
if (listener == null)
{
return;
}
if (Listeners == null)
{
Listeners = new List <INotificationListener>();
}
if (!Listeners.Contains(listener))
{
Listeners.Add(listener);
}
}
public void RemoveNotificationListener(INotificationListener listener)
{
if (listener == null)
{
return;
}
if (Listeners == null)
{
return;
}
if (Listeners.Contains(listener))
{
Listeners.Remove(listener);
}
}
public async Task DefferNotificationAsync_SendAddressedNotification(
[Frozen] Mock <INotificationsChannel> channelMock,
[Frozen] Mock <INotification> receivedNotificationMock,
INotification deferredNotification,
IEventStoreConnection connection,
INotificationListener listener,
NotificationListenerSubscription subscription)
{
receivedNotificationMock
.Setup(self => self.SendTo(listener))
.Returns(deferredNotification);
subscription.Start(connection);
await subscription.RetryNotificationProcessingAsync(receivedNotificationMock.Object);
channelMock
.Verify(self => self.SendAsync(
deferredNotification,
It.Is <TimeSpan>(v => TimeSpan.FromSeconds(deferredNotification.DeliveryCount * 2) == v)));
}
/// <summary>
/// Initializes the notification service.
/// </summary>
public static void Init()
{
// Get the listener.
sListener = GetNotificationListener();
// Subscibe to internal notification events.
if (sListener != null)
{
sListener.LocalNotificationOpened += InternalOnLocalNotificationOpened;
sListener.RemoteNotificationOpened += InternalOnRemoteNotificationOpened;
}
// Initialize remote notification service.
// On iOS, OneSignal's NotificationReceived & NotificationOpened will not really fire,
// because all notification events are handled by us from native side.
if (EM_Settings.Notifications.PushNotificationService == PushNotificationProvider.OneSignal)
{
#if EM_ONESIGNAL
// The only required method you need to call to setup OneSignal to recieve push notifications.
// Call before using any other methods on OneSignal.
// Should only be called once when your game is loaded.
OneSignal.StartInit(EM_Settings.Notifications.OneSignalAppId)
.HandleNotificationReceived(sListener.OnOneSignalNotificationReceived)
.HandleNotificationOpened(sListener.OnOneSignalNotificationOpened)
.InFocusDisplaying(OneSignal.OSInFocusDisplayOption.None)
.EndInit();
#else
Debug.LogError("SDK missing. Please import OneSignal plugin for Unity.");
#endif
}
// Initialize local notification client.
// We may need to override some configuration done by the initialization
// of the remote notification service, so this should be done later.
LocalNotificationClient.Init(EM_Settings.Notifications, sListener);
}
