rhodes 3.0.0 → 3.0.1.beta.2

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

@@ -1,6 +1,8 @@
 package com.rhomobile.rhodes;
 
 import java.lang.reflect.Constructor;
+import java.util.ArrayList;
+import java.util.Iterator;
 
 import com.rhomobile.rhodes.bluetooth.RhoBluetoothManager;
 import com.rhomobile.rhodes.mainview.MainView;
@@ -55,6 +57,7 @@ public class RhodesActivity extends BaseActivity {
 	private WebChromeClient mChromeClient;
 	private WebViewClient mWebViewClient;
 	private RhoWebSettings mWebSettings;
+
 	
 	private long uiThreadId = 0;
 	
@@ -62,6 +65,25 @@ public class RhodesActivity extends BaseActivity {
 		return uiThreadId;
 	}
 	
+	private ArrayList<RhodesActivityListener> mListeners = null;
+	
+	private boolean mIsForeground = false;
+	
+	public boolean isForegroundNow() {
+		return mIsForeground;
+	}
+	
+	public void addRhodesActivityListener(RhodesActivityListener listener) {
+		if (!mListeners.contains(listener)) {
+			mListeners.add(listener);
+		}
+	}
+	
+	public void removeRhodesActivityListener(RhodesActivityListener listener) {
+		mListeners.remove(listener);
+	}
+	
+	
 	private Runnable mSetup = new Runnable() {
 		public void run() {
 			doSetup();
@@ -73,6 +95,8 @@ public class RhodesActivity extends BaseActivity {
 		
 		super.onCreate(savedInstanceState);
 		
+		mListeners = new ArrayList<RhodesActivityListener>();
+		
 		Thread ct = Thread.currentThread();
 		//ct.setPriority(Thread.MAX_PRIORITY);
 		uiThreadId = ct.getId();
@@ -135,14 +159,19 @@ public class RhodesActivity extends BaseActivity {
 					getInstance().getWindow().setFlags( WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN, WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
 				}
 			}
-		}		
-		, false);
+		});
 	}
 
 	@Override
 	protected void onNewIntent(Intent intent) {
 	    super.onNewIntent(intent);
-        Log.i(TAG, ">>>>>>>>>>>>>>> onNewIntent()");
+        Log.d(TAG, "RhodesActivity.onNewIntent()");
+        {
+        	Iterator<RhodesActivityListener> iterator = mListeners.iterator();
+        	while (iterator.hasNext()) {
+        		iterator.next().onNewIntent(this, intent);
+        	}
+        }
 	}
 	
 	@Override
