KVO是iOS中常用的一种观察机制，具体用法这里不做过多描述。先说一下KVO的两种崩溃场景：
1.addObserver给同一个对象添加了相同的keypath;
2.removeObserver时，对象的keypath观察者重复移除，主要原因是add和remove的次数不匹配造成的。
再说一下实际开发中本人遇到的崩溃情况，之前做视频播放App，播放中可以自由切换列表播放源，在播放的过程中需要使用KVO对播放对象AVPlayerItem进行监听，具体监听如下：
//播放状态
addObserver(item, observer: self, keypath: "status", options: .new, context: nil)
//缓存进度
addObserver(item, observer: self, keypath: "loadedTimeRanges", options: .new, context: nil)
//当前缓存不够播放了
addObserver(item, observer: self, keypath: "playbackBufferEmpty", options: .new, context: nil)
//当前缓存可以播放
addObserver(item, observer: self, keypath: "playbackLikelyToKeepUp", options: .new, context: nil)
在切换到下一个播放源时，需要移除上一个AVPlayerItem对象上的Observer，再给新的AVPlayerItem添加上述监听。虽然代码层面上基本看不出什么问题，而且经过检查也确保
addObserver和removeObserver都是成对进行，然而理论终归是理论，在我们的App中，当用户量大了之后，崩溃记录上总会出现一下偶现的崩溃，防不胜防啊。
经过思考，我想到了一个解决办法，思路上通过一个中间类，在addObserver和removeObserver都加一层判断，具体代码如下：
Swift:
import UIKit
class CRProxy: NSObject {
var lock = NSLock()
///用来记录观察者、需要观察的对象、keypath的数组
lazy var kvoInfo: [KVOObject] = {
return [KVOObject]()
}()
func CR_addObserver(target:NSObject, observer: NSObject, keypath: String, options: NSKeyValueObservingOptions = [], context: UnsafeMutableRawPointer?) {
if keypath.isEmpty { return }
//加个锁更安全
lock.lock()
//判断是否是同一个target添加重复的keypath,已存在相同的记录就直接返回，不作处理
if kvoInfo.contains(where: { ($0.keypath == keypath && $0.target == target) }) {
lock.unlock()
return
}
kvoInfo.append(KVOObject(target: target, keypath: keypath, observer: observer))
target.addObserver(observer, forKeyPath: keypath, options: options, context: context)
lock.unlock()
}
func CR_removeObserver(target:NSObject, observer: NSObject, keypath: String) {
if keypath.isEmpty { return }
lock.lock()
//判断要移除的观察者是否存在，存在就移除，否则直接返回
if kvoInfo.isEmpty || !kvoInfo.contains(where: { ($0.keypath == keypath && $0.target == target) }) {
lock.unlock()
return
}
kvoInfo.removeAll(where: { $0.target == target && $0.keypath == keypath})
target.removeObserver(observer, forKeyPath: keypath)
lock.unlock()
}
struct KVOObject {
var keypath = ""
var observer: NSObject?
var target: NSObject?
init(target: NSObject, keypath: String, observer: NSObject) {
self.target = target
self.keypath = keypath
self.observer = observer
}
}
}
OC:
//
// CRProxy.m
// wxyd
//
// Created by Li Dong on 2021/10/8.
//
#import "CRProxy.h"
@interface CRKVOObject : NSObject
@property (nonatomic, copy) NSString * keypath;
@property (nonatomic, strong) NSObject * observer;
@property (nonatomic, strong) NSObject * target;
@end
@implementation CRKVOObject
- (instancetype)initWithTarget:(NSObject *)target
observer:(NSObject *)observer
keypath:(NSString *)keypath {
if (self = [super init]) {
self.target = target;
self.observer = observer;
self.keypath = keypath;
}
return self;
}
@end
@interface CRProxy ()
@property (nonatomic, strong) NSLock *lock;
@property (nonatomic, strong) NSMutableArray *kvoInfo;
@end
@implementation CRProxy
- (NSLock *)lock{
if (!_lock) {
_lock = [NSLock new];
}
return _lock;
}
- (NSMutableArray *)kvoInfo{
if (!_kvoInfo) {
_kvoInfo = [NSMutableArray new];
}
return _kvoInfo;
}
- (void)CR_addTarget:(NSObject *)target
observer:(NSObject *)observer
keypath:(NSString *)keypath
options:(NSKeyValueObservingOptions)options{
if (!target || !observer || !keypath) {
return;
}
[self.lock lock];
//判断是否是同一个target添加重复的keypath,已存在相同的记录就直接返回，不作处理
for (CRKVOObject * obj in self.kvoInfo) {
if ([obj.keypath isEqualToString:keypath] && obj.target == target) {
[self.lock unlock];
return;
}
}
CRKVOObject * obj = [[CRKVOObject alloc]initWithTarget:target observer:observer keypath:keypath];
[target addObserver:observer forKeyPath:keypath options:options context:nil];
[self.kvoInfo addObject:obj];
[self.lock unlock];
}
- (void)CR_removeTarget:(NSObject *)target
observer:(NSObject *)observer
keypath:(NSString *)keypath{
if (!target || !observer || !keypath) {
return;
}
[self.lock lock];
if (!self.kvoInfo.count) {
return;
}
//判断要移除的观察者是否存在，存在就移除，否则直接返回
CRKVOObject *kvoObj = nil;
for (CRKVOObject * obj in self.kvoInfo) {
if ([obj.keypath isEqualToString:keypath] && obj.target == target) {
kvoObj = obj;
break;
}
}
if (kvoObj) {
//移除
[self.kvoInfo removeObject:kvoObj];
[target removeObserver:observer forKeyPath:keypath];
}
[self.lock unlock];
}
@end
调用的话直接创建一个CRProxy的全局变量的对象，最好和播放器，来调用即可，具体事例如下：
//kov代理，预防kvo崩溃
lazy var proxy: CRProxy = {
return CRProxy()
}()
//监听PlayItem的缓存进度、播放状态等
func addKVOObserver(item: AVPlayerItem) {
//播放状态
proxy.CR_addObserver(target: item, observer: self, keypath: "status", options: .new, context: nil)
//缓存进度
proxy.CR_addObserver(target: item, observer: self, keypath: "loadedTimeRanges", options: .new, context: nil)
//当前缓存不够播放了
proxy.CR_addObserver(target: item, observer: self, keypath: "playbackBufferEmpty", options: .new, context: nil)
//当前缓存可以播放
proxy.CR_addObserver(target: item, observer: self, keypath: "playbackLikelyToKeepUp", options: .new, context: nil)
}
//移除PlayItem上的观察者
func removeKVOObserver(item: AVPlayerItem) {
proxy.CR_removeObserver(target: item, observer: self, keypath: "status")
proxy.CR_removeObserver(target: item, observer: self, keypath: "loadedTimeRanges")
proxy.CR_removeObserver(target: item, observer: self, keypath: "playbackBufferEmpty")
proxy.CR_removeObserver(target: item, observer: self, keypath: "playbackLikelyToKeepUp")
}
即取即用，直接给CRProxy这个类写进项目中就行。亲测手动多次添加和移除相同的观察对象也不会崩溃，放心使用，有问题请及时留言。
网友评论