工程师如何“神还原”用户问题？闲鱼回放技术揭秘

我们透过系统底层来捕获ui事件流和业务数据的流动，并利用捕获到的这些数据通过事件回放机制来复现线上的问题。本文先介绍录制和回放的整体框架，接着介绍里面涉及到的3个关键技术点，也是这里最复杂的技术（模拟触摸事件，统一拦截器实现，统一hook block）。

背景

现在的app基本都会提供用户反馈问题的入口，然而提供给用户反馈问题一般有两种方式：

这两种反馈方式常常带来以下抱怨：

所以，为了解决以上问题，我们用一套全新的思路来设计线上问题回放体系。

线上问题回放体系的意义

效果视频

技术原理

1.app与外部环境的关系

从上面的关系图可以看出，整个app的运行无非是用户ui操作，然后触发app从外界获取数据，包括网络数据，gps数据等等，也包括从手机本地获取数据，比如相册数据，机器数据，系统等数据。 所以我们要实现问题回放只需要记录用户的UI操作和外界数据，app自身数据即可。

app录制 = 用户的UI操作 + 外界数据（手机内和手机外） + app自身数据

2.线上问题回放架构由两部分组成：录制和回放

3.录制架构图

录制流程：

4.回放架构图

回放跟录制框架图基本一样，实际上录制和回放的代码是在一起，逻辑也是统一的，为了便于表达，我人为划分成两个架构图出来。

回放的流程： 

1.启动app，点击回放按钮。

2.引擎加载回放脚本。

3.从脚本中解析出需要注册的运行时事件并注册，在回放里不需要业务上层来注册事件，这里跟录制是不一样的。

4.从脚本中解析出需要注册的静态数据事件并注册。

5.从脚本中解析出需要播放的事件数据，并组成消费队列。

6.启动播放器，从消费队列里读取一个个事件来播放，如果是ui事件则直接播放，如果是静态数据事件则直接按照指令要求替换数据值，如果是非ui运行时事件则通过事件指令规则来确定是主动播放还是等待拦截对应的事件，如果需要等待拦截对应的事件，则播放器会一直等待此事件直到此事件被app消费掉为止。只有此事件被消费了，播放器才能播放下一个事件。

7.当拦截到被注册的事件后，根据此事件指令要求把相应的数据塞到相应的字段里。

8.跳回6继续运行，直到消费队列里的事件被消费完。

注意：回放每个事件时会实时自动打印出相应的堆栈信息和事件数据，有利于排查问题

关键技术介绍

1.模拟触摸事件

从ui事件数据解中析出被触摸的view，以及此view所在的视图树中的层级关系，并在当前回放界面上查找到对应的view，然后往该view上发送ui操作事件（点击，双击等等），并带上触摸事件的坐标信息，其实这里是模拟触摸事件。我们先来介绍触摸事件的处理流程：

等待触摸阶段

系统反应阶段

SpringBoard进程就是iOS的系统桌面，它存在于iDevice的进程中，不可清除，它的运行原理与Windows中的explorer.exe系统进程相类似。它主要负责界面管理，所以只有它才知道当前触摸到底有谁来响应。

SpringBoard接收阶段

app处理阶段

从上面触摸事件处理过程中我们可以看出要录制ui事件只需要在app处理阶段中的UIApplication sendEvent方法处截获触摸数据，回放时也是在这里把触摸模拟回去。

下面是触摸事件录制的代码，就是把UITouch相应的数据保存下来即可 这里有一个关键点，需要把touch.timestamp的时间戳记录下来，以及把当前touch事件距离上一个touch事件的时间间隔记录下来，因为这个涉及到触摸引起惯性加速度问题。比如我们平时滑动列表视图时，手指离开屏幕后，列表视图还要惯性地滑动一小段时间。

1. - (void)handleUIEvent:(UIEvent *)event

2. {

3. if (!self.isEnabled) return;

4. if (event.type != UIEventTypeTouches) return;

6. NSSet *allTouches = [event allTouches];

7. UITouch *touch = (UITouch *)[allTouches anyObject];

9. if (touch.view) {

10. if (self.filter && !self.filter(touch.view)) {

11. return;

12. }

13. }

15. switch (touch.phase) {

16. case UITouchPhaseBegan:

17. {

18. self.machAbsoluteTime = mach_absolute_time();

19. self.systemStartUptime = touch.timestamp;

20. self.tuochArray = [NSMutableArray array];

21. [self recordTouch:touch click:self.machAbsoluteTime];

23. break;

24. }

25. case UITouchPhaseStationary:

26. {

27. [self recordTouch:touch click:mach_absolute_time()];

28. break;

29. }

31. case UITouchPhaseCancelled:

32. {

33. [self recordTouch:touch click:mach_absolute_time()];

34. [[NSNotificationCenter defaultCenter] postNotificationName:@"notice_ui_test" object:self.tuochArray];

35. break;

36. }

38. case UITouchPhaseEnded:

39. {

40. [self recordTouch:touch click:mach_absolute_time()];

41. [[NSNotificationCenter defaultCenter] postNotificationName:@"notice_ui_test" object:self.tuochArray];

43. break;

44. }

46. case UITouchPhaseMoved:

47. {

48. [self recordTouch:touch click:mach_absolute_time()];

49. }

51. default:

52. break;

53. }

55. }