@@ -150,36 +179,54 @@ public class RhodesActivity extends BaseActivity {
 		super.onStart();
 	    RhodesService.rhodesActivityStarted(true);
 
-        Log.i(TAG, ">>>>>>>>>>>>>>> onStart()");
+        Log.d(TAG, "RhodesActivity.onStart()");
         
         RhodesApplication.stateChanged(RhodesApplication.UiState.MainActivityStarted);
-}
+	}
+	
+	@Override
+	public void onResume() {
+    	mIsForeground = true;
+		super.onResume();
+        {
+        	Iterator<RhodesActivityListener> iterator = mListeners.iterator();
+        	while (iterator.hasNext()) {
+        		iterator.next().onResume(this);
+        	}
+        }
+	}
 
     @Override
     public void onPause() 
     {
+    	mIsForeground = false;
+        {
+        	Iterator<RhodesActivityListener> iterator = mListeners.iterator();
+        	while (iterator.hasNext()) {
+        		iterator.next().onPause(this);
+        	}
+        }
+    	
         RhodesApplication.stateChanged(RhodesApplication.UiState.MainActivityPaused);
 
         RhodesService.rhodesActivityStarted(false);
 
         super.onPause();
-        Log.i(TAG, ">>>>>>>>>>>>>>> onPause()");
+        Log.d(TAG, "RhodesActivity.onPause()");
 
-        RhodesService r = RhodesService.getInstance();
-        if (r != null)
-            r.callUiDestroyedCallback();
+        RhodesService.callUiDestroyedCallback();
     }
 
     @Override
 	public void onStop() 
 	{
 		super.onStop();
-        Log.i(TAG, ">>>>>>>>>>>>>>> onStop()");
+        Log.d(TAG, "RhodesActivity.onStop()");
 	}
 	
 	@Override
 	public void onDestroy() {
-        Log.i(TAG, ">>>>>>>>>>>>>>> onDestroy()");
+        Log.d(TAG, "RhodesActivity.onDestroy()");
         
         //TODO: Check is it really correct in case activity killed immediately after onPause()
         sInstance = null;
@@ -218,10 +265,18 @@ public class RhodesActivity extends BaseActivity {
 		return mAppMenu.onMenuItemSelected(item);
 	}
 	
+	@Deprecated
 	public static RhodesActivity getInstance() {
 		return sInstance;
 	}
-	
+
+    public static RhodesActivity safeGetInstance() throws NullPointerException {
+        if(sInstance != null)
+            return sInstance;
+        else
+            throw new NullPointerException("RhodesActivity.sInstance == null");
+    }
+
 	public RhodesService getService() {
 		return mRhodesService;
 	}

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

@@ -0,0 +1,14 @@
+package com.rhomobile.rhodes;
+
+import android.content.Intent;
+
+
+public interface RhodesActivityListener {
+	
+	void onPause(RhodesActivity activity);
+	void onResume(RhodesActivity activity);
+	void onNewIntent(RhodesActivity activity, Intent intent);
+	
+	
+	
+}

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

@@ -1,5 +1,6 @@
 package com.rhomobile.rhodes;
 
+import java.util.Collection;
 import java.util.Vector;
 
 import android.app.Application;
@@ -21,11 +22,19 @@ public class RhodesApplication extends Application{
 	
     public static void create()
     {
+        if (sAppState != AppState.Undefined) {
+            Logger.E(TAG, "Cannot create application, it is already started!!!");
+            return;
+        }
         createRhodesApp();
     }
 
     public static void start()
 	{
+        if (sAppState != AppState.Undefined) {
+            Logger.E(TAG, "Cannot start application it is already started!!!");
+            return;
+        }
 	    startRhodesApp();
 	}
 
@@ -50,12 +59,34 @@ public class RhodesApplication extends Application{
         }, 500);
     }
 
-    public interface StateHandler
+    
+    public static abstract class StateHandler implements Runnable
     {
-        boolean run();
+        private Exception error;
+        private boolean runOnce;
+        
+        public StateHandler(boolean once) { runOnce = once; }
+
+        protected void setError(Exception err) { error = err; }
+        public Exception getError() { return error; }
+        public boolean isRunOnce() { return runOnce; }
+        public abstract void run();
+    }
+
+    private static void runHandlers(Collection<StateHandler> handlers)
+    { 
+    	for(StateHandler handler: handlers) {
+    		handler.run();
+            Exception error = handler.getError();
+            if (error != null)
+            {
+                Logger.E(TAG, error);
+                Thread.dumpStack();
+            }
+    	}
     }
     
