iOS Communication Patterns And Block

typedef NSString *NSNotificationName;    
    
- (void)addObserver:(id)observer // An object to register as an observer, the observer here is weak reference.    
           selector:(SEL)aSelector  // A selector that specifies the message the receiver sends observer to alert it to the notification posting.    
               name:(NSNotificationName)aName  // The name of the notification to register for delivery to the observer.    
             object:(id)anObject; // The object that sends notifications to the observer.    
// If you add the same KVO for n times, then SEL messages will be sent n times to the observer. Therefore, make sure that     
addObserver and remove observer in the same number of times.                                  

NamedTable{    
    Key: NSNotificationName    
    Value: Inner Table {    
                    Key: anObject      
                    Value: observer linked list    
                }    
}       
e.g.     
    
- (void)testNotification{    
    [[NSNotificationCenter defaultCenter]addObserver:self selector:@selector(notificationHandler:) name:@"Eezy" object:@"my object"];    
    [[NSNotificationCenter defaultCenter]postNotificationName:@"Eezy" object:@"my object" userInfo:@{@"Status": @"Success"}];    
}    
     
- (void)notificationHandler:(NSNotification *) notification{    
     NSLog(@"%@",notification.object);    
}    

self.name = @"Tom";    
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(test1) name:@"lala" object:_name];    
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(test2) name:@"lala" object:nil];    
    
[[NSNotificationCenter defaultCenter] postNotificationName:@"lala" object:nil]; // Only test2 is called.    
    
[[NSNotificationCenter defaultCenter] postNotificationName:@"lala" object:_name]; // Both test1 and test2 is called.     
    
_name = @"lala";    
[[NSNotificationCenter defaultCenter] postNotifcationName:"lala" object:_name]; // Since name changed, only test2 is called.     

When the parameter name is nil, use nameless table.     
NamelessTable{    
    Key: anObject    
    Value: observer linked list    
}    

A linked list. When the parameter object and name is nil, observers will be added to this linked list.      
All the observers in wildcard can receive all NSNotifications.      

- (void)postNotificationName:(NSNotificationName)aName // The name of the notification.    
  object:(id)anObject //The object posting the notification.    
  userInfo:(NSDictionary *)aUserInfo; // A user info dictionary with optional information about the notification.    

1) Initialize an array which is used to store observers.     
2) Traversal wildcard linked list and add all the observers to the observer array.     
3) If object is not nil, get the observers in namelessTable[object] and add them to the obeserver array.    
4) If name is not nil, get both the observers in namedTable[name][object] and namedTable[name][nilObjectCorrepsondingKey] and add     
all of them to the observer array.    
5) for (int i = 0; i < obeserverArrayLen; i++) {    
    auto observerInfo = obeserverArray[i];    
    [observerInfo->observer performSelector: observerInfo->selector withObject: notification];    
}    

Adds a notification to the notification queue with a specified posting style, criteria for coalescing, and run loop mode.    
- (void)enqueueNotification:(NSNotification *)notification  // The notification to add to the queue.    
               postingStyle:(NSPostingStyle)postingStyle //The constants that specify when notifications are posted.     
               coalesceMask:(NSNotificationCoalescing)coalesceMask //The constants that specify how notifications are coalesced.     
                   forModes:(NSArray<NSRunLoopMode> *)modes; //The list of modes the notification may be posted in.     

#import "NotificationViewController.h"    
#define NOTIFICATIONNAME @"NSNotificationCenter__"    
@interface NotificationViewController ()    
    
@end    
    
@implementation NotificationViewController    
    
- (void)viewDidLoad {    
  [super viewDidLoad];    
  UIButton *button1 = [UIButton buttonWithType:UIButtonTypeSystem];    
  button1.frame = CGRectMake(200, 0, 100, 100);    
  button1.backgroundColor = [UIColor redColor];    
  [button1 addTarget:self action:@selector(buttonClick1) forControlEvents:UIControlEventTouchUpInside];    
  [self.view addSubview:button1];    
    
  [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(addObserver) name:NOTIFICATIONNAME object:nil];    
  }    
    
