可以看到在注册后存入到了被观察者中，类型是NSKeyValueObservationInfo，它是一个私有类。NSKeyValueObservationInfo中保存的是NSKeyValueObservance。
NSKeyValueObservationInfo保存了NSKeyValueObservance集合，NSKeyValueObservance中保存了观察者注册的时候的信息。
既然是在Foundation框架中，那么dump一下这个动态库的头文件(越狱手机使用classdump-dyld导出头文件)。

NSKeyValueObservationInfo头文件：

NSKeyValueObservance头文件：

@class NSObject, NSKeyValueProperty;

@interface NSKeyValueObservance : NSObject {

    NSObject* _observer;

    NSKeyValueProperty* _property;

    void* _context;

    NSObject* _originalObservable;

    unsigned _options : 6;

    unsigned _cachedIsShareable : 1;

    unsigned _isInternalObservationHelper : 1;

}

-(id)_initWithObserver:(id)arg1 property:(id)arg2 options:(unsigned long long)arg3 context:(void*)arg4 originalObservable:(id)arg5 ;

-(unsigned long long)hash;

-(id)description;

-(BOOL)isEqual:(id)arg1 ;

-(void)observeValueForKeyPath:(id)arg1 ofObject:(id)arg2 change:(id)arg3 context:(void*)arg4 ;

@end

@class NSKeyValueContainerClass, NSString;

@interface NSKeyValueProperty : NSObject <NSCopying> {

    NSKeyValueContainerClass* _containerClass;

    NSString* _keyPath;

}

-(Class)isaForAutonotifying;

-(id)_initWithContainerClass:(id)arg1 keyPath:(id)arg2 propertiesBeingInitialized:(CFSetRef)arg3 ;

-(id)dependentValueKeyOrKeysIsASet:(BOOL*)arg1 ;

-(void)object:(id)arg1 withObservance:(id)arg2 didChangeValueForKeyOrKeys:(id)arg3 recurse:(BOOL)arg4 forwardingValues:(SCD_Struct_NS48)arg5 ;

-(BOOL)object:(id)arg1 withObservance:(id)arg2 willChangeValueForKeyOrKeys:(id)arg3 recurse:(BOOL)arg4 forwardingValues:(SCD_Struct_NS48*)arg5 ;

-(void)object:(id)arg1 didAddObservance:(id)arg2 recurse:(BOOL)arg3 ;

-(id)restOfKeyPathIfContainedByValueForKeyPath:(id)arg1 ;

-(void)object:(id)arg1 didRemoveObservance:(id)arg2 recurse:(BOOL)arg3 ;

-(BOOL)matchesWithoutOperatorComponentsKeyPath:(id)arg1 ;

-(id)copyWithZone:(NSZone*)arg1 ;

-(id)keyPath;

-(void)dealloc;

-(id)keyPathIfAffectedByValueForKey:(id)arg1 exactMatch:(BOOL*)arg2 ;

-(id)keyPathIfAffectedByValueForMemberOfKeys:(id)arg1 ;

@end

• _observer存储在NSKeyValueObservance 中。
• _keyPath存储在NSKeyValueObservance的_property（NSKeyValueProperty）中。

3.1Hook注册和移除方法

要对系统方法进行容错处理那么最好的办法就是Hook了，直接对添加和移除的3个方法进行Hook处理：

+ (void)load {

    static dispatch_once_t onceToken;

    dispatch_once(&onceToken, ^{

        [self hp_methodSwizzleWithClass:self oriSEL:@selector(addObserver:forKeyPath:options:context:) swizzledSEL:@selector(hp_addObserver:forKeyPath:options:context:) isClassMethod:NO];

        [self hp_methodSwizzleWithClass:self oriSEL:@selector(removeObserver:forKeyPath:context:) swizzledSEL:@selector(hp_removeObserver:forKeyPath:context:)isClassMethod:NO];

        [self hp_methodSwizzleWithClass:self oriSEL:@selector(removeObserver:forKeyPath:) swizzledSEL:@selector(hp_removeObserver:forKeyPath:)isClassMethod:NO];

    });

}

- (BOOL)keyPathIsExist:(NSString *)sarchKeyPath observer:(id)observer {

    BOOL findKey = NO;

    id info = self.observationInfo;

    if (info) {

        NSArray *observances = [info valueForKeyPath:@"_observances"];

        for (id observance in observances) {

            id tempObserver = [observance valueForKey:@"_observer"];

            if (tempObserver == observer) {

                NSString *keyPath = [observance valueForKeyPath:@"_property._keyPath"];

                if ([keyPath isEqualToString:sarchKeyPath]) {

                    findKey = YES;

                    break;

                }

            }

        }

    }

    return findKey;

}

- (void)hp_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(nullable void *)context {

    if ([self keyPathIsExist:keyPath observer:observer]) {//observer 观察者已经添加了对应key的观察，再次添加不做处理。

        return;

    }

    [self hp_addObserver:observer forKeyPath:keyPath options:options context:context];

}



- (void)hp_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath context:(nullable void *)context {

    if ([self keyPathIsExist:keyPath observer:observer]) {//key存在才移除

        [self hp_removeObserver:observer forKeyPath:keyPath context:context];

    }

}



- (void)hp_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath {

    if ([self keyPathIsExist:keyPath observer:observer]) {//key存在才移除

        [self hp_removeObserver:observer forKeyPath:keyPath];

    }

}

- (void)hp_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(nullable void *)context {

    if ([self keyPathIsExist:keyPath observer:observer]) {//observer 观察者已经添加了对应key的观察，再次添加不做处理。

        return;

    }

    NSString *className = NSStringFromClass([self class]);

    NSString *newClassName = [NSString stringWithFormat:@"NSKVONotifying_%@",className];

    Class newClass = NSClassFromString(newClassName);

    if (!newClass) {//类不存在的时候进行 hook 观察者 dealloc

        //hook dealloc

        [[observer class] hp_methodSwizzleWithClass:[observer class] oriSEL:NSSelectorFromString(@"dealloc") swizzledSEL:@selector(hp_dealloc) isClassMethod:NO];

    }

    [self hp_addObserver:observer forKeyPath:keyPath options:options context:context];

}



- (void)hp_dealloc {

    [self hp_removeSelfAllObserverd];

    [self hp_dealloc];

}

• 当kvo子类已经存在的时候证明已经hook过了。

在dealloc中self.observationInfo是获取不到信息的，因为observationInfo是存储在被观察者中的。所以还需要自己存储信息。
修改如下：

static NSString *const kHPSafeKVOObserverdAssiociateKey = @"HPSafeKVOObserverdAssiociateKey";



@interface HPSafeKVOObservedInfo : NSObject



@property (nonatomic, weak) id observerd;

@property (nonatomic, copy) NSString  *keyPath;

@property (nonatomic, strong) id context;



@end



@implementation HPSafeKVOObservedInfo



- (instancetype)initWitObserverd:(NSObject *)observerd forKeyPath:(NSString *)keyPath context:(nullable void *)context {

    if (self=[super init]) {

        _observerd = observerd;

        _keyPath = keyPath;

        _context = (__bridge id)(context);

    }

    return self;

}



@end



- (void)hp_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(nullable void *)context {

    if ([self keyPathIsExist:keyPath observer:observer]) {//observer 观察者已经添加了对应key的观察，再次添加不做处理。

        return;

    }

    NSString *className = NSStringFromClass([self class]);

    NSString *newClassName = [NSString stringWithFormat:@"NSKVONotifying_%@",className];

    Class newClass = NSClassFromString(newClassName);

    if (!newClass) {//类不存在的时候进行 hook 观察者 dealloc

        //hook dealloc

        [[observer class] hp_methodSwizzleWithClass:[observer class] oriSEL:NSSelectorFromString(@"dealloc") swizzledSEL:@selector(hp_dealloc) isClassMethod:NO];

    }

    

    //保存被观察者信息

    HPSafeKVOObservedInfo *kvoObservedInfo = [[HPSafeKVOObservedInfo alloc] initWitObserverd:self forKeyPath:keyPath context:context];

    NSMutableArray *observerdArray = objc_getAssociatedObject(observer, (__bridge const void * _Nonnull)(kHPSafeKVOObserverdAssiociateKey));

    if (!observerdArray) {

        observerdArray = [NSMutableArray arrayWithCapacity:1];

    }

    [observerdArray addObject:kvoObservedInfo];

    objc_setAssociatedObject(observer, (__bridge const void * _Nonnull)(kHPSafeKVOObserverdAssiociateKey), observerdArray, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

    

    //调用原始方法

    [self hp_addObserver:observer forKeyPath:keyPath options:options context:context];

}

在hp_dealloc中主动调用移除方法：

- (void)hp_dealloc {

    [self hp_removeSelfAllObserverd];

    [self hp_dealloc];

}



- (void)hp_removeSelfAllObserverd {

    NSMutableArray *observerdArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kHPSafeKVOObserverdAssiociateKey));

    for (HPSafeKVOObservedInfo *info in observerdArray) {

        if (info.observerd) {

            //调用系统方法，已经hook了，走hook逻辑。

            if (info.context) {

                [info.observerd removeObserver:self forKeyPath:info.keyPath context:(__bridge void * _Nullable)(info.context)];

            } else {

                [info.observerd removeObserver:self forKeyPath:info.keyPath];

            }

        }

    }

}

这样在dealloc的时候就主动清空了已经释放掉的observer。

3.3 问题处理

上面这样处理后在退出页面的时候发生了crash（非必现），堆栈如下：

UIScreen 观察了 CADisplay 的 cloned。但是在释放的过程中UIScreen却没有调用到Hook的hp_dealloc中，对应的汇编实现：

int -[UIScreen dealloc](int arg0) {

    [r0 _invalidate];

    __UIScreenWriteDisplayConfiguration(r0, 0x0, 0x0);

    r0 = [[&stack[0] super] dealloc];

    return r0;

}



