iOS APM Secrets
1.0.0
Embora a APM esteja se tornando cada vez mais popular, os fabricantes profissionais de APM de todos os tamanhos surgiram como cogumelos após uma chuva, e também existem muitos artigos técnicos sobre a APM no mercado, a maioria deles é apenas um sabor simples e não se aprofunda nos detalhes da implementação. Este artigo tem como objetivo expor o princípio de trabalho interno do IOS SDK dos conhecidos fabricantes de APM, analisando os detalhes específicos da implementação do SDK. Acredito que, antes de ler este artigo, os leitores também estavam curiosos sobre os detalhes da implementação do SDK APM, assim como o autor. Felizmente, o artigo que você está lendo o levará a descobrir o verdadeiro contexto do APM passo a passo. Os SDKs APM analisados neste artigo incluem o monitoramento de desempenho Tingyun , OneApm e Firebase , etc. O autor é um pouco talentoso e experiente. Se houver algum erro, ele não os corrigirá para reimprimir e torná -los mais perfeitos.
A versão do Tingyun SDK analisada neste artigo é 2.3.5, que é um pouco diferente da versão mais recente. No entanto, li aproximadamente o código da nova versão, mas a diferença não é grande e não afeta a análise.
O monitoramento da renderização de páginas parece muito simples, mas ainda haverá muitos problemas no processo de desenvolvimento real. O que é mais fácil de pensar são vários métodos importantes do ciclo de vida das páginas de gancho, como viewDidLoad , viewDidAppear: etc., para calcular o tempo de renderização da página e, finalmente, encontre a página com carga lenta. No entanto, se você realmente começar a alcançá -lo através das idéias acima, encontrará dificuldades. Como posso conectar o ciclo de vida de todas as páginas no APM SDK? E se eu tentar conectar UIViewController ? O método Hook UIViewController obviamente não é viável porque funciona apenas UIViewController e a maioria dos controladores de exibição no aplicativo herde do UIViewController , portanto esse método não é viável. Mas o Tingyun SDK pode ser implementado. A lógica do gancho da página é implementada principalmente na classe _priv_NBSUIAgent . A seguir, é apresentada a definição da classe _priv_NBSUIAgent , entre as quais hook_viewDidLoad e outros métodos são pistas.
@class _priv_NBSUIAgent : NSObject {
+hookUIImage
+hookNSManagedObjectContext
+hookNSJSONSerialization
+hookNSData
+hookNSArray
+hookNSDictionary
+hook_viewDidLoad:
+hook_viewWillAppear:
+hook_viewDidAppear:
+hook_viewWillLayoutSubviews:
+hook_viewDidLayoutSubviews:
+nbs_jump_initialize:
+hookSubOfController
+hookFMDB
+start
}
Vamos primeiro voltar nossa atenção para outro método mais suspeito: hookSubOfController , a implementação específica é a seguinte:
void +[_priv_NBSUIAgent hookSubOfController](void * self, void * _cmd) {
r14 = self;
r12 = [_subMetaClassNamesInMainBundle_c("UIViewController") retain];
var_C0 = r12;
if ((r12 != 0x0) && ([r12 count] != 0x0)) {
var_C8 = object_getClass(r14);
if ([r12 count] != 0x0) {
r15 = @selector(nbs_jump_initialize:);
rdx = 0x0;
do {
var_98 = rdx;
r12 = [[r12 objectAtIndexedSubscript:rdx, rcx, r8] retain];
[r12 release];
if ([r12 respondsToSelector:r15, rcx, r8] == 0x0) {
_hookClass_CopyAMetaMethod();
}
r13 = class_getName(r12);
rax = [NSString stringWithFormat:@"nbs_%s_initialize", r13];
rax = [rax retain];
var_A0 = rax;
rax = NSSelectorFromString(rax);
var_B0 = rax;
rax = objc_retainBlock(__NSConcreteStackBlock);
var_A8 = rax;
r15 = objc_retainBlock(rax);
var_B8 = imp_implementationWithBlock(r15);
[r15 release];
rax = class_getSuperclass(r12);
r15 = objc_retainBlock(__NSConcreteStackBlock);
rbx = objc_retainBlock(r15);
r13 = imp_implementationWithBlock(rbx);
[rbx release];
rcx = r13;
r8 = var_B8;
_nbs_Swizzle_orReplaceWithIMPs(r12, @selector(initialize), var_B0, rcx, r8);
rdi = r15;
r15 = @selector(nbs_jump_initialize:);
[rdi release];
[var_A8 release];
[var_A0 release];
rax = [var_C0 count];
r12 = var_C0;
rdx = var_98 + 0x1;
} while (var_98 + 0x1 < rax);
}
}
[r12 release];
return;
}
A partir da nomeação de _subMetaClassNamesInMainBundle_c e do parâmetro "UiviewController", pode -se inferir basicamente que essa função C é uma subclasse de todos UIViewController em Mainbundle. De fato, se você quebrar o ponto de vista da linha de montagem após a chamada de função, será concluída através do LLDB, descobrirá que a matriz retornada é realmente uma subclasse do UIViewController . A seguinte instrução if determina que o registro r12 não é nil e count do registro r12 não é igual a 0 antes da lógica if for executada. O registro r12 armazena o valor de retorno da função _subMetaClassNamesInMainBundle_c , que é a matriz UIViewController .
_subMetaClassNamesInMainBundle_c é o seguinte:
void _subMetaClassNamesInMainBundle_c(int arg0) {
rbx = objc_getClass(arg0);
rdi = 0x0;
if (rbx == 0x0) goto loc_10001dbde;
loc_10001db4d:
r15 = _classNamesInMainBundle_c(var_2C);
var_38 = [NSMutableArray new];
if (var_2C == 0x0) goto loc_10001dbd2;
loc_10001db77:
r14 = 0x0;
goto loc_10001db7a;
loc_10001db7a:
r13 = objc_getClass(*(r15 + r14 * 0x8));
r12 = r13;
if (r13 == 0x0) goto loc_10001dbc9;
loc_10001db8e:
rax = class_getSuperclass(r12);
if (rax == rbx) goto loc_10001dba5;
loc_10001db9b:
COND = rax != r12;
r12 = rax;
if (COND) goto loc_10001db8e;
loc_10001dbc9:
r14 = r14 + 0x1;
if (r14 < var_2C) goto loc_10001db7a;
loc_10001dbd2:
free(r15);
rdi = var_38;
goto loc_10001dbde;
loc_10001dbde:
[rdi autorelease];
return;
loc_10001dba5:
rax = class_getName(r13);
rax = objc_getMetaClass(rax);
[var_38 addObject:rax];
goto loc_10001dbc9;
}
A sub -rotina loc_10001db4d na função _subMetaClassNamesInMainBundle_c chama a função _classNamesInMainBundle_c , e o código da função é o seguinte:
int _classNamesInMainBundle_c(int arg0) {
rbx = [[NSBundle mainBundle] retain];
r15 = [[rbx executablePath] retain];
[rbx release];
rbx = objc_retainAutorelease(r15);
r14 = objc_copyClassNamesForImage([rbx UTF8String], arg0);
[rbx release];
rax = r14;
return rax;
}
A implementação da função _classNamesInMainBundle_c é óbvia, é nada mais do que chamar objc_copyClassNamesForImage para obter os nomes de todas as classes do caminho executável mainBundle . O número de conjuntos é atribuído à variável outCount , e o chamador pode usar outCount para atravessá -la.
static inline char ** WDTClassNamesInMainBundle ( unsigned int *outCount) {
NSString *executablePath = [[ NSBundle mainBundle ] executablePath ];
char **classNames = objc_copyClassNamesForImage ([executablePath UTF8String ], outCount);
return classNames;
} Se você não se importa com os detalhes, a implementação da função _subMetaClassNamesInMainBundle_c também será muito clara, o que é atravessar o valor de retorno da função objc_copyClassNamesForImage . Se o item for uma subclasse do UIViewController , metaClass da classe será obtido e adicionado à matriz variável var_38 .
Em seguida, vamos nos concentrar na declaração de loop do-while dentro. A declaração para o julgamento do loop é var_98 + 0x1 < rax . var_98 atribui o registro rdx no início do loop, e o registro rdx é inicializado para 0 fora do loop, então o var_98 é o contador e o registro rax é count atribuído ao registro r12 . Com base nisso do-while na verdade está atravessando a matriz UIViewController . O comportamento de travessia é trocar initialize e nbs_jump_initialize: métodos através de _nbs_Swizzle_orReplaceWithIMPs .
O código para nbs_jump_initialize é o seguinte:
void +[_priv_NBSUIAgent nbs_jump_initialize:](void * self, void * _cmd, void * arg2) {
rbx = arg2;
r15 = self;
r14 = [NSStringFromSelector(rbx) retain];
if ((r14 != 0x0) && ([r14 isEqualToString:@""] == 0x0)) {
[r15 class];
rax = _nbs_getClassImpOf();
(rax)(r15, @selector(initialize));
}
rax = class_getName(r15);
r13 = [[NSString stringWithUTF8String:rax] retain];
rdx = @"_Aspects_";
if ([r13 hasSuffix:rdx] == 0x0) goto loc_100050137;
loc_10005011e:
if (*(int8_t *)_is_tiaoshi_kai == 0x0) goto loc_100050218;
loc_10005012e:
rsi = cfstring__V__A;
goto loc_100050195;
loc_100050195:
__NBSDebugLog(0x3, rsi, rdx, rcx, r8, r9, stack[2048]);
goto loc_100050218;
loc_100050218:
[r13 release];
rdi = r14;
[rdi release];
return;
loc_100050137:
rdx = @"RACSelectorSignal";
if ([r13 hasSuffix:rdx] == 0x0) goto loc_10005016b;
loc_100050152:
if (*(int8_t *)_is_tiaoshi_kai == 0x0) goto loc_100050218;
loc_100050162:
rsi = cfstring__V__R;
goto loc_100050195;
loc_10005016b:
if (_classSelf_isImpOf(r15, "nbs_vc_flag") == 0x0) goto loc_1000501a3;
loc_10005017e:
if (*(int8_t *)_is_tiaoshi_kai == 0x0) goto loc_100050218;
loc_10005018e:
rsi = cfstring____Yh;
goto loc_100050195;
loc_1000501a3:
rbx = objc_retainBlock(void ^(void * _block, void * arg1) {
return;
});
rax = imp_implementationWithBlock(rbx);
class_addMethod(r15, @selector(nbs_vc_flag), rax, "v@:");
[rbx release];
[_priv_NBSUIAgent hook_viewDidLoad:r15];
[_priv_NBSUIAgent hook_viewWillAppear:r15];
[_priv_NBSUIAgent hook_viewDidAppear:r15];
goto loc_100050218;
}
O código de nbs_jump_initialize é um pouco longo, mas a partir da rotina de loc_1000501a3 , pode -se observar que a lógica principal executará três métodos, hook_viewDidLoad , hook_viewWillAppear e hook_viewDidAppear , coletando esses três métodos do UIViewController Subclass.
Primeiro, use hook_viewDidLoad: Método como exemplo a ser explicado. O código a seguir pode ser um pouco obscuro e requer análise cuidadosa.
void +[_priv_NBSUIAgent hook_viewDidLoad:](void * self, void * _cmd, void * arg2) {
rax = [_priv_NBSUIHookMatrix class];
var_D8 = _nbs_getInstanceImpOf();
var_D0 = _nbs_getInstanceImpOf();
rbx = class_getName(arg2);
r14 = class_getSuperclass(arg2);
rax = [NSString stringWithFormat:@"nbs_%s_viewDidLoad", rbx];
rax = [rax retain];
var_B8 = rax;
var_C0 = NSSelectorFromString(rax);
r12 = objc_retainBlock(__NSConcreteStackBlock);
var_D0 = imp_implementationWithBlock(r12);
[r12 release];
rbx = objc_retainBlock(__NSConcreteStackBlock);
r14 = imp_implementationWithBlock(rbx);
[rbx release];
_nbs_Swizzle_orReplaceWithIMPs(arg2, @selector(viewDidLoad), var_C0, r14, var_D0);
[var_B8 release];
return;
}
hook_viewDidLoad: O parâmetro arg2 no método é a classe do ViewController para conectar, obter o nome da classe de arg2 e atribuí -lo ao registro rbx e, em seguida, usar rbx para construir o string nbs_%s_viewDidLoad var_C0 como nbs_XXViewController_viewDidLoad . __NSConcreteStackBlock nas frases a seguir é o objeto de bloco da pilha de armazenamento criada. Este bloco obterá o ponteiro da função IMP através do método imp_implementationWithBlock . _nbs_Swizzle_orReplaceWithIMPs é uma função que implementa a troca de métodos, e os parâmetros são: arg2 é a classe do ViewController ; @selector(viewDidLoad) é o seletor do viewDidLoad ; var_C0 é o seletor de nbs_%s_viewDidLoad , r14 é o impulso do segundo __NSConcreteStackBlock ; var_D0 é o impulso do primeiro __NSConcreteStackBlock .
Toda a lógica de hook_viewDidLoad: é aproximadamente clara, mas há uma pergunta aqui por que não trocar diretamente dois IMPs, mas construir dois blocos primeiro e depois trocar os IMPs de dois blocos? O motivo é que o resultado da classe pai do ViewController , ou seja, class_getSuperclass , precisa ser passado como parâmetros para o método trocado. Dessa maneira, o número de parâmetros assinados pelos dois seletores trocados é inconsistente, e esse problema precisa ser resolvido de maneira inteligente, construindo um bloco. De fato, o primeiro __NSConcreteStackBlock executa nbs_jump_viewDidLoad:superClass: Método de _priv_NBSUIHookMatrix . Como mencionado anteriormente, há superClass nos parâmetros deste método. Quanto ao motivo pelo qual esse parâmetro é necessário, eu o apresentarei mais tarde.
Por que o segundo __NSConcreteStackBlock executa nbs_jump_viewDidLoad:superClass: método? Desmarcar a opção Remove potentially dead code de tremonha, o código é o seguinte:
void +[_priv_NBSUIAgent hook_viewDidLoad:](void * self, void * _cmd, void * arg2) {
rsi = _cmd;
rdi = self;
r12 = _objc_msgSend;
rax = [_priv_NBSUIHookMatrix class];
rsi = @selector(nbs_jump_viewDidLoad:superClass:);
rdi = rax;
var_D8 = _nbs_getInstanceImpOf();
rdi = arg2;
rsi = @selector(viewDidLoad);
var_D0 = _nbs_getInstanceImpOf();
rbx = class_getName(arg2);
r14 = class_getSuperclass(arg2);
LODWORD(rax) = 0x0;
rax = [NSString stringWithFormat:@"nbs_%s_viewDidLoad", rbx];
rax = [rax retain];
var_B8 = rax;
var_C0 = NSSelectorFromString(rax);
var_60 = 0xc0000000;
var_5C = 0x0;
var_58 = ___37+[_priv_NBSUIAgent hook_viewDidLoad:]_block_invoke;
var_50 = ___block_descriptor_tmp;
var_48 = var_D8;
var_40 = @selector(viewDidLoad);
var_38 = var_D0;
var_30 = r14;
r12 = objc_retainBlock(__NSConcreteStackBlock);
var_D0 = imp_implementationWithBlock(r12);
r13 = _objc_release;
rax = [r12 release];
var_A8 = 0xc0000000;
var_A4 = 0x0;
var_A0 = ___37+[_priv_NBSUIAgent hook_viewDidLoad:]_block_invoke_2;
var_98 = ___block_descriptor_tmp47;
var_90 = rbx;
var_88 = var_D8;
var_80 = @selector(viewDidLoad);
var_78 = r14;
var_70 = arg2;
rbx = objc_retainBlock(__NSConcreteStackBlock);
r14 = imp_implementationWithBlock(rbx);
rax = [rbx release];
rax = _nbs_Swizzle_orReplaceWithIMPs(arg2, @selector(viewDidLoad), var_C0, r14, var_D0);
rax = [var_B8 release];
rsp = rsp + 0xb8;
rbx = stack[2047];
r12 = stack[2046];
r13 = stack[2045];
r14 = stack[2044];
r15 = stack[2043];
rbp = stack[2042];
return;
}
Vejamos o código de _nbs_getInstanceImpOf :
void _nbs_getInstanceImpOf() {
rax = class_getInstanceMethod(rdi, rsi);
method_getImplementation(rax);
return;
}
A função da função _nbs_getInstanceImpOf é muito óbvia. Para obter o seletor de IMP do rsi na classe rdi , os leitores descobrirão que _nbs_getInstanceImpOf foi chamado duas vezes no método hook_viewDidLoad: : O primeiro rdi é a classe _priv_NBSUIHookMatrix , rdx é @selector(nbs_jump_viewDidLoad:superClass:) , o segundo rdi é ViewController rdx é @selector(viewDidLoad) .
Em seguida, vejamos o primeiro __NSConcreteStackBlock , que significa o bloco que chamará nbs_jump_viewDidLoad:superClass: O código é o seguinte:
int ___37+[_priv_NBSUIAgent hook_viewDidLoad:]_block_invoke(int arg0, int arg1) {
r8 = *(arg0 + 0x20);
rax = *(arg0 + 0x28);
rdx = *(arg0 + 0x30);
rcx = *(arg0 + 0x38);
rax = (r8)(arg1, rax, rdx, rcx, r8);
return rax;
}
O Registro r8 é o IMP de nbs_jump_viewDidLoad:superClass: e esse código chama isso de IMP. Os parâmetros da função IMP são os mesmos que nbs_jump_viewDidLoad:superClass: :.
void -[_priv_NBSUIHookMatrix nbs_jump_viewDidLoad:superClass:](void * self, void * _cmd, void * * arg2, void * arg3) {
rbx = arg3;
var_70 = arg2;
var_68 = _cmd;
r14 = self;
rax = [self class];
rax = class_getSuperclass(rax);
if ((rbx != 0x0) && (rax != rbx)) {
rax = var_70;
if (rax != 0x0) {
rdi = r14;
(rax)(rdi, @selector(viewDidLoad));
}
else {
NSLog(@"");
[[r14 super] viewDidLoad];
}
}
else {
var_B8 = rbx;
objc_storeWeak(_currentViewController, 0x0);
r14 = 0x0;
[[NSString stringWithFormat:@"%d#loading", 0x0] retain];
r12 = 0x0;
if (0x0 != 0x0) {
rcx = class_getName([r12 class]);
r14 = [[NSString stringWithFormat:@"MobileView/Controller/%s#%@", rcx, @"loading"] retain];
}
var_A0 = r14;
r14 = [[_priv_NBSUILogCenter_assistant alloc] initWithControllerName:r14];
var_80 = r14;
var_60 = _objc_release;
[r14 setTheVC:_objc_release];
[r14 setVC_Address:_objc_release];
[r14 setIsOther:0x0];
[*_controllerStack push:r14];
rbx = [_glb_all_activing_VCS() retain];
var_98 = _objc_msgSend;
[rbx setObject:r14 forKey:_objc_msgSend];
[rbx release];
r12 = [[NSDate date] retain];
[r12 timeIntervalSince1970];
xmm0 = intrinsic_mulsd(xmm0, *0x100066938);
rbx = intrinsic_cvttsd2si(rbx, xmm0);
[r12 release];
[r14 setStartTime:rbx];
rcx = class_getName([var_60 class]);
r13 = [[NSString stringWithFormat:@"%s", rcx] retain];
r14 = [NSStringFromSelector(var_68) retain];
var_88 = [_nbs_embedIn_start() retain];
[r14 release];
[r13 release];
rbx = [[NBSLensInterfaceEventLogger shareObject] retain];
var_78 = rbx;
rax = [NBSLensUITraceSegment new];
var_58 = rax;
rbx = [[rbx theStack] retain];
[rbx push:rax];
[rbx release];
rcx = class_getName([var_60 class]);
r13 = [[NSString stringWithFormat:@"%s", rcx] retain];
r12 = [NSStringFromSelector(var_68) retain];
r14 = [[NSString stringWithFormat:@"%@#%@", r13, r12] retain];
var_A8 = r14;
[r12 release];
rdi = r13;
[rdi release];
[var_58 setSegmentName:r14];
rax = [NSDictionary dictionary];
rax = [rax retain];
var_B0 = rax;
[var_58 setSegmentParam:rax];
rbx = [[NSThread currentThread] retain];
rdx = rbx;
[var_58 setThreadInfomation:rdx];
[rbx release];
rbx = [[NSDate date] retain];
[rbx timeIntervalSince1970];
xmm0 = intrinsic_mulsd(xmm0, *0x100066938);
var_68 = intrinsic_movsd(var_68, xmm0);
[rbx release];
xmm0 = intrinsic_movsd(xmm0, var_68);
[var_58 setStartTime:rdx];
[var_58 setEntryTime:0x0];
r14 = [NBSLensUITraceSegment new];
var_90 = r14;
xmm0 = intrinsic_movsd(xmm0, var_68);
[r14 setStartTime:0x0];
rcx = class_getName([var_60 class]);
r15 = [[NSString stringWithFormat:@"%s", rcx] retain];
rbx = [[NSString stringWithFormat:@"%@#viewLoading", r15] retain];
[r14 setSegmentName:rbx];
[rbx release];
[r15 release];
rcx = var_30;
rax = [NSDictionary dictionaryWithObjects:rbx forKeys:rcx count:0x0];
[r14 setSegmentParam:rax];
rbx = [[NSThread currentThread] retain];
[r14 setThreadInfomation:rbx];
[rbx release];
[r14 setEntryTime:0x0];
rax = var_70;
if (rax != 0x0) {
(rax)(var_60, @selector(viewDidLoad), 0x0, rcx, 0x0);
}
else {
NSLog(@"");
[[var_60 super] viewDidLoad];
}
_nbs_embedIn_finish();
rdx = [var_88 mach_tm2];
[var_80 setFinishTime:rdx];
rbx = [[NSDate date] retain];
[rbx timeIntervalSince1970];
xmm0 = intrinsic_mulsd(xmm0, *0x100066938);
var_70 = intrinsic_movsd(var_70, xmm0);
[rbx release];
xmm0 = intrinsic_movsd(xmm0, var_70);
xmm0 = intrinsic_subsd(xmm0, var_68);
rdx = intrinsic_cvttsd2si(rdx, xmm0);
[var_58 setExitTime:rdx];
rbx = [[var_78 theStack] retain];
rax = [rbx pop];
rax = [rax retain];
[rax release];
[rbx release];
rbx = [[var_78 theStack] retain];
r15 = [rbx isEmpty];
[rbx release];
if (r15 == 0x0) {
rbx = [[var_78 theStack] retain];
r14 = [[rbx peer] retain];
[rbx release];
[r14 startTime];
xmm1 = intrinsic_movsd(xmm1, var_68);
xmm1 = intrinsic_subsd(xmm1, xmm0);
rdx = intrinsic_cvttsd2si(rdx, xmm1);
[var_58 setEntryTime:rdx];
[r14 startTime];
rdx = intrinsic_cvttsd2si(rdx, intrinsic_subsd(intrinsic_movsd(xmm1, var_70), xmm0));
[var_58 setExitTime:rdx];
rbx = [[r14 childSegments] retain];
rdx = var_58;
[rbx addObject:rdx];
[rbx release];
[r14 release];
}
rbx = [[var_90 childSegments] retain];
[rbx addObject:var_58];
[rbx release];
objc_setAssociatedObject(var_60, @"viewLoading", var_90, 0x1);
rax = [*_controllerStack pop];
rax = [rax retain];
[rax release];
rbx = [[_priv_NBSLENS_VCSBuffer sharedObj] retain];
[rbx addObj:var_80];
[rbx release];
rbx = [_glb_all_activing_VCS() retain];
[rbx removeObjectForKey:var_98];
[rbx release];
[var_90 release];
[var_B0 release];
[var_A8 release];
[var_58 release];
[var_78 release];
[var_88 release];
[var_80 release];
[var_A0 release];
[var_98 release];
}
return;
}
O tempo de inicialização é explicado com o SDK de monitoramento de desempenho do Firebase como exemplo. O FPM SDK é usado como abreviação para descrevê -lo. O FPM SDK implementa estatísticas no tempo de inicialização a frio, e a lógica principal é implementada na classe FPRAppActivityTracker .
Primeiro, olhe para o método +load da classe, e o código de decomposição é o seguinte:
void +[FPRAppActivityTracker load](void * self, void * _cmd) {
rax = [NSDate date];
rax = [rax retain];
rdi = *_appStartTime;
*_appStartTime = rax;
[rdi release];
rbx = [[NSNotificationCenter defaultCenter] retain];
[rbx addObserver:self selector:@selector(windowDidBecomeVisible:) name:*_UIWindowDidBecomeVisibleNotification object:0x0];
rdi = rbx;
[rdi release];
return;
}
Obviamente, _appStartTime é uma instância estática NSDate usada para salvar o tempo de início de toda a inicialização do aplicativo; portanto, o FPM SDK marca o tempo de início da inicialização do aplicativo na +load do FPRAppActivityTracker . Os leitores que entendem o método +load devem saber que o método é um método de gancho antes que main seja chamada. A hora exata é quando a imagem é carregada no tempo de execução e o método +load está pronto e, em seguida, +load será iniciado para ser chamado. Além disso, diferentes tipos de métodos +load também estão relacionados à ordem do arquivo das Build Phases->Compile Sources . Acreditamos que eles não têm impacto significativo nas estatísticas do tempo de inicialização.
Posteriormente, a notificação da UIWindowDidBecomeVisibleNotification é registrada. Essa notificação é acionada quando UIWindow é ativado e exibido na interface. Os leitores podem registrar essa notificação e imprimir o objeto de notificação com LLDB. O exemplo é o seguinte:
NSConcreteNotification 0x7fc94a716f50 {name = UIWindowDidBecomeVisibleNotification; object = <UIStatusBarWindow: 0x7fc94a5092a0; frame = (0 0; 320 568); opaque = NO; gestureRecognizers = <NSArray: 0x7fc94a619f30>; layer = <UIWindowLayer: 0x7fc94a513f50>>}
A primeira vez que recebi a notificação de UIWindowDidBecomeVisibleNotification foi anterior a - application:didFinishLaunchingWithOptions: retorno de chamada, essa notificação foi acionada quando window da barra de status foi criada. Essa implementação parece um pouco complicada e não pode garantir que a Apple ajuste o momento da chamada no futuro.
Abaixo está a descrição oficial da UIWindowDidBecomeVisibleNotification .
Publicado quando um objeto UiWindow se torna visível. O objeto de notificação é o objeto de janela que se tornou visível. Esta notificação não contém um dicionário de usuário. A alternância entre os aplicativos não gera notificações relacionadas à visibilidade para o Windows. As alterações de visibilidade da janela refletem alterações na propriedade oculta da janela e refletem apenas a visibilidade da janela dentro do aplicativo.
A seguir, é apresentado o método de lidar com notificações. Eu restaurei o método para o Pseudo-código Objective-C, que pode comparar o código pseudo-código descompilado.
void +[FPRAppActivityTracker windowDidBecomeVisible:](void * self, void * _cmd, void * arg2) {
var_30 = self;
r13 = _objc_msgSend;
r12 = [[self sharedInstance] retain];
[r12 startAppActivityTracking];
rbx = [[FIRTrace alloc] initInternalTraceWithName:@"_as"];
[r12 setAppStartTrace:rbx];
[rbx release];
r15 = @selector(appStartTrace);
rbx = [_objc_msgSend(r12, r15) retain];
[rbx startWithStartTime:*_appStartTime];
[rbx release];
rbx = [_objc_msgSend(r12, r15) retain];
rcx = *_appStartTime;
rdx = @"_astui";
[rbx startStageNamed:rdx startTime:rcx];
[rbx release];
rax = *(int8_t *)_windowDidBecomeVisible:.FDDStageStarted;
rax = rax & 0x1;
COND = rax != 0x0;
if (!COND) {
r13 = _objc_msgSend;
rcx = *_appStartTime;
rbx = [_objc_msgSend(r12, r15, rdx, rcx) retain];
rdx = @"_astfd";
[rbx startStageNamed:rdx, rcx];
[rbx release];
*(int8_t *)_windowDidBecomeVisible:.FDDStageStarted = 0x1;
}
rbx = [(r13)(@class(NSNotificationCenter), @selector(defaultCenter), rdx, *_UIWindowDidBecomeVisibleNotification) retain];
(r13)(rbx, @selector(removeObserver:name:object:), var_30, *_UIWindowDidBecomeVisibleNotification, 0x0);
[rbx release];
rdi = r12;
[rdi release];
return;
}
+ (void)windowDidBecomeVisible:(NSNotification *)notification {
FPRAppActivityTracker *tracker = [self sharedInstance];
[tracker startAppActivityTracking];
FIRTrace *trace = [[FIRTrace alloc] initInternalTraceWithName:@"_as"];
[tracker setAppStartTrace: trace];
[[tracker appStartTrace] startWithStartTime:_appStartTime];
[[tracker appStartTrace] startStageNamed:@"_astui" startTime:_appStartTime];
if (_windowDidBecomeVisible:.FDDStageStarted) {
[[tracker appStartTrace] startStageNamed:@"_astfd" startTime:_appStartTime];
_windowDidBecomeVisible:.FDDStageStarted = 1;
}
[[NSNotificationCenter defaultCenter] removeObserver:self name:UIWindowDidBecomeVisibleNotification object:nil];
}
O método registrará a notificação UIWindowDidBecomeVisibleNotification no final, porque a notificação será chamada várias vezes, e precisamos apenas para executá -lo uma vez. Primeiro, ligue para o método -startAppActivityTracking para começar a rastrear a atividade do aplicativo. Este método será discutido em profundidade mais tarde.
Primeiro de tudo, estamos claros que as solicitações de rede que estamos discutindo aqui não têm instruções especiais para consultar as solicitações HTTP. O Tingyun SDK usa principalmente dois métodos para implementar o monitoramento da rede: o primeiro é conectar a API usada pela programação da rede iOS, que tem como alvo principalmente solicitações de rede nativas; O segundo é herdar NSURLProtocol para implementar solicitações de rede, que direcionam principalmente solicitações de rede no UIWebView.
O SDK conecta a API para a construção de NSURLSessionDataTask , NSURLSessionUploadTask e NSURLSessionDownloadTask em todas as solicitações de rede. A lógica do gancho está na função C _nbs_hook_NSURLSession , e o código pseudo é o seguinte:
int _nbs_hook_NSURLSession() {
_nbs_hook_NSURLSessionTask();
r13 = [[_priv_NSURLSession_NBS class] retain];
r14 = [objc_getClass("NSURLSession") retain];
r15 = [objc_getMetaClass(class_getName(r13)) retain];
r12 = [objc_getMetaClass("NSURLSession") retain];
if ((((((_nbs_hookClass_CopyAMethod() != 0x0) && (_nbs_hookClass_CopyAMethod() != 0x0)) && (_nbs_hookClass_CopyAMethod() != 0x0)) && (_nbs_hookClass_CopyAMethod() != 0x0)) && (_nbs_hookClass_CopyAMethod() != 0x0)) && (_nbs_hookClass_CopyAMethod() != 0x0)) {
if (_nbs_hookClass_CopyAMethod() != 0x0) {
if (_nbs_hookClass_CopyAMethod() != 0x0) {
if (_nbs_hookClass_CopyAMethod() != 0x0) {
if (_nbs_hookClass_CopyAMethod() != 0x0) {
_nbs_Swizzle(r14, @selector(dataTaskWithRequest:completionHandler:), @selector(nbs_dataTaskWithRequest:completionHandler:));
_nbs_Swizzle(r14, @selector(downloadTaskWithRequest:completionHandler:), @selector(nbs_downloadTaskWithRequest:completionHandler:));
_nbs_Swizzle(r14, @selector(downloadTaskWithResumeData:completionHandler:), @selector(nbs_downloadTaskWithResumeData:completionHandler:));
_nbs_Swizzle(r14, @selector(uploadTaskWithRequest:fromData:completionHandler:), @selector(nbs_uploadTaskWithRequest:fromData:completionHandler:));
_nbs_Swizzle(r14, @selector(uploadTaskWithRequest:fromFile:completionHandler:), @selector(nbs_uploadTaskWithRequest:fromFile:completionHandler:));
_nbs_Swizzle(r14, @selector(downloadTaskWithRequest:), @selector(nbs_downloadTaskWithRequest:));
_nbs_Swizzle(r14, @selector(uploadTaskWithRequest:fromFile:), @selector(nbs_uploadTaskWithRequest:fromFile:));
_nbs_Swizzle(r14, @selector(uploadTaskWithRequest:fromData:), @selector(nbs_uploadTaskWithRequest:fromData:));
_nbs_Swizzle(r12, @selector(sessionWithConfiguration:delegate:delegateQueue:), @selector(nbs_sessionWithConfiguration:delegate:delegateQueue:));
_nbs_Swizzle(r14, @selector(uploadTaskWithStreamedRequest:), @selector(nbs_uploadTaskWithStreamedRequest:));
}
}
}
}
}
[r12 release];
[r15 release];
[r14 release];
rdi = r13;
rax = [rdi release];
return rax;
}
_nbs_swizzle é a função C que ouve a nuvem para implementar o swizzling do método.
A partir do código, podemos ver que, além de usar _nbs_Swizzle para NSURLSessionDataTask , NSURLSessionUploadTask e NSURLSessionDownloadTask mencionadas acima, ele também substitui a implementação sessionWithConfiguration:delegate:delegateQueue: Método. Vou explicar por que esse método é fisgado mais tarde.
Todas as implementações do método do gancho são definidas na classe _priv_NSURLSession_NBS .
O código principal de nbs_dataTaskWithRequest:completionHandler: é o seguinte:
typedef void (^nbs_URLSessionDataTaskCompletionHandler)(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error);
- (NSURLSessionDataTask *)nbs_dataTaskWithRequest:(NSURLRequest *)request
completionHandler:(void (^)(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error))completionHandler {
_priv_NBSHTTPTransaction *httpTransaction = [_priv_NBSHTTPTransaction new];
nbs_URLSessionDataTaskCompletionHandler wrappedCompletionHandler;
__block NSURLSessionDataTask *dataTask;
if (completionHandler) {
wrappedCompletionHandler = ^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
NSTimeInterval timeInterval = [[NSDate date] timeIntervalSince1970];
[dataTask.httpTransaction finishAt:timeInterval];
completionHandler(data, response, error);
};
}
dataTask = [self nbs_dataTaskWithRequest:request
completionHandler:wrappedCompletionHandler];
if (dataTask) {
dataTask.httpTransaction = httpTransaction;
}
return dataTask;
}
_priv_NBSHTTPTransaction é um modelo de parâmetros de desempenho relacionado às solicitações HTTP no SDK. Esta estrutura de classe é a seguinte:
@class _priv_NBSHTTPTransaction : NSObject {
@property isFileURL
@property tm_dur_dns
@property tm_dur_cnnct
@property tm_pnt_send
@property tm_dur_firstP
@property tm_dur_end
@property tm_dur_ssl
@property sendSize
@property receiveSize
@property headerSize
@property dataSize
@property statusCode
@property errCode
@property contentLength
@property errText
@property url
@property ip
@property contentType
@property anyObj
@property useContentLength
@property netType
@property appData
@property request
@property response
@property responseData
@property urlParams
@property dataBody
@property httpMethodNumber
@property libClassId
@property socketItem
@property threadId
@property cdn_associate
@property connectType
@property cdnVendorName
@property cdn_flg
ivar tm_dur_cnnct
ivar tm_dur_dns
ivar tm_dur_firstP
ivar tm_dur_end
ivar tm_dur_ssl
ivar tm_pnt_send
ivar sendSize
ivar receiveSize
ivar headerSize
ivar dataSize
ivar statusCode
ivar errCode
ivar errText
ivar url
ivar ip
ivar contentType
ivar contentLength
ivar anyObj
ivar useContentLength
ivar netType
ivar appData
ivar response
ivar responseData
ivar urlParams
ivar dataBody
ivar httpMethodNumber
ivar libClassId
ivar socketItem
ivar threadId
ivar cdn_associate
ivar cdn_flg
ivar isFileURL
ivar connectType
ivar cdnVendorName
ivar _request
-clear
-init
-getText
-addIntoArray:
-startWithIP:DNSTime:atTimePoint:withObject:
-updateWithResponse:timePoint:
-updateWithReceiveData:
-updateWithTotalReceiveData:
-updateWithTotalReceiveSize:
-updateSendSize:
-updateWithError:
-finishAt:
-.cxx_destruct
-tm_dur_dns
-setTm_dur_dns:
-tm_pnt_send
-setTm_pnt_send:
-tm_dur_firstP
-setTm_dur_firstP:
-tm_dur_end
-setTm_dur_end:
-tm_dur_cnnct
-setTm_dur_cnnct:
-tm_dur_ssl
-setTm_dur_ssl:
-sendSize
-setSendSize:
-receiveSize
-setReceiveSize:
-errCode
-setErrCode:
-contentLength
-setContentLength:
-statusCode
-setStatusCode:
-headerSize
-setHeaderSize:
-dataSize
-setDataSize:
-url
-setUrl:
-ip
-setIp:
-errText
-setErrText:
-contentType
-setContentType:
-useContentLength
-setUseContentLength:
-netType
-setNetType:
-appData
-setAppData:
-response
-setResponse:
-responseData
-setResponseData:
-anyObj
-setAnyObj:
-urlParams
-setUrlParams:
-dataBody
-setDataBody:
-httpMethodNumber
-setHttpMethodNumber:
-libClassId
-setLibClassId:
-isFileURL
-setIsFileURL:
-socketItem
-setSocketItem:
-threadId
-setThreadId:
-connectType
-setConnectType:
-cdnVendorName
-setCdnVendorName:
-cdn_associate
-setCdn_associate:
-cdn_flg
-setCdn_flg:
-request
-setRequest:
}
A tabela a seguir lista os significados de alguns atributos -chave:
| propriedade | significado |
|---|---|
| tm_pnt_send | Solicitar hora de início |
| tm_dur_dns | DNS Time de resolução |
| tm_dur_cnnct | Tempo de estabelecimento de conexão TCP |
| tm_dur_firstp | Primeira hora do pacote |
| TM_DUR_SSL | Tempo de aperto de mão SSL |
| StatusCode | Código de status HTTP |
O tempo de resposta é um bom indicador quantitativo, que pode ser usado para medir o tempo de espera para os usuários solicitarem serviços. Geralmente é definido como o período em que o usuário envia uma solicitação e o conteúdo da resposta no servidor atinge o cliente.
A figura a seguir é uma explicação detalhada das solicitações HTTP
Na figura acima, podemos observar que o tempo de resposta inclui o tempo de resolução do nome do domínio DNS, o tempo de conexão estabelecido com o servidor, o tempo de processamento do servidor e o tempo em que a resposta chega ao cliente.
Se você usar o Charles para interceptar solicitações HTTP, poderá visualizar os dados do tempo de resposta na coluna de tempo da guia Visão geral. Duration na figura abaixo representa o tempo total de resposta da solicitação, que também inclui DNS (tempo de resolução do nome do domínio DNS), Connect (tempo de estabelecimento de conexão) e SSL Handshake (tempo de handshake SSL) mencionado acima. Como essa solicitação é uma solicitação HTTP, o campo SSL Handshake é deixado em branco.
De fato, depois de desenvolver o recurso de tempo de resposta no SDK, também podemos verificar a correção dos resultados dessa maneira. Obviamente, o tempo obtido no SDK não é exatamente igual a Charles, porque os dois métodos de implementação são completamente diferentes, mas a diferença entre eles deve estar dentro de um intervalo razoável. Este aspecto será discutido em detalhes abaixo.
Através da introdução acima, podemos pensar facilmente em uma idéia: através da função quando a solicitação do gancho for emitida, registre o tempo de solicitação e, em seguida, conecte a resposta do retorno de chamada no iOS SDK, registre o horário final e calcule a diferença para obter o tempo de resposta desta solicitação. O mesmo vale para a ideia geral de Tingyun, mas há muitos detalhes que precisam receber atenção. Vamos discutir seu plano de implementação específico em detalhes a seguir.
A escuta em nuvem é o método de resume de NSurlSessionTask na função _nbs_hook_NSURLSessionTask para alcançar o objetivo de registrar o início da solicitação.
void _nbs_hook_NSURLSessionTask() {
r14 = _objc_msgSend;
rax = [NSURLSessionConfiguration ephemeralSessionConfiguration];
rax = [rax retain];
var_40 = rax;
rax = [NSURLSession sessionWithConfiguration:rax];
rax = [rax retain];
rdx = 0x0;
var_38 = rax;
rax = [rax dataTaskWithURL:rdx];
rax = [rax retain];
var_30 = rax;
rbx = [rax class];
r12 = @selector(resume);
if (class_getInstanceMethod(rbx, r12) != 0x0) {
r15 = @selector(superclass);
r13 = @selector(resume);
var_48 = r15;
do {
if (_nbs_slow_isClassItSelfHasMethod(rbx, r12) != 0x0) {
r15 = class_getInstanceMethod(rbx, r12);
rax = method_getImplementation(r15);
rax = objc_retainBlock(__NSConcreteStackBlock);
var_50 = imp_implementationWithBlock(rax);
r13 = r13;
[rax release];
rdi = r15;
r15 = var_48;
rax = method_getTypeEncoding(rdi);
rdx = var_50;
rcx = rax;
class_replaceMethod(rbx, r12, rdx, rcx);
}
r14 = _objc_msgSend;
rbx = _objc_msgSend(rbx, r15, rdx, rcx);
rax = class_getInstanceMethod(rbx, r13);
r12 = r13;
} while (rax != 0x0);
}
(r14)(var_30, @selector(cancel), rdx);
(r14)(var_38, @selector(finishTasksAndInvalidate), rdx);
[var_30 release];
[var_38 release];
[var_40 release];
return;
}
Restaure o pseudocódigo acima para o código Objective-C da seguinte forma:
void _nbs_hook_NSURLSessionTask() {
NSURLSessionConfiguration *config = [NSURLSessionConfiguration ephemeralSessionConfiguration];
NSURLSession *session = [NSURLSession sessionWithConfiguration:config];
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wnonnull"
NSURLSessionDataTask *task = [session dataTaskWithURL:nil];
#pragma clang diagnostic pop
Class cls = task.class;
if (class_getInstanceMethod(cls, @selector(resume))) {
Method method;
do {
if (_nbs_slow_isClassItSelfHasMethod(cls, @selector(resume))) {
Method resumeMethod = class_getInstanceMethod(cls, @selector(resume));
IMP imp = imp_implementationWithBlock(^(id self) {
});
class_replaceMethod(cls, @selector(resume), imp, method_getTypeEncoding(resumeMethod));
}
cls = [cls superclass];
method = class_getInstanceMethod(cls, @selector(resume));
} while (method);
}
[task cancel];
[session finishTasksAndInvalidate];
}
Sabemos que, na estrutura Foundation , algumas classes são na verdade grupos de classes, como NSDictionary e NSArray . NSURLSessionTask também é uma família de classes, e as cadeias de herança são diferentes em diferentes versões do sistema, então, obviamente, você não pode conectar diretamente a classe NSURLSessionTask . Um método inteligente é adotado aqui para construir uma sessão efêmera por meio do método de ephemeralSessionConfiguration . É semelhante à sessão padrão, mas nenhum dado é armazenado no disco e todos os caches, cookies, credenciais etc. são salvos na RAM e associados à sessão. Dessa forma, eles serão limpos automaticamente quando a sessão for inválida. Então, durante esta breve sessão, um objeto de sessão é criado e o objeto de tarefas é finalmente construído, e a classe real é obtida através deste objeto de tarefas.
A abordagem inteligente acima não é criada originalmente por Tingyun. Na verdade, refere -se à abordagem do Afnetworking. Para adicionar notificações no Afnetworking, resume e suspend do gancho NSURLSessionTask também são implementados no AFURLSessionManager .
if (NSClassFromString(@"NSURLSessionTask")) {
/**
iOS 7 and iOS 8 differ in NSURLSessionTask implementation, which makes the next bit of code a bit tricky.
Many Unit Tests have been built to validate as much of this behavior has possible.
Here is what we know:
- NSURLSessionTasks are implemented with class clusters, meaning the class you request from the API isn't actually the type of class you will get back.
- Simply referencing `[NSURLSessionTask class]` will not work. You need to ask an `NSURLSession` to actually create an object, and grab the class from there.
- On iOS 7, `localDataTask` is a `__NSCFLocalDataTask`, which inherits from `__NSCFLocalSessionTask`, which inherits from `__NSCFURLSessionTask`.
- On iOS 8, `localDataTask` is a `__NSCFLocalDataTask`, which inherits from `__NSCFLocalSessionTask`, which inherits from `NSURLSessionTask`.
- On iOS 7, `__NSCFLocalSessionTask` and `__NSCFURLSessionTask` are the only two classes that have their own implementations of `resume` and `suspend`, and `__NSCFLocalSessionTask` DOES NOT CALL SUPER. This means both classes need to be swizzled.
- On iOS 8, `NSURLSessionTask` is the only class that implements `resume` and `suspend`. This means this is the only class that needs to be swizzled.
- Because `NSURLSessionTask` is not involved in the class hierarchy for every version of iOS, its easier to add the swizzled methods to a dummy class and manage them there.
Some Assumptions:
- No implementations of `resume` or `suspend` call super. If this were to change in a future version of iOS, we'd need to handle it.
- No background task classes override `resume` or `suspend`
The current solution:
1) Grab an instance of `__NSCFLocalDataTask` by asking an instance of `NSURLSession` for a data task.
2) Grab a pointer to the original implementation of `af_resume`
3) Check to see if the current class has an implementation of resume. If so, continue to step 4.
4) Grab the super class of the current class.
5) Grab a pointer for the current class to the current implementation of `resume`.
6) Grab a pointer for the super class to the current implementation of `resume`.
7) If the current class implementation of `resume` is not equal to the super class implementation of `resume` AND the current implementation of `resume` is not equal to the original implementation of `af_resume`, THEN swizzle the methods
8) Set the current class to the super class, and repeat steps 3-8
*/
NSURLSessionConfiguration *configuration = [NSURLSessionConfiguration ephemeralSessionConfiguration];
NSURLSession * session = [NSURLSession sessionWithConfiguration:configuration];
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnonnull"
NSURLSessionDataTask *localDataTask = [session dataTaskWithURL:nil];
#pragma clang diagnostic pop
IMP originalAFResumeIMP = method_getImplementation(class_getInstanceMethod([self class], @selector(af_resume)));
Class currentClass = [localDataTask class];
while (class_getInstanceMethod(currentClass, @selector(resume))) {
Class superClass = [currentClass superclass];
IMP classResumeIMP = method_getImplementation(class_getInstanceMethod(currentClass, @selector(resume)));
IMP superclassResumeIMP = method_getImplementation(class_getInstanceMethod(superClass, @selector(resume)));
if (classResumeIMP != superclassResumeIMP &&
originalAFResumeIMP != classResumeIMP) {
[self swizzleResumeAndSuspendMethodForClass:currentClass];
}
currentClass = [currentClass superclass];
}
[localDataTask cancel];
[session finishTasksAndInvalidate];
}
class_copyMethodListserá chamado no método_nbs_slow_isClassItSelfHasMethodpara obter a lista de métodos desta classe. Observe que a lista de métodos obtidos por este método não contém os métodos da classe pai; portanto,_nbs_slow_isClassItSelfHasMethodé realmente julgar se a própria classeclscontém@selector(resume).
De fato, a lógica acima também é implementada na Biblioteca de código aberto flex, mas há pequenas diferenças na implementação. O Flex o distinguirá do gancho __NSCFLocalSessionTask , NSurlSessionTask e __nscfurlSessionTask de acordo com a versão do sistema. Pessoalmente, sinto que a implementação da nuvem de escuta é mais elegante do que a codificação dura do Flex . Como __NSCFLocalSessionTask e __NSCFURLSessionTask são aulas particulares, são adotadas divisão e splicing para evitar a rejeição da auditoria.
+ (void)injectIntoNSURLSessionTaskResume
{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// In iOS 7 resume lives in __NSCFLocalSessionTask
// In iOS 8 resume lives in NSURLSessionTask
// In iOS 9 resume lives in __NSCFURLSessionTask
Class class = Nil;
if (![[NSProcessInfo processInfo] respondsToSelector:@selector(operatingSystemVersion)]) {
class = NSClassFromString([@[@"__", @"NSC", @"FLocalS", @"ession", @"Task"] componentsJoinedByString:@""]);
} else if ([[NSProcessInfo processInfo] operatingSystemVersion].majorVersion < 9) {
class = [NSURLSessionTask class];
} else {
class = NSClassFromString([@[@"__", @"NSC", @"FURLS", @"ession", @"Task"] componentsJoinedByString:@""]);
}
SEL selector = @selector(resume);
SEL swizzledSelector = [FLEXUtility swizzledSelectorForSelector:selector];
Method originalResume = class_getInstanceMethod(class, selector);
void (^swizzleBlock)(NSURLSessionTask *) = ^(NSURLSessionTask *slf) {
[[FLEXNetworkObserver sharedObserver] URLSessionTaskWillResume:slf];
((void(*)(id, SEL))objc_msgSend)(slf, swizzledSelector);
};
IMP implementation = imp_implementationWithBlock(swizzleBlock);
class_addMethod(class, swizzledSelector, implementation, method_getTypeEncoding(originalResume));
Method newResume = class_getInstanceMethod(class, swizzledSelector);
method_exchangeImplementations(originalResume, newResume);
});
}
A implementação da substituição do resume original acima é implementada através do imp_implementationWithBlock , e o bloco substituído é o seguinte:
void ___nbs_hook_NSURLSessionTask_block_invoke(int arg0, int arg1, int arg2) {
rbx = [[NSDate date] retain];
[rbx timeIntervalSince1970];
var_40 = intrinsic_movsd(var_40, xmm0);
[rbx release];
r15 = _is_tiaoshi_kai;
COND = *(int8_t *)r15 == 0x0;
var_50 = r13;
if (!COND) {
rax = [var_30 URL];
rax = [rax retain];
r14 = r15;
r15 = rax;
rbx = [[r15 absoluteString] retain];
rdx = rbx;
__NBSDebugLog(0x3, @"NSURLSession:start:url:%@", rdx, rcx, r8, r9, stack[2048]);
[rbx release];
rdi = r15;
r15 = r14;
[rdi release];
}
rbx = [objc_getAssociatedObject(r12, @"m_SessAssociatedKey") retain];
if (rbx != 0x0) {
xmm1 = intrinsic_movsd(xmm1, var_40);
xmm1 = intrinsic_mulsd(xmm1, *0x1000b9990);
xmm0 = intrinsic_movsd(xmm0, *0x1000b9da8);
[rbx startWithIP:0x0 DNSTime:var_30 atTimePoint:r8 withObject:r9];
[rbx setRequest:var_30];
[rbx setLibClassId:0x1];
}
else {
if (*(int8_t *)r15 != 0x0) {
__NBSDebugLog(0x3, cfstring_r, rdx, rcx, r8, r9, stack[2048]);
}
}
}
No pseudo-código acima, a lógica irrelevante em ___nbs_hook_NSURLSessionTask_block_invoke é ignorada. Você pode ver que um registro de data e hora é gerado e o registro de data e hora é usado como um parâmetro de entrada [rbx startWithIP:0x0 DNSTime:var_30 atTimePoint:r8 withObject:r9] . rbx é uma instância de _priv_NBSHTTPTransaction , e esta instância é obtida através do objeto associado do NSURLSessionDataTask . A lógica de criar _priv_NBSHTTPTransaction e definir o objeto associado está no -[_priv_NSURLSession_NBS nbs_dataTaskWithRequest:completionHandler:] .
r12 = [[var_30 nbs_dataTaskWithRequest:r13 completionHandler:0x0] retain];
r15 = [_priv_NBSHTTPTransaction new];
if (r12 != 0x0) {
objc_setAssociatedObject(r12, @"m_SessAssociatedKey", r15, 0x301);
}
[r15 release];
-[_priv_NBSHTTPTransaction startWithIP:DNSTime:atTimePoint:withObject:] Método atribuirá o tempo do parâmetro à sua propriedade tm_pnt_send .
-[_priv_NBSHTTPTransaction startWithIP:DNSTime:atTimePoint:withObject:] {
var_30 = intrinsic_movsd(var_30, arg4, rdx, arg5);
r12->tm_pnt_send = intrinsic_movsd(r12->tm_pnt_send, intrinsic_movsd(xmm0, var_30));
}
Obviamente, além do -[_priv_NSURLSession_NBS nbs_dataTaskWithRequest:completionHandler:] Método, o método a seguir também contém esta lógica:
nbs_downloadTaskWithRequest:nbs_downloadTaskWithRequest:completionHandler:nbs_downloadTaskWithResumeData:completionHandler:nbs_uploadTaskWithRequest:fromData:completionHandler:nbs_uploadTaskWithRequest:fromFile:completionHandler:nbs_uploadTaskWithRequest:fromFile:nbs_uploadTaskWithRequest:fromData:nbs_uploadTaskWithStreamedRequest: O tempo de resposta final é calculado no método finishAt e o atribuído ao atributo tm_dur_end .
void -[_priv_NBSHTTPTransaction finishAt:](void * self, void * _cmd, double arg2) {
r14 = self;
rbx = [r14 retain];
r14 = @selector(tm_pnt_send);
_objc_msgSend(rbx, r14);
xmm1 = intrinsic_xorpd(xmm1, xmm1);
xmm0 = intrinsic_ucomisd(xmm0, xmm1);
COND = xmm0 <= 0x0;
if (!COND) {
_objc_msgSend(rbx, r14);
xmm1 = intrinsic_movsd(xmm1, var_30);
xmm1 = intrinsic_subsd(xmm1, xmm0);
xmm0 = intrinsic_movapd(xmm0, xmm1);
[rbx setTm_dur_end:rdx];
}
}
Para solicitações de rede iniciadas ligando dataTaskWithRequest:completionHandler: Método, o retorno de chamada preenchido está no completionHandler , para que finishAt seja chamado no retorno de chamada preenchido. Métodos semelhantes incluem ___72-[_priv_NSURLSession_NBS nbs_downloadTaskWithRequest:completionHandler:]_block_invoke , ___79-[_priv_NSURLSession_NBS nbs_uploadTaskWithRequest:fromData:completionHandler:]_block_invoke
int ___68-[_priv_NSURLSession_NBS nbs_dataTaskWithRequest:completionHandler:]_block_invoke(int arg0, int arg1, int arg2, int arg3) {
rdi = *(r12 + 0x20);
xmm0 = intrinsic_movsd(xmm0, var_68);
[rdi finishAt:rdx];
}
No entanto, para solicitações de rede que ligue para dataTaskWithRequest: Método, você precisa conectar URLSession:task:didCompleteWithError: Método de NSURLSessionTaskDelegate .
void -[_priv_NBSLensAllMethodsDlgt_urlSess nbs_URLSession:task:didCompleteWithError:](void * self, void * _cmd, void * arg2, void * arg3, void * arg4) {
rbx = [[NSDate date] retain];
[rbx timeIntervalSince1970];
xmm0 = intrinsic_mulsd(xmm0, *0x1000b9990);
var_40 = intrinsic_movsd(var_40, xmm0);
[rbx release];
rax = objc_getAssociatedObject(r13, @"m_SessAssociatedKey");
rax = [rax retain];
_objc_msgSend(r12, @selector(finishAt:), var_58);
}
