DEBUG COMMIT

Author: tmolitor-stud-tu

Monal/Classes/MLNotificationQueue.h

@@ -18,9 +18,11 @@ NS_ASSUME_NONNULL_BEGIN
 -(NSUInteger) clear;
 
 +(instancetype) currentQueue;
+-(void) addObserver:(id) observer selector:(SEL) aSelector name:(NSNotificationName) aName object:(id) anObject NS_SWIFT_NAME(addObserver(_:selector:name:object:));
 -(void) postNotificationName:(NSNotificationName) notificationName object:(id _Nullable) notificationObject userInfo:(id _Nullable) notificationUserInfo NS_SWIFT_NAME(post(name:object:userInfo:));
 -(void) postNotificationName:(NSNotificationName) notificationName object:(id _Nullable) notificationObject NS_SWIFT_NAME(post(name:object:));
 -(void) postNotification:(NSNotification* _Nonnull) notification NS_SWIFT_NAME(post(name:));
+-(void) removeObserver:(id) observer;
 
 @property (readonly, strong) NSString* name;
 -(NSString*) description;

Monal/Classes/MLNotificationQueue.m

@@ -8,11 +8,27 @@
 
 #import <monalxmpp/MLNotificationQueue.h>
 
+@interface ObserverEntry : NSObject
+@property (nonatomic, weak) id observer;
+@property (nonatomic) SEL selector;
+@property (nonatomic, strong) NSMethodSignature* sig;
+@property (nonatomic, strong) IMP imp;
+@property (nonatomic, weak) id object;
+@end
+@implementation ObserverEntry
+-(NSString*) description
+{
+    return [NSString stringWithFormat:@"ObserverEntry: selector %@ on %@", self.selector, self.observer];
+}
+@end
+
 @interface MLNotificationQueue()
 {
     NSString* _queueName;
     NSMutableArray* _entries;
     id _lowerQueue;     //use id because this could be an MLNotificationQueue *or* [NSNotificationCenter defaultCenter]
+    //for direct delivery without queueing
+    NSMutableDictionary<NSNotificationName, NSMutableArray<ObserverEntry*>*>* _directObservers;
 }
 +(NSMutableArray*) getThreadLocalNotificationQueueStack;
 @end
@@ -39,6 +55,7 @@ +(void) queueNotificationsInBlock:(monal_void_block_t) block onQueue:(NSString*)
     //flush the queue to the next queue in our stack (or send them to the notification center if no queue is left on the stack)
     //don't use the flush deallocate because we want our flush to be "inline" thread-wise
     [queue flush];
+    [queue bubbleUpDirectObservers];
     //this will deallocate our queue (flushing was already done before)
     queue = nil;
 }
@@ -55,17 +72,47 @@ +(instancetype) currentQueue
 -(void) postNotificationName:(NSNotificationName) notificationName object:(id _Nullable) notificationObject userInfo:(id _Nullable) notificationUserInfo
 {
     DDLogDebug(@"Queueing notification: %@, object = %@, userInfo = %@", notificationName, notificationObject, notificationUserInfo);
-    //create queue entry (handle nil arguments)
-    NSMutableDictionary* entry = [NSMutableDictionary new];
-    entry[@"name"] = notificationName;
-    if(notificationObject != nil)
-        entry[@"obj"] = notificationObject;
-    if(notificationUserInfo != nil)
-        entry[@"userInfo"] = notificationUserInfo;
-    
-    //add entry to our queue
+    NSNotification* notification = [NSNotification notificationWithName:notificationName object:notificationObject userInfo:notificationUserInfo];
     @synchronized(_entries) {
-        [_entries addObject:entry];
+        [_entries addObject:notification];
+    }
+    
+    //allow observers in the same notification queue to receive the notification immediately rather than on queue flush
+    NSArray* observers = @[];
+    @synchronized(_directObservers) {
+        if(_directObservers[notificationName] != nil)
+            observers = [_directObservers[notificationName] copy];
+    }
+    if(observers.count > 0)
+    {
+        MLNotificationQueue* currentQueue = [MLNotificationQueue currentQueue];
+        DDLogDebug(@"Calling direct handlers for notification created in the same queue (%@): %@", currentQueue.name, notificationName);
+        for(let entry in observers[notificationName])
+        {
+            if(entry.observer == nil)
+                continue;
+            if(entry.object != nil && entry.object != notificationObject)
+                continue;
+            if(![entry.observer respondsToSelector:entry.selector])
+                continue;
+            
+            switch(entry.sig.numberOfArguments)
+            {
+                case 2:
+                    //-(void) handler;
+                    void (*func)(id, SEL) = (void (*)(id, SEL))entry.imp;
+                    func(entry.observer, entry.selector);
+                    break;
+                case 3:
+                    //-(void) handler:(NSNotification*);
+                    void (*func)(id, SEL, NSNotification*) = (void (*)(id, SEL, NSNotification*))entry.imp;
+                    func(entry.observer, entry.selector, notification);
+                    break;
+                default:
+                    unreachable(@"We should never reach this because of previous sanity checks!");
+                    break;
+            }
+        }
     }
 }
 