int -[UIScreen _invalidate](int arg0) {

    var_10 = r20;

    stack[-24] = r19;

    r31 = r31 + 0xffffffffffffffe0;

    saved_fp = r29;

    stack[-8] = r30;

    r19 = arg0;

    *(int16_t *)(arg0 + 0xb0) = *(int16_t *)(arg0 + 0xb0) & 0xffffffffffffffcf;

    r0 = [NSNotificationCenter defaultCenter];

    r0 = [r0 retain];

    [r0 removeObserver:r19];

    [r0 release];

    if ([r19 _isCarScreen] == 0x0) goto loc_7495b4;



loc_749570:

    r0 = __UIInternalPreferenceUsesDefault_751e78(0x19080b0, @"ApplySceneUserInterfaceStyleToCarScreen", 0xec7178);

    if (((*(int8_t *)0x19080b4 & 0x1) == 0x0) || (r0 != 0x0)) goto loc_74959c;



loc_7495b4:

    [r19 _endObservingBacklightLevelNotifications];

    [r19 _setSoftwareDimmingWindow:0x0];

    r0 = *(r19 + 0x90);

    r0 = [r0 _setScreen:0x0];

    return r0;



loc_74959c:

    CFNotificationCenterRemoveObserver(CFNotificationCenterGetDarwinNotifyCenter(), r19, @"CarPlayUserInterfaceStyleDidChangeNotification", 0x0);

    goto loc_7495b4;

}

那么意味着是否没有替换成功？
在_UIScreenWriteDisplayConfiguration中确实先移除后添加：

是否进行注册是通过rax控制的。也就是__UIScreenIsCapturedValueOverride.isCapturedValue控制的。
经过测试只要在系统自动调用UIScreen initialize之前调用一个UIScreen相关方法就不走kvo设置逻辑了，比如：

[UIScreen mainScreen]

//[UIScreen class]

目前不清楚原因。所以处理这个问题有两个思路：

1. 在+ load进行方法交换的时候先调用[UIScreen class]。

1. 在注册的时候对系统类或者自己的类进行过滤。

• 2.1只排除UIScreen

if ([observer isKindOfClass:[UIScreen class]]) {

    [self hp_addObserver:observer forKeyPath:keyPath options:options context:context];

    return;

}

• 2.2排除系统类

NSString *className = NSStringFromClass([observer class]);

if ([className hasPrefix:@"NS"] || [className hasPrefix:@"UI"]) { //排除某些系统类。

    [self hp_addObserver:observer forKeyPath:keyPath options:options context:context];

    return;

}

• 2.3 只处理自己的类

NSString *className = NSStringFromClass([observer class]);

if (![className hasPrefix:@"HP"]) { //排除某些系统类。

    [self hp_addObserver:observer forKeyPath:keyPath options:options context:context];

    return;

}

2.2.2 优化Hook逻辑

上面在+ load中Hook dealloc方法是在NSObject分类中处理的，那么意味着所有的类的dealloc方法都被Hook了。显然这么做是不合理的。
逻辑就是仅对需要的类进行Hook dealloc方法，所以将Hook延迟到addObserver中：

- (void)hp_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath block:(HPKVOBlock)block {

  ……

 //hook dealloc

 [[observer class] hp_methodSwizzleWithClass:[observer class] oriSEL:NSSelectorFromString(@"dealloc") swizzledSEL:@selector(hp_dealloc) isClassMethod:NO];

}

//申请类-注册类-添加方法

- (Class)_creatKVOClassWithKeyPath:(NSString *)keyPath observer:(NSObject *)observer {

    //这里重写class后kvo子类也返回的是父类的名字

    NSString *superClassName = NSStringFromClass([self class]);

    NSString *newClassName = [NSString stringWithFormat:@"%@%@",kHPBlockKVOClassPrefix,superClassName];

    Class newClass = NSClassFromString(newClassName);

    //类是否存在

    if (!newClass)  {//不存在需要创建类

        //1：申请类 父类、新类名称、额外空间

        newClass = objc_allocateClassPair([self class], newClassName.UTF8String, 0);

        //2：注册类

        objc_registerClassPair(newClass);

        //3：添加class方法，class返回父类信息 这里是`-class`

        SEL classSEL = NSSelectorFromString(@"class");

        Method classMethod = class_getInstanceMethod([self class], classSEL);

        const char *classTypes = method_getTypeEncoding(classMethod);

        class_addMethod(newClass, classSEL, (IMP)_hp_class, classTypes);

        

        //hook dealloc

        [[observer class] hp_methodSwizzleWithClass:[observer class] oriSEL:NSSelectorFromString(@"dealloc") swizzledSEL:@selector(hp_dealloc) isClassMethod:NO];

    }

    //4：添加setter方法

    SEL setterSEL = NSSelectorFromString(_setterForGetter(keyPath));

    Method setterMethod = class_getInstanceMethod([self class], setterSEL);

    const char *setterTypes = method_getTypeEncoding(setterMethod);

    class_addMethod(newClass, setterSEL, (IMP)_hp_setter, setterTypes);

    

    return newClass;

}

完整实现代码：

typedef void(^HPKVOBlock)(id observer,NSString *keyPath,id oldValue,id newValue);



@interface NSObject (HP_KVO_Block)



- (void)hp_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath block:(HPKVOBlock)block;



- (void)hp_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath;



@end



#import "NSObject+HP_KVO_Block.h"

#import <objc/runtime.h>

#import <objc/message.h>

#import "HPKVOInfo.h"



static NSString *const kHPBlockKVOClassPrefix = @"HPKVONotifying_";

static NSString *const kHPBlockKVOAssiociateKey = @"HPKVOAssiociateKey";



static NSString *const kHPBlockKVOObserverdAssiociateKey = @"HPKVOObserverdAssiociateKey";



@interface HPKVOBlockInfo : NSObject



@property (nonatomic, weak) id observer;

@property (nonatomic, copy) NSString  *keyPath;

@property (nonatomic, copy) HPKVOBlock  handleBlock;



@end



@implementation HPKVOBlockInfo



- (instancetype)initWitObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath handleBlock:(HPKVOBlock)block {

    if (self=[super init]) {

        _observer = observer;

        _keyPath  = keyPath;

        _handleBlock = block;

    }

    return self;

}



@end



@interface HPKVOObservedInfo : NSObject



@property (nonatomic, weak) id observerd;

@property (nonatomic, copy) NSString  *keyPath;



@end



@implementation HPKVOObservedInfo



- (instancetype)initWitObserverd:(NSObject *)observerd forKeyPath:(NSString *)keyPath {

    if (self=[super init]) {

        _observerd = observerd;

        _keyPath  = keyPath;

    }

    return self;

}



@end



@implementation NSObject (HP_KVO_Block)





- (void)hp_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath block:(HPKVOBlock)block {

    //1.参数判断 以及 setter检查

    if (!observer || !keyPath) return;

    BOOL result = [self _handleSetterMethodFromKeyPath:keyPath];

    if (!result) return;

    

    //2.isa_swizzle 申请类-注册类-添加方法

    Class newClass = [self _creatKVOClassWithKeyPath:keyPath observer:observer];

    

    //3.isa 指向子类

    object_setClass(self, newClass);

    //4.setter逻辑处理

    //保存观察者信息-数组

    HPKVOBlockInfo *kvoInfo = [[HPKVOBlockInfo alloc] initWitObserver:observer forKeyPath:keyPath handleBlock:block];

    NSMutableArray *observerArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kHPBlockKVOAssiociateKey));

    if (!observerArray) {

        observerArray = [NSMutableArray arrayWithCapacity:1];

    }

    [observerArray addObject:kvoInfo];

    objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kHPBlockKVOAssiociateKey), observerArray, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

    

    //保存被观察者信息

    HPKVOObservedInfo *kvoObservedInfo = [[HPKVOObservedInfo alloc] initWitObserverd:self forKeyPath:keyPath];

    NSMutableArray *observerdArray = objc_getAssociatedObject(observer, (__bridge const void * _Nonnull)(kHPBlockKVOObserverdAssiociateKey));

    if (!observerdArray) {

        observerdArray = [NSMutableArray arrayWithCapacity:1];

    }

    [observerdArray addObject:kvoObservedInfo];

    objc_setAssociatedObject(observer, (__bridge const void * _Nonnull)(kHPBlockKVOObserverdAssiociateKey), observerdArray, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

}



- (void)hp_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath {

    NSMutableArray *observerArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kHPBlockKVOAssiociateKey));

    if (observerArray.count <= 0) {

        return;

    }

    

    NSMutableArray *tempArray = [observerArray mutableCopy];

    for (HPKVOInfo *info in tempArray) {

        if ([info.keyPath isEqualToString:keyPath]) {

            if (info.observer) {

                if (info.observer == observer) {

                    [observerArray removeObject:info];

                }

            } else {

                [observerArray removeObject:info];

            }

        }

    }

    objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kHPBlockKVOAssiociateKey), observerArray, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

    //已经全部移除了

    if (observerArray.count <= 0) {

        //isa指回给父类

        Class superClass = [self class];

        object_setClass(self, superClass);

    }

}



- (BOOL)_handleSetterMethodFromKeyPath:(NSString *)keyPath {

    SEL setterSeletor = NSSelectorFromString(_setterForGetter(keyPath));

    Method setterMethod = class_getInstanceMethod(object_getClass(self), setterSeletor);

    NSAssert(setterMethod, @"%@ setter is not exist",keyPath);

    return setterMethod ? YES : NO;

}



// 从get方法获取set方法的名称 key -> setKey

static NSString *_setterForGetter(NSString *getter) {

    if (getter.length <= 0) { return nil;}

    NSString *firstString = [[getter substringToIndex:1] uppercaseString];

    NSString *otherString = [getter substringFromIndex:1];

    return [NSString stringWithFormat:@"set%@%@:",firstString,otherString];

}



//申请类-注册类-添加方法