58. 


我们来看一下代码怎么模拟单击触摸事件(为了容易理解，我把有些不是关键，复杂的代码已经去掉)，接着我们来看一下模拟触摸事件代码 一个基本的触摸事件一般由三部分组成：

实现步骤：

1.代码的前面部分都是一些UITouch和UIEvent私有接口，私有变量字段，由于苹果并不公开它们，为了让其编译不报错，所以我们需要把这些字段包含进来，回放是在线下，所以不必担心私有接口被拒的事情。

2.构造触摸对象：UITouch和UIEvent，把记录对应的字段值塞回相应的字段。塞回去就是用私有接口和私有字段。

3.触摸的view位置转换为Window坐标，然后往app里发送事件 [[UIApplication sharedApplication] sendEvent:event];

4.要回放这些触摸事件，我们需要把他丢到CADisplayLink里面来执行。

1. //

2. // SimulationTouch.m

3. //

4. // Created by 诗壮殷 on 2018/5/15.

5. //

7. #import "SimulationTouch.h"

8. #import <objc/runtime.h>

9. #include <mach/mach_time.h>

11. 


13. @implementation UITouch (replay)

16. - (id)initPoint:(CGPoint)point window:(UIWindow *)window

17. {

18. NSParameterAssert(window);

20. self = [super init];

21. if (self) {

22. [self setTapCount:1];

23. [self setIsTap:YES];

24. [self setPhase:UITouchPhaseBegan];

25. [self setWindow:window];

26. [self _setLocationInWindow:point resetPrevious:YES];

27. [self setView:[window hitTest:point withEvent:nil]];

28. [self _setIsFirstTouchForView:YES];

29. [self setTimestamp:[[NSProcessInfo processInfo] systemUptime]];

30. }

31. return self;

32. }

34. @end

39. @interface UIInternalEvent : UIEvent

40. - (void)_setHIDEvent:(IOHIDEventRef)event;

41. @end

43. @interface UITouchesEvent : UIInternalEvent

44. - (void)_addTouch:(UITouch *)touch forDelayedDelivery:(BOOL)delayedDelivery;

45. - (void)_clearTouches;

46. @end

49. 


51. typedef enum {

53. kIOHIDDigitizerEventRange = 0x00000001,

55. kIOHIDDigitizerEventTouch = 0x00000002,

57. kIOHIDDigitizerEventPosition = 0x00000004,

58. } IOHIDDigitizerEventMask;

60. IOHIDEventRef IOHIDEventCreateDigitizerFingerEvent(CFAllocatorRef allocator,

61. AbsoluteTime timeStamp,

62. uint32_t index,

63. uint32_t identity,

64. IOHIDDigitizerEventMask eventMask,

65. IOHIDFloat x,

66. IOHIDFloat y,

67. IOHIDFloat z,

68. IOHIDFloat tipPressure,

69. IOHIDFloat twist,

70. Boolean range,

71. Boolean touch,

72. IOOptionBits options);

74. @implementation SimulationTouch

76. - (void)performTouchInView:(UIView *)view start:(bool)start