-    enum AppState
+    public enum AppState
     {
         Undefined("Undefined") {
             @Override
@@ -74,30 +105,52 @@ public class RhodesApplication extends Application{
             public boolean canHandle(AppState state) { return (state == this) || (state == AppStarted); }
         };
         
+        private static boolean appActivatedFlag = false;
+        
         private Vector<StateHandler> mHandlers = new Vector<StateHandler>();
         private String TAG;
         
         private AppState(String tag) { TAG = tag; }
         
-        private synchronized void handle()
+        private synchronized Collection<StateHandler> commit()
         {
-            Logger.T(TAG, "Running AppState handlers: " + TAG);
-            Vector<StateHandler> doneHandlers = new Vector<StateHandler>();
-            for (StateHandler handler: mHandlers) {
-                if (handler.run()) {
-                    doneHandlers.add(handler);
-                }
+            Vector<StateHandler> handlers = new Vector<StateHandler>();
+
+            Logger.T(TAG, "Starting commit. Current AppState: " + sAppState.TAG);
+            if((this == AppActivated) && (sAppState == Undefined)) {
+                appActivatedFlag = true;
+                Logger.I(TAG, "Cannot commit now, application will be activated when started.");
+            } else {
+       	      	Logger.T(TAG, "Commiting AppState handlers.");
+	            Vector<StateHandler> doneHandlers = new Vector<StateHandler>();
+	            for (StateHandler handler: mHandlers) {
+	            	handlers.add(handler);
+	                if (handler.isRunOnce()) {
+	                    doneHandlers.add(handler);
+	                }
+	            }
+	            mHandlers.removeAll(doneHandlers);
+	            sAppState = this;
             }
-            mHandlers.removeAll(doneHandlers);
+            Logger.T(TAG, "After AppState commit: " + sAppState.TAG);
+            return handlers;
         }
         
         public synchronized void addHandler(StateHandler handler) { mHandlers.add(handler); }
         public abstract boolean canHandle(AppState state);
         
-        static public void handleState(AppState state) { state.handle(); }
+        static public void handleState(AppState state) {
+            runHandlers(state.commit());
+            Logger.I(sAppState.TAG, "Handlers have completed.");
+            if((state == AppStarted) && appActivatedFlag) {
+                runHandlers(AppActivated.commit());
+                Logger.I(sAppState.TAG, "Handlers have completed.");
+            }
+            return;
+        }
     }
     
-    enum UiState
+    public enum UiState
     {
         Undefined("Undefined") {
             @Override
@@ -121,31 +174,50 @@ public class RhodesApplication extends Application{
         
         private UiState(String tag) { TAG = tag; }
         
-        private synchronized void handle()
+        private synchronized Collection<StateHandler> commit()
         {
-            Logger.T(TAG, "Running AppState handlers: " + TAG);
-            Vector<StateHandler> doneHandlers = new Vector<StateHandler>();
-            for (StateHandler handler: mHandlers) {
-                if (handler.run()) {
-                    doneHandlers.add(handler);
-                }
-            }
-            mHandlers.removeAll(doneHandlers);
+            Vector<StateHandler> handlers = new Vector<StateHandler>();
+
+            Logger.T(TAG, "Starting commit. Current UiState: " + sUiState.TAG);
+
+            if (!sUiState.canHandle(this)) {
+        		
+	            Logger.T(TAG, "Commiting UiState handlers.");
+	            Vector<StateHandler> doneHandlers = new Vector<StateHandler>();
+	            for (StateHandler handler: mHandlers) {
+	            	handlers.add(handler);
+	                if (handler.isRunOnce()) {
+	                    doneHandlers.add(handler);
+	                }
+	            }
+	            mHandlers.removeAll(doneHandlers);
+	            sUiState = this;
+        	}
+            Logger.T(TAG, "After UiState commit: " + sUiState.TAG);
+            return handlers;
         }
         
         public synchronized void addHandler(StateHandler handler) { mHandlers.add(handler); }
         public abstract boolean canHandle(UiState state);
         
-        static public void handleState(UiState state) { state.handle(); }
+        static public void handleState(UiState state) {
+            runHandlers(state.commit());
+            Logger.I(sAppState.TAG, "Handlers have completed.");
+        }
     }
 
     private static AppState sAppState = AppState.Undefined;
     private static UiState sUiState = UiState.Undefined;
     
+    public static boolean canHandleNow(AppState state) { return sAppState.canHandle(state); }
+    public static boolean canHandleNow(UiState state) { return sUiState.canHandle(state); }
+    
     public static void runWhen(AppState state, StateHandler handler) {
+        Logger.T(TAG, "Current AppState : " + sAppState.TAG);
         if (sAppState.canHandle(state)) {
             Logger.T(TAG, "Running AppState handler immediately: " + state.TAG);
-            if (handler.run())
+            handler.run();
+            if (handler.isRunOnce())
                 return;
         }
         state.addHandler(handler);
@@ -153,9 +225,11 @@ public class RhodesApplication extends Application{
     }
 
     public static void runWhen(UiState state, StateHandler handler) {
+        Logger.T(TAG, "Current UiState : " + sUiState.TAG);
         if (sUiState.canHandle(state)) {
             Logger.T(TAG, "Running UiState handler immediately: " + state.TAG);
-            if (handler.run())
+            handler.run();
+            if (handler.isRunOnce())
                 return;
         }
         state.addHandler(handler);
@@ -164,13 +238,13 @@ public class RhodesApplication extends Application{
 
     public static void stateChanged(AppState state)
     {
-        sAppState = state;
-        AppState.handleState(state); 
+        AppState.handleState(state);
+        Logger.I(TAG, "New AppState: " + sAppState.TAG);
     }
     public static void stateChanged(UiState state)
     {
-        sUiState = state;
         UiState.handleState(state);
+        Logger.I(TAG, "New UiState: " + sUiState.TAG);
     }
 
 }

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

@@ -74,7 +74,7 @@ public class RhodesService extends Service {
 	
 	private static final String TAG = RhodesService.class.getSimpleName();
 	
-	private static final boolean DEBUG = true;
+	private static final boolean DEBUG = false;
 	
 	public static final String INTENT_EXTRA_PREFIX = "com.rhomobile.rhodes.";
 	
@@ -404,8 +404,11 @@ public class RhodesService extends Service {
 		
 		try {
 			if (Capabilities.PUSH_ENABLED) {
-				if (getPushRegistrationId().length() == 0)
+				String pushPin = getPushRegistrationId();
+				if (pushPin.length() == 0)
 					PushService.register();
+				else
+				    Log.i(TAG, "PUSH already registered: " + pushPin);
 			}
 		} catch (IllegalAccessException e) {
 			Log.e(TAG, e.getMessage());
@@ -512,12 +515,11 @@ public class RhodesService extends Service {
 				Logger.D(TAG, "Received PUSH message: " + extras);
 				RhodesApplication.runWhen(
 				        RhodesApplication.AppState.AppStarted,
-				        new RhodesApplication.StateHandler() {
+				        new RhodesApplication.StateHandler(true) {
                             @Override
-                            public boolean run()
+                            public void run()
                             {
                                 handlePushMessage(extras);
-                                return true;
                             }
                         });
 				break;
@@ -583,9 +585,8 @@ public class RhodesService extends Service {
 		}
 	}
 	
-	public void setMainView(MainView v) {
-		RhodesActivity ra = RhodesActivity.getInstance();
-		ra.setMainView(v);
+	public void setMainView(MainView v) throws NullPointerException {
+		RhodesActivity.safeGetInstance().setMainView(v);
 	}
 	
 	public MainView getMainView() {
@@ -638,7 +639,7 @@ public class RhodesService extends Service {
 				aboutDialog.setCancelable(true);
 				aboutDialog.show();
 			}
-		}, false);
+		});
 	}
 	
 	public static void showLogView() {
@@ -649,7 +650,7 @@ public class RhodesService extends Service {
 				logViewDialog.setCancelable(true);
 				logViewDialog.show();
 			}
-		}, false);
+		});
 	}
 	
 	public static void showLogOptions() {
@@ -660,7 +661,7 @@ public class RhodesService extends Service {
 				logOptionsDialog.setCancelable(true);
 				logOptionsDialog.show();
 			}
-		}, false);
+		});
 	}
 	
 	// Called from native code