- (Class)_creatKVOClassWithKeyPath:(NSString *)keyPath observer:(NSObject *)observer {

    //这里重写class后kvo子类也返回的是父类的名字

    NSString *superClassName = NSStringFromClass([self class]);

    NSString *newClassName = [NSString stringWithFormat:@"%@%@",kHPBlockKVOClassPrefix,superClassName];

    Class newClass = NSClassFromString(newClassName);

    //类是否存在

    if (!newClass)  {//不存在需要创建类

        //1：申请类 父类、新类名称、额外空间

        newClass = objc_allocateClassPair([self class], newClassName.UTF8String, 0);

        //2：注册类

        objc_registerClassPair(newClass);

        //3：添加class方法，class返回父类信息 这里是`-class`

        SEL classSEL = NSSelectorFromString(@"class");

        Method classMethod = class_getInstanceMethod([self class], classSEL);

        const char *classTypes = method_getTypeEncoding(classMethod);

        class_addMethod(newClass, classSEL, (IMP)_hp_class, classTypes);

        

        //hook dealloc

        [[observer class] hp_methodSwizzleWithClass:[observer class] oriSEL:NSSelectorFromString(@"dealloc") swizzledSEL:@selector(hp_dealloc) isClassMethod:NO];

    }

    //4：添加setter方法

    SEL setterSEL = NSSelectorFromString(_setterForGetter(keyPath));

    Method setterMethod = class_getInstanceMethod([self class], setterSEL);

    const char *setterTypes = method_getTypeEncoding(setterMethod);

    class_addMethod(newClass, setterSEL, (IMP)_hp_setter, setterTypes);

    

    return newClass;

}



//返回父类信息

Class _hp_class(id self,SEL _cmd) {

    return class_getSuperclass(object_getClass(self));

}



static void _hp_setter(id self,SEL _cmd,id newValue) {

    //自动开关判断，省略

    //保存旧值

    NSString *keyPath = _getterForSetter(NSStringFromSelector(_cmd));

    id oldValue = [self valueForKey:keyPath];

    //1.调用父类的setter(也可以通过performSelector调用)

    void (*hp_msgSendSuper)(void *,SEL , id) = (void *)objc_msgSendSuper;

    struct objc_super super_struct = {

        .receiver = self,

        .super_class = class_getSuperclass(object_getClass(self)),

    };

    hp_msgSendSuper(&super_struct,_cmd,newValue);

    

    //2.通知观察者

    NSMutableArray *observerArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kHPBlockKVOAssiociateKey));

    for (HPKVOBlockInfo *info in observerArray) {//循环调用,可能添加多次。

        if ([info.keyPath isEqualToString:keyPath] && info.handleBlock && info.observer) {

            dispatch_async(dispatch_get_global_queue(0, 0), ^{

                info.handleBlock(info.observer, keyPath, oldValue, newValue);

            });

        }

    }

}



//获取getter

static NSString *_getterForSetter(NSString *setter){

    if (setter.length <= 0 || ![setter hasPrefix:@"set"] || ![setter hasSuffix:@":"]) { return nil;}

    NSRange range = NSMakeRange(3, setter.length - 4);

    NSString *getter = [setter substringWithRange:range];

    NSString *firstString = [[getter substringToIndex:1] lowercaseString];

    return  [getter stringByReplacingCharactersInRange:NSMakeRange(0, 1) withString:firstString];

}



+ (void)hp_methodSwizzleWithClass:(Class)cls oriSEL:(SEL)oriSEL swizzledSEL:(SEL)swizzledSEL isClassMethod:(BOOL)isClassMethod {

    if (!cls) {

        NSLog(@"class is nil");

        return;

    }

    if (!swizzledSEL) {

        NSLog(@"swizzledSEL is nil");

        return;

    }

    //类/元类

    Class swizzleClass = isClassMethod ? object_getClass(cls) : cls;

    Method oriMethod = class_getInstanceMethod(swizzleClass, oriSEL);

    Method swiMethod = class_getInstanceMethod(swizzleClass, swizzledSEL);

    if (!oriMethod) {//原始方法没有实现

        // 在oriMethod为nil时，替换后将swizzledSEL复制一个空实现

        class_addMethod(swizzleClass, oriSEL, method_getImplementation(swiMethod), method_getTypeEncoding(swiMethod));

        //添加一个空的实现

        method_setImplementation(swiMethod, imp_implementationWithBlock(^(id self, SEL _cmd){

           NSLog(@"imp default null implementation");

        }));

    }

    //自己没有则会添加成功，自己有添加失败

    BOOL success = class_addMethod(swizzleClass, oriSEL, method_getImplementation(swiMethod), method_getTypeEncoding(oriMethod));

    if (success) {//自己没有方法添加一个，添加成功则证明自己没有。

       class_replaceMethod(swizzleClass, swizzledSEL, method_getImplementation(oriMethod), method_getTypeEncoding(oriMethod));

    } else { //自己有直接进行交换

       method_exchangeImplementations(oriMethod, swiMethod);

    }

}



- (void)hp_dealloc {

    NSMutableArray *observerdArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kHPBlockKVOObserverdAssiociateKey));

    for (HPKVOObservedInfo *info in observerdArray) {

        if (info.observerd) {

            [info.observerd hp_removeObserver:self forKeyPath:info.keyPath];

        }

    }

    [self hp_dealloc];

}



@end

• 根据类名字拼接kvo类名字，判断是否已经存在。（superClassName由于class重写了，即使二次进入也获取到的是父类的名字）。
• newClass不存在则调用objc_allocateClassPair创建kvo子类。并且重写- class方法。
• 添加对应的setter方法。

当然也可以写+class，写入元类中。在objc_allocateClassPair后元类就存在了：

object_setClass(self, newClass);

源码中就是修改对象的isa指向。

1.1.4 setter逻辑

在进行了上面逻辑的处理后，这个时候调用如下代码：

[self.obj hp_addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:NULL];

self.obj.name = @"HP";

static void hp_setter(id self,SEL _cmd,id newValue) {

    //自动开关判断，省略

    //1.调用父类的setter(也可以通过performSelector调用)

    void (*hp_msgSendSuper)(void *,SEL , id) = (void *)objc_msgSendSuper;

    struct objc_super super_struct = {

        .receiver = self,

        .super_class = class_getSuperclass(object_getClass(self)),

    };

    hp_msgSendSuper(&super_struct,_cmd,newValue);

    

    //2.通知观察者

    [observer hp_observeValueForKeyPath:getterForSetter(_cmd) ofObject:self change:@{} context:NULL];

}

static NSString *const kHPKVOAssiociateKey = @"HPKVOAssiociateKey";



objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kHPKVOAssiociateKey), observer, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

//2.通知观察者

id observer = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kHPKVOAssiociateKey));

[observer hp_observeValueForKeyPath:getterForSetter(NSStringFromSelector(_cmd)) ofObject:self change:@{@"kind":@1,@"new":newValue} context:NULL];



//获取getter

static NSString *getterForSetter(NSString *setter){

    if (setter.length <= 0 || ![setter hasPrefix:@"set"] || ![setter hasSuffix:@":"]) { return nil;}

    NSRange range = NSMakeRange(3, setter.length - 4);

    NSString *getter = [setter substringWithRange:range];

    NSString *firstString = [[getter substringToIndex:1] lowercaseString];

    return  [getter stringByReplacingCharactersInRange:NSMakeRange(0, 1) withString:firstString];

}

change:{

    kind = 1;

    new = HP;

}

typedef NS_OPTIONS(NSUInteger, HPKeyValueObservingOptions) {

    HPKeyValueObservingOptionNew = 0x01,

    HPKeyValueObservingOptionOld = 0x02,

};



@interface HPKVOInfo : NSObject



@property (nonatomic, weak) id observer;

@property (nonatomic, copy) NSString *keyPath;

@property (nonatomic, assign) HPKeyValueObservingOptions options;

@property (nonatomic, strong) id context;



- (instancetype)initWitObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(HPKeyValueObservingOptions)options context:(nullable void *)context;



@end



@implementation HPKVOInfo



- (instancetype)initWitObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(HPKeyValueObservingOptions)options context:(nullable void *)context {

    self = [super init];

    if (self) {

        self.observer = observer;

        self.keyPath  = keyPath;

        self.options  = options;

        self.context = (__bridge id _Nonnull)(context);

    }

    return self;

}



@end

//保存观察者信息-数组

HPKVOInfo *kvoInfo = [[HPKVOInfo alloc] initWitObserver:observer forKeyPath:keyPath options:options context:context];

NSMutableArray *observerArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kHPKVOAssiociateKey));

if (!observerArray) {

    observerArray = [NSMutableArray arrayWithCapacity:1];

}

[observerArray addObject:kvoInfo];

objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kHPKVOAssiociateKey), observerArray, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

static void hp_setter(id self,SEL _cmd,id newValue) {

    //自动开关判断，省略

    //保存旧值

    NSString *keyPath = getterForSetter(NSStringFromSelector(_cmd));

    id oldValue = [self valueForKey:keyPath];

    //1.调用父类的setter(也可以通过performSelector调用)

    void (*hp_msgSendSuper)(void *,SEL , id) = (void *)objc_msgSendSuper;

    struct objc_super super_struct = {

        .receiver = self,

        .super_class = class_getSuperclass(object_getClass(self)),

    };

    hp_msgSendSuper(&super_struct,_cmd,newValue);

    

    //2.通知观察者

    NSMutableArray *observerArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kHPKVOAssiociateKey));

    for (HPKVOInfo *info in observerArray) {//循环调用,可能添加多次。

        if ([info.keyPath isEqualToString:keyPath]) {

            dispatch_async(dispatch_get_global_queue(0, 0), ^{

                NSMutableDictionary<NSKeyValueChangeKey,id> *change = [NSMutableDictionary dictionaryWithCapacity:1];

                //对新旧值进行处理

                if (info.options & HPKeyValueObservingOptionNew) {

                    [change setObject:newValue forKey:NSKeyValueChangeNewKey];

                }

                if (info.options & HPKeyValueObservingOptionOld) {

                    if (oldValue) {

                        [change setObject:oldValue forKey:NSKeyValueChangeOldKey];

                    } else {

                        [change setObject:@"" forKey:NSKeyValueChangeOldKey];

                    }

                }

                [change setObject:@1 forKey:@"kind"];

                //消息发送给观察者

                [info.observer hp_observeValueForKeyPath:keyPath ofObject:self change:change context:(__bridge void * _Nullable)(info.context)];

            });

        }

    }

}

- (void)hp_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath {

    [self hp_removeObserver:observer forKeyPath:keyPath context:NULL];

}



