rhodes 2.2.6 → 2.3.0.beta.1

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

@@ -48,16 +48,28 @@ public class NativeBar {
 		public void run() {
 			try {
 				RhodesService r = RhodesService.getInstance();
+				
 				MainView mainView = r.getMainView();
 				MainView v = null;
 				
+				SimpleMainView smv = null;
+				if (mainView instanceof SimpleMainView) {
+					smv = (SimpleMainView)mainView;
+				}
+				
 				switch (type) {
 				case NOBAR_TYPE:
-					v = new SimpleMainView(mainView);
+					if (smv == null)
+						v = new SimpleMainView(mainView);
+					else
+						smv.removeToolbar();
 					started = false;
 					break;
 				case TOOLBAR_TYPE:
-					v = new SimpleMainView(mainView, params);
+					if (smv == null)
+						v = new SimpleMainView(mainView, params);
+					else
+						smv.setToolbar(params);
 					started = true;
 					break;
 				case TABBAR_TYPE:
@@ -68,8 +80,14 @@ public class NativeBar {
 					Logger.E(TAG, "Unknown bar type passed: " + type);
 				}
 				
-				if (v != null)
+				if (v != null) {
 					r.setMainView(v);
+					if (v instanceof TabbedMainView) {
+						// loading of default opened tab should be after TabView insert to real Views tree
+						TabbedMainView tmv = (TabbedMainView)v;
+						tmv.loadFirstPage();
+					}
+				}
 			}
 			catch (Exception e) {
 				reportFail("CreateTask", e);

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

@@ -8,9 +8,21 @@ import android.util.Log;
 
 public class PushReceiver extends BroadcastReceiver {
 	
-	private static final String TAG = "PushReceiver";
+	private static final String TAG = PushReceiver.class.getSimpleName();
 	
 	private static final String REG_ID = "registration_id";
+	
+	public static final String INTENT_SOURCE = PushReceiver.class.getName();
+	
+	private static final String INTENT_PREFIX = PushReceiver.class.getPackage().getName();
+	
+	public static final String INTENT_TYPE = INTENT_PREFIX + ".type";
+	public static final String INTENT_REGISTRATION_ID = INTENT_PREFIX + ".registration_id";
+	public static final String INTENT_EXTRAS = INTENT_PREFIX + ".extras";
+	
+	public static final int INTENT_TYPE_UNKNOWN = 0;
+	public static final int INTENT_TYPE_REGISTRATION_ID = 1;
+	public static final int INTENT_TYPE_MESSAGE = 2;
 
 	private void handleRegistration(Context context, Intent intent) {
 		String id = intent.getStringExtra(REG_ID);
@@ -23,26 +35,22 @@ public class PushReceiver extends BroadcastReceiver {
 			Log.d(TAG, "Unregistered: " + unregistered);
 		}
 		else if (id != null) {
-			// TODO: store it in reg_id variable
-			Log.d(TAG, "Registered: id: " + id);
-			RhodesService r = RhodesService.getInstance();
-			if (r == null) {
-				Log.e(TAG, "Rhodes instance is null");
-				return;
-			}
-			r.setPushRegistrationId(id);
+			Intent serviceIntent = new Intent(context, RhodesService.class);
+			serviceIntent.putExtra(RhodesService.INTENT_SOURCE, INTENT_SOURCE);
+			serviceIntent.putExtra(INTENT_TYPE, INTENT_TYPE_REGISTRATION_ID);
+			serviceIntent.putExtra(INTENT_REGISTRATION_ID, id);
+			context.startService(serviceIntent);
 		}
 		else
 			Log.w(TAG, "Unknown registration event");
 	}
 	
 	private void handleMessage(Context context, Intent intent) {
-		RhodesService r = RhodesService.getInstance();
-		if (r == null) {
-			Log.e(TAG, "Rhodes instance is null");
-			return;
-		}
-		r.handlePushMessage(intent);
+		Intent serviceIntent = new Intent(context, RhodesService.class);
+		serviceIntent.putExtra(RhodesService.INTENT_SOURCE, INTENT_SOURCE);
+		serviceIntent.putExtra(INTENT_TYPE, INTENT_TYPE_MESSAGE);
+		serviceIntent.putExtra(INTENT_EXTRAS, intent.getExtras());
+		context.startService(serviceIntent);
 	}
 	
 	@Override

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

@@ -29,7 +29,7 @@ public class PushService {
 		
 		Logger.D(TAG, "Register for PUSH messages (use \"" + Push.SENDER + "\" as sender)");
 		
-		Context ctx = RhodesService.getInstance().getContext();
+		Context ctx = RhodesService.getContext();
 		Intent registrationIntent = new Intent(C2DM_INTENT_PREFIX + "REGISTER");
 		registrationIntent.putExtra("app", PendingIntent.getBroadcast(ctx, 0, new Intent(), 0));
 		registrationIntent.putExtra("sender", Push.SENDER);
@@ -44,7 +44,7 @@ public class PushService {
 		
 		Logger.D(TAG, "Unregister from PUSH messages");
 		
-		Context ctx = RhodesService.getInstance().getContext();
+		Context ctx = RhodesService.getContext();
 		Intent unregIntent = new Intent(C2DM_INTENT_PREFIX + "UNREGISTER");
 		unregIntent.putExtra("app", PendingIntent.getBroadcast(ctx, 0, new Intent(), 0));
 		ctx.startService(unregIntent);

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

@@ -0,0 +1,151 @@
+package com.rhomobile.rhodes;
+
+import java.security.SecureRandom;
+import java.security.spec.AlgorithmParameterSpec;
+
+import javax.crypto.Cipher;
+import javax.crypto.KeyGenerator;
+import javax.crypto.SecretKey;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+import java.nio.ByteBuffer;
+
+//import android.util.Base64;
+import android.content.SharedPreferences;
+import android.app.Activity;
+import com.rhomobile.rhodes.Logger;
+
+public class RhoCryptImpl 
+{
+    private static final String TAG = "RhoCryptJava";
+
+	byte[] m_dbKeyData;
+	String m_strDBPartition;
+	final String m_strPrefName = "rho_internal_data";
+	Cipher m_encryptCipher, m_decryptCipher;
+	final int m_nKeyLenBit = 128;  // 192 and 256 bits may not be available
+	
+	private void readKeyFromStorage()
+	{
+    	SharedPreferences settings = RhodesActivity.getInstance().getSharedPreferences( m_strPrefName, Activity.MODE_PRIVATE);
+    	String strOldKey = settings.getString(m_strDBPartition, "");
+    	if ( strOldKey != null && strOldKey.length() > 0 )
+    	{
+    		m_dbKeyData = Base64.decode(strOldKey);//, Base64.DEFAULT);
+    	}
+	}
+
+	private void generateNewKey()throws Exception
+	{
+	    KeyGenerator kgen = KeyGenerator.getInstance("AES");  
+	    SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");  
+	    kgen.init(m_nKeyLenBit, sr);  
+	    SecretKey skey = kgen.generateKey();  
+	    m_dbKeyData = skey.getEncoded();
+	}
+
+	private void writeKeyToStorage()
+	{
+		SharedPreferences settings = RhodesActivity.getInstance().getSharedPreferences(m_strPrefName, Activity.MODE_PRIVATE);		
+    	SharedPreferences.Editor editor = settings.edit();
+    	String strKey = Base64.encodeToString(m_dbKeyData, false);//, Base64.DEFAULT);
+    	editor.putString(m_strDBPartition, strKey );
+    	editor.commit();
+	}
+
+	private void initKey(String szPartition)throws Exception
+	{
+	    if ( m_dbKeyData != null )
+	        return;
+
+	    m_strDBPartition = szPartition;
+		
+		readKeyFromStorage();
+	    if ( m_dbKeyData != null )
+	        return;
+
+		generateNewKey();
+		writeKeyToStorage();
+	}
+	
+	private void initContext(String szPartition)throws Exception
+	{
+	    if ( m_dbKeyData != null )
+	        return;
+
+	    initKey(szPartition);
+	    
+		byte[] iv = new byte[]
+     	{
+     	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+     	};
+	    
+		AlgorithmParameterSpec paramSpec = new IvParameterSpec(iv);
+    	
+		SecretKeySpec skeySpec = new SecretKeySpec(m_dbKeyData, "AES");  
+		m_encryptCipher = Cipher.getInstance("AES/CBC/NoPadding");  
+		m_encryptCipher.init(Cipher.ENCRYPT_MODE, skeySpec, paramSpec);
+
+		m_decryptCipher = Cipher.getInstance("AES/CBC/NoPadding");  
+		m_decryptCipher.init(Cipher.DECRYPT_MODE, skeySpec, paramSpec);
+		
+	}
+	
+	private static void reportFail(String name, Exception e) 
+	{
+	    Logger.E(TAG, "Call of \"" + name + "\" failed: " + e.getMessage());
+	}
+	
+    public boolean db_encrypt( String szPartition, ByteBuffer dataIn, ByteBuffer dataOut )
+    {
+    	try
+    	{
+	    	initContext(szPartition);
+
+            dataOut.rewind();
+	    	m_encryptCipher.doFinal(dataIn, dataOut);
+	    	
+	    	return true;
+    	}catch(Exception exc)
+    	{
+    		reportFail("db_encrypt", exc);
+    		return false;
+    	}
+    }
+    
+    public boolean db_decrypt( String szPartition, ByteBuffer dataIn, ByteBuffer dataOut )
+    {
+    	try
+    	{
+	    	initContext(szPartition);
+
+            dataOut.rewind();
+	    	m_decryptCipher.doFinal(dataIn, dataOut);            
+	    	
+	    	return true;
+		}catch(Exception exc)
+		{
+			reportFail("db_encrypt", exc);
+			return false;
+		}
+    }
+    
+    public boolean set_db_CryptKey( String szPartition, String szKey, boolean bPersistent )
+    {
+	    m_strDBPartition = szPartition;
+	    byte[] keyData = Base64.decode(szKey);//, Base64.DEFAULT);
+	    
+	    if ( keyData.length != (m_nKeyLenBit/8))
+	    {
+	    	reportFail("set_db_CryptKey", new Exception("Incorrect key size : " + keyData.length + "; Should be: " + (int)(m_nKeyLenBit/8)));
+	    	return false;
+	    }
+	    m_dbKeyData = keyData;
+
+		if ( bPersistent )
+			writeKeyToStorage();
+	    
+    	return true;
+    }
+
+}

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

@@ -68,7 +68,7 @@ public class RhoMenu {
 			mainView.reload(mainView.activeTab());
 		}
 		else if (type.equalsIgnoreCase("home")) {
-			mainView.navigate(r.getStartUrl(), mainView.activeTab());
+			mainView.navigate(RhodesAppOptions.getStartUrl(), mainView.activeTab());
 		}
 		else if (type.equalsIgnoreCase("back")) {
 			mainView.back(mainView.activeTab());
@@ -77,7 +77,7 @@ public class RhoMenu {
 			mainView.forward(mainView.activeTab());
 		}
 		else if (type.equalsIgnoreCase("options")) {
-			mainView.navigate(r.getOptionsUrl(), mainView.activeTab());
+			mainView.navigate(RhodesAppOptions.getOptionsUrl(), mainView.activeTab());
 		}
 		else if (type.equalsIgnoreCase("sync")) {
 			r.doSyncAllSources(true);

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

@@ -0,0 +1,372 @@
+package com.rhomobile.rhodes;
+
+import java.lang.reflect.Constructor;
+
+import com.rhomobile.rhodes.bluetooth.RhoBluetoothManager;
+import com.rhomobile.rhodes.mainview.MainView;
+import com.rhomobile.rhodes.util.PerformOnUiThread;
+import com.rhomobile.rhodes.webview.ChromeClientOld;
+import com.rhomobile.rhodes.webview.RhoWebSettings;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.graphics.Bitmap;
+import android.os.Build;
+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.Window;
+import android.view.WindowManager;
+import android.webkit.WebChromeClient;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+
+public class RhodesActivity extends BaseActivity {
+	
+	private static final String TAG = RhodesActivity.class.getSimpleName();
+	
+	private static final boolean DEBUG = false;
+	
+	public static boolean ENABLE_LOADING_INDICATION = true;
+	
+	public static int MAX_PROGRESS = 10000;
+	
+	static final String RHO_START_PARAMS_KEY = "RhoStartParams";
+	
+	private static RhodesActivity sInstance;
+	
+	private Handler mHandler;
+	
+	private SplashScreen mSplashScreen;
+	
+	private MainView mMainView;
+	
+	private RhoMenu mAppMenu;
+	
+	private WebChromeClient mChromeClient;
+	private WebViewClient mWebViewClient;
+	private RhoWebSettings mWebSettings;
+	
+	private long uiThreadId = 0;
+	
+	public long getUiThreadId() {
+		return uiThreadId;
+	}
+	
+	private Runnable mSetup = new Runnable() {
+		public void run() {
+			doSetup();
+		}
+	};
+	
+	@Override
+	protected void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		
+		Thread ct = Thread.currentThread();
+		//ct.setPriority(Thread.MAX_PRIORITY);
+		uiThreadId = ct.getId();
+
+		//requestWindowFeature(Window.FEATURE_NO_TITLE);
+		
+		requestWindowFeature(Window.FEATURE_PROGRESS);
+		getWindow().setFeatureInt(Window.FEATURE_PROGRESS, 10000);
+
+		mSplashScreen = new SplashScreen(this);
+		setMainView(mSplashScreen);
+		
+		mHandler = new Handler();
+		mHandler.post(mSetup);
+		
+		sInstance = this;
+
+		RhodesService r = RhodesService.getInstance();
+		if ( r != null )
+		{
+			r.callUiCreatedCallback();
+		}else
+		{
+			mHandler.post(new Runnable() {
+				public void run() {
+					RhodesService r = RhodesService.getInstance();
+					if (r == null) {
+						// If there is no yet running RhodesService instance,
+						// try to do the same after 100ms
+						mHandler.postDelayed(this, 100);
+						return;
+					}
+				
+					r.callUiCreatedCallback();
+				}
+			});
+		}
+	}
+	
+	public static void setFullscreen(int enable) {
+		//Utils.platformLog(TAG, "setFullscreen("+String.valueOf(enable)+")");
+		final int en = enable;
+		PerformOnUiThread.exec( new Runnable() {
+			public void run() {
+				if (en != 0) {
+					getInstance().getWindow().clearFlags( WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
+					getInstance().getWindow().setFlags( WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
+				}
+				else {
+					getInstance().getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
+					getInstance().getWindow().setFlags( WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN, WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
+				}
+			}
+		}		
+		, false);
+	}
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		//sInstance = this;
+	}
+	
+	@Override
+	public void onStop() 
+	{
+		super.onStop();
+
+		RhodesService r = RhodesService.getInstance();
+		if (r != null)
+			r.callUiDestroyedCallback();
+	}
+	
+	@Override
+	public void onDestroy() {
+		//RhodesService r = RhodesService.getInstance();
+		//if (r != null)
+		//	r.callUiDestroyedCallback();
+		
+		sInstance = null;
+		super.onDestroy();
+	}
+	
+	@Override
+	public boolean onKeyDown(int keyCode, KeyEvent event) {
+		switch (keyCode) {
+		case KeyEvent.KEYCODE_BACK:
+			RhodesService r = RhodesService.getInstance();
+			if (DEBUG)
+				Log.d(TAG, "onKeyDown: r=" + r);
+			if (r == null)
+				return false;
+			
+			MainView v = r.getMainView();
+			v.back(v.activeTab());
+			return true;
+		}
+		
+		return super.onKeyDown(keyCode, event);
+	}
+	
+	@Override
+	public boolean onPrepareOptionsMenu(Menu menu) {
+		super.onPrepareOptionsMenu(menu);
+		mAppMenu = new RhoMenu(menu);
+		return true;
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item) {
+		if (mAppMenu == null)
+			return false;
+		return mAppMenu.onMenuItemSelected(item);
+	}
+	
+	public static RhodesActivity getInstance() {
+		return sInstance;
+	}
+	
+	public RhodesService getService() {
+		return mRhodesService;
+	}
+	
+	public void post(Runnable r) {
+		mHandler.post(r);
+	}
+	
+	public void post(Runnable r, int delay) {
+		mHandler.postDelayed(r, delay);
+	}
+	
+	private void doSetup() {
+		initWebStuff();
+	}
+	
+	public SplashScreen getSplashScreen() {
+		return mSplashScreen;
+	}
+	
+	public void setMainView(MainView v) {
+		setMainView(v, true);
+	}
+	
+	public void setMainView(final MainView v, boolean waitUntilNavigationDone) {
+		if (DEBUG)
+			Log.d(TAG, "setMainView: v=" + v + "; mMainView=" + mMainView);
+		
+		// If there's no previous mMainView, don't wait
+		if (mMainView == null)
+			waitUntilNavigationDone = false;
+		
+		// Set mMainView right now but not yet do it visible
+		mMainView = v;
+
+		// This is action need to be executed when mMainView should become visible 
+		final Runnable setMainViewVisible = new Runnable() {
+			public void run() {
+				if (DEBUG)
+					Log.d(TAG, "setMainViewAction: v=" + v);
+				setContentView(v.getView());
+			}
+		};
+		
+		if (true/*!waitUntilNavigationDone*/) {
+			// Make new MainView visible right now
+			setMainViewVisible.run();
+		}
+		else {
+			// If we're requested to wait until first navigation will be done,
+			// use the trick: keep current main view until first navigate will be
+			// finished in the new MainView.
+			// This will end up in good user experience - user will see
+			// new MainView only when it will have completely load its content
+			// (no blank screens for user).
+			WebView webView = v.getWebView(0);
+			webView.setWebViewClient(new WebViewClient() {
+				@Override
+				public void onPageFinished(WebView view, String url) {
+					mWebViewClient.onPageFinished(view, url);
+					// Restore standard WebViewClient to be sure this callback will not
+					// be called anymore (it should be called only once)
+					view.setWebViewClient(mWebViewClient);
+					
+					setMainViewVisible.run();
+				}
+			});
+		}
+	}
+	
+	public MainView getMainView() {
+		return mMainView;
+	}
+	
+	public WebView createWebView() {
+		WebView view = new WebView(this);
+		mWebSettings.setWebSettings(view);
+		view.setWebChromeClient(mChromeClient);
+		view.setWebViewClient(mWebViewClient);
+		view.clearCache(true);
+		
+		return view;
+	}
+	
+	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);
+			
+			Constructor<? extends WebChromeClient> ctor = ccClass.getConstructor(RhodesActivity.class);
+			mChromeClient = ctor.newInstance(this);
+			
+			pkgname = RhoWebSettings.class.getPackage().getName();
+			fullName = pkgname + "." + wsName;
+			Class<? extends RhoWebSettings> wsClass =
+				Class.forName(fullName).asSubclass(RhoWebSettings.class);
+			mWebSettings = wsClass.newInstance();
+			
+			mWebViewClient = new WebViewClient() {
+				@Override
+				public boolean shouldOverrideUrlLoading(WebView view, String url) {
+					return getService().handleUrlLoading(url);
+				}
+				
+				@Override
+				public void onPageStarted(WebView view, String url, Bitmap favicon) {
+					if (ENABLE_LOADING_INDICATION)
+						getWindow().setFeatureInt(Window.FEATURE_PROGRESS, 0);
+					super.onPageStarted(view, url, favicon);
+				}
+				
+				@Override
+				public void onPageFinished(WebView view, String url) {
+					// Set title
+					String title = view.getTitle();
+					setTitle(title);
+					if (ENABLE_LOADING_INDICATION)
+						getWindow().setFeatureInt(Window.FEATURE_PROGRESS, MAX_PROGRESS);
+					
+					super.onPageFinished(view, url);
+				}
+			};
+		}
+		catch (Exception e) {
+			throw new IllegalStateException(e);
+		}
+	}
+
+	@Override
+	public void onServiceConnected(ComponentName name, IBinder service) {
+		super.onServiceConnected(name, service);
+		
+		if (!isValidSecurityToken()) {
+			Logger.E(TAG, "This is hidden app and can be started only with security key.");
+			getRhodesApplication().exit();
+			return;
+		}
+		
+		ENABLE_LOADING_INDICATION = !RhoConf.getBool("disable_loading_indication");
+	}
+
+	private boolean isValidSecurityToken() 
+	{
+	    String rho_start_params = "";
+	    
+		Object params = getIntent().getExtras();
+		if (params != null && params instanceof Bundle) 
+		{
+			Bundle startParams = (Bundle)params;
+			rho_start_params = startParams.getString(RHO_START_PARAMS_KEY);
+	    }
+	    
+	    return RhodesService.canStartApp(rho_start_params, ", ");
+	}
+	
+	public static Context getContext() {
+		RhodesActivity ra = RhodesActivity.getInstance();
+		if (ra == null)
+			throw new IllegalStateException("No rhodes activity instance at this moment");
+		return ra;
+	}
+	
+	@Override
+	public void onActivityResult(int requestCode, int resultCode, Intent data) {
+		RhoBluetoothManager.onActivityResult(requestCode, resultCode, data);
+	}
+	
+}

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

@@ -0,0 +1,11 @@
+package com.rhomobile.rhodes;
+
+public class RhodesAppOptions {
+
+	public static native String getOptionsUrl();
+	public static native String getStartUrl();
+	public static native String getCurrentUrl();
+	public static native String getAppBackUrl();
+	public static native String getBlobPath();
+	
+}