77. {

78. UIWindow *_window = view.window;

79. CGRect fInWindow;

80. if ([view isKindOfClass:[UIWindow class]])

81. {

82. fInWindow = view.frame;

83. }

84. else

85. {

86. fInWindow = [_window convertRect:view.frame fromView:view.superview];

87. }

89. CGPoint point =

90. CGPointMake(fInWindow.origin.x + fInWindow.size.width/2,

91. fInWindow.origin.y + fInWindow.size.height/2);

93. if(start)

94. {

95. self.touch = [[UITouch alloc] initPoint:point window:_window];

96. [self.touch setPhase:UITouchPhaseBegan];

98. }

99. else

100. {

101. [self.touch _setLocationInWindow:point resetPrevious:NO];

102. [self.touch setPhase:UITouchPhaseEnded];

103. }

105. CGPoint currentTouchLocation = point;

107. UITouchesEvent *event = [[UIApplication sharedApplication] _touchesEvent];

108. [event _clearTouches];

110. uint64_t machAbsoluteTime = mach_absolute_time();

111. AbsoluteTime timeStamp;

112. timeStamp.hi = (UInt32)(machAbsoluteTime >> 32);

113. timeStamp.lo = (UInt32)(machAbsoluteTime);

115. [self.touch setTimestamp:[[NSProcessInfo processInfo] systemUptime]];

117. IOHIDDigitizerEventMask eventMask = (self.touch.phase == UITouchPhaseMoved)

118. ? kIOHIDDigitizerEventPosition

119. : (kIOHIDDigitizerEventRange | kIOHIDDigitizerEventTouch);

122. Boolean isRangeAndTouch = (self.touch.phase != UITouchPhaseEnded);

123. IOHIDEventRef hidEvent = IOHIDEventCreateDigitizerFingerEvent(kCFAllocatorDefault,

124. timeStamp,

125. 0,

126. 2,

127. eventMask,

128. currentTouchLocation.x,

129. currentTouchLocation.y,

130. 0,

131. 0,

132. 0,

133. isRangeAndTouch,

134. isRangeAndTouch,

135. 0);

136. if ([self.touch respondsToSelector:@selector(_setHidEvent:)]) {

137. [self.touch _setHidEvent:hidEvent];

138. }

140. [event _setHIDEvent:hidEvent];

141. [event _addTouch:self.touch forDelayedDelivery:NO];

142. [[UIApplication sharedApplication] sendEvent:event];

144. }

146. @end

总的来说就下载苹果提供触摸事件的源码库，分析源码，然后设置断掉调试，甚至反汇编来理解触摸事件的原理。

2.统一拦截器

录制和回放都居于事件流来处理的，而数据的事件流其实就是对一些关键方法的hook，由于我们为了保证对业务代码无侵入和扩展性（随便注册事件），我们需要对所有方法统一hook，所有的方法由同一个钩子来响应处理。如下图所示

这个钩子是用用汇编编写，由于汇编代码比较多，而且比较难读懂，所以这里暂时不附上源码，汇编层主要把硬件里面的一些数据统一读取出来，比如通用寄存器数据和浮点寄存器数据,堆栈信息等等，甚至前面的前面的方法参数都可以读取出来，最后转发给c语言层处理。

汇编层把硬件相关信息组装好后调用c层统一拦截接口，汇编层是为c层服务。c层无法读取硬件相关信息，所以这里只能用汇编来读取。c层接口通过硬件相关信息定位到当前的方法是属于哪个事件，知道了事件，也意味着知道了事件指令，知道了事件指令，也知道了哪些字段需要塞回去，也知道了被hook的原始方法。

c层代码介绍如下： 由于是统一调用这个拦截器，所以拦截器并不知道当前是哪个业务代码执行过来的，也不知道当前这个业务方法有多少个参数，每个参数类型是什么等等，这个接口代码处理过程大概如下：

1. //xRegs 表示统一汇编器传入当前所有的通用寄存器数据，它们地址存在一个数组指针里

2. //dRegs 表示统一汇编器传入当前所有的浮点寄存器数据，它们地址也存在一个数组指针里

3. //dRegs 表示统一汇编器传入当前堆栈指针

4. //fp 表示调用栈帧指针

5. void replay_entry_start(void* xRegs, void* dRegs, void* spReg, CallBackRetIns *retIns,StackFrame *fp, void *con_stub_lp)