- (void)hp_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath context:(void *)context {

    NSMutableArray *observerArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kHPKVOAssiociateKey));

    if (observerArray.count <= 0) {

        return;

    }

    

    NSMutableArray *tempArray = [observerArray mutableCopy];

    for (HPKVOInfo *info in tempArray) {

        if ([info.keyPath isEqualToString:keyPath]) {

            if (info.observer) {

                if (info.observer == observer) {

                    if (context != NULL) {

                        if (info.context == context) {

                            [observerArray removeObject:info];

                        }

                    } else {

                        [observerArray removeObject:info];

                    }

                }

            } else {

                if (context != NULL) {

                    if (info.context == context) {

                        [observerArray removeObject:info];

                    }

                } else {

                    [observerArray removeObject:info];

                }

            }

        }

    }

    objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kHPKVOAssiociateKey), observerArray, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

    //已经全部移除了

    if (observerArray.count <= 0) {

        //isa指回给父类

        Class superClass = [self class];

        object_setClass(self, superClass);

    }

}

@interface NSObject (HP_KVO)



- (void)hp_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(HPKeyValueObservingOptions)options context:(nullable void *)context;

- (void)hp_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath context:(nullable void *)context;

- (void)hp_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath;



- (void)hp_observeValueForKeyPath:(nullable NSString *)keyPath ofObject:(nullable id)object change:(nullable NSDictionary<NSKeyValueChangeKey, id> *)change context:(nullable void *)context;



@end



#import "NSObject+HP_KVO.h"

#import 

#import 



static NSString *const kHPKVOClassPrefix = @"HPKVONotifying_";

static NSString *const kHPKVOAssiociateKey = @"HPKVOAssiociateKey";



@implementation NSObject (HP_KVO)



- (void)hp_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(HPKeyValueObservingOptions)options context:(nullable void *)context {

    //1.参数判断 以及 setter检查

    if (!observer || !keyPath) return;

    BOOL result = [self handleSetterMethodFromKeyPath:keyPath];

    if (!result) return;

    

    //2.isa_swizzle 申请类-注册类-添加方法

    Class newClass = [self creatKVOClassWithKeyPath:keyPath];

    

    //3.isa 指向子类

    object_setClass(self, newClass);

    //4.setter逻辑处理

    //保存观察者信息-数组

    HPKVOInfo *kvoInfo = [[HPKVOInfo alloc] initWitObserver:observer forKeyPath:keyPath options:options context:context];

    NSMutableArray *observerArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kHPKVOAssiociateKey));

    if (!observerArray) {

        observerArray = [NSMutableArray arrayWithCapacity:1];

    }

    [observerArray addObject:kvoInfo];

    objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kHPKVOAssiociateKey), observerArray, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

}



- (void)hp_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath {

    [self hp_removeObserver:observer forKeyPath:keyPath context:NULL];

}



- (void)hp_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath context:(void *)context {

    NSMutableArray *observerArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kHPKVOAssiociateKey));

    if (observerArray.count <= 0) {

        return;

    }

    

    NSMutableArray *tempArray = [observerArray mutableCopy];

    for (HPKVOInfo *info in tempArray) {

        if ([info.keyPath isEqualToString:keyPath]) {

            if (info.observer) {

                if (info.observer == observer) {

                    if (context != NULL) {

                        if (info.context == context) {

                            [observerArray removeObject:info];

                        }

                    } else {

                        [observerArray removeObject:info];

                    }

                }

            } else {

                if (context != NULL) {

                    if (info.context == context) {

                        [observerArray removeObject:info];

                    }

                } else {

                    [observerArray removeObject:info];

                }

            }

        }

    }

    objc_setAssociatedObject(self, (__bridge const void * _Nonnull)(kHPKVOAssiociateKey), observerArray, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

    //已经全部移除了

    if (observerArray.count <= 0) {

        //isa指回给父类

        Class superClass = [self class];

        object_setClass(self, superClass);

    }

}



- (BOOL)handleSetterMethodFromKeyPath:(NSString *)keyPath {

    SEL setterSeletor = NSSelectorFromString(setterForGetter(keyPath));

    Method setterMethod = class_getInstanceMethod(object_getClass(self), setterSeletor);

    NSAssert(setterMethod, @"%@ setter is not exist",keyPath);

    return setterMethod ? YES : NO;

}



// 从get方法获取set方法的名称 key -> setKey

static NSString *setterForGetter(NSString *getter) {

    if (getter.length <= 0) { return nil;}

    NSString *firstString = [[getter substringToIndex:1] uppercaseString];

    NSString *otherString = [getter substringFromIndex:1];

    return [NSString stringWithFormat:@"set%@%@:",firstString,otherString];

}



//申请类-注册类-添加方法

- (Class)creatKVOClassWithKeyPath:(NSString *)keyPath {

    //这里重写class后kvo子类也返回的是父类的名字

    NSString *superClassName = NSStringFromClass([self class]);

    NSString *newClassName = [NSString stringWithFormat:@"%@%@",kHPKVOClassPrefix,superClassName];

    Class newClass = NSClassFromString(newClassName);

    //类是否存在

    if (!newClass)  {//不存在需要创建类

        //1：申请类 父类、新类名称、额外空间

        newClass = objc_allocateClassPair([self class], newClassName.UTF8String, 0);

        //2：注册类

        objc_registerClassPair(newClass);

        //3：添加class方法，class返回父类信息 这里是`-class`

        SEL classSEL = NSSelectorFromString(@"class");

        Method classMethod = class_getInstanceMethod([self class], classSEL);

        const char *classTypes = method_getTypeEncoding(classMethod);

        class_addMethod(newClass, classSEL, (IMP)hp_class, classTypes);

    }

    //4：添加setter方法

    SEL setterSEL = NSSelectorFromString(setterForGetter(keyPath));

    Method setterMethod = class_getInstanceMethod([self class], setterSEL);

    const char *setterTypes = method_getTypeEncoding(setterMethod);

    class_addMethod(newClass, setterSEL, (IMP)hp_setter, setterTypes);

    

    return newClass;

}



//返回父类信息

Class hp_class(id self,SEL _cmd) {

    return class_getSuperclass(object_getClass(self));

}



static void hp_setter(id self,SEL _cmd,id newValue) {

    //自动开关判断，省略

    //保存旧值

    NSString *keyPath = getterForSetter(NSStringFromSelector(_cmd));

    id oldValue = [self valueForKey:keyPath];

    //1.调用父类的setter(也可以通过performSelector调用)

    void (*hp_msgSendSuper)(void *,SEL , id) = (void *)objc_msgSendSuper;

    struct objc_super super_struct = {

        .receiver = self,

        .super_class = class_getSuperclass(object_getClass(self)),

    };

    hp_msgSendSuper(&super_struct,_cmd,newValue);

    

    //2.通知观察者

    NSMutableArray *observerArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kHPKVOAssiociateKey));

    for (HPKVOInfo *info in observerArray) {//循环调用,可能添加多次。

        if ([info.keyPath isEqualToString:keyPath]) {

            dispatch_async(dispatch_get_global_queue(0, 0), ^{

                NSMutableDictionary<NSKeyValueChangeKey,id> *change = [NSMutableDictionary dictionaryWithCapacity:1];

                //对新旧值进行处理

                if (info.options & HPKeyValueObservingOptionNew) {

                    [change setObject:newValue forKey:NSKeyValueChangeNewKey];

                }

                if (info.options & HPKeyValueObservingOptionOld) {

                    if (oldValue) {

                        [change setObject:oldValue forKey:NSKeyValueChangeOldKey];

                    } else {

                        [change setObject:@"" forKey:NSKeyValueChangeOldKey];

                    }

                }

                [change setObject:@1 forKey:@"kind"];

                //消息发送给观察者

                [info.observer hp_observeValueForKeyPath:keyPath ofObject:self change:change context:(__bridge void * _Nullable)(info.context)];

            });

        }

    }

}



//获取getter

static NSString *getterForSetter(NSString *setter){

    if (setter.length <= 0 || ![setter hasPrefix:@"set"] || ![setter hasSuffix:@":"]) { return nil;}

    NSRange range = NSMakeRange(3, setter.length - 4);

    NSString *getter = [setter substringWithRange:range];

    NSString *firstString = [[getter substringToIndex:1] lowercaseString];

    return  [getter stringByReplacingCharactersInRange:NSMakeRange(0, 1) withString:firstString];

}



@end

typedef void(^HPKVOBlock)(id observer,NSString *keyPath,id oldValue,id newValue);



- (void)hp_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath block:(HPKVOBlock)block {

……

    //保存观察者信息-数组

    HPKVOBlockInfo *kvoInfo = [[HPKVOBlockInfo alloc] initWitObserver:observer forKeyPath:keyPath handleBlock:block];

……

}

NSMutableArray *observerArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kHPBlockKVOAssiociateKey));

for (HPKVOBlockInfo *info in observerArray) {//循环调用,可能添加多次。

    if ([info.keyPath isEqualToString:keyPath] && info.handleBlock) {

        dispatch_async(dispatch_get_global_queue(0, 0), ^{

            info.handleBlock(info.observer, keyPath, oldValue, newValue);

        });

    }

}

[self.obj hp_addObserver:self forKeyPath:@"name" block:^(id  _Nonnull observer, NSString * _Nonnull keyPath, id  _Nonnull oldValue, id  _Nonnull newValue) {

    NSLog(@"block: oldValue:%@,newValue:%@",oldValue,newValue);

}];

+ (void)hp_methodSwizzleWithClass:(Class)cls oriSEL:(SEL)oriSEL swizzledSEL:(SEL)swizzledSEL isClassMethod:(BOOL)isClassMethod {

    if (!cls) {

        NSLog(@"class is nil");

        return;

    }

    if (!swizzledSEL) {

        NSLog(@"swizzledSEL is nil");

        return;

    }

    //类/元类

    Class swizzleClass = isClassMethod ? object_getClass(cls) : cls;

    Method oriMethod = class_getInstanceMethod(swizzleClass, oriSEL);

    Method swiMethod = class_getInstanceMethod(swizzleClass, swizzledSEL);

    if (!oriMethod) {//原始方法没有实现

        // 在oriMethod为nil时，替换后将swizzledSEL复制一个空实现

        class_addMethod(swizzleClass, oriSEL, method_getImplementation(swiMethod), method_getTypeEncoding(swiMethod));

        //添加一个空的实现

        method_setImplementation(swiMethod, imp_implementationWithBlock(^(id self, SEL _cmd){

           NSLog(@"imp default null implementation");

        }));

    }

    //自己没有则会添加成功，自己有添加失败

    BOOL success = class_addMethod(swizzleClass, oriSEL, method_getImplementation(swiMethod), method_getTypeEncoding(oriMethod));

    if (success) {//自己没有方法添加一个，添加成功则证明自己没有。

       class_replaceMethod(swizzleClass, swizzledSEL, method_getImplementation(oriMethod), method_getTypeEncoding(oriMethod));

    } else { //自己有直接进行交换

       method_exchangeImplementations(oriMethod, swiMethod);

    }

}



