rhodes 2.2.4.beta.1 → 2.2.5.beta.1

data/platform/android/Rhodes/jni/src/rhodes.cpp

@@ -3,6 +3,7 @@
 #include "rhodes/jni/com_rhomobile_rhodes_RhodesService.h"
 
 #include <common/RhoConf.h>
+#include <common/app_build_configs.h>
 #include <logging/RhoLogConf.h>
 #include <common/RhodesApp.h>
 #include <sync/SyncThread.h>
@@ -223,39 +224,83 @@ jint JNI_OnLoad(JavaVM* vm, void* /*reserved*/)
     return jversion;
 }
 
-VALUE convertJavaMapToRubyHash(jobject objMap)
+namespace details
 {
-    jclass clsMap = getJNIClass(RHODES_JAVA_CLASS_MAP);
-    if (!clsMap) return Qnil;
-    jclass clsSet = getJNIClass(RHODES_JAVA_CLASS_SET);
-    if (!clsSet) return Qnil;
-    jclass clsIterator = getJNIClass(RHODES_JAVA_CLASS_ITERATOR);
-    if (!clsIterator) return Qnil;
 
-    JNIEnv *env = jnienv();
+std::string rho_cast_helper<std::string, jstring>::operator()(JNIEnv *env, jstring s)
+{
+    const char *ts = env->GetStringUTFChars(s, JNI_FALSE);
+    std::string ret(ts);
+    env->ReleaseStringUTFChars(s, ts);
+    return ret;
+}
+
+jstring rho_cast_helper<jstring, char const *>::operator()(JNIEnv *env, char const *s)
+{
+    return env->NewStringUTF(s);
+}
 
-    jmethodID midGet = getJNIClassMethod(env, clsMap, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
-    if (!midGet) return Qnil;
-    jmethodID midKeySet = getJNIClassMethod(env, clsMap, "keySet", "()Ljava/util/Set;");
-    if (!midKeySet) return Qnil;
-    jmethodID midIterator = getJNIClassMethod(env, clsSet, "iterator", "()Ljava/util/Iterator;");
-    if (!midIterator) return Qnil;
-    jmethodID midHasNext = getJNIClassMethod(env, clsIterator, "hasNext", "()Z");
-    if (!midHasNext) return Qnil;
-    jmethodID midNext = getJNIClassMethod(env, clsIterator, "next", "()Ljava/lang/Object;");
-    if (!midNext) return Qnil;
+static rho::common::CMutex rho_cast_java_ruby_mtx;
+
+static jclass clsString;
+static jclass clsMap;
+static jclass clsSet;
+static jclass clsIterator;
+
+static jmethodID midMapGet;
+static jmethodID midMapKeySet;
+static jmethodID midSetIterator;
+static jmethodID midIteratorHasNext;
+static jmethodID midIteratorNext;
+
+static bool rho_cast_java_ruby_init(JNIEnv *env)
+{
+    static rho::common::CMutex rho_fd_mtx;
+    static bool initialized = false;
+    if (initialized)
+        return true;
+
+    rho::common::CMutexLock guard(rho_cast_java_ruby_mtx);
+    if (initialized)
+        return true;
+
+    clsString = getJNIClass(RHODES_JAVA_CLASS_STRING);
+    if (!clsString) return false;
+    clsMap = getJNIClass(RHODES_JAVA_CLASS_MAP);
+    if (!clsMap) return false;
+    clsSet = getJNIClass(RHODES_JAVA_CLASS_SET);
+    if (!clsSet) return false;
+    clsIterator = getJNIClass(RHODES_JAVA_CLASS_ITERATOR);
+    if (!clsIterator) return false;
+
+    midMapGet = getJNIClassMethod(env, clsMap, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
+    if (!midMapGet) return false;
+    midMapKeySet = getJNIClassMethod(env, clsMap, "keySet", "()Ljava/util/Set;");
+    if (!midMapKeySet) return false;
+    midSetIterator = getJNIClassMethod(env, clsSet, "iterator", "()Ljava/util/Iterator;");
+    if (!midSetIterator) return false;
+    midIteratorHasNext = getJNIClassMethod(env, clsIterator, "hasNext", "()Z");
+    if (!midIteratorHasNext) return false;
+    midIteratorNext = getJNIClassMethod(env, clsIterator, "next", "()Ljava/lang/Object;");
+    if (!midIteratorNext) return false;
+
+    initialized = true;
+    return true;
+}
 
-    jobject objSet = env->CallObjectMethod(objMap, midKeySet);
+static VALUE convertJavaMapToRubyHash(JNIEnv *env, jobject objMap)
+{
+    jobject objSet = env->CallObjectMethod(objMap, midMapKeySet);
     if (!objSet) return Qnil;
-    jobject objIterator = env->CallObjectMethod(objSet, midIterator);
+    jobject objIterator = env->CallObjectMethod(objSet, midSetIterator);
     if (!objIterator) return Qnil;
                                   
     CHoldRubyValue retval(rho_ruby_createHash());
-    while(env->CallBooleanMethod(objIterator, midHasNext))
+    while(env->CallBooleanMethod(objIterator, midIteratorHasNext))
     {
-        jstring objKey = (jstring)env->CallObjectMethod(objIterator, midNext);
+        jstring objKey = (jstring)env->CallObjectMethod(objIterator, midIteratorNext);
         if (!objKey) return Qnil;
-        jstring objValue = (jstring)env->CallObjectMethod(objMap, midGet, objKey);
+        jstring objValue = (jstring)env->CallObjectMethod(objMap, midMapGet, objKey);
         if (!objValue) return Qnil;
 
         std::string const &strKey = rho_cast<std::string>(objKey);
@@ -268,20 +313,43 @@ VALUE convertJavaMapToRubyHash(jobject objMap)
     return retval;
 }
 
-namespace details
+jobject rho_cast_helper<jobject, VALUE>::operator()(JNIEnv *env, VALUE value)
 {
+    if (!rho_cast_java_ruby_init(env))
+    {
+        env->ThrowNew(getJNIClass(RHODES_JAVA_CLASS_RUNTIME_EXCEPTION), "Java <=> Ruby conversion initialization failed");
+        return NULL;
+    }
 
-std::string rho_cast_helper<std::string, jstring>::operator()(JNIEnv *env, jstring s)
-{
-    const char *ts = env->GetStringUTFChars(s, JNI_FALSE);
-    std::string ret(ts);
-    env->ReleaseStringUTFChars(s, ts);
-    return ret;
+    if (NIL_P(value))
+        return NULL;
+
+    if (TYPE(value) == T_STRING)
+        return env->NewStringUTF(RSTRING_PTR(value));
+
+    RAWLOG_ERROR("rho_cast<jobject, VALUE>: unknown type of value");
+    return NULL;
 }
 
-jstring rho_cast_helper<jstring, char const *>::operator()(JNIEnv *env, char const *s)
+VALUE rho_cast_helper<VALUE, jobject>::operator()(JNIEnv *env, jobject obj)
 {
-    return env->NewStringUTF(s);
+    if (!rho_cast_java_ruby_init(env))
+    {
+        env->ThrowNew(getJNIClass(RHODES_JAVA_CLASS_RUNTIME_EXCEPTION), "Java <=> Ruby conversion initialization failed");
+        return Qnil;
+    }
+
+    if (!obj)
+        return Qnil;
+
+    if (env->IsInstanceOf(obj, clsString))
+        return rho_ruby_create_string(rho_cast<std::string>(env, (jstring)obj).c_str());
+
+    if (env->IsInstanceOf(obj, clsMap))
+        return convertJavaMapToRubyHash(env, obj);
+
+    RAWLOG_ERROR("rho_cast<VALUE, jobject>: unknown type of value");
+    return Qnil;
 }
 
 } // namespace details
@@ -477,6 +545,15 @@ RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesService_normalizeUrl
     return rho_cast<jstring>(env, cs);
 }
 
+RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesService_getBuildConfig
+  (JNIEnv *env, jobject, jstring key)
+{
+    std::string const &s = rho_cast<std::string>(key);
+    const char* cs = get_app_build_config_item(s.c_str());
+    return rho_cast<jstring>(env, cs);
+}
+
+
 RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_navigateBack
   (JNIEnv *, jclass)
 {
@@ -532,3 +609,7 @@ RHO_GLOBAL char *rho_timezone()
     }
     return tz;
 }
+
+RHO_GLOBAL const char* rho_sys_get_start_params() {
+    return "";
+}

data/platform/android/Rhodes/jni/src/ringtones.cpp

@@ -13,7 +13,7 @@ RHO_GLOBAL VALUE rho_ringtone_manager_get_all()
 
     jobject obj = env->CallStaticObjectMethod(cls, mid);
     if (!obj) return Qnil;
-    return convertJavaMapToRubyHash(obj);
+    return rho_cast<VALUE>(obj);
 }
 
 RHO_GLOBAL void rho_ringtone_manager_stop()

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

@@ -3,6 +3,7 @@ package com.rhomobile.rhodes;
 public class Capabilities {
 	
 	public static boolean AUDIO_ENABLED = true;
+	public static boolean BLUETOOTH_ENABLED = true;
 	public static boolean CALENDAR_ENABLED = true;
 	public static boolean CAMERA_ENABLED = true;
 	public static boolean GPS_ENABLED = true;

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

@@ -21,10 +21,8 @@
 package com.rhomobile.rhodes;
 
 import java.util.Timer;
-import java.util.TimerTask;
 
 import com.rhomobile.rhodes.mainview.MainView;
-import com.rhomobile.rhodes.util.PerformOnUiThread;
 
 import android.content.Intent;
 import android.content.pm.ActivityInfo;
@@ -57,6 +55,8 @@ public class Rhodes extends RhoActivity {
 	private Bundle mSavedBundle = null;
 	private SplashScreen mSplashScreen = null;
 	private Handler mHandler = null;
+	
+	private Object mStartParams = null;
 		
 	/** Called when the activity is first created. */
 	@Override
@@ -65,10 +65,13 @@ public class Rhodes extends RhoActivity {
 		
 		super.onCreate(savedInstanceState);
 		mHandler = new Handler();
-
+		
 		// Here Log should be used, not Logger. It is because Logger is not initialized yet.
 		Log.v(TAG, "+++ onCreate");
 		
+		mStartParams = getIntent().getExtras();
+		Log.d(TAG, "start parameters: " + mStartParams);
+		
 		instance = this;
 		
 		FrameLayout v = new FrameLayout(this);
@@ -100,7 +103,7 @@ public class Rhodes extends RhoActivity {
 		RhodesService service = RhodesService.getInstance();
 		if (service == null) {
 			Log.v(TAG, "Starting rhodes service...");
-			service = new RhodesService(this, mOuterFrame, mSplashScreen);
+			service = new RhodesService(this, mOuterFrame, mSplashScreen, mStartParams);
 		}
 		else
 			Log.v(TAG, "Rhodes service already started...");
@@ -130,13 +133,11 @@ public class Rhodes extends RhoActivity {
 	private Timer mTimerPostponeCreate = null;
 	
 	public void onResume() {
-		RhodesService.platformLog("Rhodes", "onResume()");
-		
 		super.onResume();
-
+		RhodesService.platformLog("Rhodes", "onResume()");
 	}
 	
-	public static void runPosponedSetup() {
+	public static void runPostponedSetup() {
 		final Rhodes r = Rhodes.getInstance();
 		r.mHandler.post( new Runnable() {
 				public void run() {

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

@@ -4,6 +4,8 @@ import java.io.File;
 import java.io.IOException;
 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;
@@ -11,7 +13,7 @@ import java.util.TimeZone;
 import java.util.Vector;
 
 import com.rhomobile.rhodes.alert.Alert;
-import com.rhomobile.rhodes.bluetooth.RhoBluetoothManager;
+import com.rhomobile.rhodes.event.EventStore;
 import com.rhomobile.rhodes.file.RhoFileApi;
 import com.rhomobile.rhodes.geolocation.GeoLocation;
 import com.rhomobile.rhodes.mainview.MainView;
@@ -68,6 +70,8 @@ public class RhodesService {
 	public static final int RHO_MAIN_VIEW = 2;
 	public static final int RHO_TOOLBAR_VIEW = 3;
 	
+	private static final String RHO_START_PARAMS_KEY = "RhoStartParams";
+	
 	private static RhodesService instance = null;
 	
 	public static RhodesService getInstance() {
@@ -128,6 +132,10 @@ public class RhodesService {
 		uiHandler.post(r);
 	}
 	
+	public void post(Runnable r, int delay) {
+		uiHandler.postDelayed(r, delay);
+	}
+	
 	private static int screenWidth;
 	private static int screenHeight;
 	private static int screenOrientation;
@@ -162,6 +170,8 @@ public class RhodesService {
 	
 	public native String normalizeUrl(String url);
 	
+	public static native String getBuildConfig(String key);
+	
 	public static native void loadUrl(String url);
 	
 	public static native void navigateBack();
@@ -273,13 +283,19 @@ public class RhodesService {
 		
 		return false;
 	}
+
+	private static int mGeoLocationInactivityTimeout;
+
+	public static int getGeoLocationInactivityTimeout() {
+		return mGeoLocationInactivityTimeout;
+	}
 	
 	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() {
@@ -324,7 +340,7 @@ public class RhodesService {
 				Rhodes.getInstance().getWindow().setFeatureInt(Window.FEATURE_PROGRESS, MAX_PROGRESS);
 				super.onPageFinished(view, url);
 				if (!setupExecuted) {
-					Rhodes.runPosponedSetup();
+					Rhodes.runPostponedSetup();
 					setupExecuted = true;
 				}
 				
@@ -444,7 +460,7 @@ public class RhodesService {
 		return instance != null;
 	}
 	
-	public RhodesService(Activity c, ViewGroup rootWindow, SplashScreen splash_s) {
+	public RhodesService(Activity c, ViewGroup rootWindow, SplashScreen splash_s, Object params) {
 	
 		ctx = c;
 		instance = this;
@@ -467,7 +483,13 @@ public class RhodesService {
 		if (Utils.isAppHashChanged()) {
 			try {
 				Log.i(TAG, "Application hash was changed, so remove files");
-				Utils.deleteRecursively(new File(rootPath));
+				String[] folders = {"apps", "lib"};
+				for (String folder : folders) {
+					File f = new File(rootPath, folder);
+					if (!f.exists())
+						continue;
+					Utils.deleteRecursively(f);
+				}
 				initRootPath();
 				RhoFileApi.init();
 				RhoFileApi.copy("hash");
@@ -480,6 +502,53 @@ public class RhodesService {
 		
 		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();
+		}
+		
 		boolean fullScreen = true;
 		if (RhoConf.isExist("full_screen"))
 			fullScreen = RhoConf.getBool("full_screen");
@@ -494,7 +563,9 @@ public class RhodesService {
 
 		Logger.I("Rhodes", "Loading...");
 		//showSplashScreen();
-		splashScreen.rho_start();
+		if (splashScreen != null) {
+			splashScreen.rho_start();
+		}
 		
 		// Increase WebView rendering priority
 		WebView w = new WebView(ctx);
@@ -516,6 +587,10 @@ public class RhodesService {
 		// TODO: detect camera availability
 		isCameraAvailable = 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));
@@ -563,6 +638,7 @@ public class RhodesService {
 				}
 			}
 		}, false);
+		getMainActivity().finish();
 		Process.killProcess(Process.myPid());
 	}
 	
@@ -595,17 +671,17 @@ public class RhodesService {
 	}
 	
 	public void activityStopped() {
-		PerformOnUiThread.exec( new Runnable() {
-			public void run() {
-				if (wakeLockObject != null) {
-					Logger.I(TAG, "activityStopped() temporary destroy wakeLock object");
-					wakeLockObject.release();
-					wakeLockObject = null;
-				}
-			}
-		}, false);
 		--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);
@@ -726,40 +802,47 @@ public class RhodesService {
 	}
 	
 	public static Object getProperty(String name) {
-		if (name.equalsIgnoreCase("platform"))
-			return "ANDROID";
-		else if (name.equalsIgnoreCase("locale"))
-			return getCurrentLocale();
-		else if (name.equalsIgnoreCase("country"))
-			return getCurrentCountry();
-		else if (name.equalsIgnoreCase("screen_width"))
-			return new Integer(getScreenWidth());
-		else if (name.equalsIgnoreCase("screen_height"))
-			return new Integer(getScreenHeight());
-		else if (name.equalsIgnoreCase("has_camera"))
-			return new Boolean(isCameraAvailable);
-		else if (name.equalsIgnoreCase("has_network"))
-			return hasNetwork();
-		else if (name.equalsIgnoreCase("ppi_x"))
-			return new Float(screenPpiX);
-		else if (name.equalsIgnoreCase("ppi_y"))
-			return new Float(screenPpiY);
-		else if (name.equalsIgnoreCase("phone_number")) {
-			TelephonyManager manager = (TelephonyManager)RhodesService.getInstance().
-				getContext().getSystemService(Context.TELEPHONY_SERVICE);
-			String number = manager.getLine1Number();
-			return number;
-		}
-		else if (name.equalsIgnoreCase("device_name")) {
-			return Build.DEVICE;
-		}
-		else if (name.equalsIgnoreCase("is_emulator")) 
-		{
-		    String strDevice = Build.DEVICE;
-			return new Boolean(strDevice != null && strDevice.equalsIgnoreCase("generic"));
+		try {
+			if (name.equalsIgnoreCase("platform"))
+				return "ANDROID";
+			else if (name.equalsIgnoreCase("locale"))
+				return getCurrentLocale();
+			else if (name.equalsIgnoreCase("country"))
+				return getCurrentCountry();
+			else if (name.equalsIgnoreCase("screen_width"))
+				return new Integer(getScreenWidth());
+			else if (name.equalsIgnoreCase("screen_height"))
+				return new Integer(getScreenHeight());
+			else if (name.equalsIgnoreCase("has_camera"))
+				return new Boolean(isCameraAvailable);
+			else if (name.equalsIgnoreCase("has_network"))
+				return hasNetwork();
+			else if (name.equalsIgnoreCase("ppi_x"))
+				return new Float(screenPpiX);
+			else if (name.equalsIgnoreCase("ppi_y"))
+				return new Float(screenPpiY);
+			else if (name.equalsIgnoreCase("phone_number")) {
+				TelephonyManager manager = (TelephonyManager)RhodesService.getInstance().
+					getContext().getSystemService(Context.TELEPHONY_SERVICE);
+				String number = manager.getLine1Number();
+				return number;
+			}
+			else if (name.equalsIgnoreCase("device_name")) {
+				return Build.DEVICE;
+			}
+			else if (name.equalsIgnoreCase("is_emulator")) {
+			    String strDevice = Build.DEVICE;
+				return new Boolean(strDevice != null && strDevice.equalsIgnoreCase("generic"));
+			}
+			else if (name.equalsIgnoreCase("os_version")) {
+				return Build.VERSION.RELEASE;
+			}
+			else if (name.equalsIgnoreCase("has_calendar")) {
+				return new Boolean(EventStore.hasCalendar());
+			}
 		}
-		else if (name.equalsIgnoreCase("os_version")) {
-			return Build.VERSION.RELEASE;
+		catch (Exception e) {
+			Logger.E(TAG, "Can't get property \"" + name + "\": " + e);
 		}
 		
 		return null;
@@ -775,7 +858,7 @@ public class RhodesService {
 		return tz.getDisplayName();
 	}
 	
-	public static void runApplication(String appName, Map<Object, Object> params) {
+	public static void runApplication(String appName, Object params) {
 		try {
 			Context ctx = RhodesService.getInstance().getContext();
 			PackageManager mgr = ctx.getPackageManager();
@@ -791,12 +874,64 @@ public class RhodesService {
 
 			Intent intent = new Intent();
 			intent.setClassName(appName, className);
+			if (params != null) {
+				Bundle startParams = new Bundle();
+				if (params instanceof String) {
+					startParams.putString(RHO_START_PARAMS_KEY, (String)params);
+				}
+				/*
+				else if (params instanceof List<?>) {
+					for (Object obj : (List<?>)params) {
+						startParams.putInt(obj.toString(), 1);
+					}
+				}
+				else if (params instanceof Map<?,?>) {
+					Map<?,?> mp = (Map<?,?>)params;
+					for (Iterator<?> it = mp.keySet().iterator(); it.hasNext();) {
+						Object key = it.next();
+						Object value = mp.get(key);
+						startParams.putString(key.toString(), value == null ? null : value.toString());
+					}
+				}
+				*/
+				else
+					throw new IllegalArgumentException("Unknown type of incoming parameter");
+
+				intent.putExtras(startParams);
+			}
 			ctx.startActivity(intent);
 		}
 		catch (Exception e) {
 			Logger.E(TAG, "Can't run application " + appName + ": " + e.getMessage());
 		}
 	}
+	
+	public static boolean isAppInstalled(String appName) {
+		try {
+			try {
+				RhodesService.getInstance().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());
+			return false;
+		}
+	}
+	
+	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);
+		}
+		catch (Exception e) {
+			Logger.E(TAG, "Can't uninstall application " + appName + ": " + e.getMessage());
+		}
+	}
 
 	public static void openExternalUrl(String url) {
 		try {