rhodes 3.3.3.beta.4 → 3.3.3

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

@@ -136,7 +136,7 @@ void* RhoNativeViewManager::getWebViewObject(int tab_index) {
     JNIEnv *env = jnienv();
     jclass cls = rho_find_class(env, "com/rhomobile/rhodes/nativeview/RhoNativeViewManager");
     if (!cls) return null;
-    jmethodID mid = env->GetStaticMethodID( cls, "getWebViewObject", "(I)Landroid/webkit/WebView;");
+    jmethodID mid = env->GetStaticMethodID( cls, "getWebViewObject", "(I)Ljava/lang/Object;");
     if (!mid) return null;
     return env->CallStaticObjectMethod(cls, mid, tab_index);
 }

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

@@ -68,6 +68,19 @@ void AndroidLogSink::writeLogMessage(String &strMsg)
     __android_log_write(ANDROID_LOG_INFO, "APP", strMsg.c_str());
 }
 
+String AndroidMemoryInfoCollector::collect()
+{
+    String ret;
+    JNIEnv *env = jnienv();
+    jclass cls = getJNIClass(RHODES_JAVA_CLASS_MEMORY_INFO_COLLECTOR);
+    if (!cls) return ret;
+    jmethodID mid = getJNIClassStaticMethod(env, cls, "collect", "()Ljava/lang/String;");
+    if (!mid) return ret;
+    jhstring jStr( static_cast<jstring>(env->CallStaticObjectMethod(cls, mid)) );
+    return rho_cast<String>(env,jStr);
+}
+
+
 } // namespace common
 } // namespace rho
 

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

@@ -234,6 +234,14 @@ RHO_GLOBAL jboolean JNICALL Java_com_rhomobile_rhodes_RhodesService_isOnStartPag
 }
 
 
+RHO_GLOBAL jboolean JNICALL Java_com_rhomobile_rhodes_RhodesService_isMotorolaLicencePassed
+(JNIEnv *env, jclass)
+{
+    bool res = (rho_can_app_started_with_current_licence() == 1);
+    return (jboolean)res;
+}
+
+
 RHO_GLOBAL jboolean JNICALL Java_com_rhomobile_rhodes_RhodesService_isTitleEnabled
   (JNIEnv *, jclass)
 {
@@ -318,6 +326,18 @@ RHO_GLOBAL jboolean JNICALL Java_com_rhomobile_rhodes_RhodesService_callPushCall
     return (jboolean)rho_rhodesapp_callPushCallback(data.c_str());
 }
 
+
+RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_resetHttpLogging
+  (JNIEnv *env, jobject, jstring jId)
+{
+    //RAWLOG_ERROR("$$$$$$$$$$$ RESET HTTP LOGGING 1 $$$$$$$$$$$$$");
+    std::string url = rho_cast<std::string>(env, jId);
+    rho_log_resetup_http_url(url.c_str());	
+    //RAWLOG_ERROR("$$$$$$$$$$$ RESET HTTP LOGGING 2 $$$$$$$$$$$$$");
+}
+
+
+
 RHO_GLOBAL char *rho_timezone()
 {
     static char *tz = NULL;

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

@@ -33,20 +33,30 @@
 #include "common/RhoStd.h"
 #include "common/RhoConf.h"
 #include "common/RhodesAppBase.h"
+#include "common/app_build_capabilities.h"
 #include "sqlite/sqlite3.h"
 #include "logging/RhoLogConf.h"
 
 //--------------------------------------------------------------------------------------------------
 static rho::common::CAutoPtr<rho::common::AndroidLogSink> s_logSink(new rho::common::AndroidLogSink());
+static rho::common::CAutoPtr<rho::common::AndroidMemoryInfoCollector> s_memory_info_collector(new rho::common::AndroidMemoryInfoCollector());
 
 static rho::String s_root_path;
 static rho::String s_sqlite_path;
+static rho::String s_shared_path;
+static rho::String s_log_path;
 
 //--------------------------------------------------------------------------------------------------
-RHO_GLOBAL void android_set_path(const rho::String& root, const rho::String& sqlite)
+RHO_GLOBAL void android_set_path(const rho::String& root, const rho::String& sqlite, const rho::String& shared)
 {
     s_root_path = root;
     s_sqlite_path = sqlite;
+    s_shared_path = shared;
+}
+//--------------------------------------------------------------------------------------------------
+RHO_GLOBAL void android_set_log_path(const rho::String& path)
+{
+    s_log_path = path;
 }
 //--------------------------------------------------------------------------------------------------
 rho::String const &rho_root_path()
@@ -54,6 +64,11 @@ rho::String const &rho_root_path()
     return s_root_path;
 }
 //--------------------------------------------------------------------------------------------------