+ (void)load {

    [self hp_methodSwizzleWithClass:[self class] oriSEL:NSSelectorFromString(@"dealloc") swizzledSEL:@selector(hp_dealloc) isClassMethod:NO];

}



- (void)hp_dealloc {

   // [self.obj hp_removeObserver:self forKeyPath:@""];

    [self hp_dealloc];

}

static NSString *const kHPBlockKVOObserverdAssiociateKey = @"HPKVOObserverdAssiociateKey";



@interface HPKVOObservedInfo : NSObject



@property (nonatomic, weak) id observerd;

@property (nonatomic, copy) NSString  *keyPath;



@end



@implementation HPKVOObservedInfo



- (instancetype)initWitObserverd:(NSObject *)observerd forKeyPath:(NSString *)keyPath {

    if (self=[super init]) {

        _observerd = observerd;

        _keyPath  = keyPath;

    }

    return self;

}



@end





- (void)hp_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath block:(HPKVOBlock)block {

    ……    

    //保存被观察者信息

    HPKVOObservedInfo *kvoObservedInfo = [[HPKVOObservedInfo alloc] initWitObserverd:self forKeyPath:keyPath];

    NSMutableArray *observerdArray = objc_getAssociatedObject(observer, (__bridge const void * _Nonnull)(kHPBlockKVOObserverdAssiociateKey));

    if (!observerdArray) {

        observerdArray = [NSMutableArray arrayWithCapacity:1];

    }

    [observerdArray addObject:kvoObservedInfo];

    objc_setAssociatedObject(observer, (__bridge const void * _Nonnull)(kHPBlockKVOObserverdAssiociateKey), observerdArray, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

}

- (void)hp_dealloc {

    NSMutableArray *observerdArray = objc_getAssociatedObject(self, (__bridge const void * _Nonnull)(kHPBlockKVOObserverdAssiociateKey));

    for (HPKVOObservedInfo *info in observerdArray) {

        if (info.observerd) {

            [info.observerd hp_removeObserver:self forKeyPath:info.keyPath];

        }

    }

    [self hp_dealloc];

}

1. DecorView何时绘制到屏幕中
2. DecorView如何绘制到屏幕中（addView,removeView,upDateViewLayout）
3. Activity是如何得到Touch事件的

DecorView何时绘制到屏幕中

在Activity的启动流程中提到执行Activity的performLaunchActivity方法执行的时，先是通过反射创建了Activity,然后会调用Activity的attach方法，在上一篇我们知道attach方法做了PhoneWindow的初始化操作，再然后才是执行生命周期onCreate，而setContent方法又是在onCreate执行后，看起来一切都很合理。

先创建一个Activity,然后再为这个Activity创建一个PhoneWindow，执行onCreate,最后再把我们写的XML设置进去。

一切都准备就绪，但是我们到目前还是看不到界面，因为我们知道，Activity真正可见是在执行onResume的时候。所以对于DecorView何时绘制到屏幕中问题，其实答案已经出来了，接下来需要去代码里进行验证。

看过我之前文章的人知道找Activity不同生命周期具体执行代码要去TransactionExecutor里看performLifecycleSequence方法。

Activity的onRemune具体执行是在Activity的handleResumeActivity方法中，我们去看看这里是怎么处理PhoneWindow的。

android.app.ActivityThread



@Override

public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,

        String reason) {

            ......

            // TODO Push resumeArgs into the activity for consideration

            performResumeActivity内会触发Activity的onResume生命周期

            final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);

            ......

            r.window = r.activity.getWindow();

            //获取到当前PhoneWindow的DecorView

            View decor = r.window.getDecorView();

            decor.setVisibility(View.INVISIBLE);

            ViewManager wm = a.getWindowManager();

            ......

            关键代码

            wm.addView(decor, l);

            ......

}

 

关键代码只有简单的一句wm.addView(decor, l);

找出WindowManagerImpl

这个wm是ViewManager类型，然后获取他的方法是Activity的WindowManager。先来搞清楚一下WindowManager和ViewManager是什么关系。

假装分析一波，能用ViewManager去接收WindowManager，说明WindowManager要么是ViewManager的子类，要么是实现了ViewManager接口。而且会使用wm.addView。就说明这个addView方法ViewManager里被定义了，在WindowManager中没有，否则不会这么去写。

其实也不用想这么多，各自点进去看看就知道了。

android.view.ViewManager



public interface ViewManager

{

    public void addView(View view, ViewGroup.LayoutParams params);

    public void updateViewLayout(View view, ViewGroup.LayoutParams params);

    public void removeView(View view);

}



 

android.view.WindowManager

@SystemService(Context.WINDOW_SERVICE)

public interface WindowManager extends ViewManager {

   ......

}

 

ViewManager是个接口，里面虽然只有三个方法，但是我们却非常熟悉，这三个方法的重要性就不用多说了。

让我没想到的是WindowManager居然也是个接口......那addView具体的实现在哪呢。只能去getWindowManager具体找找了。

android.app.Activity

......

 private WindowManager mWindowManager;

 ......

public WindowManager getWindowManager() {

   return mWindowManager;

}

 

而的赋值操作在attach里

   final void attach(......){

        mWindow = new PhoneWindow(this, window, activityConfigCallback);

        mWindow.setWindowControllerCallback(mWindowControllerCallback);

        mWindow.setCallback(this);

        mWindow.setOnWindowDismissedCallback(this);

        mWindow.getLayoutInflater().setPrivateFactory(this);

        ......

       给PhoneWindow设置一个WindowManager 

       mWindow.setWindowManager((WindowManager)context.getSystemService(Context.WINDOW_SERVICE),

                mToken, mComponent.flattenToString(),

                (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);

        if (mParent != null) {

            mWindow.setContainer(mParent.getWindow());

        }

        取出WindowManager来赋值给mWindowManager

        mWindowManager = mWindow.getWindowManager();

   }

 

所以想知道mWindowManager到底是啥还得看mWindow.getWindowManager。而mWindow.getWindowManager返回的又是上面的一行mWindow.setWindowManager，所以去setWindowManager看看吧

android.view.Window



    ......

    private WindowManager mWindowManager;

    ......

    public void setWindowManager(WindowManager wm, IBinder appToken, String appName,

    boolean hardwareAccelerated) {

        mAppToken = appToken;

        mAppName = appName;

        mHardwareAccelerated = hardwareAccelerated;

        if (wm == null) {

            wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);

        }

        关键代码

        mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this);

    }

    ......

    public WindowManager getWindowManager() {

        return mWindowManager;

    }



 

真相浮出水面

mWindowManager的真实对象是WindowManagerImpl

addView

这一小节我们来看看Window的添加过程

找了这么久我们就是为了弄明白wm.addView(decor, l);的wm到底是个啥。下面去看看addView到底把我们的DecorView怎么了。

android.view.WindowManagerImpl



public final class WindowManagerImpl implements WindowManager {

    @UnsupportedAppUsage

    private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();

    ......

    @Override

    public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {

        applyDefaultToken(params);

        mGlobal.addView(view, params, mContext.getDisplayNoVerify(), mParentWindow,

                mContext.getUserId());

    }

    ......

}

 

WindowManagerImpl居然又是个空壳，大部分操作都给了单例类WindowManagerGlobal去处理,

android.view.WindowManagerGlobal

    

    private final ArrayList<View> mViews = new ArrayList<View>();

   

    private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();

    

    private final ArrayList<WindowManager.LayoutParams> mParams =

            new ArrayList<WindowManager.LayoutParams>();

    private final ArraySet<View> mDyingViews = new ArraySet<View>();

    

    public void addView(View view, ViewGroup.LayoutParams params,Display display,

    Window parentWindow, int userId) {

    ......

     ViewRootImpl root;

     View panelParentView = null;

     synchronized (mLock) {

            进行参数检查 

            if (view == null) {

            throw new IllegalArgumentException("view must not be null");

            }

            if (display == null) {

                throw new IllegalArgumentException("display must not be null");

            }

            if (!(params instanceof WindowManager.LayoutParams)) {

                throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");

            }



            final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;

            如果是子Windowh还需要进行布局参数的调整

            if (parentWindow != null) {

                parentWindow.adjustLayoutParamsForSubWindow(wparams);

            }       

            ......

            创建ViewRootImpl

            root = new ViewRootImpl(view.getContext(), display);



            view.setLayoutParams(wparams);



            mViews.add(view);

            mRoots.add(root);

            mParams.add(wparams);



            // do this last because it fires off messages to start doing things

            try {

                //把DecorView交给ViewRootImpl

                root.setView(view, wparams, panelParentView, userId);

            } catch (RuntimeException e) {

                // BadTokenException or InvalidDisplayException, clean up.

                if (index >= 0) {

                    removeViewLocked(index, true);

                }

                throw e;

            }

      }

   }

 

首先我们看到WindowManagerGlobal维护了4个集合

• mViews :存储了所有Window所对应的View

• mRoots :存储的是所以Window所对应的ViewRootImpl

• mParams:存储的是所有Window所对应的布局参数

• mDyingViews:存储的是那些正在被删除的View

在addView中后面的关键代码创建了ViewRootImpl,并将我们的DecorView交给了它。