- (void)addObserver    
  {    
    NSLog(@"接收到消息==%@",[[NSThread currentThread]description]);    
    NSLog(@"睡眠5秒");    
    sleep(5);    
  }    
    
    
- (void)buttonClick1    
  {    
    NSLog(@"开始postNotificationName==%@",[[NSThread currentThread]description]);    
    NSNotification *noti = [NSNotification notificationWithName:NOTIFICATIONNAME object:nil];    
    [[NSNotificationQueue defaultQueue] enqueueNotification:noti postingStyle:NSPostASAP];    
    NSLog(@"结束postNotificationName==%@",[[NSThread currentThread]description]);    
  }    
  @end    
// The printing result is :     
开始postNotificationName==<NSThread: 0x600002b84680>{number = 1, name = main}    
结束postNotificationName==<NSThread: 0x600002b84680>{number = 1, name = main}    
接收到消息==<NSThread: 0x600002b84680>{number = 1, name = main}    
睡眠5秒      

Delegate mode: better for one-to-one reltionship    
Observer mode: better for one-to-many reltionship    
    
Delegate mode has higher couping while observer mode has lower one.     
FYI, coupling refers to how related or dependent two classes/modules are toward each other.    

//Registers the observer object to receive KVO notifications for the key path relative to the object receiving this message.    
(void)addObserver:(NSObject *)observer   // The object to register for KVO notifications.    
       forKeyPath:(NSString *)keyPath    // The key path, relative to the array, of the property to observe.     
          options:(NSKeyValueObservingOptions)options // A combination of the NSKeyValueObservingOptions values that specifies what is included in observation notifications.     
          context:(void *)context; // Arbitrary data that is passed to observer in observeValueForKeyPath:ofObject:change:context:.    

#import <Foundation/Foundation.h>    
@interface Person : NSObject    
@property (nonatomic, assign) int age;    
@end    
    
    
- (void)viewDidLoad {    
  [super viewDidLoad];    
  Person *p1 = [[Person alloc] init];    
  Person *p2 = [[Person alloc] init];    
  p1.age = 1;    
  p1.age = 2;    
  p2.age = 2;    
  // self 监听 p1的 age属性    
  NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld;    
    
  [p1 addObserver:self forKeyPath:@"age" options:options context:nil];    
  p1.age = 10;    
  [p1 removeObserver:self forKeyPath:@"age"];    
}    
    
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context    
{    
  NSLog(@"监听到%@的%@改变了%@", object, keyPath,change);    
}    
// The printing result:     
监听到<Person: 0x604000205460>的age改变了{    
    kind = 1;    
    new = 10;    
    old = 2;    
}    

1)The isa pointer of p1 changes from Person Class object to NSKVONotifyin_Person class object.     
2)The pseudo code of NSKVONotifyin_Person class.     
    
///NSKVONotifying_Person.m     
#import "NSKVONotifying_Person.h"    
    
@implementation NSKVONotifying_Person    
    
- (void)setAge:(int)age{    
  _NSSetIntValueAndNotify();     
}    
    
void _NSSetIntValueAndNotify(){    
  [self willChangeValueForKey:@"age"];    
  [super setAge:age];    
  [self didChangeValueForKey:@"age"];    
}    
    
- (void)didChangeValueForKey:(NSString *)key{    
  [observe observeValueForKeyPath:key ofObject:self change:nil context:nil];    
}     
@end    
Therefore, when excecuting [p1.age = 10], what actually happens is     
objc_send_message(p1->isa, setAge, 10), which further elicit [observeValueForKeyPath:ofObject:change:context:] method.    

