Phonegap 2.4.0 Value Conversion Issue - ios

I'm getting an error when I create a new project skeleton using phonegap 2.4 in my CDVLocation.m file. The error I'm getting is
if ([cdvViewController supportsOrientation:currentOrientation]) Implicit conversion from enumeration type "UIDeviceOrientation"(aka "enum UIDeviceOrientation") to different enumeration type "UIInterfaceOrientation" (aka "enum UIInterfaceOrientation")
Im not 100% sure whats going on here since I dont know OBJ-C, any idea?

currentOrientation is of type UIDeviceOrientation which has more values thanUIInterfaceOrientation
Since the method expects a UIInterfaceOrientation instead of a UIDeviceOrientation
Replace:
supportsOrientation:currentOrientation
with
supportsOrientation:[[UIApplication sharedApplication] statusBarOrientation]]
Try changing the method in CDVLocation.m:
if ([self.locationManager respondsToSelector:#selector(headingOrientation)]) {
UIDeviceOrientation currentOrientation = [[UIDevice currentDevice] orientation];
if (currentOrientation != UIDeviceOrientationUnknown) {
CDVViewController* cdvViewController = (CDVViewController*)self.viewController;
//change this line
if ([cdvViewController supportsOrientation:[[UIApplication sharedApplication] statusBarOrientation]]) {
self.locationManager.headingOrientation = (CLDeviceOrientation)currentOrientation;
// FYI UIDeviceOrientation and CLDeviceOrientation enums are currently the same
}
}
}

Related

iPhone / iPad macro or c function?

What's the best way to define the following ternary operator?
[[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPhone ? x : y
I considered using the macro
#define phonePad(x, y) ([[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPhone ? x : y)
But this article mentions that it may not be the best idea. Is there a way to do the equivalent using a C function or is this the best way of implementing it?
I wouldn't use a macro for this. By using a macro, you require for the device to check the user interface idiom ever time this is used, and set x or y accordingly. Consider making a new method that returns based on the interface idiom. This can be static, because it's impossible for this value to ever change at runtime.
- (id)determineXOrY {
static id obj = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
obj = [[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPhone ? x : y
});
return obj;
}
Neither.
BOOL isiPhone = ([[UIDevice currentDevice] userInterfaceIdiom]
== UIUserInterfaceIdiomPhone);
foo = isiPhone ? x : y;
bar = isiPhone ? xprime : yprime;
...
If you turn that into a macro, you'll get a bunch of unnecessary calls into the Objective-C runtime. So just cache the result. Plus, it'll probably be a lot easier to read if you just write plain C code instead of using a macro.
If you do use the macro you must add some parentheses:
#define phonePad(x, y) ([[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPhone ? (x) : (y))
Without the parentheses you will have serious issues if x or y are more than simple values.
One downside to the macro is that you really need to be sure that both x and y evaluate to the same non-ambiguous data type.

iOS7 specific code in iOS6

I need to use iOS7 specific code in certain places, usually this has not caused much problem until now. I tried some different approaches for the first if statement, the one below seams to be the recommended way. None works. The error i get is this:
dyld: Symbol not found: _UITransitionContextToViewControllerKey
Referenced from: /Users/pese/Library/Application Support/iPhone Simulator/6.1/Applications/0A4B5156-84D8-41DE-C9D1-2E4C9DB38983/aaaa.app/aaaa
Expected in: /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator6.1.sdk/System/Library/Frameworks/UIKit.framework/UIKit
in /Users/pese/Library/Application Support/iPhone Simulator/6.1/Applications/0A4B5156-84D8-41DE-C9D1-2E4C9DB38983/aaaa.app/aaaa
Program ended with exit code: 0
And my code:
if ( &UITransitionContextToViewControllerKey != nil )
{
id<UIViewControllerTransitionCoordinator> tc = self.topViewController.transitionCoordinator;
[tc animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> context) {
CGRect newRect = _inRect;
if ([context viewControllerForKey:UITransitionContextToViewControllerKey] == [self.viewControllers objectAtIndex:0])
{
newRect = _outRect;
}
_backButton.frame = newRect;
} completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
BOOL enableSwipeToGoBack = YES;
if ([context viewControllerForKey:UITransitionContextToViewControllerKey] == [self.viewControllers objectAtIndex:0] && ![context isCancelled])
{
enableSwipeToGoBack = NO;
}
self.interactivePopGestureRecognizer.enabled = enableSwipeToGoBack;
}];
}
If i just put NO in the if statement it works but i guess that the compiler removes the code during compilation. If i replace the two UITransitionContextToViewControllerKey with nil it also works. Also the symbol causing the error is defined in UIKit/UIViewControllerTransitioning.h and look like this:
UIKIT_EXTERN NSString *const UITransitionContextToViewControllerKey NS_AVAILABLE_IOS(7_0);
Any help would be greatly appreciated.
SOLUTION:
Make UIKit framework optional and change if test to:
NSString * const *exists = &UITransitionContextToViewControllerKey;
if ( exists != NULL )
....
As others have mentioned, testing the features is typically better, but you can use a compiler directive to conditionally compile based on the OS version.
#ifdef __IPHONE_OS_VERSION_MIN_REQUIRED
// target is iOS
#if __IPHONE_OS_VERSION_MIN_REQUIRED < 70000
// target is lower than iOS 7.0
NSLog(#"This message should only appear if iOS version is 6.x or lower");
#else
// target is at least iOS 7.0
#endif
#endif

How to make test with UIInterfaceOrientation enum values

I'm a little bit lost in the bitwise ;)
My goal is to retrieve the whole set of orientations supported by an application and to test each result value to update a custom variable.
My problem is that I don't know how to make the comparison (I got a conversion/test problem...)
First I read this article : Testing for bitwise Enum values
But it doesn't bring me the light...
Let say I have the following orientation declare for my application (following is the log output for my variable supportedOrientations) :
supported orientations = (
UIInterfaceOrientationPortrait
)
So my first attempt was to try some test on integer values but it does not work (even if the application is declared to be in portrait mode the test return 'false') :
NSArray *supportedOrientations = [[NSBundle mainBundle] objectForInfoDictionaryKey:#"UISupportedInterfaceOrientations"];
NSLog(#"[supported orientations = %#", supportedOrientations);
// for clarity just make a test on the first orientation we found
if ((NSInteger)supportedOrientations[0] == UIInterfaceOrientationPortrait) {
NSLog(#"We detect Portrait mode!");
}
My second attempt was to try the bitwise thing but this time it always return 'true' (even if the supported orientation is not UIInterfaceOrientationPortrait). :
NSArray *supportedOrientations = [[NSBundle mainBundle] objectForInfoDictionaryKey:#"UISupportedInterfaceOrientations"];
NSLog(#"[supported orientations = %#", supportedOrientations);
// for clarity just make a test on the first orientation we found
if ((NSInteger)supportedOrientations[0] | UIInterfaceOrientationPortrait) { // <-- I also test with UIInterfaceOrientationMaskPortrait but no more success
NSLog(#"We detect Portrait mode!");
}
So my question is :
How to test the orientation in my case?
Is it a way to use a test by using a bitwise thing (using | operand)?
The official doc says that UISupportedInterfaceOrientations is an array of strings.
https://developer.apple.com/library/ios/documentation/general/Reference/InfoPlistKeyReference/Articles/iPhoneOSKeys.html#//apple_ref/doc/uid/TP40009252-SW10
So the solution is to use NSString comparison for each element found in the array.
NSArray *supportedOrientations = [[NSBundle mainBundle] objectForInfoDictionaryKey:#"UISupportedInterfaceOrientations"];
for (NSString *orientation in supportedOrientations) {
if ([orientation isEqualToString:#"UIInterfaceOrientationPortrait"] ||
[orientation isEqualToString:#"UIInterfaceOrientationPortraitUpsideDown"]) {
NSLog(#"*** We detect Portrait mode!");
} else if ([orientation isEqualToString:#"UIInterfaceOrientationLandscapeLeft"] ||
[orientation isEqualToString:#"UIInterfaceOrientationLandscapeRight"]) {
NSLog(#"*** We detect Landscape mode!");
}
}
Note that doing like this we didn't take advantage of the enum values (of type UIInterfaceOrientation), but it works!

iPad universal app has method with 'not found in protocol' warning, but it works

My iPad universal app has a method I implemented from here:
Best way to programmatically detect iPad/iPhone hardware
-(BOOL)isPad
{
BOOL isPad;
NSRange range = [[[UIDevice currentDevice] model] rangeOfString:#"iPad"];
if(range.location==NSNotFound) isPad=NO;
else isPad=YES;
return isPad;
}
When I write my code like this:
if( [[[UIApplication sharedApplication] delegate] isPad] ) // do something
I get the warning:
'-isPad' not found in protocol
However, it's declared in my app delegate class:
-(BOOL)isPad;
And in the implementation (above).
Any ideas why this is?
Thanks in advance.
-delegate returns an id<UIApplicationDelegate>. Even if your app delegate supports -isPad, the UIApplicationDelegate does not, which is the warning is about.
You need to cast the return value to your class to eliminate the warning.
YourAppDelClass* appDel = [UIApplication sharedApplication].delegate;
if ([appDel isPad]) {
...
The compiler expects to find isPad declared in the uiapplicationdelegate protocol. Try making it an instance method of uiapplication instead.

How can I programmatically determine if my app is running in the iphone simulator?

As the question states, I would mainly like to know whether or not my code is running in the simulator, but would also be interested in knowing the specific iphone version that is running or being simulated.
EDIT: I added the word 'programmatically' to the question name. The point of my question is to be able to dynamically include / exclude code depending on which version / simulator is running, so I'd really be looking for something like a pre-processor directive that can provide me this info.
Already asked, but with a very different title.
What #defines are set up by Xcode when compiling for iPhone
I'll repeat my answer from there:
It's in the SDK docs under "Compiling source code conditionally"
The relevant definition is TARGET_OS_SIMULATOR, which is defined in /usr/include/TargetConditionals.h within the iOS framework. On earlier versions of the toolchain, you had to write:
#include "TargetConditionals.h"
but this is no longer necessary on the current (Xcode 6/iOS8) toolchain.
So, for example, if you want to check that you are running on device, you should do
#if TARGET_OS_SIMULATOR
// Simulator-specific code
#else
// Device-specific code
#endif
depending on which is appropriate for your use-case.
Updated code:
This is purported to work officially.
#if TARGET_IPHONE_SIMULATOR
NSString *hello = #"Hello, iPhone simulator!";
#elif TARGET_OS_IPHONE
NSString *hello = #"Hello, device!";
#else
NSString *hello = #"Hello, unknown target!";
#endif
Original post (since deprecated)
This code will tell you if you are running in a simulator.
#ifdef __i386__
NSLog(#"Running in the simulator");
#else
NSLog(#"Running on a device");
#endif
Not pre-processor directive, but this was what I was looking for when i came to this question;
NSString *model = [[UIDevice currentDevice] model];
if ([model isEqualToString:#"iPhone Simulator"]) {
//device is simulator
}
There is a better way now in Swift.
As of Xcode 9.3 and newer, you can use #if targetEnvironment(simulator) to check.
#if targetEnvironment(simulator)
//Your simulator code
#endif
The best way to do this is:
#if TARGET_IPHONE_SIMULATOR
and not
#ifdef TARGET_IPHONE_SIMULATOR
since its always defined: 0 or 1
In case of Swift we can implement following
We can create struct which allows you to create a structured data
struct Platform {
static var isSimulator: Bool {
#if targetEnvironment(simulator)
// We're on the simulator
return true
#else
// We're on a device
return false
#endif
}
}
Then If we wanted to Detect if app is being built for device or simulator in Swift then .
if Platform.isSimulator {
// Do one thing
} else {
// Do the other
}
Works for Swift 4.1 and newer and Xcode 9.3 and newer
Use this code:
#if targetEnvironment(simulator)
// Simulator
#else
// Device
#endif
All those answer are good, but it somehow confuses newbie like me as it does not clarify compile check and runtime check. Preprocessor are before compile time, but we should make it clearer
This blog article shows How to detect the iPhone simulator? clearly
Runtime
First of all, let’s shortly discuss. UIDevice provides you already information about the device
[[UIDevice currentDevice] model]
will return you “iPhone Simulator” or “iPhone” according to where the app is running.
Compile time
However what you want is to use compile time defines. Why? Because you compile your app strictly to be run either inside the Simulator or on the device. Apple makes a define called TARGET_IPHONE_SIMULATOR. So let’s look at the code :
#if TARGET_IPHONE_SIMULATOR
NSLog(#"Running in Simulator - no app store or giro");
#endif
For Swift 4.2 / Xcode 10
I created an extension on UIDevice, so I can easily ask for if the simulator is running.
// UIDevice+CheckSimulator.swift
import UIKit
extension UIDevice {
/// Checks if the current device that runs the app is xCode's simulator
static func isSimulator() -> Bool {
#if targetEnvironment(simulator)
return true
#else
return false
#endif
}
}
In my AppDelegate for example I use this method to decide wether registering for remote notification is necessary, which is not possible for the simulator.
// CHECK FOR REAL DEVICE / OR SIMULATOR
if UIDevice.isSimulator() == false {
// REGISTER FOR SILENT REMOTE NOTIFICATION
application.registerForRemoteNotifications()
}
The previous answers are a little dated. I found that all you need to do is query the TARGET_IPHONE_SIMULATOR macro (no need to include any other header files [assuming you are coding for iOS]).
I attempted TARGET_OS_IPHONE but it returned the same value (1) when running on an actual device and simulator, that's why I recommend using TARGET_IPHONE_SIMULATOR instead.
In swift :
#if (arch(i386) || arch(x86_64))
...
#endif
From Detect if app is being built for device or simulator in Swift
Has anyone considered the answer provided here?
I suppose the objective-c equivalent would be
+ (BOOL)isSimulator {
NSOperatingSystemVersion ios9 = {9, 0, 0};
NSProcessInfo *processInfo = [NSProcessInfo processInfo];
if ([processInfo isOperatingSystemAtLeastVersion:ios9]) {
NSDictionary<NSString *, NSString *> *environment = [processInfo environment];
NSString *simulator = [environment objectForKey:#"SIMULATOR_DEVICE_NAME"];
return simulator != nil;
} else {
UIDevice *currentDevice = [UIDevice currentDevice];
return ([currentDevice.model rangeOfString:#"Simulator"].location != NSNotFound);
}
}
I had the same problem, both TARGET_IPHONE_SIMULATOR and TARGET_OS_IPHONE are always defined, and are set to 1. Pete's solution works, of course, but if you ever happen to build on something other than intel (unlikely, but who knows), here's something that's safe as long as the iphone hardware doesn't change (so your code will always work for the iphones currently out there):
#if defined __arm__ || defined __thumb__
#undef TARGET_IPHONE_SIMULATOR
#define TARGET_OS_IPHONE
#else
#define TARGET_IPHONE_SIMULATOR 1
#undef TARGET_OS_IPHONE
#endif
Put that somewhere convenient, and then pretend that the TARGET_* constants were defined correctly.
To include all types of "simulators"
NSString *model = [[UIDevice currentDevice] model];
if([model rangeOfString:#"Simulator" options:NSCaseInsensitiveSearch].location !=NSNotFound)
{
// we are running in a simulator
}
With Swift 4.2 (Xcode 10), we can do this
#if targetEnvironment(simulator)
//simulator code
#else
#warning("Not compiling for simulator")
#endif
My answer is based on #Daniel Magnusson answer and comments of #Nuthatch and #n.Drake. and I write it to save some time for swift users working on iOS9 and onwards.
This is what worked for me:
if UIDevice.currentDevice().name.hasSuffix("Simulator"){
//Code executing on Simulator
} else{
//Code executing on Device
}
/// Returns true if its simulator and not a device
public static var isSimulator: Bool {
#if (arch(i386) || arch(x86_64)) && os(iOS)
return true
#else
return false
#endif
}
Apple has added support for checking the app is targeted for the simulator with the following:
#if targetEnvironment(simulator)
let DEVICE_IS_SIMULATOR = true
#else
let DEVICE_IS_SIMULATOR = false
#endif
if nothing worked, try this
public struct Platform {
public static var isSimulator: Bool {
return TARGET_OS_SIMULATOR != 0 // Use this line in Xcode 7 or newer
}
}
This worked for me best
NSString *name = [[UIDevice currentDevice] name];
if ([name isEqualToString:#"iPhone Simulator"]) {
}
In my opinion, the answer (presented above and repeated below):
NSString *model = [[UIDevice currentDevice] model];
if ([model isEqualToString:#"iPhone Simulator"]) {
//device is simulator
}
is the best answer because it is obviously executed at RUNTIME versus being a COMPILE DIRECTIVE.

Resources