+rho::String const &rho_shared_path()
+{
+    return s_shared_path;
+}
+//--------------------------------------------------------------------------------------------------
 const char* rho_native_rhopath()
 {
     return rho_root_path().c_str();
@@ -72,6 +87,22 @@ rho::String rho_cur_path()
     return buf;
 }
 //--------------------------------------------------------------------------------------------------
+rho::String rho_log_path()
+{
+    if (!s_log_path.empty())
+    {
+        return s_log_path;
+    }
+    else if (!s_shared_path.empty())
+    {
+        return s_shared_path;
+    }
+    else
+    {
+        return s_root_path;
+    }
+}
+//--------------------------------------------------------------------------------------------------
 static bool set_posix_environment(JNIEnv *env, jclass clsRE)
 {
     // Set USER variable
@@ -166,14 +197,16 @@ RHO_GLOBAL void android_setup(JNIEnv *env)
     sqlite3_temp_directory = (char*)s_sqlite_path.c_str();
 
     // Init logconf
-    rho_logconf_Init(rho_native_rhopath(), rho_native_rhopath(), "");
+    rho_logconf_Init(rho_log_path().c_str(), rho_native_rhopath(), "");
 
     // Disable log to stdout as on android all stdout redirects to /dev/null
     RHOCONF().setBool("LogToOutput", false, true);
     LOGCONF().setLogToOutput(false);
     // Add android system log sink
     LOGCONF().setLogView(s_logSink);
-    
+
+    LOGCONF().setMemoryInfoCollector(s_memory_info_collector);
+
 }
 //--------------------------------------------------------------------------------------------------
 RHO_GLOBAL void *rho_nativethread_start()

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

@@ -29,8 +29,10 @@
 
 #include "rhodes/jni/com_rhomobile_rhodes_signature_Signature.h"
 
-#include <common/rhoparams.h>
-#include <common/RhodesApp.h>
+#include "common/app_build_capabilities.h"
+#include "common/rhoparams.h"
+#include "common/RhodesApp.h"
+#include "logging/RhoLog.h"
 #include "ruby/ext/rho/rhoruby.h"
 
 #undef DEFAULT_LOGCATEGORY