// Solution : Check whether the observing object is the one we want, otherwise, throw it to super class.     
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context{    
  if (object == _myObject && [keyPath isEqualToString:@"contentOffset"]) {    
      [self doSomethingWhenContentOffsetChanges];}    
  else {    
      [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];}    
  }    

// NSObject+SafeKVO.h    
@interface NSObject (SafeKVO)    
- (void)removeAllObserverdKeyPath;    
@end    
    
// NSObject+SafeKVO.m    
#import "NSObject+SafeKVO.h"    
#import <objc/runtime.h>    
@implementation NSObject (SafeKVO)    
     
+ (void)load {    
        
    Method originAddM = class_getInstanceMethod([self class], @selector(addObserver:forKeyPath:options:context:));    
    Method swizzAddM = class_getInstanceMethod([self class], @selector(swizz_addObserver:forKeyPath:options:context:));    
        
    Method originRemoveM = class_getInstanceMethod([self class], @selector(removeObserver:forKeyPath:context:));    
    Method swizzRemoveM = class_getInstanceMethod([self class], @selector(swizz_removeObserver:forKeyPath:context:));    
        
    IMP originAddMIMP = class_getMethodImplementation([self class], @selector(addObserver:forKeyPath:options:context:));    
    IMP originRemoveIMP = class_getMethodImplementation([self class], @selector(removeObserver:name:object:));    
        
    BOOL hasAddM = class_addMethod([self class], @selector(addObserver:forKeyPath:options:context:), originAddMIMP, method_getTypeEncoding(originAddM));    
        
        
    BOOL hasRemoveM = class_addMethod([self class], @selector(removeObserver:forKeyPath:context:), originRemoveIMP, method_getTypeEncoding(originRemoveM));    
        
    // excute once     
    static dispatch_once_t onceToken;    
    dispatch_once(&onceToken, ^{    
        if (!hasAddM) {    
            method_exchangeImplementations(originAddM, swizzAddM);    
        }    
        if (!hasRemoveM) {    
            method_exchangeImplementations(originRemoveM, swizzRemoveM);    
        }    
    });    
}    
     
- (void)swizz_addObserver:(nonnull NSObject *)observer forKeyPath:(nonnull NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(nullable void *)context {    
    if (![self hasKey:keyPath]) {    
        // 调用系统的添加observer 方法    
        [self swizz_addObserver:observer forKeyPath:keyPath options:options context:context];    
    }    
}    
- (void)swizz_removeObserver:(nonnull NSObject *)observer forKeyPath:(nonnull NSString *)keyPath context:(nullable void *)context {    
    if ([self hasKey:keyPath]) {    
        [self swizz_removeObserver:observer forKeyPath:keyPath context:context];    
    }    
}    
     
- (void)removeAllObserverdKeyPath {    
    id info = self.observationInfo;    
    NSArray *arr = [info valueForKeyPath:@"_observances._property._keyPath"];    
    for (NSString *keyPath in arr) {    
        // TODO context 需要考虑值不为nil的时候    
        [self removeObserver:self forKeyPath:keyPath context:nil];    
    }    
}    
     
- (BOOL)hasKey:(NSString *)kvoKey {    
    BOOL hasKey = NO;    
    id info = self.observationInfo;    
    NSArray *arr = [info valueForKeyPath:@"_observances._property._keyPath"];    
    for (id keypath in arr) {    
        // 存在kvo 的key    
        if ([keypath isEqualToString:kvoKey]) {    
            hasKey = YES;    
            break;    
        }    
    }    
    return hasKey;    
}    
     
@end    

The relationship graph can be described as follows:

The dependent keys are person.name and person.age, and we want to observe the information change of a Student instance object.    
Here is the implementation:

### **Block**
1)Variable Capture    
Example:

__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_static_k, int _val, int flags=0) : static_k(_static_k), val(_val) {    
    impl.isa = &_NSConcreteStackBlock;    
    impl.Flags = flags;    
    impl.FuncPtr = fp;    
    Desc = desc;    
}     };    

        global_i ++;    
        static_global_j ++;    
        (*static_k) ++;    
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_45_k1d9q7c52vz50wz1683_hk9r0000gn_T_main_6fe658_mi_0,global_i,static_global_j,(*static_k),val);     }    