@@ -1109,7 +1110,7 @@ public class RhodesService extends Service {
 									Logger.E(TAG, "Can't install file from " + tmpFile.getAbsolutePath() + ": " + e.getMessage());
 								}
 							}
-						}, false);
+						});
 					}
 				}
 				catch (IOException e) {
@@ -1206,7 +1207,7 @@ public class RhodesService extends Service {
         if (Push.PUSH_NOTIFICATIONS.equals(NOTIFICATION_ALWAYS))
             statusNotification = true;
         else if (Push.PUSH_NOTIFICATIONS.equals(NOTIFICATION_BACKGROUND))
-            statusNotification = !isRhodesActivityStarted();
+            statusNotification = !RhodesApplication.canHandleNow(RhodesApplication.AppState.AppActivated);
         
         if (statusNotification) {
             Intent intent = new Intent(getContext(), RhodesActivity.class);
@@ -1215,28 +1216,12 @@ public class RhodesService extends Service {
 
 		if (alert != null) {
 			Logger.D(TAG, "PUSH: Alert: " + alert);
-			RhodesApplication.runWhen(
-			        RhodesApplication.UiState.MainActivityStarted,
-			        new RhodesApplication.StateHandler() {
-                        @Override
-                        public boolean run() {
-                            Alert.showPopup(alert);
-                            return true;
-                        }
-			        });
+            Alert.showPopup(alert);
 		}
 		final String sound = extras.getString("sound");
 		if (sound != null) {
 			Logger.D(TAG, "PUSH: Sound file name: " + sound);
-            RhodesApplication.runWhen(
-                    RhodesApplication.UiState.MainActivityStarted,
-                    new RhodesApplication.StateHandler() {
-                        @Override
-                        public boolean run() {
-                            Alert.playFile("/public/alerts/" + sound, null);
-                            return true;
-                        }
-                    });
+            Alert.playFile("/public/alerts/" + sound, null);
 		}
 		String vibrate = extras.getString("vibrate");
 		if (vibrate != null) {
@@ -1250,15 +1235,7 @@ public class RhodesService extends Service {
 			}
 			final int arg_duration = duration;
 			Logger.D(TAG, "Vibrate " + duration + " seconds");
-            RhodesApplication.runWhen(
-                    RhodesApplication.UiState.MainActivityStarted,
-                    new RhodesApplication.StateHandler() {
-                        @Override
-                        public boolean run() {
-                            Alert.vibrate(arg_duration);
-                            return true;
-                        }
-                    });
+            Alert.vibrate(arg_duration);
 		}
 		
 		String syncSources = extras.getString("do_sync");
@@ -1272,28 +1249,12 @@ public class RhodesService extends Service {
 				    break;
 				} else {
 				    final String arg_source = source.trim();
-		            RhodesApplication.runWhen(
-		                    RhodesApplication.AppState.AppStarted,
-		                    new RhodesApplication.StateHandler() {
-		                        @Override
-		                        public boolean run() {
-		                            doSyncSource(arg_source);
-		                            return true;
-		                        }
-		                    });
+                    doSyncSource(arg_source);
 				}
 			}
 			
 			if (syncAll) {
-                RhodesApplication.runWhen(
-                        RhodesApplication.AppState.AppStarted,
-                        new RhodesApplication.StateHandler() {
-                            @Override
-                            public boolean run() {
-                                doSyncAllSources(true); 
-                                return true;
-                            }
-                        });
+                doSyncAllSources(true); 
 			}
 		}
 	}
@@ -1337,7 +1298,7 @@ public class RhodesService extends Service {
 			            RhodesService rs = RhodesService.getInstance();
 			            if(rs != null) rs.wakeLock.acquire(true);
 			            else Logger.E(TAG, "rho_sys_set_sleeping() - No RhodesService has initialized !!!"); }
-			    }, false);
+			    });
 			}
 		}
 		return wasEnabled;
