rhodes 3.4.2 → 3.5.1.12

data/platform/iphone/Classes/Reachability.h

@@ -0,0 +1,31 @@
+#import <Foundation/Foundation.h>
+#import <SystemConfiguration/SystemConfiguration.h>
+
+typedef enum {
+	NotReachable = 0,
+	ReachableViaWiFi,
+	ReachableViaWWAN
+} NetworkStatus;
+#define kReachabilityChangedNotification @"kNetworkReachabilityChangedNotification"
+
+@interface Reachability: NSObject
+{
+	BOOL localWiFiRef;
+	SCNetworkReachabilityRef reachabilityRef;
+}
+
++ (Reachability*) reachabilityWithHostName: (NSString*) hostName;
++ (Reachability*) reachabilityWithAddress: (const struct sockaddr_in*) hostAddress;
++ (Reachability*) reachabilityForInternetConnection;
++ (Reachability*) reachabilityForLocalWiFi;
+
+- (BOOL) startNotifier;
+- (void) stopNotifier;
+
+- (NetworkStatus) currentReachabilityStatus;
+//WWAN may be available, but not active until a connection has been established.
+//WiFi may require a connection for VPN on Demand.
+- (BOOL) connectionRequired;
+@end
+
+

data/platform/iphone/Classes/Reachability.m