static int static_k = 3;    
int val = 4;    

void (*myBlock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_k, val));    

global_i ++;    
static_global_j ++;    
static_k ++;    
val ++;    
NSLog((NSString *)&__NSConstantStringImpl__var_folders_45_k1d9q7c52vz50wz1683_hk9r0000gn_T_main_6fe658_mi_1,global_i,static_global_j,static_k,val);    

((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);    

return 0;     }     ```     As shown in the example, there are 4 types of var:     global var:  global_i (stored in data section)    // no capture but use directly since it exists in the whole life of the program     static global var: static_global_j  (stored in data section)    // no capture but use directly since it exists in the whole life of the program     static local var: static_k (stored in data section)    // captured by refrence copy      local var: val (stored in stack)  // captured by value copy   ```     1) static global variable, global variable are stored in data section, which can be accessed any where      2）static local variable, the block store its address (int *static_k = &static_k)     3) local variable, the block just copy the value to an internal read-only variable (int val = _val) // shallow copy       ```     2)Block Type     _NSConcreteStackBlock ```     Block which only uses local var, no strong reference (once stack is pop, life ends)     ```     _NSConcreteMallocBlock ```     Block which uses strong reference  (livelihood :Depend on developers, once released, life ends)     ```     _NSConcreteGlobalBlock ```     Block which only uses global or static var, no strong reference, (livelihood :from Created to Termination of the program)     ```     3)Variable Storage in Block and __block Variable Storage in Block:   ```   1) automatic variables (i.e. integer): value copy       2) __block variables : __block->forwarding reference copy         3) objects : reference copy        ``` Variable Storage in __block:     ```   1) automatic variables (i.e. integer): value copy                     3) objects : id value copy : strong / weak   ``` 3.1)Under ARC environment, in most of the cases, we don't need to manually copy the block from stack to heap. The compiler automatically detects and does that for us.     So, in what situation can't the compiler detect it? ```     The answer is when a Block is passed as an argument for methods or functions.      But if the method or the function copies the argument inside, the caller doesn’t need to copy it manually in following cases:       1)Cocoa Framework methods, the name of which includes “usingBlock”     2)Grand Central Dispatch API     ```     3.2)Non-id Type Var Storage ```     1)Under MRC environment, unless we manually call **copy**, the block will stay in stack, and the __block variable it     capture will also have __forwarding referring to itself in the stack.     2)Under ARC environment, when the __block variable is copied from the stack to the heap, a _Block_object_assign function is called      so that the Block takes ownership of the __block variable. When the __block variable on the heap is disposed of,      the _Block_object_dispose function is called to release the object in the __block variable.     ```     3.2)Id Type Var Storage ```     _Block_object_assign     ```     The function assigns the object to the member variable and calls a function, which is equivalent to the retain method. ```     _Block_object_dispose     ```     The function calls a function, which is equivalent to the instance method “release”, on the object in the target member variable of the struct. ```     ```     3.2.1)Under ARC environment, when an automatic variable of id or object type is captured for a Block and the Block is copied from the stack to the heap,     the _Block_object_assign function is called so that the Block takes ownership of the captured object. It is just like an object,     which is assigned to the object type automatic variable with a __strong qualifier, is used inside a Block.     When the block on the heap is disposed of, the _Block_object_dispose function is called to release the captured object.     When an automatic variable of id or object type with a __strong qualifier has a __block specifier, the same thing happens. ```     struct __Block_byref_obj_0 {        void *__isa;       __Block_byref_obj_0 *__forwarding;       int __flags;       int __size;       void (*__Block_byref_id_object_copy)(void*, void*);       void (*__Block_byref_id_object_dispose)(void*);        __strong id obj;     };