@@ -79,6 +81,12 @@ RHO_GLOBAL void rho_signature_take(char* callback_url, rho_param* p)
 
 RHO_GLOBAL void rho_signature_visible(bool visible, rho_param* p)
 {
+    // check for RhoElements :
+    if (!rho_is_rho_elements_extension_can_be_used()) {
+        RAWLOG_ERROR("Rho::SignatureCapture.visible() is unavailable without RhoElements ! For more information go to http://www.motorolasolutions.com/rhoelements");
+        return;
+    }
+
     JNIEnv *env = jnienv();
     jclass cls = getJNIClass(RHODES_JAVA_CLASS_SIGNATURE);
     if (!cls) return;
@@ -92,6 +100,12 @@ RHO_GLOBAL void rho_signature_visible(bool visible, rho_param* p)
 
 RHO_GLOBAL void rho_signature_capture(const char* callback_url) 
 {
+    // check for RhoElements :
+    if (!rho_is_rho_elements_extension_can_be_used()) {
+        RAWLOG_ERROR("Rho::SignatureCapture.capture() is unavailable without RhoElements ! For more information go to http://www.motorolasolutions.com/rhoelements");
+        return;
+    }
+    
     JNIEnv *env = jnienv();
     jclass cls = getJNIClass(RHODES_JAVA_CLASS_SIGNATURE);
     if (!cls) return;
@@ -106,6 +120,12 @@ RHO_GLOBAL void rho_signature_capture(const char* callback_url)
 
 RHO_GLOBAL void rho_signature_clear() 
 {
+    // check for RhoElements :
+    if (!rho_is_rho_elements_extension_can_be_used()) {
+        RAWLOG_ERROR("Rho::SignatureCapture.clear() is unavailable without RhoElements ! For more information go to http://www.motorolasolutions.com/rhoelements");
+        return;
+    }
+    
     JNIEnv *env = jnienv();
     jclass cls = getJNIClass(RHODES_JAVA_CLASS_SIGNATURE);
     if (!cls) return;

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

@@ -1,19 +1,20 @@
 package com.rhomobile.rhodes;
-
 public class Capabilities {
-	  public static final boolean AUDIO_ENABLED = true;
-	  public static final boolean BLUETOOTH_ENABLED = true;
-	  public static final boolean CALENDAR_ENABLED = true;
-	  public static final boolean CAMERA_ENABLED = true;
-	  public static final boolean GPS_ENABLED = true;
-	  public static final boolean NETWORK_STATE_ENABLED = true;
-	  public static final boolean PHONE_ENABLED = true;
-	  public static final boolean PIM_ENABLED = true;
-	  public static final boolean PUSH_ENABLED = true;
-	  public static final boolean RECORD_AUDIO_ENABLED = true;
-	  public static final boolean SDCARD_ENABLED = true;
-	  public static final boolean VIBRATE_ENABLED = true;
-      public static final boolean MOTOROLA_ENABLED = false;
-	  public static final boolean WEBKIT_BROWSER_ENABLED = false;
-	  
+  public static final boolean AUDIO_ENABLED = false;
+  public static final boolean BLUETOOTH_ENABLED = true;
+  public static final boolean CALENDAR_ENABLED = true;
+  public static final boolean CAMERA_ENABLED = true;
+  public static final boolean GPS_ENABLED = true;
+  public static final boolean MOTOROLA_ENABLED = false;
+  public static final boolean MOTOROLA_BROWSER_ENABLED = false;
+  public static final boolean MOTOROLADEV_ENABLED = false;
+  public static final boolean NETWORK_STATE_ENABLED = true;
+  public static final boolean PHONE_ENABLED = true;
+  public static final boolean PIM_ENABLED = true;
+  public static final boolean PUSH_ENABLED = false;
+  public static final boolean RECORD_AUDIO_ENABLED = false;
+  public static final boolean SDCARD_ENABLED = true;
+  public static final boolean SHARED_RUNTIME_ENABLED = false;
+  public static final boolean VIBRATE_ENABLED = true;
+  public static final boolean WEBKIT_BROWSER_ENABLED = false;
 }

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

@@ -29,6 +29,10 @@ package com.rhomobile.rhodes;
 import java.io.CharArrayWriter;
 import java.io.PrintWriter;
 import java.io.Writer;
+import android.app.ActivityManager;
+import android.content.Context;
+
+import java.io.*;
 
 public class Logger {
 
@@ -71,5 +75,4 @@ public class Logger {
 	public static void T(String tag, Throwable e) {
 		T(tag, e.getMessage());
 	}
-	
 }

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

@@ -0,0 +1,67 @@
+package com.rhomobile.rhodes;
+
+import android.app.ActivityManager;
+import android.content.Context;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class MemoryInfoCollector {
+	public static String collect() {
+		StringBuilder builder = new StringBuilder();
+		builder.append("Memory usage:\n");
+
+		{
+			builder.append("Contents of /proc/meminfo:\n");
+			builder.append(getProcMeminfoContents());
+			builder.append("\n");
+		}
+
+		{
+			builder.append("MemoryInfo from ActivityService:\n");
+			builder.append( getActivitiManagerMemInfo() );
+			builder.append("\n");
+		}
+
+		return builder.toString();
+	}
+
+	private static String getProcMeminfoContents() {
+		try {
+			BufferedReader reader = new BufferedReader( new FileReader("/proc/meminfo"));
+			String line  = null;
+			StringBuilder stringBuilder = new StringBuilder();
+			String ls = System.getProperty("line.separator");
+			int nLines = 0;
+			//get only first 5 lines
+			while( (( line = reader.readLine() ) != null) && ( nLines++ < 5 ) ) {
+
+				stringBuilder.append( line );
+				stringBuilder.append( ls );
+			}
+			return stringBuilder.toString();
+		} catch (IOException e) {
+			return "Can't get contents of /proc/meminfo";
+		}
+	}
+
+	private static String getActivitiManagerMemInfo() {
+		try {
+			Context context = RhodesService.getContext();
+			ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+			ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
+			activityManager.getMemoryInfo(memoryInfo);
+
+			StringBuilder builder = new StringBuilder();
+
+			builder.append("memoryInfo.availMem ").append(memoryInfo.availMem).append("\n");
+			builder.append("memoryInfo.lowMemory ").append(memoryInfo.lowMemory).append("\n");
+			builder.append("memoryInfo.threshold ").append(memoryInfo.threshold).append("\n");
+
+			return builder.toString();
+		} catch ( IllegalStateException e ) {
+			return "Can't get memory info from ActivityManager";
+		}
+	}
+}

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

@@ -27,35 +27,38 @@
 package com.rhomobile.rhodes;
 
 import java.lang.reflect.Constructor;
-import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.Set;
 
 import com.rhomobile.rhodes.bluetooth.RhoBluetoothManager;
 import com.rhomobile.rhodes.camera.Camera;
+import com.rhomobile.rhodes.extmanager.RhoExtManager;
+import com.rhomobile.rhodes.file.RhoFileApi;
 import com.rhomobile.rhodes.mainview.MainView;
 import com.rhomobile.rhodes.mainview.SimpleMainView;
 import com.rhomobile.rhodes.mainview.SplashScreen;
-import com.rhomobile.rhodes.signature.Signature;
 import com.rhomobile.rhodes.util.PerformOnUiThread;
-import com.rhomobile.rhodes.util.Utils;
+import com.rhomobile.rhodes.webview.GoogleWebView;
+import com.rhomobile.rhodes.webview.IRhoWebView;
 
+import android.app.Dialog;
+import android.app.AlertDialog;
 import android.content.ComponentName;
 import android.content.Context;
+import android.content.DialogInterface;
 import android.content.Intent;
 import android.net.Uri;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
-import android.util.Log;
 import android.view.KeyEvent;
 import android.view.Menu;
 import android.view.MenuItem;
+import android.view.ViewGroup;
 import android.view.Window;
 import android.view.WindowManager;
-import android.webkit.WebView;
+import android.widget.AbsoluteLayout;
 
-public class RhodesActivity extends BaseActivity {
+public class RhodesActivity extends BaseActivity implements SplashScreen.SplashScreenListener {
 	
 	private static final String TAG = RhodesActivity.class.getSimpleName();
 	
@@ -81,8 +84,6 @@ public class RhodesActivity extends BaseActivity {
 		return uiThreadId;
 	}
 	
-	private ArrayList<RhodesActivityListener> mListeners = null;
-	
 	private boolean mIsForeground = false;
 	private boolean mIsInsideStartStop = false;
 	
@@ -94,53 +95,16 @@ public class RhodesActivity extends BaseActivity {
 		return mIsInsideStartStop;
 	}
 	
-	public void addRhodesActivityListener(RhodesActivityListener listener) {
-		if (!mListeners.contains(listener)) {
-			mListeners.add(listener);
-		}
-	}
-	
-	public void removeRhodesActivityListener(RhodesActivityListener listener) {
-		mListeners.remove(listener);
-	}
-	
-	public void processStartupListeners() {
-		int i;
-		for (i = 1; i < RhodesActivityStartupListeners.ourRunnableList.length; i++) {
-			String classname = RhodesActivityStartupListeners.ourRunnableList[i];
-			Class<? extends RhodesActivityListener> klass = null;
-			try {
-				klass = Class.forName(classname).asSubclass(RhodesActivityListener.class);
-			} catch (ClassNotFoundException e) {
-				Utils.platformLog("RhodesActivity", "processStartupListeners() : ClassNotFoundException for ["+classname+"]");
-				e.printStackTrace();
-			}
-			RhodesActivityListener listener = null;
-			try {
-				if (klass != null) {
-					listener = klass.newInstance();
-				}
-			} catch (InstantiationException e) {
-				Utils.platformLog("RhodesActivity", "processStartupListeners() : InstantiationException for ["+classname+"]");
-				e.printStackTrace();
-			} catch (IllegalAccessException e) {
-				Utils.platformLog("RhodesActivity", "processStartupListeners() : IllegalAccessException for ["+classname+"]");
-				e.printStackTrace();
-			}
-			if (listener != null) {
-				listener.onRhodesActivityStartup(this);
-			}
-		}
-	}
 	
+	//public void removeRhodesActivityListener(IRhoListener listener) {
+	//	mListeners.remove(listener);
+	//}
 	
 	@Override
 	protected void onCreate(Bundle savedInstanceState) {
         Logger.T(TAG, "onCreate");
 		super.onCreate(savedInstanceState);
 		
-		mListeners = new ArrayList<RhodesActivityListener>();
-
 		Thread ct = Thread.currentThread();
 		//ct.setPriority(Thread.MAX_PRIORITY);
 		uiThreadId = ct.getId();
@@ -157,28 +121,84 @@ public class RhodesActivity extends BaseActivity {
 		requestWindowFeature(Window.FEATURE_PROGRESS);
         getWindow().setFeatureInt(Window.FEATURE_PROGRESS, MAX_PROGRESS);
 
-		mHandler = new Handler();
+        mHandler = new Handler();
 
-        mSplashScreen = new SplashScreen(this);
+        Logger.T(TAG, "Creating splash screen");
+        mSplashScreen = new SplashScreen(this, createWebView(), this);
         setMainView(mSplashScreen);
 
+        RhoExtManager.getImplementationInstance().onCreateActivity(this, getIntent());
+
+        notifyUiCreated();
+        RhodesApplication.stateChanged(RhodesApplication.UiState.MainActivityCreated);
         
-        Signature.registerSignatureCaptureExtension();
         
-		processStartupListeners();
-        {
-        	Iterator<RhodesActivityListener> iterator = mListeners.iterator();
-        	while (iterator.hasNext()) {
-        		iterator.next().onCreate(this, getIntent());
-        	}
+        if (!isPassMotoLicence()) {
+        	Logger.E(TAG, "############################");
+        	Logger.E(TAG, " ");
+        	Logger.E(TAG, "ERROR: motorola_license is INVALID !");
+        	Logger.E(TAG, " ");
+        	Logger.E(TAG, "############################");
+            AlertDialog.Builder b = new AlertDialog.Builder(this);
+            b.setCancelable(true);
+            b.setOnCancelListener( new DialogInterface.OnCancelListener() {
+				public void onCancel(DialogInterface dialog) {
+					//RhodesService.exit();
+				}
+			});
+            AlertDialog securityAlert = b.create();
+            securityAlert.setMessage("Please provide RhoElements license key.");
+            securityAlert.setButton("OK", new DialogInterface.OnClickListener(){
+				public void onClick(DialogInterface arg0, int arg1) {
+					//RhodesService.exit();
+				}
+            	
+            });
+            securityAlert.show();
+            return;
+        }        
+    }
+
+    public IRhoWebView createWebView() {
+        IRhoWebView view = null;
+        if (Capabilities.WEBKIT_BROWSER_ENABLED) {
+            Logger.T(TAG, "Creating Motorola WebKIT view");
+            try {
+                Class<? extends IRhoWebView> viewClass = Class.forName("com.rhomobile.rhodes.webview.EkiohWebView").asSubclass(IRhoWebView.class);
+                if (Capabilities.MOTOROLA_BROWSER_ENABLED) {
+                    Constructor<? extends IRhoWebView> viewCtor = viewClass.getConstructor(Context.class, Runnable.class, String.class);
+                    view = viewCtor.newInstance(this, RhodesApplication.AppState.AppStarted.addObserver("MotorolaStartEngineObserver", true), RhoFileApi.getRootPath());
+                } else {
+                    Constructor<? extends IRhoWebView> viewCtor = viewClass.getConstructor(Context.class, Runnable.class);
+                    view = viewCtor.newInstance(this, RhodesApplication.AppState.AppStarted.addObserver("MotorolaStartEngineObserver", true));
+                }
+            } catch (Throwable e) {
+                Logger.E(TAG, e);
+                RhodesApplication.stop();
+            }
+        } else {
+            Logger.T(TAG, "Creating Google web view");
+            final GoogleWebView googleWebView = new GoogleWebView(this);
+            view = googleWebView;
+            RhodesApplication.runWhen(RhodesApplication.AppState.AppStarted, new RhodesApplication.StateHandler(true) {
+                @Override
+                public void run()
+                {
+                    googleWebView.applyWebSettings();
+                }
+            });
         }
-		
-		notifyUiCreated();
-        RhodesApplication.stateChanged(RhodesApplication.UiState.MainActivityCreated);
+        AbsoluteLayout containerView = new AbsoluteLayout(this);
+        containerView.addView(view.getView(), new AbsoluteLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT, 0, 0));
+        view.setContainerView(containerView);
+
+        return view;
     }
 
     public MainView switchToSimpleMainView(MainView currentView) {
-        MainView view = new SimpleMainView(currentView.detachWebView()); 
+        IRhoWebView rhoWebView = currentView.detachWebView();
+        SimpleMainView view = new SimpleMainView(rhoWebView);
+        rhoWebView.setWebClient(this);
         setMainView(view);
         return view;
     }
@@ -230,51 +250,35 @@ public class RhodesActivity extends BaseActivity {
 
         handleStartParams(intent);
 
-        {
-        	Iterator<RhodesActivityListener> iterator = mListeners.iterator();
-        	while (iterator.hasNext()) {
-        		iterator.next().onNewIntent(this, intent);
-        	}
-        }
+        RhoExtManager.getImplementationInstance().onNewIntent(this, intent);
     }
 
-	@Override
-	public void onStart() {
-		super.onStart();
+    @Override
+    public void onStart() {
+        super.onStart();
 
         Logger.D(TAG, "onStart");
         mIsInsideStartStop = true;
-        
+
         RhodesApplication.stateChanged(RhodesApplication.UiState.MainActivityStarted);
-        
-        for(RhodesActivityListener listener: mListeners) {
-            listener.onStart(this);
-        }
-	}
-	
-	@Override
-	public void onResume() {
+        RhoExtManager.getImplementationInstance().onStartActivity(this);
+    }
+
+    @Override
+    public void onResume() {
         Logger.D(TAG, "onResume");
-    	mIsForeground = true;
-		super.onResume();
-        {
-        	Iterator<RhodesActivityListener> iterator = mListeners.iterator();
-        	while (iterator.hasNext()) {
-        		iterator.next().onResume(this);
-        	}
-        }
-	}
+        mIsForeground = true;
+        super.onResume();
+
+        RhoExtManager.getImplementationInstance().onResumeActivity(this);
+    }
 
     @Override
     public void onPause() 
     {
-    	mIsForeground = false;
-        {
-        	Iterator<RhodesActivityListener> iterator = mListeners.iterator();
-        	while (iterator.hasNext()) {
-        		iterator.next().onPause(this);
-        	}
-        }
+        mIsForeground = false;
+
+        RhoExtManager.getImplementationInstance().onPauseActivity(this);
 
         super.onPause();
         Logger.D(TAG, "onPause");
@@ -283,27 +287,25 @@ public class RhodesActivity extends BaseActivity {
     }
 
     @Override
-	public void onStop() 
-	{
-		super.onStop();
+    public void onStop() 
+    {
+        super.onStop();
         Logger.D(TAG, "onStop");
-        for(RhodesActivityListener listener: mListeners) {
-            listener.onStop(this);
-        }
+
+        RhoExtManager.getImplementationInstance().onStopActivity(this);
+
         mIsInsideStartStop = false;
-	}
-	
-	@Override
-	public void onDestroy() {
+    }
+
+    @Override
+    public void onDestroy() {
         Logger.D(TAG, "onDestroy");
 
-        for(RhodesActivityListener listener: mListeners) {
-            listener.onDestroy(this);
-        }
-        
+        RhoExtManager.getImplementationInstance().onDestroyActivity(this);
+
         sInstance = null;
-		super.onDestroy();
-	}
+        super.onDestroy();
+    }
 	
 	@Override
 	public boolean onKeyDown(int keyCode, KeyEvent event) {
@@ -336,7 +338,22 @@ public class RhodesActivity extends BaseActivity {
 			return false;
 		return mAppMenu.onMenuItemSelected(item);
 	}
-	
+
+    @Override
+    public void onSplashScreenGone(SplashScreen splashScreen) {
+        switchToSimpleMainView(splashScreen).navigate(splashScreen.getUrlToNavigate(), 0);
+    }
+
+    @Override
+    public void onSplashScreenNavigateBack() {
+        moveTaskToBack(true);
+    }
+    
+    @Override
+    protected Dialog onCreateDialog(int id/*, Bundle args*/) {
+        return RhoExtManager.getImplementationInstance().onCreateDialog(this, id);
+    }
+
 	@Deprecated
 	public static RhodesActivity getInstance() {
 		return sInstance;
@@ -384,7 +401,7 @@ public class RhodesActivity extends BaseActivity {
 
         handleStartParams(getIntent());
 
-		ENABLE_LOADING_INDICATION = !RhoConf.getBool("disable_loading_indication");
+		//ENABLE_LOADING_INDICATION = !RhoConf.getBool("disable_loading_indication");
 	}
 
     private void handleStartParams(Intent intent)
@@ -457,6 +474,7 @@ public class RhodesActivity extends BaseActivity {
             return;
         }
 
+
 //        String urlStart = uri.getPath();
 //        if (urlStart != null) { 
 //            if ("".compareTo(urlStart) != 0)
@@ -467,6 +485,13 @@ public class RhodesActivity extends BaseActivity {
 //        }
     }
 
+    private boolean isPassMotoLicence() {
+    	if (Capabilities.MOTOROLA_ENABLED) {
+    		return true;
+    	}
+    	return RhodesService.isMotorolaLicencePassed();
+    }
+
 	public static Context getContext() {
 		RhodesActivity ra = RhodesActivity.getInstance();
 		if (ra == null)