@@ -0,0 +1,223 @@
+#import <sys/socket.h>
+#import <netinet/in.h>
+#import <netinet6/in6.h>
+#import <arpa/inet.h>
+#import <ifaddrs.h>
+#import <netdb.h>
+
+#import <CoreFoundation/CoreFoundation.h>
+
+#import "Reachability.h"
+
+//#define kShouldPrintReachabilityFlags 1
+
+static void PrintReachabilityFlags(SCNetworkReachabilityFlags    flags, const char* comment)
+{
+#if kShouldPrintReachabilityFlags
+	
+    NSLog(@"Reachability Flag Status: %c%c %c%c%c%c%c%c%c %s\n",
+			(flags & kSCNetworkReachabilityFlagsIsWWAN)				  ? 'W' : '-',
+			(flags & kSCNetworkReachabilityFlagsReachable)            ? 'R' : '-',
+			
+			(flags & kSCNetworkReachabilityFlagsTransientConnection)  ? 't' : '-',
+			(flags & kSCNetworkReachabilityFlagsConnectionRequired)   ? 'c' : '-',
+			(flags & kSCNetworkReachabilityFlagsConnectionOnTraffic)  ? 'C' : '-',
+			(flags & kSCNetworkReachabilityFlagsInterventionRequired) ? 'i' : '-',
+			(flags & kSCNetworkReachabilityFlagsConnectionOnDemand)   ? 'D' : '-',
+			(flags & kSCNetworkReachabilityFlagsIsLocalAddress)       ? 'l' : '-',
+			(flags & kSCNetworkReachabilityFlagsIsDirect)             ? 'd' : '-',
+			comment
+			);
+#endif
+}
+
+
+@implementation Reachability
+static void ReachabilityCallback(SCNetworkReachabilityRef target, SCNetworkReachabilityFlags flags, void* info)
+{
+	#pragma unused (target, flags)
+	NSCAssert(info != NULL, @"info was NULL in ReachabilityCallback");
+	NSCAssert([(NSObject*) info isKindOfClass: [Reachability class]], @"info was wrong class in ReachabilityCallback");
+
+	NSAutoreleasePool* myPool = [[NSAutoreleasePool alloc] init];
+	
+	Reachability* noteObject = (Reachability*) info;
+	[[NSNotificationCenter defaultCenter] postNotificationName: kReachabilityChangedNotification object: noteObject];
+	
+	[myPool release];
+}
+
+- (BOOL) startNotifier
+{
+	BOOL retVal = NO;
+	SCNetworkReachabilityContext	context = {0, self, NULL, NULL, NULL};
+	if(SCNetworkReachabilitySetCallback(reachabilityRef, ReachabilityCallback, &context))
+	{
+		if(SCNetworkReachabilityScheduleWithRunLoop(reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode))
+		{
+			retVal = YES;
+		}
+	}
+	return retVal;
+}
+
+- (void) stopNotifier
+{
+	if(reachabilityRef!= NULL)
+	{
+		SCNetworkReachabilityUnscheduleFromRunLoop(reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
+	}
+}
+
+- (void) dealloc
+{
+	[self stopNotifier];
+	if(reachabilityRef!= NULL)
+	{
+		CFRelease(reachabilityRef);
+	}
+	[super dealloc];
+}
+
++ (Reachability*) reachabilityWithHostName: (NSString*) hostName;
+{
+	Reachability* retVal = NULL;
+	SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithName(NULL, [hostName UTF8String]);
+	if(reachability!= NULL)
+	{
+		retVal= [[[self alloc] init] autorelease];
+		if(retVal!= NULL)
+		{
+			retVal->reachabilityRef = reachability;
+			retVal->localWiFiRef = NO;
+		}
+	}
+	return retVal;
+}
+
++ (Reachability*) reachabilityWithAddress: (const struct sockaddr_in*) hostAddress;
+{
+	SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, (const struct sockaddr*)hostAddress);
+	Reachability* retVal = NULL;
+	if(reachability!= NULL)
+	{
+		retVal= [[[self alloc] init] autorelease];
+		if(retVal!= NULL)
+		{
+			retVal->reachabilityRef = reachability;
+			retVal->localWiFiRef = NO;
+		}
+	}
+	return retVal;
+}
+
++ (Reachability*) reachabilityForInternetConnection;
+{
+	struct sockaddr_in zeroAddress;
+	bzero(&zeroAddress, sizeof(zeroAddress));
+	zeroAddress.sin_len = sizeof(zeroAddress);
+	zeroAddress.sin_family = AF_INET;
+	return [self reachabilityWithAddress: &zeroAddress];
+}
+
++ (Reachability*) reachabilityForLocalWiFi;
+{
+	struct sockaddr_in localWifiAddress;
+	bzero(&localWifiAddress, sizeof(localWifiAddress));
+	localWifiAddress.sin_len = sizeof(localWifiAddress);
+	localWifiAddress.sin_family = AF_INET;
+	// IN_LINKLOCALNETNUM is defined in <netinet/in.h> as 169.254.0.0
+	localWifiAddress.sin_addr.s_addr = htonl(IN_LINKLOCALNETNUM);
+	Reachability* retVal = [self reachabilityWithAddress: &localWifiAddress];
+	if(retVal!= NULL)
+	{
+		retVal->localWiFiRef = YES;
+	}
+	return retVal;
+}
+
+#pragma mark Network Flag Handling
+
+- (NetworkStatus) localWiFiStatusForFlags: (SCNetworkReachabilityFlags) flags
+{
+	PrintReachabilityFlags(flags, "localWiFiStatusForFlags");
+
+	BOOL retVal = NotReachable;
+	if((flags & kSCNetworkReachabilityFlagsReachable) && (flags & kSCNetworkReachabilityFlagsIsDirect))
+	{
+		retVal = ReachableViaWiFi;	
+	}
+	return retVal;
+}
+
+- (NetworkStatus) networkStatusForFlags: (SCNetworkReachabilityFlags) flags
+{
+	PrintReachabilityFlags(flags, "networkStatusForFlags");
+	if ((flags & kSCNetworkReachabilityFlagsReachable) == 0)
+	{
+		// if target host is not reachable
+		return NotReachable;
+	}
+
+	BOOL retVal = NotReachable;
+	
+	if ((flags & kSCNetworkReachabilityFlagsConnectionRequired) == 0)
+	{
+		// if target host is reachable and no connection is required
+		//  then we'll assume (for now) that your on Wi-Fi
+		retVal = ReachableViaWiFi;
+	}
+	
+	
+	if ((((flags & kSCNetworkReachabilityFlagsConnectionOnDemand ) != 0) ||
+		(flags & kSCNetworkReachabilityFlagsConnectionOnTraffic) != 0))
+	{
+			// ... and the connection is on-demand (or on-traffic) if the
+			//     calling application is using the CFSocketStream or higher APIs
+
+			if ((flags & kSCNetworkReachabilityFlagsInterventionRequired) == 0)
+			{
+				// ... and no [user] intervention is needed
+				retVal = ReachableViaWiFi;
+			}
+		}
+	
+	if ((flags & kSCNetworkReachabilityFlagsIsWWAN) == kSCNetworkReachabilityFlagsIsWWAN)
+	{
+		// ... but WWAN connections are OK if the calling application
+		//     is using the CFNetwork (CFSocketStream?) APIs.
+		retVal = ReachableViaWWAN;
+	}
+	return retVal;
+}
+
+- (BOOL) connectionRequired;
+{
+	NSAssert(reachabilityRef != NULL, @"connectionRequired called with NULL reachabilityRef");
+	SCNetworkReachabilityFlags flags;
+	if (SCNetworkReachabilityGetFlags(reachabilityRef, &flags))
+	{
+		return (flags & kSCNetworkReachabilityFlagsConnectionRequired);
+	}
+	return NO;
+}
+
+- (NetworkStatus) currentReachabilityStatus
+{
+	NSAssert(reachabilityRef != NULL, @"currentNetworkStatus called with NULL reachabilityRef");
+	NetworkStatus retVal = NotReachable;
+	SCNetworkReachabilityFlags flags;
+	if (SCNetworkReachabilityGetFlags(reachabilityRef, &flags))
+	{
+		if(localWiFiRef)
+		{
+			retVal = [self localWiFiStatusForFlags: flags];
+		}
+		else
+		{
+			retVal = [self networkStatusForFlags: flags];
+		}
+	}
+	return retVal;
+}
+@end

