I am using Map box iOS SDK 3.0.1 in my App and facing issues on slow network. It crashed very often.
libc++abi.dylib: terminating with uncaught exception of type
std::runtime_error: Failed to load
[https://a.tiles.mapbox.com/v4/mapbox.mapbox-terrain-v2,mapbox.mapbox-streets-v6/0/0/0.vector.pbf?access_token=pk.xxxx]:
and Xcode crash log is :
libsystem_kernel.dylib`__pthread_kill:
0x114edcff8 <+0>: movl $0x2000148, %eax
0x114edcffd <+5>: movq %rcx, %r10
0x114edd000 <+8>: syscall
-> 0x114edd002 <+10>: jae 0x114edd00c ; <+20>
0x114edd004 <+12>: movq %rax, %rdi
0x114edd007 <+15>: jmp 0x114ed7bdd ; cerror_nocancel
0x114edd00c <+20>: retq
0x114edd00d <+21>: nop
0x114edd00e <+22>: nop
0x114edd00f <+23>: nop
Anyone faced any such issue with map box SDK ? Let me know how it can be prevented to the error can be bought ?
Give Mapbox iOS SDK v3.1.1 a try — there have been significant networking improvements made in the v3.1.x releases.
Related
For some reason, on iOS 15, I am receiving lots of crashes where I have a sheet presented, and then exit the app to the home screen. The app crashes giving me the exception:
libswiftCore.dylib`:
-> 0x123c02a20 <+0>: pushq %rbp Thread 1: Fatal error: Index out of range
0x123c02a21 <+1>: movq %rsp, %rbp
0x123c02a24 <+4>: popq %rbp
0x123c02a25 <+5>: retq
0x123c02a26 <+6>: nopw %cs:(%rax,%rax)
Has anyone experienced this error before?
Thanks
What is the fix for a SwiftUI iOS app with Firebase framework error not allowing to build and run on connected devices?
Xcode builds and runs the code flawless in the Canvas panel and Simulator, but does not build and run on connected devices.
(on a new project)
Error Messages :
Thread 1 #0 0x00000001029172ac in __abort_with_payload ()
dyld`__abort_with_payload:
0x1029172a4 <+0>: mov x16, #0x209
0x1029172a8 <+4>: svc #0x80
-> 0x1029172ac <+8>: b.lo 0x1029172c8 ; <+36>
0x1029172b0 <+12>: stp x29, x30, [sp, #-0x10]!
0x1029172b4 <+16>: mov x29, sp
0x1029172b8 <+20>: bl 0x1029157d8 ; cerror_nocancel
0x1029172bc <+24>: mov sp, x29
0x1029172c0 <+28>: ldp x29, x30, [sp], #0x10
0x1029172c4 <+32>: ret
0x1029172c8 <+36>: ret'
debug area
dyld: Library not loaded: #rpath/FBLPromises.framework/FBLPromises
Referenced from: /private/var/containers/Bundle/Application/1ECE175B-46E5-4FC0-A28A-
BC3255C9F124/Bennett Application.app/Bennett Application
Reason: no suitable image found. Did find:
/private/var/containers/Bundle/Application/1ECE175B-46E5-4FC0-A28A-BC3255C9F124/Bennett
Application.app/Frameworks/FBLPromises.framework/FBLPromises: code signature invalid for
'/private/var/containers/Bundle/Application/1ECE175B-46E5-4FC0-A28A-BC3255C9F124/Bennett
Application.app/Frameworks/FBLPromises.framework/FBLPromises'
Also, when you deploy an iOS app to the store, will you encounter similar problems as above?
This error was simply fixed by upgrading to the Apple Developers Program.
I work on a project that includes several libraries integrated as pods by Cocoapods - it has been a while but I think this error came up first when I integrated Cocoapods and hasn't disappeared ever since (so I started to use a real device for testing my builds).
Like I mentioned, I have no problems building on any real device but I constantly face the following error when building on the iOS simulator. Xcode completes the build successfully and starts up the simulator which then crashes as soon as it tries to load the build.
dyld: Symbol not found: _ACAccountTypeIdentifierTwitter
Referenced from: .../Library/Developer/CoreSimulator/Devices/28482AD6-B0F2-4FBF-B525-C1EA3F2E07FA/data/Containers/Bundle/Application/D9992D1D-FE14-4403-A9DC-E5C1BB787E9E/projectName.app/projectName
Expected in: flat namespace
in .../Library/Developer/CoreSimulator/Devices/28482AD6-B0F2-4FBF-B525-C1EA3F2E07FA/data/Containers/Bundle/Application/D9992D1D-FE14-4403-A9DC-E5C1BB787E9E/projectName.app/projectName
(lldb)
I got cautious with changing linking options because when I faced this problem first, it affected also the building of Xcode itself which then failed again and again because of some difficult-for-me-to-understand errors. Furthermore I don't make use of any Twitter specific code, it just seems to be part of an integrated library.
Any help is highly appreciate as I'd very much like to be able to build on the simulator again!
EDIT 1
EDIT 2
dyld`_dyld_start:
0x7fff6431d000 <+0>: popq %rdi
0x7fff6431d001 <+1>: pushq $0x0
0x7fff6431d003 <+3>: movq %rsp, %rbp
0x7fff6431d006 <+6>: andq $-0x10, %rsp
0x7fff6431d00a <+10>: subq $0x10, %rsp
0x7fff6431d00e <+14>: movl 0x8(%rbp), %esi
0x7fff6431d011 <+17>: leaq 0x10(%rbp), %rdx
0x7fff6431d015 <+21>: movq 0x37aec(%rip), %r8 ; _dyld_start_static
0x7fff6431d01c <+28>: leaq -0x23(%rip), %rcx ; <+0>
0x7fff6431d023 <+35>: subq %r8, %rcx
0x7fff6431d026 <+38>: leaq -0x102d(%rip), %r8
0x7fff6431d02d <+45>: leaq -0x8(%rbp), %r9
0x7fff6431d031 <+49>: callq 0x7fff6431d076 ; dyldbootstrap::start(macho_header const*, int, char const**, long, macho_header const*, unsigned long*)
-> 0x7fff6431d036 <+54>: movq -0x8(%rbp), %rdi
0x7fff6431d03a <+58>: cmpq $0x0, %rdi
0x7fff6431d03e <+62>: jne 0x7fff6431d050 ; <+80>
0x7fff6431d040 <+64>: movq %rbp, %rsp
0x7fff6431d043 <+67>: addq $0x8, %rsp
0x7fff6431d047 <+71>: movq $0x0, %rbp
0x7fff6431d04e <+78>: jmpq *%rax
0x7fff6431d050 <+80>: addq $0x10, %rsp
0x7fff6431d054 <+84>: pushq %rdi
0x7fff6431d055 <+85>: movq 0x8(%rbp), %rdi
0x7fff6431d059 <+89>: leaq 0x10(%rbp), %rsi
0x7fff6431d05d <+93>: leaq 0x8(%rsi,%rdi,8), %rdx
0x7fff6431d062 <+98>: movq %rdx, %rcx
0x7fff6431d065 <+101>: movq (%rcx), %r8
0x7fff6431d068 <+104>: addq $0x8, %rcx
0x7fff6431d06c <+108>: testq %r8, %r8
0x7fff6431d06f <+111>: jne 0x7fff6431d065 ; <+101>
0x7fff6431d071 <+113>: jmpq *%rax
0x7fff6431d073 <+115>: nop
Unfortunately, the iOS simulator does not fully support twitter accounts. Your phone does. The crash you're getting is for missing the _ACAccountTypeIdentifierTwitter. If you want to make sure that does not happen on the simulator, wherever you're checking for ACAccountType, check to make sure that ACAccountTypeIdentifierTwitter is available. Same for facebook, SinaWeibo, and TencentWeibo.
Obj-C
You need to import both Twitter and Accounts frameworks.
Swift
The entire project below compiles, builds, links and runs on the iOS Simulator. If you follow these instructions, you can verify in no time the integrity of your development environment.
Project
Xcode > New > Project... > Single View Application, SO-Twitter, Swift, Universal, Next, Create.
Code
import UIKit
import Twitter
import Accounts
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
let accountStore = ACAccountStore()
let accountType = accountStore.accountTypeWithAccountTypeIdentifier(
ACAccountTypeIdentifierTwitter)
accountStore.requestAccessToAccountsWithType(accountType, options: nil) {(
granted:Bool, error:NSError!) -> Void in
println("granted:\(granted) error:\(error)"
)}
}
}
Above code posted on Github for convenience.
Link, build, run on iOS Simulator
(Verified as far back as Xcode 6.3.2 on Simulator 8.3)
granted:true error:nil
Once OK it tapped, you likely need to iOS Simulator > Reset Content and Settings... > Reset.
Don't use -undefined dynamic_lookup. That is causing you to hit the failure at runtime instead of getting a more obvious and helpful error at link time. If you remove that from LDFLAGS, you'll likely see an error message about not being able to resolve the _ACAccountTypeIdentifierTwitter symbol and where it's being used.
_ACAccountTypeIdentifierTwitter is provided by Accounts.framework:
$ nm $(xcrun --sdk iphonesimulator --show-sdk-path)/System/Library/Frameworks/Accounts.framework/Accounts | grep _ACAccountTypeIdentifierTwitter
000000000003bdd0 S _ACAccountTypeIdentifierTwitter
How do I temporarily disallow selectors to be called on nil objects.
Actually I was getting a Bad access exception, hours after I learned that some where I was using array with out calling alloc-init on it.
So can I have something like
#define DISABLE_SELECTORS_ON_NIL_OBJECTS in prefix.h file
or some checkbox some where in project settings, or some exception which can disable selectors on nil objects, or
do I have to always put the code in if(object != nil) ?
The bad access exception means that your uninitialized object variable was not nil. In Objective-C, only instance variables are zeroed out for you automatically. Others hold whatever value is left in that memory location or register from the last time it was used. The only fix is to make sure the variable is initialized before you use it, even if that means setting it to nil.
Run the static analyzer on your code. It can often find issues like this and help you fix them.
Short answer: I don't beleive there is any simple way to do this in the way you suggest.
Long answer: You can catch it at runtime...
If you are using ARC all your variables of type Objective-C object reference will be initialised to nil by the runtime. However as Eric Skroch suggests a bad access is likely something other than a nil.
As a debugging aid there are various environment variables which can be set to have the Objective-C runtime print out lots of information as your code runs, see Apple's Mac OS X Debugging Magic (that document references an iOS version but its appears to be MIA). However there doesn't seem to be anything for trapping messages to nil.
If all else fails use a breakpoint... Here is the start of objc_msgsend (OS X):
libobjc.A.dylib`objc_msgSend:
0x7fff9774d240: testq %rdi, %rdi
0x7fff9774d243: je 0x7fff9774d270 ; objc_msgSend + 48
0x7fff9774d245: testb $0x1, %dil
0x7fff9774d249: jne 0x7fff9774d287 ; objc_msgSend + 71
0x7fff9774d24c: movq (%rdi), %r11
0x7fff9774d24f: pushq %rax
0x7fff9774d250: movq 0x10(%r11), %r10
0x7fff9774d254: movl %esi, %eax
0x7fff9774d256: andl (%r10), %eax
0x7fff9774d259: movq 0x10(%r10,%rax,8), %r11
0x7fff9774d25e: incl %eax
0x7fff9774d260: testq %r11, %r11
0x7fff9774d263: je 0x7fff9774d29b ; objc_msgSend + 91
0x7fff9774d265: cmpq (%r11), %rsi
0x7fff9774d268: jne 0x7fff9774d256 ; objc_msgSend + 22
0x7fff9774d26a: popq %rax
0x7fff9774d26b: jmpq *0x10(%r11)
0x7fff9774d26f: nop
0x7fff9774d270: movq -0x19eb41e7(%rip), %rdi ; _objc_nilReceiver
0x7fff9774d277: testq %rdi, %rdi
0x7fff9774d27a: jne 0x7fff9774d245 ; objc_msgSend + 5
0x7fff9774d27c: xorl %eax, %eax
The last instruction is the first one hit when its determined the receiver is definitely nil. So if you think you might have an accidental message to nil you can breakpoint on that instruction - the LLDB docs will tell you how if you don't know.
HTH.
Leanplum, Apptimize and other A/B testing platforms for iOS have the ability to download assets (nib files ,images, etc...) from the web and replace them at runtime.
The naive approach will be to download the new assets and replace them in the resource bundle directory, but it is impossible to write files to the resource directory because of permissions.
The question is, what techniques does these A/B testing platforms use to replace assets at runtime?
EDIT:
After reading the symbols on leanplum static library file (using nm) it seems that they are Swizzling cocoa file system API's.
for example: (an example line from nm -m leanplum.a)
-[NSBundle(LeanplumExtension) leanplum_URLForResource:withExtension:]
By using otool I can print the implementation:
-[NSBundle(LeanplumExtension) leanplum_URLForResource:withExtension:]:
0000000000000069 pushq %rbp
000000000000006a movq %rsp, %rbp
000000000000006d pushq %r15
000000000000006f pushq %r14
0000000000000071 pushq %r13
0000000000000073 pushq %r12
0000000000000075 pushq %rbx
0000000000000076 subq $0x18, %rsp
000000000000007a movq %rcx, %rbx
000000000000007d movq %rdi, 0xffffffffffffffc8(%rbp)
0000000000000081 movq %rdx, %rdi
0000000000000084 callq _objc_retain
0000000000000089 movq %rax, %r14
000000000000008c movq %rbx, %rdi
000000000000008f callq _objc_retain
0000000000000094 movq %rax, 0xffffffffffffffd0(%rbp)
0000000000000098 movq _originalMainBundle(%rip), %rcx
000000000000009f movq "+[NSBundle(LeanplumExtension) leanplum_mainBundle]"(%rcx), %rdi
00000000000000a2 movq 0x4487(%rip), %rsi
00000000000000a9 movq _objc_msgSend(%rip), %r12
00000000000000b0 movq %r14, %rdx
00000000000000b3 movq %rax, %rcx
00000000000000b6 callq *%r12
00000000000000b9 movq %rax, %rdi
00000000000000bc callq _objc_retainAutoreleasedReturnValue
00000000000000c1 movq %rax, %r13
00000000000000c4 movq _skippedFiles(%rip), %rax
00000000000000cb movq "+[NSBundle(LeanplumExtension) leanplum_mainBundle]"(%rax), %rbx
00000000000000ce movq 0x4463(%rip), %rsi
00000000000000d5 movq %r13, %rdi
00000000000000d8 callq *%r12
00000000000000db movq %rax, %rdi
00000000000000de callq _objc_retainAutoreleasedReturnValue
00000000000000e3 movq %rax, %r15
00000000000000e6 movq 0x4453(%rip), %rsi
00000000000000ed movq %rbx, %rdi
00000000000000f0 movq %r15, %rdx
00000000000000f3 callq *%r12
00000000000000f6 movb %al, %bl
00000000000000f8 movq %r15, %rdi
00000000000000fb callq _objc_release
0000000000000100 testb %bl, %bl
0000000000000102 je 0x115
0000000000000104 movq %r13, %rdi
0000000000000107 callq _objc_retain
000000000000010c movq %rax, %r15
000000000000010f movq 0xffffffffffffffd0(%rbp), %rbx
0000000000000113 jmp 0x13b
0000000000000115 movq 0x4414(%rip), %rsi
000000000000011c movq 0xffffffffffffffc8(%rbp), %rdi
0000000000000120 movq %r14, %rdx
0000000000000123 movq 0xffffffffffffffd0(%rbp), %rbx
0000000000000127 movq %rbx, %rcx
000000000000012a callq *_objc_msgSend(%rip)
0000000000000130 movq %rax, %rdi
0000000000000133 callq _objc_retainAutoreleasedReturnValue
0000000000000138 movq %rax, %r15
000000000000013b movq %r13, %rdi
000000000000013e callq _objc_release
0000000000000143 movq %rbx, %rdi
0000000000000146 callq _objc_release
000000000000014b movq %r14, %rdi
000000000000014e callq _objc_release
0000000000000153 movq %r15, %rdi
0000000000000156 addq $0x18, %rsp
000000000000015a popq %rbx
000000000000015b popq %r12
000000000000015d popq %r13
000000000000015f popq %r14
0000000000000161 popq %r15
0000000000000163 popq %rbp
0000000000000164 jmpq _objc_autoreleaseReturnValue
Can someone verify my findings?
I wonder how they get this entire list of API covered?
What happens if I open an image with fopen or other C lib?
How can I decipher the output of otool?
The question is, what techniques does these A/B testing platforms use to replace assets at runtime?
An educated guess is that they use method swizzling to swap the implementations of standard methods (e.g. [NSBundle URLForResource:withExtension:]) with those of their own versions of those methods (e.g. [NSBundle(LeanplumExtension) leanplum_URLForResource:withExtension:]). This means that your code uses the same method that you would otherwise, but you get different behavior -- in this case, the URL that's returned depends on which version of the resource the A/B testing framework decides to present to the user.
I wonder how they get this entire list of API covered?
By working carefully. The number of methods used to load resources isn't unmanageable.
What happens if I open an image with fopen or other C lib?
I expect that the framework wouldn't be able to swap resources in such a case. There are lots of ways to load data, and the framework can't possibly anticipate all of them. But if you're using an A/B framework, you presumably want the resources to be replaced as appropriate for your testing, so it doesn't make a lot of sense to try to defeat the framework.
How can I decipher the output of tool?
For the case you've shown, learn to read assembly language. (otool has a lot of options, though, and they don't all produce assembly.)
As an example, the company Leanplum offers a Visual Interface Editor for iOS and Android: This requires no coding, and Leanplum will automatically detect the elements and allow you to change them. No engineering or app store resubmissions are required.
Let me give you a little bit more high level insights about it:
With installing the iOS or Android SDK in your app, you enable a feature called Visual Editor. While in development mode and with the Website Dashboard open, the SDK sends information about the view hierarchy in real-time to your Browser. The view hierarchy is scanned in a similar way a DOM is built on a regular website.
You can choose any UI element on your app and change the appearance of it in real-time. This works by identifying the exact element in the view tree and sending the changes to the SDK.
This can be achieved by adding custom hooks or a technique called "swizzling". Take a look at this blog post, how it works.
To learn more about the Leanplum Visual Interface Editor, check out leanplum.com. They offer a free 30-day trial.
(Disclaimer: I'm an engineer at Leanplum)