6. {

7. void *objAdr = (((void **)xRegs)[0]);//获取对象本身self或者block对象本身

8. EngineManager *manager = [EngineManager sharedInstance];

9. ReplayEventIns *node = [manager getEventInsWithBlock:objAdr];

10. id obj = (__bridge id)objAdr;

11. void *xrArg = ((void **)xRegs)+2;

12. if(nil == node)

13. {

14. SEL selecter = (SEL)(((void **)xRegs)[1]); //对应的对象调用的方法

15. Class tclass = [obj class];//object_getClass(obj);object_getClass方法只能通过对象获取它的类，不能传入class 返回class本身，

16. do

17. {

18. node = [manager getEventIns:tclass sel:selecter];//通过对象和方法获取对应的事件指令节点

19. }while(nil == node && (tclass = class_getSuperclass(tclass)));

20. }

21. else

22. {

23. xrArg = ((void **)xRegs)+1;

24. }

25. assert(node && "node is nil in replay_call_start");

26. //回调通知上层当前回放是否打断

27. if(node.BreakCurReplayExe && node.BreakCurReplayExe(obj,node,xrArg,dRegs))

28. {

29. retIns->nodeAddr = NULL;

30. retIns->recordOrReplayData = NULL;

31. retIns->return_address = NULL;

32. return;

33. }

34. bool needReplay = true;

35. //回调通知上层当前即将回放该事件

36. if(node.willReplay)

37. {

38. needReplay = (*(node.willReplay))(obj,node,xrArg,dRegs);

39. }

40. if(needReplay)

41. {

42. ReplayEventData *replayData = nil;

43. if(node.getReplayData)

44. {

45. //获取回放该事件对应的数据

46. replayData = (*(node.getReplayData))(obj,node,xrArg,dRegs);

47. }

48. else//默认获取方法

49. {

50. replayData = [manager getNextReplayEventData:node];

51. }

52. //以下就是真正的回放，即是把数据塞回去，并调用原来被hook的方法

53. if(replayData)

54. {

55. if(replay_type_intercept_call == node.replayType)

56. {

57. sstuffArg(xRegs,dRegs,spReg,node,replayData.orgDic);

58. NSArray *arglist = fetchAllArgInReplay(xRegs, dRegs, spReg, node);

59. ReplayInvocation *funobj = [[ReplayInvocation alloc] initWithFunPtr:node.callBack ? node.callBack : [node getOrgFun]

60. args:arglist

61. argType:[node getFunTypeStr]

62. retType:rf_return_type_v];

63. if([[EngineManager sharedInstance] setRepalyEventReady:replayData funObj:funobj])

64. {

65. //放到播放队列里播放，返回没调用地址，让其不往下走

66. retIns->return_address = NULL;

67. return ;

68. }

69. }

70. else

71. {

72. //塞数据

73. sstuffArg(xRegs,dRegs,spReg,node,replayData.orgDic);

74. }

75. }

76. retIns->nodeAddr = (__bridge void *)node;

77. retIns->recordOrReplayData = (__bridge void *)replayData;

78. retIns->return_address = node.callBack ? node.callBack : [node getOrgFun];

79. replayData.runStatus = relay_event_run_status_runFinish;

80. }

81. else

82. {

83. retIns->nodeAddr = NULL;

84. retIns->recordOrReplayData = NULL;

85. retIns->return_address = [node getOrgFun];

86. }

87. }

3.怎样统一hook block

如果你只是想大概理解block的底层技术，你只需google一下即可。 如果你想全面深入的理解block底层技术，那网上的那些资料远远满足不了你的需求。 只能阅读苹果编译器clang源码和列出比较有代表性的block例子源码，然后转成c语言和汇编，通过c语言结合汇编研究底层细节。

何谓 oc block？

系统底层怎样表达block？

我们先来看一下block的例子：

1. void test()

2. {

3. __block int var1 = 8; //上下文变量

5. NSString *var2 = @"我是第二个变量”; //上下文变量

7. void (^block)(int) = ^(int arg)//参数列表

8. {

9. var1 = 6;

10. NSLog(@"arg = %d,var1 = %d, var2 = %@", arg, var1, var2);

11. };

13. block(1);//调用block语法

15. dispatch_async(dispatch_get_global_queue(0, 0), ^

16. {

17. block(2); //异步调用block

18. });

19. }

这段代码首先定义两个变量，接着定义一个block，最后调用block。

系统底层表达block比较重要的几种数据结构如下：

注意：虽然底层是用这些结构体来表达block，但是它们并不是源码，是二进制代码

1. enum

2. {

3. BLOCK_REFCOUNT_MASK = (0xffff),

4. BLOCK_NEEDS_FREE = (1 << 24),

5. BLOCK_HAS_COPY_DISPOSE = (1 << 25),

6. BLOCK_HAS_CTOR = (1 << 26),//todo ＝＝ BLOCK_HAS_CXX_OBJ？

7. BLOCK_IS_GC = (1 << 27),

8. BLOCK_IS_GLOBAL = (1 << 28),

9. BLOCK_HAS_DESCRIPTOR = (1 << 29),//todo ＝＝ BLOCK_USE_STRET？

11. BLOCK_HAS_SIGNATURE = (1 << 30),

12. OBLOCK_HAS_EXTENDED_LAYOUT = (1 << 31)

13. };

15. enum

16. {

17. BLOCK_FIELD_IS_OBJECT = 3,

18. BLOCK_FIELD_IS_BLOCK = 7,

19. BLOCK_FIELD_IS_BYREF = 8,

20. OBLOCK_FIELD_IS_WEAK = 16,

21. OBLOCK_BYREF_CALLER = 128

22. };