data/platform/iphone/Classes/RhoMainView.h

@@ -43,6 +43,7 @@
 - (void)executeJs:(NSString*)js tab:(int)index;
 
 - (NSString*)currentLocation:(int)index;
+- (NSString*)get_current_url:(int)index;
 
 - (void)switchTab:(int)index;
 - (int)activeTab;

data/platform/iphone/Classes/RhoViewController.m

@@ -35,4 +35,20 @@
 	return YES;
 }
 
+#ifdef __IPHONE_6_0
+- (BOOL)shouldAutorotate {
+    if ([[Rhodes sharedInstance] isRotationLocked])
+        return NO;
+	return YES;
+}
+
+
+- (NSUInteger)supportedInterfaceOrientations
+{
+     if ([[Rhodes sharedInstance] isRotationLocked])
+         return UIInterfaceOrientationMaskPortrait;
+    return UIInterfaceOrientationMaskAll;
+}
+#endif
+
 @end

data/platform/iphone/Classes/Rhodes.h

@@ -39,6 +39,7 @@
 #import "PickImageDelegate.h"
 #import "SignatureDelegate.h"
 #import "NVDelegate.h"
+#import "NetworkStatusMonitor.h"
 
 @interface Rhodes : NSObject <UIApplicationDelegate,
     UITabBarControllerDelegate, AVAudioPlayerDelegate, UIAlertViewDelegate>
@@ -58,6 +59,7 @@
 	NVDelegate* nvDelegate;
 #ifdef __IPHONE_4_0
     EKEventStore *eventStore;
+	__block UIBackgroundTaskIdentifier syncBackgroundTask;
 #endif
 	
     id<RhoMainView,NSObject> mainView;

data/platform/iphone/Classes/Rhodes.m

@@ -41,7 +41,7 @@
 #include "common/app_build_capabilities.h"
 
 #include "InitMemoryInfoCollector.h"
-
+#include "Reachability.h"
 
 
 /*
@@ -138,7 +138,20 @@ static Rhodes *instance = NULL;
     //CGRect sbFrame = [[UIApplication sharedApplication] statusBarFrame];
     //frame.origin.y += sbFrame.size.height;
     //frame.size.height -= sbFrame.size.height;
-    return frame;
+    
+    //CGRect screen_bounds = [[UIScreen mainScreen] bounds];
+
+    CGRect appFrame = [[UIScreen mainScreen] applicationFrame];
+    UIDeviceOrientation orientation = [[UIApplication sharedApplication] statusBarOrientation];
+    if (UIDeviceOrientationLandscapeLeft == orientation ||
+        UIDeviceOrientationLandscapeRight == orientation)
+    {
+        if (appFrame.size.width < appFrame.size.height)
+        {
+            appFrame = CGRectMake(appFrame.origin.y, appFrame.origin.x, appFrame.size.height, appFrame.size.width);
+        }
+    }
+    return appFrame;//frame;
 }
 
 
@@ -453,7 +466,8 @@ static Rhodes *instance = NULL;
         [splashViewController release];
         splashViewController = nil;
 		
-		[window addSubview:mainView.view];
+		//[window addSubview:mainView.view];
+        window.rootViewController = mainView;
 		[window bringSubviewToFront:mainView.view];
     }
 }
@@ -499,7 +513,14 @@ static Rhodes *instance = NULL;
 	}
 	
     mainView = [view retain];
-    [window addSubview:mainView.view];
+    //[window addSubview:mainView.view];
+    
+    //[window setRootViewController:mainView];
+    
+    window.rootViewController = mainView;
+    
+    
+    
 	//[window bringSubviewToFront:mainView.view];
 	
 	if (isVerticalTab) {
@@ -588,6 +609,10 @@ static Rhodes *instance = NULL;
         app_created = YES;
         
         rotationLocked = rho_conf_getBool("disable_screen_rotation");
+		
+		NSLog(@"Init network monitor");
+		initNetworkMonitoring();
+		[self performSelectorInBackground:@selector(monitorNetworkStatus) withObject:nil];
         
         NSLog(@"Show loading page");
         [self performSelectorOnMainThread:@selector(showLoadingPagePost) withObject:nil waitUntilDone:NO];
@@ -595,7 +620,7 @@ static Rhodes *instance = NULL;
         NSLog(@"Start rhodes app");
         rho_rhodesapp_start();
 		rho_rhodesapp_callUiCreatedCallback();
-    }
+	}
     @finally {
         [pool release];
     }
@@ -632,7 +657,8 @@ static Rhodes *instance = NULL;
 	BOOL is_splash_screen_maked = [self showLoadingPagePre];
 	
 	if (!is_splash_screen_maked) {
-		[window addSubview:mainView.view];
+        window.rootViewController = mainView;
+		//[window addSubview:mainView.view];
 	}
 	
     [window makeKeyAndVisible];
@@ -659,11 +685,22 @@ static Rhodes *instance = NULL;
     [[UIApplication sharedApplication] registerForRemoteNotificationTypes:
      (UIRemoteNotificationTypeBadge | UIRemoteNotificationTypeAlert | UIRemoteNotificationTypeSound)];
 #endif //__IPHONE_3_0
-#endif //APP_BUILD_CAPABILITY_PUSH    
-    
+#endif //APP_BUILD_CAPABILITY_PUSH
+        
     NSLog(@"Initialization finished");
 }
 
+- (void) monitorNetworkStatus
+{
+	while(true)
+	{
+		[NSThread sleepForTimeInterval:getNetworkStatusPollInterval()];
+		Reachability* r = [Reachability reachabilityForInternetConnection];
+		networkStatusNotify([r currentReachabilityStatus]==NotReachable?0:1);
+		[r release];
+	}
+}
+
 #ifdef __IPHONE_3_0
 - (void)processDoSync:(NSDictionary *)userInfo
 {
@@ -686,7 +723,7 @@ static Rhodes *instance = NULL;
 		}
 		
 		if (sync_all) {
-			rho_sync_doSyncAllSources(TRUE,"");
+			rho_sync_doSyncAllSources(TRUE,"",false);
 		}
 	}
 }
@@ -940,7 +977,11 @@ static Rhodes *instance = NULL;
         */
         //exit(EXIT_SUCCESS);
     }