@@ -1395,7 +1356,7 @@ public class RhodesService extends Service {
 	public void startActivity(Intent intent) {
 
         RhodesActivity ra = RhodesActivity.getInstance();
-        if(intent.getComponent().compareTo(new ComponentName(this, RhodesActivity.class.getName())) == 0) {
+        if(intent.getComponent() != null && intent.getComponent().compareTo(new ComponentName(this, RhodesActivity.class.getName())) == 0) {
             Logger.T(TAG, "Start or bring main activity: " + RhodesActivity.class.getName() + ".");
             intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
             if (ra == null) {
@@ -1406,6 +1367,19 @@ public class RhodesService extends Service {
         }
 
         if (ra != null) {
+            Logger.T(TAG, "Starting new activity on top.");
+            if (DEBUG) {
+                Bundle extras = intent.getExtras();
+                if (extras != null) {
+                    for (String key: extras.keySet()) {
+                        Object val = extras.get(key);
+                        if(val != null)
+                            Log.d(TAG, key + ": " + val.toString());
+                        else
+                            Log.d(TAG, key + ": <empty>");
+                    }
+                }
+            }
             ra.startActivity(intent);
         } else {
             throw new IllegalStateException("Trying to start activity, but there is no main activity instance (we are in background, no UI active)");
@@ -1434,13 +1408,8 @@ public class RhodesService extends Service {
             throw new IllegalStateException("No rhodes service instance at this moment");
 
         Logger.T(TAG, "Bring main activity to front");
-        if (RhodesActivity.getInstance() != null)
-            Logger.T(TAG, "There is main activity, should bring to front");
-        else
-            Logger.T(TAG, "There is no main activity, should start new one");
-        
+
         Intent intent = new Intent(srv, RhodesActivity.class);
-//        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
         srv.startActivity(intent);
     }