24. typedef struct block_descriptor_head

25. {

26. unsigned long int reserved;

27. unsigned long int size; //表示主体block结构体的内存大小

29. }block_descriptor_head;

32. typedef struct block_descriptor_has_help

33. {

34. unsigned long int reserved;

35. unsigned long int size; //表示主体block结构体的内存大小

36. void (*copy)(void *dst, void *src);//当block被retain时会执行此函数指针

37. void (*dispose)(void *);//block被销毁时调用

38. struct block_arg_var_descriptor *argVar;

40. }block_descriptor_has_help;

42. typedef struct block_descriptor_has_sig

43. {

44. unsigned long int reserved;

45. unsigned long int size;

46. const char *signature;//block的签名信息

47. struct block_arg_var_descriptor *argVar;

49. }block_descriptor_has_sig;

52. typedef struct block_descriptor_has_all

53. {

54. unsigned long int reserved;

55. unsigned long int size;

56. void (*copy)(void *dst, void *src);

57. void (*dispose)(void *);

58. const char *signature;

59. struct block_arg_var_descriptor *argVar;

61. }block_descriptor_has_all;

64. typedef struct block_info_1

65. {

67. void *isa;//表示当前blcok是在堆上还是在栈上，或在全局区_NSConcreteGlobalBlock

68. int flags; //对应上面的enum值，这些枚举值是我从编译器源码拷贝过来的

69. int reserved;

70. void (*invoke)(void *, ...);//block对应的方法体（执行体，就是代码段）

71. void *descriptor;//此处指向上面几个结构体中的一个，具体哪一个根据flags值来定，它用来进一步来描述block信息

73. //从这个字段开始起，后面的字段表示的都是此block对外引用的变量。

74. NSString *var2;

75. byref_var1_1 var1;

78. } block_info_1;

这个例子中的block在底层表达大概如下图：

首先用block_info_1来表达block本身，然后用block_desc_1来具体描述block相关信息（比如block_info_1结构体大小，在堆上还是在栈上？copy或dispose时调用哪个方法等等），然而block_desc_1具体是哪个结构体是由block_info_1中flags字段来决定的，block_info_1里的invoke字段是指向block方法体，即是代码段。block的调用就是执行这个函数指针。由于var1是可写的，所以需要设计一个结构体（byref_var1_1）来表达var1，为什么var2直接用他原有的类型表达，而var1要用结构体来表达。篇幅有限，这个自己想想吧？

block小结

怎样统一 hook block？

通过上面的分析，得知oc里的block就是一个结构体指针，所以我在源码里可以直接把它转成结构体指针来处理。 统一hook block源码如下：

1. VoidfunBlock createNewBlock(VoidfunBlock orgblock, ReplayEventIns *blockEvent,bool isRecord)

2. {

3. if(orgblock && blockEvent)

4. {

5. VoidfunBlock newBlock = ^(void)

6. {

7. orgblock();

8. if(nil == blockEvent)

9. {

10. assert(0);

11. }

12. };

13. trace_block_layout *blockLayout = (__bridge trace_block_layout *)newBlock;

14. blockLayout->invoke = (void (*)(void *, ...))(isRecord?hook_var_block_callBack_record:hook_var_block_callBack_replay);

15. return newBlock;

16. }

17. return nil;

18. }

我们首先新建一个新的block newBlock，然后把原来的block orgblock 和 事件指令blockEvent包到新的blcok中，这样达到引用的效果。然后把

新的block转

成结构体指针，并把结构体指针中的字段invoke（方法体）指向统一回调方法。你可能诧异新的block是没有参数类型的，原来block是有参数类型，

外面调用原

来block传递参数时会不会引起crash？答案是否定的，因为这里构造新的block时 我们只用block数据结构，block的回调方法字段已经被阉割，回

调方法已经指

向统一方法了，这个统一方法可以接受任何类型的参数，包括没有参数类型。这个统一方法也是汇编实现，代码实现跟上面的汇编层代码类似，这

里就不附上源

码了。

那怎样在新的blcok里读取原来的block和事件指令对象呢？ 代码如下：

1. void var_block_callback_start_record(trace_block_layout * blockLayout)

2. {

3. VoidfunBlock orgBlock = (__bridge VoidfunBlock)(*((void **)((char *)blockLayout + sizeof(trace_block_layout))));

4. ReplayEventIns *node = (__bridge ReplayEventIns *)(*((void **)((char *)blockLayout + 40)));

6. }

本文大概介绍了问题回放框架，接着介绍三个关键技术。这三个技术相对比较深入，欢迎在留言区评论，我们期待与大家交流，共同探讨。