-    if (!rho_can_app_started_with_current_licence()) {
+    if (!rho_can_app_started_with_current_licence(
+               get_app_build_config_item("motorola_license"),
+               get_app_build_config_item("motorola_license_company"),
+               get_app_build_config_item("name")))
+    {
 		NSLog(@"############################");
 		NSLog(@" ");
 		NSLog(@"ERROR: motorola_license is INVALID !");
@@ -1025,6 +1066,12 @@ static Rhodes *instance = NULL;
 
 - (void)applicationDidBecomeActive:(UIApplication *)application {
     RAWLOG_INFO("Application did become active");
+	
+	if (syncBackgroundTask != UIBackgroundTaskInvalid) {
+		[application endBackgroundTask: syncBackgroundTask];
+		syncBackgroundTask = UIBackgroundTaskInvalid;
+	}
+	
     if (!app_created) {
         NSLog(@"Application is not created yet so postpone activation callback");
         [NSThread detachNewThreadSelector:@selector(doRhoActivate) toTarget:self withObject:nil];
@@ -1045,6 +1092,38 @@ static Rhodes *instance = NULL;
     RAWLOG_INFO("Application go to background");
     rho_rhodesapp_callUiDestroyedCallback();
     rho_rhodesapp_canstartapp("", ", ");
+	
+	if (rho_conf_getBool("finish_sync_in_background")/* && (rho_sync_issyncing()==1)*/) {
+		if ([[UIDevice currentDevice] respondsToSelector:@selector(isMultitaskingSupported)]) { 
+			if ([[UIDevice currentDevice] isMultitaskingSupported]) { //Check if device supports mulitasking 
+
+				syncBackgroundTask = [application beginBackgroundTaskWithExpirationHandler: ^ { 
+					NSLog(@"$$$ Background task is terminated by System !!!");
+					[application endBackgroundTask: syncBackgroundTask]; //Tell the system that we are done with the tasks 
+					syncBackgroundTask = UIBackgroundTaskInvalid; //Set the task to be invalid 
+				}]; 
+				
+				NSLog(@"Will wait sync thread to finish sync");
+				
+				dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
+					
+					NSLog(@"Waiting for sync thread");
+					
+					do 
+					{
+						NSLog(@"Check sync");
+						[NSThread sleepForTimeInterval:1];
+					}while (rho_sync_issyncing()==1);
+
+					NSLog(@"Sync is finished");
+					
+					[application endBackgroundTask: syncBackgroundTask]; //End the task so the system knows that you are done with what you need to perform 
+					syncBackgroundTask = UIBackgroundTaskInvalid; //Invalidate the background_task 
+					
+				}); 
+			}
+		}
+	}
 }
 
 - (void)applicationWillEnterForeground:(UIApplication *)application {