rhodes 2.2.6 → 2.3.0.beta.1

data/platform/android/Rhodes/src/com/rhomobile/rhodes/RhodesService.java

@@ -2,14 +2,19 @@ package com.rhomobile.rhodes;
 
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLConnection;
 import java.util.Calendar;
 import java.util.Enumeration;
-import java.util.Iterator;
-import java.util.List;
 import java.util.Locale;
-import java.util.Map;
 import java.util.Set;
 import java.util.TimeZone;
+import java.util.UUID;
 import java.util.Vector;
 
 import com.rhomobile.rhodes.alert.Alert;
@@ -27,131 +32,118 @@ import com.rhomobile.rhodes.uri.TelUriHandler;
 import com.rhomobile.rhodes.uri.UriHandler;
 import com.rhomobile.rhodes.uri.VideoUriHandler;
 import com.rhomobile.rhodes.util.PerformOnUiThread;
-import com.rhomobile.rhodes.webview.ChromeClientOld;
-import com.rhomobile.rhodes.webview.RhoWebSettings;
 
-import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.BroadcastReceiver;
 import android.content.Context;
+import android.content.DialogInterface;
 import android.content.Intent;
+import android.content.IntentFilter;
 import android.content.pm.ActivityInfo;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
-import android.graphics.Bitmap;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 import android.net.Uri;
+import android.os.Binder;
 import android.os.Build;
 import android.os.Bundle;
-import android.os.Handler;
+import android.os.IBinder;
 import android.os.PowerManager;
-import android.os.Process;
 import android.telephony.TelephonyManager;
 import android.util.DisplayMetrics;
 import android.util.Log;
 import android.view.Display;
-import android.view.View;
-import android.view.ViewGroup;
-import android.view.Window;
 import android.view.WindowManager;
-import android.webkit.WebChromeClient;
 import android.webkit.WebSettings;
 import android.webkit.WebView;
-import android.webkit.WebViewClient;
+import android.widget.RemoteViews;
 