android.view.ViewRootImpl



   public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView,

   int userId) {

        synchronized (this) {

            if (mView == null) {

                mView = view;

                }

            ......

            触发一次屏幕刷新

            requestLayout();

        try {

            将最后的操作给mWindowSession

            res = mWindowSession.addToDisplayAsUser(mWindow, mSeq, mWindowAttributes,

                    getHostVisibility(), mDisplay.getDisplayId(), userId, mTmpFrame,

                    mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,

                    mAttachInfo.mDisplayCutout, inputChannel,

                    mTempInsets, mTempControls);

            setFrame(mTmpFrame);

        } ......

       // Set up the input pipeline.

       输入事件处理

       CharSequence counterSuffix = attrs.getTitle();

       mSyntheticInputStage = new SyntheticInputStage();

       InputStage viewPostImeStage = new ViewPostImeInputStage(mSyntheticInputStage);

       InputStage nativePostImeStage = new NativePostImeInputStage(viewPostImeStage,

                        "aq:native-post-ime:" + counterSuffix);

       InputStage earlyPostImeStage = new EarlyPostImeInputStage(nativePostImeStage);

       InputStage imeStage = new ImeInputStage(earlyPostImeStage,

                        "aq:ime:" + counterSuffix);

       InputStage viewPreImeStage = new ViewPreImeInputStage(imeStage);

       InputStage nativePreImeStage = new NativePreImeInputStage(viewPreImeStage,

                        "aq:native-pre-ime:" + counterSuffix);        

        ......

   }

    @Override

    public void requestLayout() {

        if (!mHandlingLayoutInLayoutRequest) {

            checkThread();

            mLayoutRequested = true;

            scheduleTraversals();

        }

    }

 

setView方法先是做了个刷新布局的操作，内部执行的scheduleTraversals() 就是View绘制的入口，调用此方法后 ViewRootImpl 所关联的 View 也执行 measure - layout - draw 操作，确保在 View 被添加到 Window 上显示到屏幕之前，已经完成测量和绘制操作。至此由ViewRootImpl完成了添加View到Window的操作。 然后将调用mWindowSession的addToDisplayAsUser方法来完成Window的添加过程，内部真实执行的地方在WMS（WindowManagerService)

View的事件如何反馈到Activity

对于后面的输入事件处理的代码我也不是很明白，但是之前好像在哪里看过，所有对于利用管道和系统底层通信的机制有点印象。 这一块的简单的理解就是：这里是设置了一系列的输入通道。因为一个触屏事件的发生是肯定是由屏幕发起，再经过驱动层一系列的计算处理最后通过 Socket 跨进程通知 Android Framework 层。 其实看到这一块我一开始是不打算继续深入了，因为的也知道我的能力差不多就这了，但是抱着好奇的心点了进去想看看ViewPostImeInputStage是个啥。结果却有了意想不到的收获。

android.view.ViewRootImpl

   final class ViewPostImeInputStage extends InputStage {

        public ViewPostImeInputStage(InputStage next) {

            super(next);

        }



        @Override

        protected int onProcess(QueuedInputEvent q) {

            if (q.mEvent instanceof KeyEvent) {

                return processKeyEvent(q);

            } else {

                final int source = q.mEvent.getSource();

                if ((source & InputDevice.SOURCE_CLASS_POINTER) != 0) {

                    只看这里，其实下面的两个都是类似

                    return processPointerEvent(q);

                } else if ((source & InputDevice.SOURCE_CLASS_TRACKBALL) != 0) {

                    return processTrackballEvent(q);

                } else {

                    return processGenericMotionEvent(q);

                }

            }

        }

       }

 

private int processPointerEvent(QueuedInputEvent q) {

    final MotionEvent event = (MotionEvent)q.mEvent;



    mAttachInfo.mUnbufferedDispatchRequested = false;

    mAttachInfo.mHandlingPointerEvent = true;

    boolean handled = mView.dispatchPointerEvent(event);

    ......

    return handled ? FINISH_HANDLED : FORWARD;

}

 

注意一下参数的传递就知道这个mView其实就是一开始我们DecorView。但是dispatchPointerEvent是在View定义的。

android.view.View

    public final boolean dispatchPointerEvent(MotionEvent event) {

        if (event.isTouchEvent()) {

            return dispatchTouchEvent(event);

        } else {

            return dispatchGenericMotionEvent(event);

        }

    }

 

返回了dispatchTouchEvent和dispatchGenericMotionEvent的执行。所以去DecorView看看

com.android.internal.policy.DecorView



    @Override

    public boolean dispatchTouchEvent(MotionEvent ev) {

        final Window.Callback cb = mWindow.getCallback();

        return cb != null && !mWindow.isDestroyed() && mFeatureId < 0

                ? cb.dispatchTouchEvent(ev) : super.dispatchTouchEvent(ev);

    }



    @Override

    public boolean dispatchTrackballEvent(MotionEvent ev) {

        final Window.Callback cb = mWindow.getCallback();

        return cb != null && !mWindow.isDestroyed() && mFeatureId < 0

                ? cb.dispatchTrackballEvent(ev) : super.dispatchTrackballEvent(ev);

    }



    @Override

    public boolean dispatchGenericMotionEvent(MotionEvent ev) {

        final Window.Callback cb = mWindow.getCallback();

        return cb != null && !mWindow.isDestroyed() && mFeatureId < 0

                ? cb.dispatchGenericMotionEvent(ev) : super.dispatchGenericMotionEvent(ev);

    }



 

我们发现不管是哪个方法，最后都是从mWindow获取一个回调cb,然后把事回调出去。不知道读者对之前在Activity的attach里的时候的代码 mWindow.setCallback(this);还有没有印象，方法接收的参数类型是Window内部的一个接口Callback而我们的Activity实现了这个接口。所以mWindow.setCallback就是把Activity设置了进去，所以这个cb就是我们的Activity，所以DecorView的事件，就这样传递给了Activity

removeView

android.view.WindowManagerGlobal



   @UnsupportedAppUsage

    public void removeView(View view, boolean immediate) {

        if (view == null) {

            throw new IllegalArgumentException("view must not be null");

        }



        synchronized (mLock) {

            找到需要删除View的索引

            int index = findViewLocked(view, true);

            View curView = mRoots.get(index).getView();

            真的执行删除操作

            removeViewLocked(index, immediate);

            if (curView == view) {

                return;

            }



            throw new IllegalStateException("Calling with view " + view

                    + " but the ViewAncestor is attached to " + curView);

        }

    }

 

Window的删除过程页是在WindowManagerGlobal中。先是找到需要删除View的索引，然后传递到removeViewLocked方法里。

   private void removeViewLocked(int index, boolean immediate) {

        ViewRootImpl root = mRoots.get(index);

        View view = root.getView();



        if (root != null) {

            root.getImeFocusController().onWindowDismissed();

        }

        boolean deferred = root.die(immediate);

        if (view != null) {

            view.assignParent(null);

            if (deferred) {

                mDyingViews.add(view);

            }

        }

    }

 

removeViewLocked内部也是通过ViewRootImpl來完成刪除操作的。 在removeView方法里我们就看到了mRoots.get(index).getView()，里面又有View view = root.getView();ViewRootImpl的getView返回的View其实就是上面setView方法里，传进来的我们的顶层视图DecorView。

看看ViewRootImpl的die方法

Params:immediate – True, do now if not in traversal. False, put on queue and do later.

Returns:True, request has been queued. False, request has been completed.

boolean die(boolean immediate) {

        // Make sure we do execute immediately if we are in the middle of a traversal or the damage

        // done by dispatchDetachedFromWindow will cause havoc on return.

        if (immediate && !mIsInTraversal) {

            doDie();

            return false;

        }



        if (!mIsDrawing) {

            destroyHardwareRenderer();

        } else {

            Log.e(mTag, "Attempting to destroy the window while drawing!\n" +

                    "  window=" + this + ", title=" + mWindowAttributes.getTitle());

        }

        mHandler.sendEmptyMessage(MSG_DIE);

        return true;

    }

 

参数immediates表示是否立即删除，返回false表示删除已完成，返回true表示加入待删除的队列里。看removeViewLocked的最后，将返回true加入了待删除的列表mDyingViews就明白了。 如果是需要立即删除则执行doDie，如果是是异步删除，则发送个消息，ViewRootImpl内部Handle接收消息的处理还是执行doDie。

现在看来doDie才是真正执行删除操作的地方。