@@ -81,6 +128,54 @@ -(void) postNotification:(NSNotification*) notification
     [self postNotificationName:notification.name object:notification.object userInfo:notification.userInfo];
 }
 
+//this is compatible to [NSNotificationCenter defaultCenter]
+-(void) addObserver:(id) observer selector:(SEL) aSelector name:(NSNotificationName) aName object:(id) anObject
+{
+    if(!observer || !aSelector || !aName)
+        return;
+    
+    ObserverEntry* entry = [ObserverEntry new];
+    entry.observer = observer;
+    entry.selector = aSelector;
+    entry.object = anObject;
+    entry.imp = [observer methodForSelector:aSelector];
+    entry.sig = [observer methodSignatureForSelector:aSelector];
+    
+    //sanity checks (do them here to have higher performance when calling handlers later)
+    if(entry.sig.methodReturnType != "v")
+        @throw [NSException exceptionWithName:@"NotificationQueueException" reason:@"Tried to use notification handler with non-void return value!" userInfo:@{
+            @"sig": sig,
+            @"sig.methodReturnType": @(sig.methodReturnType),
+        }];
+    if(sig.numberOfArguments > 3 || sig.numberOfArguments < 2)
+        @throw [NSException exceptionWithName:@"NotificationQueueException" reason:@"Tried to use notification handler with unsupported argument count!" userInfo:@{
+            @"sig": sig,
+            @"sig.numberOfArguments": @(sig.numberOfArguments),
+        }];
+        
+    @synchronized(_directObservers) {
+        if(_directObservers[aName] == nil)
+            _directObservers[aName] = [NSMutableArray new];
+        [_directObservers[aName] addObject:entry];
+    }
+}
+
+//this is compatible to [NSNotificationCenter defaultCenter]
+-(void) removeObserver:(id) observer
+{
+    @synchronized(_directObservers) {
+        for(let name in _directObservers)
+        {
+            for(let entry in [_directObservers[name] copy])
+                if(entry.observer == observers)
+                {
+                    DDLogDebug(@"Removing observer for notification %@: %@", name, entry);
+                    [_directObservers[name] removeObject:observer];
+                }
+        }
+    }
+}
+
 -(NSUInteger) flush
 {
     DDLogDebug(@"Flushing queue '%@', current stack: %@", [self name], [[[[self class] getThreadLocalNotificationQueueStack] reverseObjectEnumerator] allObjects]);
@@ -91,7 +186,7 @@ -(NSUInteger) flush
     }
     DDLogVerbose(@"Notifications in queue '%@': %@", [self name], toFlush);
     for(NSDictionary* entry in toFlush)
-        [_lowerQueue postNotificationName:entry[@"name"] object:entry[@"obj"] userInfo:entry[@"userInfo"]];
+        [_lowerQueue postNotificationName:entry.name object:entry.object userInfo:name.userInfo];
     @synchronized(_entries) {
         if([_entries count])
             @throw [NSException exceptionWithName:@"NotificationQueueException" reason:[NSString stringWithFormat:@"Tried to add more entries to queue while flushing: %@", _queueName] userInfo:nil];
@@ -121,7 +216,7 @@ -(NSString*) description
     NSMutableArray* queuedNotificationNames = [NSMutableArray new];
     @synchronized(_entries) {
         for(NSDictionary* entry in _entries)
-            [queuedNotificationNames addObject:entry[@"name"]];
+            [queuedNotificationNames addObject:entry.name];
     }
     return [NSString stringWithFormat:@"%@: %@", self.name, queuedNotificationNames];
 }
@@ -141,14 +236,40 @@ -(instancetype) initWithName:(NSString*) queueName
     _queueName = queueName;
     _entries = [NSMutableArray new];
     _lowerQueue = [MLNotificationQueue currentQueue];
+    _directObservers = [NSMutableDictionary new];
     return self;
 }
 
+-(void) bubbleUpDirectObservers
+{
+    /*NSArray* observers = @[];
+    @synchronized(_directObservers) {
+        if(_directObservers[notificationName] != nil)
+        {
+            observers = [_directObservers[notificationName] copy];
+            _directObservers = [NSMutableDictionary new];
+        }
+    }
+    if(observers.count > 0)
+    {
+        MLNotificationQueue* currentQueue = [MLNotificationQueue currentQueue];
+        DDLogDebug(@"Promoting direct all handlers to next queue: %@", currentQueue);
+        for(let name in observers)
+            for(let entry in observers[name])
+                if(entry.observer != nil)
+                    [currentQueue addObserver:entry.observer selector:entry.selector name:name object:entry.object];
+    }*/
+}
+
 -(void) dealloc
 {
     //there should only be one thread calling dealloc ever (per objc runtime) --> no @synchronized needed
     if([_entries count])
         [self flush];
+    
+    //bubble up all observers still registered with us
+    if([_directObservers count])
+        [self bubbleUpDirectObservers];
 }
 
 @end