-public class RhodesService {
+public class RhodesService extends Service {
 	
-	private final static String TAG = "RhodesService";
-
-	public static final String INTENT_EXTRA_PREFIX = "com.rhomobile.rhodes.";
+	private static final String TAG = RhodesService.class.getSimpleName();
 	
-	public static final int RHO_SPLASH_VIEW = 1;
-	public static final int RHO_MAIN_VIEW = 2;
-	public static final int RHO_TOOLBAR_VIEW = 3;
+	private static final boolean DEBUG = false;
 	
-	private static final String RHO_START_PARAMS_KEY = "RhoStartParams";
+	public static final String INTENT_EXTRA_PREFIX = "com.rhomobile.rhodes.";
 	
-	private static RhodesService instance = null;
+	public static final String INTENT_SOURCE = INTENT_EXTRA_PREFIX + ".intent.source";
 	
-	public static RhodesService getInstance() {
-		return instance;
-	}
+	public static int WINDOW_FLAGS = WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN;
+	public static int WINDOW_MASK = WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN;
 	
-	private Activity ctx;
+	private static final int DOWNLOAD_PACKAGE_ID = 1;
 	
-	public Context getContext() {
-		return ctx;
-	}
+	private static final String ACTION_ASK_CANCEL_DOWNLOAD = "com.rhomobile.rhodes.DownloadManager.ACTION_ASK_CANCEL_DOWNLOAD";
+	private static final String ACTION_CANCEL_DOWNLOAD = "com.rhomobile.rhodes.DownloadManager.ACTION_CANCEL_DOWNLOAD";
 	
-	public Activity getMainActivity() {
-		return ctx;
-	}
+	private static RhodesService sInstance;
 	
-	public static void platformLog(String _tag, String _message) {
-		StringBuilder s = new StringBuilder();
-		s.append("ms[");
-		s.append(System.currentTimeMillis());
-		s.append("] ");
-		s.append(_message);
-		android.util.Log.v(_tag, s.toString());
-	}
+	private final IBinder mBinder = new LocalBinder();
 	
-	private RhoLogConf m_rhoLogConf = new RhoLogConf();
-	public RhoLogConf getLogConf() {
-		return m_rhoLogConf;
-	}
+	@SuppressWarnings("rawtypes")
+	private static final Class[] mStartForegroundSignature = new Class[] {int.class, Notification.class};
+	@SuppressWarnings("rawtypes")
+	private static final Class[] mStopForegroundSignature = new Class[] {boolean.class};
 	
-	private boolean needGeoLocationRestart = false;
+	private Method mStartForeground;
+	private Method mStopForeground;
 	
-	private int activitiesActive = 0;
+	private NotificationManager mNM;
 	
-	public static int WINDOW_FLAGS = WindowManager.LayoutParams.FLAG_FULLSCREEN;
-	public static int WINDOW_MASK = WindowManager.LayoutParams.FLAG_FULLSCREEN;
+	//private MainView mMainView;
 	
-	public static boolean ENABLE_LOADING_INDICATION = true;
+	private static int mScreenWidth;
+	private static int mScreenHeight;
+	private static int mScreenOrientation;
 	
-	public static int MAX_PROGRESS = 10000;
-	
-	private long uiThreadId = 0;
-	
-	public long getUiThreadId() {
-		return uiThreadId;
-	}
+	private static float mScreenPpiX;
+	private static float mScreenPpiY;
 	
-	public void setInfo(Activity c, long id, Handler handler) {
-		ctx = c;
-		uiThreadId = id;
-		uiHandler = handler;
-		//RhoBluetoothManager.sharedInstance();
-	}
+	private static boolean mCameraAvailable;
 	
-	private Handler uiHandler;
+	private static int sActivitiesActive;
 	
-	public void post(Runnable r) {
-		uiHandler.post(r);
+	private static int mGeoLocationInactivityTimeout;
+
+	public static int getGeoLocationInactivityTimeout() {
+		return mGeoLocationInactivityTimeout;
 	}
 	
-	public void post(Runnable r, int delay) {
-		uiHandler.postDelayed(r, delay);
+	private RhoLogConf m_rhoLogConf = new RhoLogConf();
+	public RhoLogConf getLogConf() {
+		return m_rhoLogConf;
 	}
 	
-	private static int screenWidth;
-	private static int screenHeight;
-	private static int screenOrientation;
+	private boolean mNeedGeoLocationRestart = false;
 	
-	private static float screenPpiX;
-	private static float screenPpiY;
-	
-	private static boolean isCameraAvailable;
-	
-	private WebChromeClient chromeClient;
-	private RhoWebSettings webSettings;
+	static PowerManager.WakeLock wakeLockObject = null;
+	static boolean wakeLockEnabled = false;
 	
-	private SplashScreen splashScreen = null;
+	private Vector<UriHandler> mUriHandlers = new Vector<UriHandler>();
 	
-	private ViewGroup outerFrame = null;
-	private MainView mainView;
+	public boolean handleUrlLoading(String url) {
+		Enumeration<UriHandler> e = mUriHandlers.elements();
+		while (e.hasMoreElements()) {
+			UriHandler handler = e.nextElement();
+			try {
+				if (handler.handle(url))
+					return true;
+			}
+			catch (Exception ex) {
+				Logger.E(TAG, ex.getMessage());
+				continue;
+			}
+		}
+		
+		return false;
+	}
 	
 	private native void initClassLoader(ClassLoader c);
 	
@@ -161,85 +153,44 @@ public class RhodesService {
 	public native void doSyncAllSources(boolean v);
 	public native void doSyncSource(String source);
 	
-	public native String getOptionsUrl();
-	public native String getStartUrl();
-	public native String getCurrentUrl();
-	public native String getAppBackUrl();
-	
-	public static native String getBlobPath();
-	
 	public native String normalizeUrl(String url);
 	
-	public static native String getBuildConfig(String key);
+	public native void doRequest(String url);
 	
 	public static native void loadUrl(String url);
 	
 	public static native void navigateBack();
 	
-	public native void doRequest(String url);
+	private String mRootPath;
+	private native void nativeInitPath(String rootPath, String sqliteJournalsPath, String apkPath);
 	
-	public native void callActivationCallback(boolean active);
+	public static native void onScreenOrientationChanged(int width, int height, int angle);
 	
-	public native static void makeLink(String src, String dst);
+	public native void callUiCreatedCallback();
+	public native void callUiDestroyedCallback();
+	public native void callActivationCallback(boolean active);
 	
-	public static native void onScreenOrientationChanged(int width, int height, int angle);
+	public static native String getBuildConfig(String key);
 	
-	private String rootPath = null;
-	private native void nativeInitPath(String rootPath, String sqliteJournalsPath, String apkPath);
+	public static native boolean isOnStartPage();
 	
-	static PowerManager.WakeLock wakeLockObject = null;
-	static boolean wakeLockEnabled = false;
+	public static native boolean canStartApp(String strCmdLine, String strSeparators);
 	
-	public static int rho_sys_set_sleeping(int enable) {
-		Logger.I(TAG, "rho_sys_set_sleeping("+enable+")");
-		int wasEnabled = 1;
-		if (wakeLockObject != null) {
-			wasEnabled = 0;
-		}
-		if (enable != 0) {
-			// disable lock device
-			PerformOnUiThread.exec( new Runnable() {
-				public void run() {
-					if (wakeLockObject != null) {
-						wakeLockObject.release();
-						wakeLockObject = null;
-						wakeLockEnabled = false;
-					}
-				}
-			}, false);
-		}
-		else {
-			// lock device from sleep
-			PerformOnUiThread.exec( new Runnable() {
-				public void run() {
-					if (wakeLockObject == null) {
-						PowerManager pm = (PowerManager)getInstance().getContext().getSystemService(Context.POWER_SERVICE);
-						if (pm != null) {
-							wakeLockObject = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP, TAG);
-							wakeLockObject.acquire();
-							wakeLockEnabled = true;
-						}
-						else {
-							Logger.E(TAG, "rho_sys_set_sleeping() - Can not get PowerManager !!!");
-						}
-					}
-				}
-			}, false);
-		}
-		return wasEnabled;
+	public static RhodesService getInstance() {
+		return sInstance;
 	}
 	
 	private void initRootPath() {
 		ApplicationInfo appInfo = getAppInfo();
 		String dataDir = appInfo.dataDir;
 		
-		rootPath = dataDir + "/rhodata/";
-		Log.d(TAG, "Root path: " + rootPath);
+		mRootPath = dataDir + "/rhodata/";
+		Log.d(TAG, "Root path: " + mRootPath);
 		
 		String sqliteJournalsPath = dataDir + "/sqlite_stmt_journals/";
 		Log.d(TAG, "Sqlite journals path: " + sqliteJournalsPath);
 		
-		File f = new File(rootPath);
+		File f = new File(mRootPath);
 		f.mkdirs();
 		f = new File(f, "db/db-files");
 		f.mkdirs();
@@ -248,464 +199,325 @@ public class RhodesService {
 		
 		String apkPath = appInfo.sourceDir;
 		
-		nativeInitPath(rootPath, sqliteJournalsPath, apkPath);
+		nativeInitPath(mRootPath, sqliteJournalsPath, apkPath);
+	}
+	
+	public String getRootPath() {
+		return mRootPath;
 	}
 	
 	private ApplicationInfo getAppInfo() {
-		String pkgName = ctx.getPackageName();
+		Context context = this;
+		String pkgName = context.getPackageName();
 		try {
-			ApplicationInfo info = ctx.getPackageManager().getApplicationInfo(pkgName, 0);
+			ApplicationInfo info = context.getPackageManager().getApplicationInfo(pkgName, 0);
 			return info;
 		} catch (NameNotFoundException e) {
 			throw new RuntimeException("Internal error: package " + pkgName + " not found: " + e.getMessage());
 		}
 	}
 	
-	public String getRootPath() {
-		return rootPath;
-	}
-	
-	private Vector<UriHandler> uriHandlers = new Vector<UriHandler>();
-	
-	private boolean handleUrlLoading(String url) {
-		Enumeration<UriHandler> e = uriHandlers.elements();
-		while (e.hasMoreElements()) {
-			UriHandler handler = e.nextElement();
-			try {
-				if (handler.handle(url))
-					return true;
-			}
-			catch (Exception ex) {
-				Logger.E(TAG, ex.getMessage());
-				continue;
-			}
+	public class LocalBinder extends Binder {
+		RhodesService getService() {
+			return RhodesService.this;
 		}
-		
-		return false;
-	}
+	};
 
-	private static int mGeoLocationInactivityTimeout;
-
-	public static int getGeoLocationInactivityTimeout() {
-		return mGeoLocationInactivityTimeout;
+	@Override
+	public IBinder onBind(Intent intent) {
+		if (DEBUG)
+			Log.d(TAG, "+++ onBind");
+		return mBinder;
 	}
 	
-	public static SplashScreen showSplashScreen(Context ctx, ViewGroup myOuterFrame) {
-		SplashScreen splashScreen = new SplashScreen(ctx);
-		splashScreen.start(myOuterFrame);
-		return splashScreen;
-	}
-
-	public void hideSplashScreen() {
-		PerformOnUiThread.exec(new Runnable() {
-					public void run() {
-		if (splashScreen != null) {
-			splashScreen.hide(outerFrame);
-			splashScreen = null;
-		}
-		View view = mainView.getView();
-		view.setVisibility(View.VISIBLE);
-		view.requestFocus();
-		}
-				}, false);
-	}
-	
-	public static WebView createLoadingWebView(Context ctx) {
-		WebView w = new WebView(ctx);
-		
-		//webSettings.setWebSettings(w);
-		
-		w.clearCache(true);
-
-		w.setWebViewClient(new WebViewClient() {
-			
-			private boolean splashHidden = false;
-			private boolean setupExecuted = false;
-			
-			@Override
-			public void onPageStarted(WebView view, String url, Bitmap favicon) {
-				super.onPageStarted(view, url, favicon);
-			}
-			
-			@Override
-			public void onPageFinished(WebView view, String url) {
-				RhodesService rs = RhodesService.getInstance();
-				if (rs != null) {
-					if (!splashHidden && url.startsWith("http://")) {
-						rs.hideSplashScreen();
-						splashHidden = true;
-					}
-				}
-				//if (ENABLE_LOADING_INDICATION)
-				Rhodes.getInstance().getWindow().setFeatureInt(Window.FEATURE_PROGRESS, MAX_PROGRESS);
-				super.onPageFinished(view, url);
-				if (!setupExecuted) {
-					Rhodes.runPostponedSetup();
-					setupExecuted = true;
-				}
-				
-			}
-
-		});
-		
-		//w.setWebChromeClient(chromeClient);
-		
-		return w;
-	
-	}
-	
-	public WebView createWebView() {
-		WebView w = new WebView(ctx);
+	@Override
+	public void onCreate() {
+		if (DEBUG)
+			Log.d(TAG, "+++ onCreate");
 		
-		webSettings.setWebSettings(w);
+		sInstance = this;
 		
-		w.clearCache(true);
-
-		w.setWebViewClient(new WebViewClient() {
-			
-			private boolean splashHidden = false;
-
-			@Override
-			public boolean shouldOverrideUrlLoading(WebView view, String url) {
-				return handleUrlLoading(url);
-			}
-			
-			@Override
-			public void onPageStarted(WebView view, String url, Bitmap favicon) {
-				Rhodes r = Rhodes.getInstance();
-				if (ENABLE_LOADING_INDICATION)
-					r.getWindow().setFeatureInt(Window.FEATURE_PROGRESS, 0);
-				super.onPageStarted(view, url, favicon);
-			}
-			
-			@Override
-			public void onPageFinished(WebView view, String url) {
-				// Set title
-				Rhodes r = Rhodes.getInstance();
-				String title = view.getTitle();
-				r.setTitle(title);
-				// Hide splash screen
-				if (!splashHidden && url.startsWith("http://")) {
-					hideSplashScreen();
-					splashHidden = true;
-				}
-				//if (ENABLE_LOADING_INDICATION)
-					r.getWindow().setFeatureInt(Window.FEATURE_PROGRESS, MAX_PROGRESS);
-				super.onPageFinished(view, url);
-			}
-
-		});
+		Context context = this;
 		
-		w.setWebChromeClient(chromeClient);
+		mNM = (NotificationManager)context.getSystemService(Context.NOTIFICATION_SERVICE);
 		
-		return w;
-	}
-	
-	private void initWebStuff() {
-		String ccName;
-		String wsName;
-		int sdkVersion = Integer.parseInt(Build.VERSION.SDK);
-		if (sdkVersion < Build.VERSION_CODES.ECLAIR_MR1) {
-			ccName = "ChromeClientOld";
-			wsName = "RhoWebSettingsOld";
-		}
-		else {
-			ccName = "ChromeClientNew";
-			wsName = "RhoWebSettingsNew";
-		}
-		
-		try {
-			String pkgname = ChromeClientOld.class.getPackage().getName();
-			String fullName = pkgname + "." + ccName;
-			Class<? extends WebChromeClient> ccClass =
-				Class.forName(fullName).asSubclass(WebChromeClient.class);
-			chromeClient = ccClass.newInstance();
-			
-			pkgname = RhoWebSettings.class.getPackage().getName();
-			fullName = pkgname + "." + wsName;
-			Class<? extends RhoWebSettings> wsClass =
-				Class.forName(fullName).asSubclass(RhoWebSettings.class);
-			webSettings = wsClass.newInstance();
-		}
-		catch (Exception e) {
-			throw new IllegalStateException(e);
-		}
-	}
-	
-	public void setMainView(MainView v) {
-		View main = outerFrame.findViewById(RHO_MAIN_VIEW);
-		if (main != null)
-			outerFrame.removeView(main);
-		mainView = v;
-		main = mainView.getView();
-		if (outerFrame.findViewById(RHO_SPLASH_VIEW) != null)
-			main.setVisibility(View.INVISIBLE);
-		outerFrame.addView(main);
-	}
-	
-	public MainView getMainView() {
-		return mainView;
-	}
-	
-	public void setRootWindow(ViewGroup rootWindow) {
-		if (rootWindow == outerFrame)
-			return;
-		if (outerFrame != null)
-			outerFrame.removeAllViews();
-		outerFrame = rootWindow;
-		outerFrame.addView(mainView.getView());
-	}
-	
-	public static boolean isCreated() {
-		return instance != null;
-	}
-	
-	public RhodesService(Activity c, ViewGroup rootWindow, SplashScreen splash_s, Object params) {
-	
-		ctx = c;
-		instance = this;
-		outerFrame = rootWindow;
-
-		//showSplashScreen();
-		splashScreen = splash_s;
+		initClassLoader(context.getClassLoader());
 		
-		initClassLoader(ctx.getClassLoader());
-
 		try {
 			initRootPath();
 			RhoFileApi.init();
 		} catch (IOException e) {
 			Log.e(TAG, e.getMessage());
-			exitApp();
+			exit();
 			return;
 		}
 		
 		if (Utils.isAppHashChanged()) {
 			try {
 				Log.i(TAG, "Application hash was changed, so remove files");
+				Utils.deleteChildrenIgnoreFirstLevel(new File(getRootPath(), "apps"), "rhoconfig.txt");
+				Utils.deleteRecursively(new File(getRootPath(), "lib"));
+/*				
 				String[] folders = {"apps", "lib"};
 				for (String folder : folders) {
-					File f = new File(rootPath, folder);
+					File f = new File(getRootPath(), folder);
 					if (!f.exists())
 						continue;
 					Utils.deleteRecursively(f);
-				}
+				}*/
 				initRootPath();
 				RhoFileApi.init();
 				RhoFileApi.copy("hash");
 			} catch (IOException e) {
 				Log.e(TAG, e.getMessage());
-				exitApp();
+				exit();
 				return;
 			}
 		}
 		
 		createRhodesApp();
 		
-		/*
-		boolean rhoGalleryApp = false;
-		if (params != null && params instanceof Bundle) {
-			Bundle startParams = (Bundle)params;
-			String v = startParams.getString("rhogallery_app");
-			if (v != null && v.equals("1"))
-				rhoGalleryApp = true;
-		}
-		if (!rhoGalleryApp && RhoConf.getBool("rhogallery_only_app")) {
-			Logger.E(TAG, "This is RhoGallery only app and can be started only from RhoGallery");
-			exitApp();
-		}
-		*/
-		boolean can_start = true;
-		String security_token = getBuildConfig("security_token"); 
-		if (security_token != null) {
-			if (security_token.length() > 0) {
-				can_start = false;
-				if (params != null && params instanceof Bundle) {
-					Bundle startParams = (Bundle)params;
-					String rho_start_params = startParams.getString(RHO_START_PARAMS_KEY);
-					if (rho_start_params != null) {
-						String security_token_key = "sequrity_token=";
-						int sec_index = rho_start_params.indexOf(security_token_key);
-						if (sec_index >= 0) {
-							String tmp = rho_start_params.substring(sec_index + security_token_key.length(), rho_start_params.length() - sec_index - security_token_key.length());
-							int end_of_token = tmp.indexOf(",");
-							if (end_of_token >= 0) {
-								tmp = tmp.substring(0, end_of_token);
-							}
-							end_of_token = tmp.indexOf(" ");
-							if (end_of_token >= 0) {
-								tmp = tmp.substring(0, end_of_token);
-							}
-							if (tmp.equals(security_token)) {
-								can_start = true;
-							}
-						}
-					}
-				}
-			}
-		}
-		if (!can_start) {
-			Logger.E(TAG, "SECURITY_TOKEN parameter is not valid for this application !");
-			exitApp();
-		}
+		RhodesActivity ra = RhodesActivity.getInstance();
+		SplashScreen splashScreen = ra.getSplashScreen();
+		splashScreen.start();
 		
-		boolean fullScreen = true;
-		if (RhoConf.isExist("full_screen"))
-			fullScreen = RhoConf.getBool("full_screen");
-		if (!fullScreen) {
-			WINDOW_FLAGS = WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN;
-			WINDOW_MASK = WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN;
-		}
+		initForegroundServiceApi();
 		
-		ENABLE_LOADING_INDICATION = !RhoConf.getBool("disable_loading_indication");
+		setFullscreenParameters();
 		
-		initWebStuff();
-
 		Logger.I("Rhodes", "Loading...");
-		//showSplashScreen();
-		if (splashScreen != null) {
-			splashScreen.rho_start();
-		}
 		
 		// Increase WebView rendering priority
-		WebView w = new WebView(ctx);
+		WebView w = new WebView(context);
 		WebSettings webSettings = w.getSettings();
 		webSettings.setRenderPriority(WebSettings.RenderPriority.HIGH);
 		
 		// Get screen width/height
-		WindowManager wm = (WindowManager)ctx.getSystemService(Context.WINDOW_SERVICE);
+		WindowManager wm = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
 		Display d = wm.getDefaultDisplay();
-		screenHeight = d.getHeight();
-		screenWidth = d.getWidth();
-		screenOrientation = d.getOrientation();
+		mScreenHeight = d.getHeight();
+		mScreenWidth = d.getWidth();
+		mScreenOrientation = d.getOrientation();
 		
 		DisplayMetrics metrics = new DisplayMetrics();
 		d.getMetrics(metrics);
-		screenPpiX = metrics.xdpi;
-		screenPpiY = metrics.ydpi;
+		mScreenPpiX = metrics.xdpi;
+		mScreenPpiY = metrics.ydpi;
 		
 		// TODO: detect camera availability
-		isCameraAvailable = true;
+		mCameraAvailable = true;
 		
 		mGeoLocationInactivityTimeout = RhoConf.getInt("geo_location_inactivity_timeout");
 		if (mGeoLocationInactivityTimeout == 0)
 			mGeoLocationInactivityTimeout = 25*1000; // 25s
 		
 		// Register custom uri handlers here
-		uriHandlers.addElement(new ExternalHttpHandler(ctx));
-		uriHandlers.addElement(new MailUriHandler(ctx));
-		uriHandlers.addElement(new TelUriHandler(ctx));
-		uriHandlers.addElement(new SmsUriHandler(ctx));
-		uriHandlers.addElement(new VideoUriHandler(ctx));
+		mUriHandlers.addElement(new ExternalHttpHandler(context));
+		mUriHandlers.addElement(new MailUriHandler(context));
+		mUriHandlers.addElement(new TelUriHandler(context));
+		mUriHandlers.addElement(new SmsUriHandler(context));
+		mUriHandlers.addElement(new VideoUriHandler(context));
+		
+		getRhodesApplication().addOnExitHandler(new Runnable() {
+			public void run() {
+				PerformOnUiThread.exec( new Runnable() {
+					public void run() {
+						if (wakeLockObject != null) {
+							wakeLockObject.release();
+							wakeLockObject = null;
+							wakeLockEnabled = false;
+						}
+					}
+				}, false);
+			}
+		});
 		
 		try {
-			if (Capabilities.PUSH_ENABLED)
+			if (Capabilities.PUSH_ENABLED) {
 				PushService.register();
+				
+				getRhodesApplication().addOnExitHandler(new Runnable() {
+					public void run() {
+						try {
+							PushService.unregister();
+						} catch (IllegalAccessException e) {
+							Log.e(TAG, e.getMessage());
+						}
+					}
+				});
+			}
 		} catch (IllegalAccessException e) {
 			Log.e(TAG, e.getMessage());
-			exitApp();
+			exit();
 			return;
 		}
 		
-		Thread init = new Thread(new Runnable() {
-
-			public void run() {
-				startRhodesApp();
-			}
-			
-		});
-		init.start();
+		startRhodesApp();
+		
+		if (sActivitiesActive > 0)
+			handleAppActivation();
 	}
 	
-	public void startActivity(Intent intent) {
-		ctx.startActivity(intent);
+	private void setFullscreenParameters() {
+		boolean fullScreen = true;
+		if (RhoConf.isExist("full_screen"))
+			fullScreen = RhoConf.getBool("full_screen");
+		if (fullScreen) {
+			WINDOW_FLAGS = WindowManager.LayoutParams.FLAG_FULLSCREEN;
+			WINDOW_MASK = WindowManager.LayoutParams.FLAG_FULLSCREEN;
+			RhodesActivity.setFullscreen(1);
+		}
+		else {
+			WINDOW_FLAGS = WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN;
+			WINDOW_MASK = WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN;
+			RhodesActivity.setFullscreen(0);
+		}
+		//Utils.platformLog(TAG, "rhoconfig    full_screen = "+String.valueOf(fullScreen)+" ");
 	}
-
-	public void exitApp() {
+	
+	private void initForegroundServiceApi() {
 		try {
-			if (Capabilities.PUSH_ENABLED)
-				PushService.unregister();
-		} catch (IllegalAccessException e) {
-			Log.e(TAG, e.getMessage());
+			mStartForeground = getClass().getMethod("startForeground", mStartForegroundSignature);
+			mStopForeground = getClass().getMethod("stopForeground", mStopForegroundSignature);
+		}
+		catch (NoSuchMethodException e) {
+			mStartForeground = null;
+			mStopForeground = null;
 		}
+	}
+	
+	@Override
+	public void onDestroy() {
+		if (DEBUG)
+			Log.d(TAG, "+++ onDestroy");
+		sInstance = null;
+		getRhodesApplication().exit();
+	}
+	
+	@Override
+	public void onStart(Intent intent, int startId) {
+		if (DEBUG)
+			Log.d(TAG, "+++ onStart");
+		try {
+			handleCommand(intent);
+		}
+		catch (Exception e) {
+			Logger.E(TAG, "Can't handle service command: " + e.getMessage());
+		}
+	}
+	
+	@Override
+	public int onStartCommand(Intent intent, int flags, int startId) {
+		if (DEBUG)
+			Log.d(TAG, "+++ onStartCommand");
+		try {
+			handleCommand(intent);
+		}
+		catch (Exception e) {
+			Logger.E(TAG, "Can't handle service command: " + e.getMessage());
+		}
+		return Service.START_STICKY;
+	}
+	
+	private void handleCommand(Intent intent) {
+		String source = intent.getStringExtra(INTENT_SOURCE);
+		if (source == null)
+			throw new IllegalArgumentException("Service command received from empty source");
 		
-		PerformOnUiThread.exec( new Runnable() {
-			public void run() {
-				if (wakeLockObject != null) {
-					wakeLockObject.release();
-					wakeLockObject = null;
-					wakeLockEnabled = false;
-				}
+		Logger.D(TAG, "Service command received from " + source);
+		if (source.equals(PushReceiver.INTENT_SOURCE)) {
+			int type = intent.getIntExtra(PushReceiver.INTENT_TYPE, PushReceiver.INTENT_TYPE_UNKNOWN);
+			switch (type) {
+			case PushReceiver.INTENT_TYPE_REGISTRATION_ID:
+				String id = intent.getStringExtra(PushReceiver.INTENT_REGISTRATION_ID);
+				if (id == null)
+					throw new IllegalArgumentException("Empty registration id received in service command");
+				setPushRegistrationId(id);
+				break;
+			case PushReceiver.INTENT_TYPE_MESSAGE:
+				Bundle extras = intent.getBundleExtra(PushReceiver.INTENT_EXTRAS);
+				handlePushMessage(extras);
+				break;
+			default:
+				Logger.W(TAG, "Unknown command type received from " + source + ": " + type);
 			}
-		}, false);
-		getMainActivity().finish();
-		Process.killProcess(Process.myPid());
+		}
 	}
 	
-	public void activityStarted() {
-		if (activitiesActive == 0) {
-			if (needGeoLocationRestart) {
-				GeoLocation.isKnownPosition();
-				needGeoLocationRestart = false;
+	public void startServiceForeground(int id, Notification notification) {
+		if (mStartForeground != null) {
+			try {
+				mStartForeground.invoke(this, new Object[] {Integer.valueOf(id), notification});
 			}
-			PerformOnUiThread.exec( new Runnable() {
-				public void run() {
-					if (wakeLockEnabled) {
-						if (wakeLockObject == null) {
-							PowerManager pm = (PowerManager)getInstance().getContext().getSystemService(Context.POWER_SERVICE);
-							if (pm != null) {
-								Logger.I(TAG, "activityStarted() restore wakeLock object");
-								wakeLockObject = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP, TAG);
-								wakeLockObject.acquire();
-							}
-							else {
-								Logger.E(TAG, "activityStarted() - Can not get PowerManager !!!");
-							}
-						}
-					}
-				}
-			}, false);
-			callActivationCallback(true);
+			catch (InvocationTargetException e) {
+				Log.e(TAG, "Unable to invoke startForeground", e);
+			}
+			catch (IllegalAccessException e) {
+				Log.e(TAG, "Unable to invoke startForeground", e);
+			}
+			return;
 		}
-		++activitiesActive;
+		
+		setForeground(true);
+		mNM.notify(id, notification);
 	}
 	
-	public void activityStopped() {
-		--activitiesActive;
-		if (activitiesActive == 0) {
-			PerformOnUiThread.exec( new Runnable() {
-				public void run() {
-					if (wakeLockObject != null) {
-						Logger.I(TAG, "activityStopped() temporary destroy wakeLock object");
-						wakeLockObject.release();
-						wakeLockObject = null;
-					}
-				}
-			}, false);
-			needGeoLocationRestart = GeoLocation.isAvailable();
-			GeoLocation.stop();
-			callActivationCallback(false);
+	public void stopServiceForeground(int id) {
+		if (mStopForeground != null) {
+			try {
+				mStopForeground.invoke(this, new Object[] {Integer.valueOf(id)});
+			}
+			catch (InvocationTargetException e) {
+				Log.e(TAG, "Unable to invoke stopForeground", e);
+			}
+			catch (IllegalAccessException e) {
+				Log.e(TAG, "Unable to invoke stopForeground", e);
+			}
+			return;
 		}
+		
+		mNM.cancel(id);
+		setForeground(false);
+	}
+	
+	public void setMainView(MainView v) {
+		RhodesActivity ra = RhodesActivity.getInstance();
+		ra.setMainView(v);
+	}
+	
+	public MainView getMainView() {
+		RhodesActivity ra = RhodesActivity.getInstance();
+		if (ra == null)
+			return null;
+		return ra.getMainView();
+	}
+
+	public RhodesApplication getRhodesApplication() {
+		return (RhodesApplication)getApplication();
+	}
+	
+	public static void exit() {
+		getInstance().getRhodesApplication().exit();
 	}
 	
 	public void rereadScreenProperties() {
 		// check for orientarion changed
 		// Get screen width/height
-		WindowManager wm = (WindowManager)ctx.getSystemService(Context.WINDOW_SERVICE);
+		WindowManager wm = (WindowManager)getSystemService(Context.WINDOW_SERVICE);
 		Display d = wm.getDefaultDisplay();
-		screenHeight = d.getHeight();
-		screenWidth = d.getWidth();
+		mScreenHeight = d.getHeight();
+		mScreenWidth = d.getWidth();
 		int newScreenOrientation = d.getOrientation();
-		if (newScreenOrientation != screenOrientation) {
-			onScreenOrientationChanged(screenWidth, screenHeight, 90);
-			screenOrientation = newScreenOrientation; 				
+		if (newScreenOrientation != mScreenOrientation) {
+			onScreenOrientationChanged(mScreenWidth, mScreenHeight, 90);
+			mScreenOrientation = newScreenOrientation; 				
 		}
 	}
 	
 	public static void showAboutDialog() {
 		PerformOnUiThread.exec(new Runnable() {
 			public void run() {
-				final AboutDialog aboutDialog = new AboutDialog(Rhodes.getInstance());
+				final AboutDialog aboutDialog = new AboutDialog(RhodesActivity.getInstance());
 				aboutDialog.setTitle("About");
 				aboutDialog.setCanceledOnTouchOutside(true);
 				aboutDialog.setCancelable(true);
@@ -717,7 +529,7 @@ public class RhodesService {
 	public static void showLogView() {
 		PerformOnUiThread.exec(new Runnable() {
 			public void run() {
-				final LogViewDialog logViewDialog = new LogViewDialog(Rhodes.getInstance());
+				final LogViewDialog logViewDialog = new LogViewDialog(RhodesActivity.getInstance());
 				logViewDialog.setTitle("Log View");
 				logViewDialog.setCancelable(true);
 				logViewDialog.show();
@@ -728,7 +540,7 @@ public class RhodesService {
 	public static void showLogOptions() {
 		PerformOnUiThread.exec(new Runnable() {
 			public void run() {
-				final LogOptionsDialog logOptionsDialog = new LogOptionsDialog(Rhodes.getInstance());
+				final LogOptionsDialog logOptionsDialog = new LogOptionsDialog(RhodesActivity.getInstance());
 				logOptionsDialog.setTitle("Logging Options");
 				logOptionsDialog.setCancelable(true);
 				logOptionsDialog.show();
@@ -754,7 +566,7 @@ public class RhodesService {
 			return false;
 		}
 		
-		Context ctx = RhodesService.getInstance().getContext();
+		Context ctx = RhodesService.getContext();
 		ConnectivityManager conn = (ConnectivityManager)ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
 		if (conn == null)
 		{
@@ -794,11 +606,11 @@ public class RhodesService {
 	}
 	
 	public static int getScreenWidth() {
-		return screenWidth;
+		return mScreenWidth;
 	}
 	
 	public static int getScreenHeight() {
-		return screenHeight;
+		return mScreenHeight;
 	}
 	
 	public static Object getProperty(String name) {
@@ -814,16 +626,16 @@ public class RhodesService {
 			else if (name.equalsIgnoreCase("screen_height"))
 				return new Integer(getScreenHeight());
 			else if (name.equalsIgnoreCase("has_camera"))
-				return new Boolean(isCameraAvailable);
+				return new Boolean(mCameraAvailable);
 			else if (name.equalsIgnoreCase("has_network"))
 				return hasNetwork();
 			else if (name.equalsIgnoreCase("ppi_x"))
-				return new Float(screenPpiX);
+				return new Float(mScreenPpiX);
 			else if (name.equalsIgnoreCase("ppi_y"))
-				return new Float(screenPpiY);
+				return new Float(mScreenPpiY);
 			else if (name.equalsIgnoreCase("phone_number")) {
-				TelephonyManager manager = (TelephonyManager)RhodesService.getInstance().
-					getContext().getSystemService(Context.TELEPHONY_SERVICE);
+				Context context = RhodesService.getContext();
+				TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);
 				String number = manager.getLine1Number();
 				return number;
 			}
@@ -848,10 +660,6 @@ public class RhodesService {
 		return null;
 	}
 	
-	public static void exit() {
-		RhodesService.getInstance().exitApp();
-	}
-	
 	public static String getTimezoneStr() {
 		Calendar cal = Calendar.getInstance();
 		TimeZone tz = cal.getTimeZone();
@@ -860,7 +668,7 @@ public class RhodesService {
 	
 	public static void runApplication(String appName, Object params) {
 		try {
-			Context ctx = RhodesService.getInstance().getContext();
+			Context ctx = RhodesService.getContext();
 			PackageManager mgr = ctx.getPackageManager();
 			PackageInfo info = mgr.getPackageInfo(appName, PackageManager.GET_ACTIVITIES);
 			if (info.activities.length == 0) {
@@ -874,10 +682,11 @@ public class RhodesService {
 
 			Intent intent = new Intent();
 			intent.setClassName(appName, className);
+			intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
 			if (params != null) {
 				Bundle startParams = new Bundle();
 				if (params instanceof String) {
-					startParams.putString(RHO_START_PARAMS_KEY, (String)params);
+					startParams.putString(RhodesActivity.RHO_START_PARAMS_KEY, (String)params);
 				}
 				/*
 				else if (params instanceof List<?>) {
@@ -908,13 +717,11 @@ public class RhodesService {
 	
 	public static boolean isAppInstalled(String appName) {
 		try {
-			try {
-				RhodesService.getInstance().getContext().getPackageManager().getPackageInfo(appName, 0);
-				return true;
-			}
-			catch (NameNotFoundException ne) {
-				return false;
-			}
+			RhodesService.getContext().getPackageManager().getPackageInfo(appName, 0);
+			return true;
+		}
+		catch (NameNotFoundException ne) {
+			return false;
 		}
 		catch (Exception e) {
 			Logger.E(TAG, "Can't check is app " + appName + " installed: " + e.getMessage());
@@ -922,40 +729,269 @@ public class RhodesService {
 		}
 	}
 	
+	private void updateDownloadNotification(String url, int totalBytes, int currentBytes) {
+		Context context = RhodesActivity.getContext();
+		
+		Notification n = new Notification();
+		n.icon = android.R.drawable.stat_sys_download;
+		n.flags |= Notification.FLAG_ONGOING_EVENT;
+		
+		RemoteViews expandedView = new RemoteViews(context.getPackageName(),
+				AndroidR.layout.status_bar_ongoing_event_progress_bar);
+		
+		StringBuilder newUrl = new StringBuilder();
+		if (url.length() < 17)
+			newUrl.append(url);
+		else {
+			newUrl.append(url.substring(0, 7));
+			newUrl.append("...");
+			newUrl.append(url.substring(url.length() - 7, url.length()));
+		}
+		expandedView.setTextViewText(AndroidR.id.title, newUrl.toString());
+		
+		StringBuffer downloadingText = new StringBuffer();
+		if (totalBytes > 0) {
+			long progress = currentBytes*100/totalBytes;
+			downloadingText.append(progress);
+			downloadingText.append('%');
+		}
+		expandedView.setTextViewText(AndroidR.id.progress_text, downloadingText.toString());
+		expandedView.setProgressBar(AndroidR.id.progress_bar,
+				totalBytes < 0 ? 100 : totalBytes,
+				currentBytes,
+				totalBytes < 0);
+		n.contentView = expandedView;
+		
+		Intent intent = new Intent(ACTION_ASK_CANCEL_DOWNLOAD);
+		n.contentIntent = PendingIntent.getBroadcast(context, 0, intent, 0);
+		intent = new Intent(ACTION_CANCEL_DOWNLOAD);
+		n.deleteIntent = PendingIntent.getBroadcast(context, 0, intent, 0);
+
+		mNM.notify(DOWNLOAD_PACKAGE_ID, n);
+	}
+	
+	private File downloadPackage(String url) throws IOException {
+		final Context ctx = RhodesActivity.getContext();
+		
+		final Thread thisThread = Thread.currentThread();
+		
+		final Runnable cancelAction = new Runnable() {
+			public void run() {
+				thisThread.interrupt();
+			}
+		};
+		
+		BroadcastReceiver downloadReceiver = new BroadcastReceiver() {
+			@Override
+			public void onReceive(Context context, Intent intent) {
+				String action = intent.getAction();
+				if (action.equals(ACTION_ASK_CANCEL_DOWNLOAD)) {
+					AlertDialog.Builder builder = new AlertDialog.Builder(ctx);
+					builder.setMessage("Cancel download?");
+					AlertDialog dialog = builder.create();
+					dialog.setButton(AlertDialog.BUTTON_POSITIVE, ctx.getText(android.R.string.yes),
+							new DialogInterface.OnClickListener() {
+								public void onClick(DialogInterface dialog, int which) {
+									cancelAction.run();
+								}
+					});
+					dialog.setButton(AlertDialog.BUTTON_NEGATIVE, ctx.getText(android.R.string.no),
+							new DialogInterface.OnClickListener() {
+								public void onClick(DialogInterface dialog, int which) {
+									// Nothing
+								}
+							});
+					dialog.show();
+				}
+				else if (action.equals(ACTION_CANCEL_DOWNLOAD)) {
+					cancelAction.run();
+				}
+			}
+		};
+		IntentFilter filter = new IntentFilter();
+		filter.addAction(ACTION_ASK_CANCEL_DOWNLOAD);
+		filter.addAction(ACTION_CANCEL_DOWNLOAD);
+		ctx.registerReceiver(downloadReceiver, filter);
+		
+		File tmpFile = null;
+		InputStream is = null;
+		OutputStream os = null;
+		try {
+			updateDownloadNotification(url, -1, 0);
+			
+			/*
+			List<File> folders = new ArrayList<File>();
+			folders.add(Environment.getDownloadCacheDirectory());
+			folders.add(Environment.getDataDirectory());
+			folders.add(ctx.getCacheDir());
+			folders.add(ctx.getFilesDir());
+			try {
+				folders.add(new File(ctx.getPackageManager().getApplicationInfo(ctx.getPackageName(), 0).dataDir));
+			} catch (NameNotFoundException e1) {
+				// Ignore
+			}
+			folders.add(Environment.getExternalStorageDirectory());
+			
+			for (File folder : folders) {
+				File tmpRootFolder = new File(folder, "rhodownload");
+				File tmpFolder = new File(tmpRootFolder, ctx.getPackageName());
+				if (tmpFolder.exists())
+					deleteFilesInFolder(tmpFolder.getAbsolutePath());
+				else
+					tmpFolder.mkdirs();
+				
+				File of = new File(tmpFolder, UUID.randomUUID().toString() + ".apk");
+				Logger.D(TAG, "Check path " + of.getAbsolutePath() + "...");
+				try {
+					os = new FileOutputStream(of);
+				}
+				catch (FileNotFoundException e) {
+					Logger.D(TAG, "Can't open file " + of.getAbsolutePath() + ", check next path");
+					continue;
+				}
+				Logger.D(TAG, "File " + of.getAbsolutePath() + " succesfully opened for write, start download app");
+				
+				tmpFile = of;
+				break;
+			}
+			*/
+			
+			tmpFile = ctx.getFileStreamPath(UUID.randomUUID().toString() + ".apk");
+			os = ctx.openFileOutput(tmpFile.getName(), Context.MODE_WORLD_READABLE);
+			
+			Logger.D(TAG, "Download " + url + " to " + tmpFile.getAbsolutePath() + "...");
+			
+			URL u = new URL(url);
+			URLConnection conn = u.openConnection();
+			int totalBytes = -1;
+			if (conn instanceof HttpURLConnection) {
+				HttpURLConnection httpConn = (HttpURLConnection)conn;
+				totalBytes = httpConn.getContentLength();
+			}
+			is = conn.getInputStream();
+			
+			int downloaded = 0;
+			updateDownloadNotification(url, totalBytes, downloaded);
+			
+			long prevProgress = 0;
+			byte[] buf = new byte[65536];
+			for (;;) {
+				if (thisThread.isInterrupted()) {
+					tmpFile.delete();
+					Logger.D(TAG, "Download of " + url + " was canceled");
+					return null;
+				}
+				int nread = is.read(buf);
+				if (nread == -1)
+					break;
+				
+				//Logger.D(TAG, "Downloading " + url + ": got " + nread + " bytes...");
+				os.write(buf, 0, nread);
+				
+				downloaded += nread;
+				if (totalBytes > 0) {
+					// Update progress view only if current progress is greater than
+					// previous by more than 10%. Otherwise, if update it very frequently,
+					// user will no have chance to click on notification view and cancel if need
+					long progress = downloaded*10/totalBytes;
+					if (progress > prevProgress) {
+						updateDownloadNotification(url, totalBytes, downloaded);
+						prevProgress = progress;
+					}
+				}
+			}
+			
+			Logger.D(TAG, "File stored to " + tmpFile.getAbsolutePath());
+			
+			return tmpFile;
+		}
+		catch (IOException e) {
+			if (tmpFile != null)
+				tmpFile.delete();
+			throw e;
+		}
+		finally {
+			try {
+				if (is != null)
+					is.close();
+			} catch (IOException e) {}
+			try {
+				if (os != null)
+					os.close();
+			} catch (IOException e) {}
+			
+			mNM.cancel(DOWNLOAD_PACKAGE_ID);
+			ctx.unregisterReceiver(downloadReceiver);
+		}
+	}
+	
+	public static void installApplication(final String url) {
+		Thread bgThread = new Thread(new Runnable() {
+			public void run() {
+				try {
+					final RhodesService r = RhodesService.getInstance();
+					final File tmpFile = r.downloadPackage(url);
+					if (tmpFile != null) {
+						PerformOnUiThread.exec(new Runnable() {
+							public void run() {
+								try {
+									Logger.D(TAG, "Install package " + tmpFile.getAbsolutePath());
+									Uri uri = Uri.fromFile(tmpFile);
+									Intent intent = new Intent(Intent.ACTION_VIEW);
+									intent.setDataAndType(uri, "application/vnd.android.package-archive");
+									r.startActivity(intent);
+								}
+								catch (Exception e) {
+									Log.e(TAG, "Can't install file from " + tmpFile.getAbsolutePath(), e);
+									Logger.E(TAG, "Can't install file from " + tmpFile.getAbsolutePath() + ": " + e.getMessage());
+								}
+							}
+						}, false);
+					}
+				}
+				catch (IOException e) {
+					Log.e(TAG, "Can't download package from " + url, e);
+					Logger.E(TAG, "Can't download package from " + url + ": " + e.getMessage());
+				}
+			}
+		});
+		bgThread.setPriority(Thread.MIN_PRIORITY);
+		bgThread.start();
+	}
+	
 	public static void uninstallApplication(String appName) {
 		try {
 			Uri packageUri = Uri.parse("package:" + appName);
 			Intent intent = new Intent(Intent.ACTION_DELETE, packageUri);
-			RhodesService.getInstance().startActivity(intent);
+			RhodesService.getContext().startActivity(intent);
 		}
 		catch (Exception e) {
 			Logger.E(TAG, "Can't uninstall application " + appName + ": " + e.getMessage());
 		}
 	}
-
+	
 	public static void openExternalUrl(String url) {
 		try {
-			Context ctx = RhodesService.getInstance().getContext();
+			Context ctx = RhodesService.getContext();
             Uri uri = Uri.parse(url);			
             
 		    Intent intent = new Intent(Intent.ACTION_VIEW);
 		    intent.setData(uri);
-    		
+		    
 		    ctx.startActivity(Intent.createChooser(intent, "Open in..."));
 		}
 		catch (Exception e) {
 			Logger.E(TAG, "Can't open url :" + url + ": " + e.getMessage());
 		}
 	}
-
-	public native void setPushRegistrationId(String id);
+	
+	private native void setPushRegistrationId(String id);
 	
 	private native boolean callPushCallback(String data);
 	
-	public void handlePushMessage(Intent intent) {
+	private void handlePushMessage(Bundle extras) {
 		Logger.D(TAG, "Receive PUSH message");
 		
-		Bundle extras = intent.getExtras();
 		if (extras == null) {
 			Logger.W(TAG, "Empty PUSH message received");
 			return;
@@ -1026,4 +1062,150 @@ public class RhodesService {
 		}
 	}
 	
+	private void restartGeoLocationIfNeeded() {
+		if (mNeedGeoLocationRestart) {
+			GeoLocation.isKnownPosition();
+			mNeedGeoLocationRestart = false;
+		}
+	}
+	
+	private void stopGeoLocation() {
+		mNeedGeoLocationRestart = GeoLocation.isAvailable();
+		GeoLocation.stop();
+	}
+	
+	private void restoreWakeLockIfNeeded() {
+		PerformOnUiThread.exec( new Runnable() {
+			public void run() {
+				if (wakeLockEnabled) {
+					if (wakeLockObject == null) {
+						PowerManager pm = (PowerManager)getSystemService(Context.POWER_SERVICE);
+						if (pm != null) {
+							Logger.I(TAG, "activityStarted() restore wakeLock object");
+							wakeLockObject = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP, TAG);
+							wakeLockObject.acquire();
+						}
+						else {
+							Logger.E(TAG, "activityStarted() - Can not get PowerManager !!!");
+						}
+					}
+				}
+			}
+		}, false);
+	}
+	
+	private void stopWakeLock() {
+		PerformOnUiThread.exec( new Runnable() {
+			public void run() {
+				if (wakeLockObject != null) {
+					Logger.I(TAG, "activityStopped() temporary destroy wakeLock object");
+					wakeLockObject.release();
+					wakeLockObject = null;
+				}
+			}
+		}, false);
+	}
+	
+	public static int rho_sys_set_sleeping(int enable) {
+		Logger.I(TAG, "rho_sys_set_sleeping("+enable+")");
+		int wasEnabled = 1;
+		if (wakeLockObject != null) {
+			wasEnabled = 0;
+		}
+		if (enable != 0) {
+			// disable lock device
+			PerformOnUiThread.exec( new Runnable() {
+				public void run() {
+					if (wakeLockObject != null) {
+						wakeLockObject.release();
+						wakeLockObject = null;
+						wakeLockEnabled = false;
+					}
+				}
+			}, false);
+		}
+		else {
+			// lock device from sleep
+			PerformOnUiThread.exec( new Runnable() {
+				public void run() {
+					if (wakeLockObject == null) {
+						PowerManager pm = (PowerManager)getInstance().getContext().getSystemService(Context.POWER_SERVICE);
+						if (pm != null) {
+							wakeLockObject = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP, TAG);
+							wakeLockObject.acquire();
+							wakeLockEnabled = true;
+						}
+						else {
+							Logger.E(TAG, "rho_sys_set_sleeping() - Can not get PowerManager !!!");
+						}
+					}
+				}
+			}, false);
+		}
+		return wasEnabled;
+	}
+	
+	
+	
+	private void handleAppActivation() {
+		if (DEBUG)
+			Log.d(TAG, "handle app activation");
+		restartGeoLocationIfNeeded();
+		restoreWakeLockIfNeeded();
+		callActivationCallback(true);
+	}
+	
+	private void handleAppDeactivation() {
+		if (DEBUG)
+			Log.d(TAG, "handle app deactivation");
+		stopWakeLock();
+		stopGeoLocation();
+		callActivationCallback(false);
+	}
+	
+	public static void activityStarted() {
+		if (DEBUG)
+			Log.d(TAG, "activityStarted (1): sActivitiesActive=" + sActivitiesActive);
+		if (sActivitiesActive == 0) {
+			RhodesService r = RhodesService.getInstance();
+			if (DEBUG)
+				Log.d(TAG, "first activity started; r=" + r);
+			if (r != null)
+				r.handleAppActivation();
+		}
+		++sActivitiesActive;
+		if (DEBUG)
+			Log.d(TAG, "activityStarted (2): sActivitiesActive=" + sActivitiesActive);
+	}
+	
+	public static void activityStopped() {
+		if (DEBUG)
+			Log.d(TAG, "activityStopped (1): sActivitiesActive=" + sActivitiesActive);
+		--sActivitiesActive;
+		if (sActivitiesActive == 0) {
+			RhodesService r = RhodesService.getInstance();
+			if (DEBUG)
+				Log.d(TAG, "last activity stopped; r=" + r);
+			if (r != null)
+				r.handleAppDeactivation();
+		}
+		if (DEBUG)
+			Log.d(TAG, "activityStopped (2): sActivitiesActive=" + sActivitiesActive);
+	}
+	
+	@Override
+	public void startActivity(Intent intent) {
+		RhodesActivity ra = RhodesActivity.getInstance();
+		if (ra == null)
+			throw new IllegalStateException("Trying to start activity, but main activity is empty (we are in background, no UI active)");
+		ra.startActivity(intent);
+	}
+	
+	public static Context getContext() {
+		RhodesService r = RhodesService.getInstance();
+		if (r == null)
+			throw new IllegalStateException("No rhodes service instance at this moment");
+		return r;
+	}
+	
 }