void doDie() {

        checkThread();

        if (LOCAL_LOGV) Log.v(mTag, "DIE in " + this + " of " + mSurface);

        synchronized (this) {

            if (mRemoved) {

                return;

            }

            mRemoved = true;

            if (mAdded) {

                关键代码

                dispatchDetachedFromWindow();

            }

        ......

        全局单例WindowManagerGlobal也执行对应方法

        WindowManagerGlobal.getInstance().doRemoveView(this);

    }

 

void dispatchDetachedFromWindow() {

    内部完成视图的移除

    mView.dispatchDetachedFromWindow();

     try {

 内部通过WMA完成Window的删除

       mWindowSession.remove(mWindow);

      } catch (RemoteException e) {}

}

 

在dispatchDetachedFromWindow方法内部通过View的dispatchDetachedFromWindow方法完成View的删除，同时在通过mWindowSession来完成Window的删除

updateViewLayout

android.view.WindowManagerGlobal

    public void updateViewLayout(View view, ViewGroup.LayoutParams params) {

        if (view == null) {

            throw new IllegalArgumentException("view must not be null");

        }

        if (!(params instanceof WindowManager.LayoutParams)) {

            throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");

        }



        final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;

        更新View参数

        view.setLayoutParams(wparams);



        synchronized (mLock) {

            int index = findViewLocked(view, true);

            ViewRootImpl root = mRoots.get(index);

            mParams.remove(index);

            mParams.add(index, wparams);

            更新ViewRootImpl参数

            root.setLayoutParams(wparams, false);

        }

    }

 

updateViewLayout内部做的事情比较简单，先是更新View的参数，然后更新ViewRootImpl的参数。

• setLayoutParams内部会触发scheduleTraversals来对View重新布局，scheduleTraversals一旦触发，就会执行relayoutWindow方法，触发WMS来更新Window视图。我就不贴代码了，太多了，附上调用路径吧。
• scheduleTraversals->mTraversalRunnable（TraversalRunnable）->doTraversal->performTraversals->relayoutWindow->内部执行mWindowSession.relayout通知WMS更新Window

总结

1. DecorView在Activity的handleResumeActivity方法执行通过wm.addView完成操作。执行时机是在onResume后面一点点
2. DecorView存在于PhoneWindow中，DecorView的添加删除更新曹组是由ViewRootImpl负责，而PhoneWindow的添加删除更新操作由WMS负责
3. PhoneWindow的事件通过Callback接口回调给Activity

原文地址：medium.com/androiddeve…

原文作者：medium.com/@pmaggi

发布时间：2021年8月20日 - 6分钟阅读

为可折叠设备和大屏幕设备优化应用程序

Android的屏幕尺寸正在迅速变化，随着平板电脑和可折叠设备的不断普及，了解你的应用程序的窗口尺寸和状态对于开发一个响应式的UI至关重要。Jetpack WindowManager现在处于测试阶段，它是一个库和API，提供类似于Android框架WindowManager的功能，包括对响应式UI的支持、检测屏幕变化的回调适配器以及窗口测试API。但Jetpack WindowManager还提供了对新型设备的支持，如可折叠设备和Chrome OS等窗口环境。

新的WindowManager APIs包括以下内容。

• WindowLayoutInfo：包含了一个窗口的显示特征，例如窗口是否包含了折叠或铰链
• FoldingFeature：使你能够监测可折叠设备的折叠状态，以确定设备的姿势
• WindowMetrics：提供当前窗口的指标或整体显示的指标

Jetpack WindowManager与安卓系统没有捆绑，允许更快地迭代API，以快速支持快速发展的设备市场，并使应用程序开发人员能够采用库的更新，而不必等待最新的安卓版本。

现在该库已经进入测试阶段，我们鼓励所有的开发者采用Jetpack WindowManager，它具有设备无关的API，测试API，以及带来WindowMetrics，使你能够轻松应对窗口尺寸的变化。逐步过渡到测试版意味着你可以对你所采用的API有信心，使你可以完全专注于在这些设备上建立令人兴奋的体验。Jetpack WindowManager支持低至API 14的功能检测。

该库

Jetpack WindowManager是一个现代的、以Kotlin为首的库，它支持新的设备形态因素，并提供 "类似AppCompat "的功能，以构建具有响应式用户界面的应用程序。

折叠状态

这个库所提供的最明显的功能是对可折叠设备的支持。当设备的折叠状态发生变化时，应用程序可以接收事件，允许更新用户界面以支持新的用户互动。

三星Galaxy Z Fold2上的Google Duo

请看这个Google Duo案例研究，它介绍了如何为可折叠设备添加支持。

有两种可能的折叠状态：平面和半开放。对于FLAT，你可以认为表面是完全平坦地打开的，尽管在某些情况下它可能被铰链分割。对于HALF_OPENED，窗口至少有两个逻辑区域。下面，我们有图片说明每种状态的可能性。

折叠状态。平坦和半开放

当应用程序处于活动状态时，应用程序可以通过收集Kotlin流的事件来接收关于折叠状态变化的信息。 为了开始和停止事件收集，我们可以使用一个生命周期范围，正如 repeatOnLifeCycle API设计故事博文和下面的代码示例中所解释的。

lifecycleScope.launch(Dispatchers.Main) {

    // The block passed to repeatOnLifecycle is executed when the lifecycle

    // is at least STARTED and is cancelled when the lifecycle is STOPPED.

    // It automatically restarts the block when the lifecycle is STARTED again.

    lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {

        // Safely collects from windowInfoRepository when the lifecycle is STARTED

        // and stops collection when the lifecycle is STOPPED.

        windowInfoRepository.windowLayoutInfo

            .collect { newLayoutInfo ->

                updateStateLog(newLayoutInfo)

                updateCurrentState(newLayoutInfo)

            }

    }

}

 

然后，应用程序可以使用收到的WindowLayoutInfo对象中的可用信息，在应用程序对用户可见时更新其布局。

FoldingFeature包括铰链方向和折叠功能是否创建两个逻辑屏幕区域（isSeparating属性）等信息。我们可以使用这些值来检查设备是否处于桌面模式（半开，铰链水平）。

设备处于TableTop模式

private fun isTableTopMode(foldFeature: FoldingFeature) =

    foldFeature.isSeparating && 

            foldFeature.orientation == FoldingFeature.Orientation.HORIZONTAL

 

或处于书本模式（半开，铰链垂直）。

设备在书本模式下

private fun isBookMode(foldFeature: FoldingFeature) =

    foldFeature.isSeparating &&

            foldFeature.orientation == FoldingFeature.Orientation.VERTICAL

 

你可以在《可折叠设备上的桌面模式》一文中看到一个例子，说明如何为一个媒体播放器应用程序做到这一点。

注意：在主/UI线程上收集这些事件很重要，以避免UI和处理这些事件之间的同步问题。

对响应式UI的支持

由于安卓系统中的屏幕尺寸变化非常频繁，因此开始设计完全自适应和响应式的UI非常重要。WindowManager库中包含的另一个功能是能够检索当前和最大的窗口度量信息。这与API 30中包含的框架WindowMetrics API提供的信息类似，但它向后兼容到API 14。

Jetpack WindowManager提供了两种检索WindowMetrics信息的方式，作为流事件流或通过WindowMetricsCalculator类同步进行。

当在视图中写代码时，异步的API可能太难处理（比如onMeasure），就使用WindowMetricsCalculator。

val windowMetrics = 

    WindowMetricsCalculator.getOrCreate().computeCurrentWindowMetrics(activity)

 

另一个用例是在测试中（见下面的测试）。

对于应用程序UI的更高层次的处理，使用WindowInfoRepository#currentWindowMetrics来获得库的通知，当有一个窗口大小的变化时，独立于这个变化是否触发了配置的变化。

下面是一个如何根据你的可用区域的大小来切换你的布局的例子。

// Create a new coroutine since repeatOnLifecycle is a suspend function

lifecycleScope.launch(Dispatchers.Main) {

   // The block passed to repeatOnLifecycle is executed when the lifecycle

   // is at least STARTED and is cancelled when the lifecycle is STOPPED.

   // It automatically restarts the block when the lifecycle is STARTED again.

   lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {

       // Safely collect from currentWindowMetrics when the lifecycle is STARTED

       // and stops collection when the lifecycle is STOPPED

       windowInfoRepository.currentWindowMetrics

           .collect { windowMetrics ->

               val currentBounds = windowMetrics.bounds

               Log.i(TAG, "New bounds: {$currentBounds}")

               // We can update the layout if needed from here

           }

   }

}

 

回调适配器 要在Java编程语言中使用这个库，或者使用回调接口，请在你的应用程序中包含androidx.window:window-java依赖项。该工件提供了WindowInfoRepositoryCallbackAdapter，你可以用它来注册（和取消注册）一个回调，以接收设备姿态和窗口度量信息的更新。

public class SplitLayoutActivity extends AppCompatActivity {



   private WindowInfoRepositoryCallbackAdapter windowInfoRepository;

   private ActivitySplitLayoutBinding binding;

   private final LayoutStateChangeCallback layoutStateChangeCallback =

           new LayoutStateChangeCallback();



   @Override

   protected void onCreate(@Nullable Bundle savedInstanceState) {

       super.onCreate(savedInstanceState);



       binding = ActivitySplitLayoutBinding.inflate(getLayoutInflater());

       setContentView(binding.getRoot());



       windowInfoRepository =

               new WindowInfoRepositoryCallbackAdapter(WindowInfoRepository.getOrCreate(this));

   }



   @Override

   protected void onStart() {

       super.onStart();

       windowInfoRepository.addWindowLayoutInfoListener(Runnable::run, layoutStateChangeCallback);

   }



   @Override

   protected void onStop() {

       super.onStop();

       windowInfoRepository.removeWindowLayoutInfoListener(layoutStateChangeCallback);

   }



   class LayoutStateChangeCallback implements Consumer<WindowLayoutInfo> {

       @Override

       public void accept(WindowLayoutInfo windowLayoutInfo) {

           binding.splitLayout.updateWindowLayout(windowLayoutInfo);

       }

   }

}

 

测试

我们从开发者那里听说，更强大的测试API对于维持长期支持至关重要。让我们来谈谈如何在正常设备上测试可折叠的姿势。

到目前为止，我们已经看到Jetpack WindowManager库在设备姿态发生变化时通知你的应用程序，这样你就可以修改应用程序的布局。

该库在androidx.window:window-testing中提供了WindowLayoutInfoPublisherRule，它使你可以在测试FoldingFeature的支持下发布WindowInfoLayout。

import androidx.window.testing.layout.FoldingFeature

import androidx.window.testing.layout.WindowLayoutInfoPublisherRule

 

我们可以用它来创建一个假的FoldingFeature，在我们的测试中使用。

val feature = FoldingFeature(

   activity = activity,

   center = center,

   size = 0,

   orientation = VERTICAL,

   state = HALF_OPENED

)

val expected =

   WindowLayoutInfo.Builder().setDisplayFeatures(listOf(feature)).build()



publisherRule.overrideWindowLayoutInfo(expected)

 

然后使用WindowLayoutInfoPublisherRule来发布它。

val publisherRule = WindowLayoutInfoPublisherRule()



publisherRule.overrideWindowLayoutInfo(expected)

 

最后一步是使用可用的Espresso匹配器检查我们正在测试的活动的布局是否符合预期。

下面是一个测试发布FoldingFeature的例子，它在屏幕中心有一个HALF_OPENED的垂直铰链。

@Test

fun testDeviceOpen_Vertical(): Unit = testScope.runBlockingTest {

   activityRule.scenario.onActivity { activity ->

       val feature = FoldingFeature(

           activity = activity,

           orientation = VERTICAL,

           state = HALF_OPENED

       )

       val expected =

           WindowLayoutInfo.Builder().setDisplayFeatures(listOf(feature)).build()



       val value = testScope.async {

           activity.windowInfoRepository().windowLayoutInfo.first()

       }

       publisherRule.overrideWindowLayoutInfo(expected)

       runBlockingTest {

           Assert.assertEquals(

               expected,

               value.await()

           )

       }

   }



   // Checks that start_layout is on the left of end_layout with a vertical folding feature.

   // This requires to run the test on a big enough screen to fit both views on screen

   onView(withId(R.id.start_layout))

       .check(isCompletelyLeftOf(withId(R.id.end_layout)))

}

 

请看它的运行情况。代码样本

GitHub上的一个最新样本显示了如何使用Jetpack WindowManager库来检索显示姿势信息，从WindowLayoutInfo流中收集信息或通过WindowInfoRepositoryCallbackAdapter注册一个回调。

该样本还包括一些测试，可以在任何设备或模拟器上运行。

在你的应用程序中采用WindowManager

可折叠和双屏设备不再是实验性的或未来主义的--大的显示区域和额外的姿势具有被证实的用户价值，而且现在有更多的设备可以供你的用户使用。可折叠设备和双屏设备代表了智能手机的自然进化。对于安卓开发者来说，他们提供了进入一个正在增长的高端市场的机会，这也得益于设备制造商的重新关注。

我们去年推出了Jetpack WindowManager alpha01。从那时起，该库有了稳定的发展，针对早期的反馈有了一些很大的改进。该库现在已经接受了Android的Kotlin优先理念，从回调驱动的模型过渡到coroutines和flow。随着WindowManager现在处于测试阶段，该API已经稳定，我们强烈建议采用。 而更新并不限于此。我们计划为该库添加更多的功能，并将其发展成一个用于系统UI的非捆绑式AppCompat，使开发者能够在所有的Android设备上轻松实现现代的、响应式的UI。

什么是组件化

组件化就是将一个app拆分成不同的组件，每一个组件都是一个独立的module。

组件化的意义

组件化能降低耦合性，而耦合性低就能提高维护性。

于此同时由于组件间是独立的，所以组件与组件间耦合性低，所以我们在团队开发的时候可以以组件为分割单位，这样就能提高开发效率。

如何进行组件化

组件化是依靠gradle实现的。所以不会gradle的得去学学基础语法。当然也可以不学，只是说看别人写的代码看的半懂不懂的。

第一步创建Module

起点是一个全新的Project

创建Module有好几种方法。

• 右击new Module

  

  这个得注意位置哦，不然new出来全在app包下不是很好，通常我们的module是和app平级的。也就是说在大project下面。

  在我的这个demo中就是Modularization下面

• 点击File new一个Module

  

这里我创建了3个module，一个lib

注意命名，module是module_模块名，lib是lib__库名称.

简单区分以下module和lib，lib就是不显示页面的模块，module就是一个页面模块的集合。

将版本信息配置到一个gradle文件中

Tips:

    fileName :app_versions.gradle



//applicationIds

def appIds = [:]

appIds.module_main = "com.example.module_main"

appIds.module_one = "com.example.module_one"

appIds.module_two = "com.example.module_two"

appIds.app = "com.example.modularization"

ext.appIds = appIds

 

将该gradle文件配置到project的build.gradle中

// Top-level build file where you can add configuration options common to all sub-projects/modules.

buildscript {

    apply from: 'app_versions.gradle'

    ext{

        app_configs = "$rootDir/app_config.gradle"

    }

    repositories {

        google()

        mavenCentral()

    }

    dependencies {

        classpath "com.android.tools.build:gradle:7.0.0"

        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.20"



        // NOTE: Do not place your application dependencies here; they belong

        // in the individual module build.gradle files

    }

}



task clean(type: Delete) {

    delete rootProject.buildDir

}

 

配置gradle的编译插件

先在gradle.properties，加入一个变量判断是否是发行状态

组件化中有两种状态，一种是debug状态，一个是发行状态，

• debug状态也就是开发阶段，这个阶段每一个模块都是一个独立的app，可以独立运行
• release发行状态，这个状态下只有app模块可以独立运行，其他的模块都是lib，依托于app模块。

然后创建了一个app_config.gradle文件

编写代码使得module_XX能在lib和app中切换状态。

这里有一点需要注意我们在gradle.propergies虽然写了一个isRelease的bool变量但是其实gradle这里获取的是一个string，得用toBoolean()进行转化。

if (isRelease.toBoolean()){

    if (project.name != 'app')  apply plugin: 'com.android.library'

    else apply plugin: 'com.andorid.application'

}

else{

    if (project.name.matches('module_.+') || project.name == 'app') apply plugin: 'com.android.application'

    else if (project.name.matches('lib_.+')) apply plugin: 'com.android.library'

}

 

然后加入必要的依赖

apply plugin: 'kotlin-android'

apply plugin: 'kotlin-kapt'

 

配置Manifest文件

android{

`````



sourceSets{

    main{

        if (isRelease.toBoolean()){

            manifest.srcFile "src/main/AndroidManifest.xml"

        }else {

            if (project.name.matches('module_.+')){

                manifest.srcFile "src/main/manifest/AndroidManifest.xml"

            }else if (project.name.matches('lib_.+') || project.name == 'app'){

                manifest.srcFile "src/main/AndroidManifest.xml"

            }

        }

    }

}





`````

}

 

然后对module的manifest文件进行一点变动

在main文件夹下创建manifest文件夹，然后把debug状态的manifest的文件放进去。

debug状态下的文件(这个状态下编译的文件是apk所以需要配置启动页和一些application的选项)

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

    package="com.example.module_main">



    <application

        android:allowBackup="true"

        android:icon="@mipmap/ic_launcher"

        android:label="@string/app_name"

        android:roundIcon="@mipmap/ic_launcher_round"

        android:supportsRtl="true"

        android:theme="@style/Theme.Modularization">

        <activity

            android:name=".MainMainActivity"

            android:exported="true">

            <intent-filter>

                <action android:name="android.intent.action.MAIN" />



                <category android:name="android.intent.category.LAUNCHER" />

            </intent-filter>

        </activity>

    </application>



</manifest>

 

release状态下的manifest文件(这个状态下的编译文件是aar文件所以只需要注册一个activity，其余的都不需要)

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

    package="com.example.module_main">



    <application>

        <activity

            android:name=".MainMainActivity"

            android:exported="true" />

    </application>



</manifest>

 

其余的module_XX，模块也是按照这样改。

配置applicationId

由于application才有applicationId，所以lib是没有applicationId的，而module在application和module之间疯狂切换，说以是有必要进行设置的。

if (isRelease.toBoolean()) {

    applicationId "com.example.modularization"

}else {

    if (project.name.matches('module_.+') || project.name == 'app') {

        applicationId appIds[project.name]

    }

}

 

之后在project的build.gradle中加点变量方便其gradle文件访问app_config.gradle文件（注意要加等号‘=’）

buildscript {

    ext{

        app_config = "$rootDir/app_config.gradle"

    }

    repositories {

        google()

        mavenCentral()

    }

    dependencies {

        classpath "com.android.tools.build:gradle:7.0.0"

        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.20"



        // NOTE: Do not place your application dependencies here; they belong

        // in the individual module build.gradle files

    }

}

 

module引用app_config.gradle

之前

plugins {

    id 'com.android.application'

    id 'kotlin-android'

}



android {

    compileSdk 30



    defaultConfig {

        applicationId "com.example.module_main"

        minSdk 21

        targetSdk 30

        versionCode 1

        versionName "1.0"



        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"

    }



    buildTypes {

        release {

            minifyEnabled false

            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'

        }

    }

    compileOptions {

        sourceCompatibility JavaVersion.VERSION_1_8

        targetCompatibility JavaVersion.VERSION_1_8

    }

    kotlinOptions {

        jvmTarget = '1.8'

    }

}



dependencies {



    implementation 'androidx.core:core-ktx:1.3.2'

    implementation 'androidx.appcompat:appcompat:1.2.0'

    implementation 'com.google.android.material:material:1.3.0'

    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'

    testImplementation 'junit:junit:4.+'

    androidTestImplementation 'androidx.test.ext:junit:1.1.2'

    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'

}

 

之后

apply from: app_configs



dependencies {



    implementation 'androidx.core:core-ktx:1.3.2'

    implementation 'androidx.appcompat:appcompat:1.2.0'

    implementation 'com.google.android.material:material:1.3.0'

    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'

    testImplementation 'junit:junit:4.+'

    androidTestImplementation 'androidx.test.ext:junit:1.1.2'

    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'

}

 

其余的lib和module都是这样

把android闭包下的一些属性进行抽离

def android_versions = [:]

android_versions.sdk_version = 30

android_versions.min_version = 21

android_versions.target_version = 30

android_versions.version_code = 1

android_versions.version_name = "1.0"



def kotlin_options = [:]

kotlin_options.jvm_target = '1.8'

android_versions.kotlin_options = kotlin_options



ext.android_versions = android_versions

 

app_config.gradle的内容

if (isRelease.toBoolean()){

    if (project.name != 'app')  apply plugin: 'com.android.library'

    else apply plugin: 'com.andorid.application'

}

else{

    if (project.name.matches('module_.+') || project.name == 'app') apply plugin: 'com.android.application'

    else if (project.name.matches('lib_.+')) apply plugin: 'com.android.library'

}



apply plugin: 'kotlin-android'

apply plugin: 'kotlin-kapt'



android {

    compileSdk android_versions.sdk_version



    defaultConfig {

        if (isRelease.toBoolean()) {

            applicationId "com.example.modularization"

        }else {

            if (project.name.matches('module_.+') || project.name == 'app') {

                applicationId appIds[project.name]

            }

        }



        minSdk android_versions.min_version

        targetSdk android_versions.target_version

        versionCode android_versions.version_code

        versionName android_versions.version_name



        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"

    }



    sourceSets{

        main{

            if (isRelease.toBoolean()){

                manifest.srcFile "src/main/AndroidManifest.xml"

            }else {

                if (project.name.matches('module_.+')){

                    manifest.srcFile "src/main/manifest/AndroidManifest.xml"

                }else if (project.name.matches('lib_.+') || project.name == 'app'){

                    manifest.srcFile "src/main/AndroidManifest.xml"

                }

            }

        }

    }



    buildTypes {

        release {

            minifyEnabled false

            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'

        }

    }

    compileOptions {

        sourceCompatibility JavaVersion.VERSION_1_8

        targetCompatibility JavaVersion.VERSION_1_8

    }

    kotlinOptions {

        jvmTarget = android_versions.kotlin_options.jvm_target

    }

}