rhodes 2.3.2 → 2.4.0.beta.1

data/platform/wp7/RhoRubyLib/rubyext/RhoJSON.cs

@@ -0,0 +1,39 @@
+using Microsoft.Scripting.Utils;
+using Microsoft.Scripting.Runtime;
+using IronRuby.Runtime;
+using IronRuby.Builtins;
+using System;
+using System.Runtime.InteropServices;
+
+namespace rho.rubyext
+{
+    [RubyModule("Rho")]
+    public static class Rho
+    {
+        [RubyModule("JSON")]
+        public static class RhoJSON
+        {
+            #region Private Implementation Details
+
+            #endregion
+
+            #region Private Instance & Singleton Methods
+
+            [RubyMethodAttribute("parse", RubyMethodAttributes.PublicSingleton)]
+            public static object parse(RubyModule/*!*/ self, [NotNull]string/*!*/ strData)
+            {
+                return fastJSON.RJSONTokener.JsonDecode(strData);
+            }
+
+            [RubyMethodAttribute("quote_value", RubyMethodAttributes.PublicSingleton)]
+            public static object quote_value(RubyModule/*!*/ self, [NotNull]string/*!*/ strData)
+            {
+                String strRes = rho.json.JSONEntry.quoteValue(strData);
+
+                return CRhoRuby.Instance.createString(strRes);
+            }
+
+            #endregion
+        }
+    }
+}

data/platform/wp7/RhoRubyLib/rubyext/RhoKernelOps.cs

@@ -0,0 +1,19 @@
+using System;
+using Microsoft.Scripting.Utils;
+using Microsoft.Scripting.Runtime;
+using IronRuby.Runtime;
+using IronRuby.Builtins;
+using rho.common;
+
+namespace rho.rubyext
+{
+    public static class RhoKernelOps
+    {
+        private static CRhodesApp RhodesApp { get { return CRhodesApp.Instance; } }
+
+        public static Object __rhoGetCallbackObject(Object/*!*/ self, int index)
+        {
+            return RhodesApp.getCallbackObject(index); ;
+        }
+    }
+}

data/platform/wp7/RhoRubyLib/rubyext/RhoNativeBar.cs

@@ -0,0 +1,117 @@
+using Microsoft.Scripting.Utils;
+using Microsoft.Scripting.Runtime;
+using IronRuby.Runtime;
+using IronRuby.Builtins;
+using System;
+using System.Runtime.InteropServices;
+using rho.common;
+
+namespace rho.rubyext
+{
+    [RubyModule("NativeBar")]
+    public static class RhoNativeBar
+    {
+
+        #region Private Implementation Details
+
+        private static CRhodesApp RhodesApp { get { return CRhodesApp.Instance; } }
+
+        #endregion
+
+        #region Private Instance & Singleton Methods
+
+        [RubyMethodAttribute("create", RubyMethodAttributes.PublicSingleton)]
+        public static void Create(RubyModule/*!*/ self, int barType, RubyArray args)
+        {
+            if (args != null && args.Count > 0)
+                RhodesApp.createToolBar(barType, (Object)args);
+
+            if (barType == 2)
+                RhodesApp.removeToolBar();
+        }
+
+        [RubyMethodAttribute("create", RubyMethodAttributes.PublicSingleton)]
+        public static void Create(RubyModule/*!*/ self, int barType, Hash args)
+        {
+            if (args != null && args.Count > 0)
+                RhodesApp.createToolBar(barType, (Object)args);
+
+            if (barType == 2)
+                RhodesApp.removeToolBar();
+        }
+
+        [RubyMethodAttribute("remove", RubyMethodAttributes.PublicSingleton)]
+        public static void Remove(RubyModule/*!*/ self)
+        {
+            RhodesApp.removeToolBar();
+        }
+
+        [RubyMethodAttribute("switch_tab", RubyMethodAttributes.PublicSingleton)]
+        public static void switchTab(RubyModule/*!*/ self, int index)
+        {
+
+        }
+
+        [RubyMethodAttribute("started", RubyMethodAttributes.PublicSingleton)]
+        public static Boolean isStarted(RubyModule/*!*/ self)
+        {
+            return RhodesApp.barIsStarted;
+        }
+
+        [RubyMethodAttribute("set_tab_badge", RubyMethodAttributes.PublicSingleton)]
+        public static void setTabBadge(RubyModule/*!*/ self, int index, MutableString/*!*/ val)
+        {
+
+        }
+
+        [RubyMethodAttribute("create_native_toolbar", RubyMethodAttributes.PublicSingleton)]
+        public static void createNativeToolBar(RubyModule/*!*/ self, int barType, RubyArray args)
+        {
+            Create(self, barType, args);
+        }
+
+        [RubyMethodAttribute("create_native_toolbar", RubyMethodAttributes.PublicSingleton)]
+        public static void createNativeToolBar(RubyModule/*!*/ self, int barType, Hash args)
+        {
+            Create(self, barType, args);
+        }
+
+        [RubyMethodAttribute("remove_native_toolbar", RubyMethodAttributes.PublicSingleton)]
+        public static void removeNativeToolBar(RubyModule/*!*/ self)
+        {
+            Remove(self);
+        }
+
+        [RubyMethodAttribute("create_native_tabbar", RubyMethodAttributes.PublicSingleton)]
+        public static void createNativeTabBar(RubyModule/*!*/ self, int barType, RubyArray args)
+        {
+
+        }
+
+        [RubyMethodAttribute("remove_native_tabbar", RubyMethodAttributes.PublicSingleton)]
+        public static void removeNativeTabBar(RubyModule/*!*/ self)
+        {
+
+        }
+
+        [RubyMethodAttribute("native_tabbar_switch_tab", RubyMethodAttributes.PublicSingleton)]
+        public static void nativeTabBarSwitchTab(RubyModule/*!*/ self, int index)
+        {
+
+        }
+
+        [RubyMethodAttribute("native_tabbar_set_tab_badge", RubyMethodAttributes.PublicSingleton)]
+        public static void nativeTabBarSetTabBadge(RubyModule/*!*/ self, int index, MutableString/*!*/ val)
+        {
+
+        }
+
+        [RubyMethodAttribute("native_tabbar_get_current_tab", RubyMethodAttributes.PublicSingleton)]
+        public static void nativeTabBarGetCurrentTab(RubyModule/*!*/ self)
+        {
+      
+        }
+
+        #endregion
+    }
+}

data/platform/wp7/RhoRubyLib/rubyext/RhoSyncEngine.cs

@@ -0,0 +1,199 @@
+using Microsoft.Scripting.Utils;
+using Microsoft.Scripting.Runtime;
+using IronRuby.Runtime;
+using IronRuby.Builtins;
+using System;
+using rho.sync;
+using rho.common;
+using rho.db;
+
+namespace rho.rubyext
+{
+    [RubyModule("SyncEngine")]
+    public static class RhoSyncEngine
+    {
+        private static RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() :
+                    new RhoLogger("Sync");
+        static CRhoRuby RhoRuby { get { return CRhoRuby.Instance; } }
+
+        [RubyMethod("dosync", RubyMethodAttributes.PublicSingleton)]
+        public static object dosync(RubyModule/*!*/ self)
+        {
+            SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncAll, false));
+            return SyncThread.getInstance().getRetValue();
+        }
+
+        [RubyMethod("dosync", RubyMethodAttributes.PublicSingleton)]
+        public static object dosync(RubyModule/*!*/ self, bool/*!*/ show_status_popup)
+        {
+            SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncAll, show_status_popup));
+            return SyncThread.getInstance().getRetValue();
+        }
+
+        [RubyMethod("dosync_source", RubyMethodAttributes.PublicSingleton)]
+        public static object dosync_source(RubyModule/*!*/ self, [NotNull]object/*!*/ srcID)
+        {
+            int nSrcID = 0;
+			String strName = "";
+            if (srcID is long)
+                nSrcID = (int)(long)srcID;
+            else if (srcID is int)
+                nSrcID = (int)srcID;
+            else
+                strName = srcID.ToString();
+
+            SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncOne, strName, nSrcID, true));
+            return SyncThread.getInstance().getRetValue();
+        }
+        
+        [RubyMethod("dosync_source", RubyMethodAttributes.PublicSingleton)]
+        public static object dosync_source(RubyModule/*!*/ self, [NotNull]object/*!*/ srcID, bool/*!*/ show_status_popup)
+        {
+            int nSrcID = 0;
+            String strName = "";
+            if (srcID is long)
+                nSrcID = (int)(long)srcID;
+            else if (srcID is int)
+                nSrcID = (int)srcID;
+            else
+                strName = srcID.ToString();
+
+            SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncOne, strName, nSrcID, show_status_popup));
+            return SyncThread.getInstance().getRetValue();
+        }
+
+        [RubyMethod("dosearch", RubyMethodAttributes.PublicSingleton)]
+        public static object dosearch(RubyModule/*!*/ self, [NotNull]RubyArray/*!*/ arSourcesR, [NotNull]String/*!*/ from, [NotNull]String/*!*/ strParams,
+            [NotNull]bool/*!*/ bSearchSyncChanges, [NotNull]int/*!*/ nProgressStep, String/*!*/ strCallback, String/*!*/ strCallbackParams)
+        {
+            SyncThread.stopSync();
+
+			if ( strCallback != null && strCallback.Length > 0 )
+				SyncThread.getSyncEngine().getNotify().setSearchNotification(strCallback, strCallbackParams);
+
+            Vector<String> arSources = RhoRuby.makeVectorStringFromArray(arSourcesR);
+
+            SyncThread.getInstance().addQueueCommand(new SyncThread.SyncSearchCommand(from, strParams, arSources, bSearchSyncChanges, nProgressStep));        
+
+            return SyncThread.getInstance().getRetValue();
+        }
+
+        [RubyMethod("logged_in", RubyMethodAttributes.PublicSingleton)]
+        public static int logged_in(RubyModule/*!*/ self)
+        {
+            return SyncThread.getSyncEngine().isLoggedIn() ? 1 : 0;
+        }
+
+        [RubyMethod("login", RubyMethodAttributes.PublicSingleton)]
+        public static object login(RubyModule/*!*/ self, [NotNull]String/*!*/ name, [NotNull]String/*!*/ pwd, [NotNull]String/*!*/ callback)
+        {
+            try{
+                SyncThread.stopSync();
+
+                SyncThread.getInstance().addQueueCommand(new SyncThread.SyncLoginCommand(name, pwd, callback,
+                        new SyncNotify.SyncNotification(callback, "", false)));
+                return SyncThread.getInstance().getRetValue();
+            }
+            catch (Exception e)
+            {
+                LOG.ERROR("SyncEngine.login", e);
+                RhoRuby.raise_RhoError(RhoAppAdapter.ERR_RUNTIME);
+            }
+
+            return null;
+        }
+
+        [RubyMethod("set_notification", RubyMethodAttributes.PublicSingleton)]
+        public static void set_notification(RubyModule/*!*/ self, [NotNull]int/*!*/ nSrcID, [NotNull]String/*!*/ url, string/*!*/ callback_param)
+        {
+            SyncThread.getSyncEngine().getNotify().setSyncNotification(nSrcID,
+                new SyncNotify.SyncNotification(url, callback_param != null ? callback_param : "", nSrcID != -1));
+        }
+
+        [RubyMethod("enable_status_popup", RubyMethodAttributes.PublicSingleton)]
+        public static void enable_status_popup(RubyModule/*!*/ self, bool/*!*/ bEnable)
+        {
+            SyncThread.getSyncEngine().getNotify().enableStatusPopup(bEnable);
+        }
+
+        [RubyMethod("is_blob_attr", RubyMethodAttributes.PublicSingleton)]
+        public static bool is_blob_attr(RubyModule/*!*/ self, [NotNull]String/*!*/ strPartition, [NotNull]int/*!*/ nSrcID, [NotNull]String/*!*/ strAttrName)
+        {
+            return DBAdapter.getDB(strPartition).getAttrMgr().isBlobAttr(nSrcID, strAttrName);
+        }
+
+        [RubyMethod("update_blob_attribs", RubyMethodAttributes.PublicSingleton)]
+        public static void update_blob_attribs(RubyModule/*!*/ self, [NotNull]String/*!*/ strPartition, [NotNull]int/*!*/ srcID)
+        {
+            DBAdapter db = DBAdapter.getDB(strPartition);
+            db.getAttrMgr().loadBlobAttrs(db);
+        }
+
+        [RubyMethod("set_threaded_mode", RubyMethodAttributes.PublicSingleton)]
+        public static void set_threaded_mode(RubyModule/*!*/ self, [NotNull]bool/*!*/ bThreadMode)
+        {
+            SyncThread.getInstance().setNonThreadedMode(!bThreadMode);
+            SyncThread.getSyncEngine().setNonThreadedMode(!bThreadMode);
+        }
+
+        [RubyMethod("logout", RubyMethodAttributes.PublicSingleton)]
+        public static void logout(RubyModule/*!*/ self)
+        {
+            SyncThread.stopSync();
+            SyncThread.getSyncEngine().stopSyncByUser();
+            SyncThread.getSyncEngine().logout();
+        }
+
+        [RubyMethod("set_syncserver", RubyMethodAttributes.PublicSingleton)]
+        public static void set_syncserver(RubyModule/*!*/ self, [NotNull]String/*!*/ syncserver)
+        {
+            SyncThread.stopSync();
+            SyncThread.getSyncEngine().setSyncServer(syncserver);
+
+            if (syncserver != null && syncserver.length() > 0)
+            {
+                SyncThread.getInstance().start(SyncThread.epLow);
+                if (ClientRegister.getInstance() != null)
+                    ClientRegister.getInstance().startUp();
+            }
+        }
+
+        [RubyMethod("set_pollinterval", RubyMethodAttributes.PublicSingleton)]
+        public static int set_pollinterval(RubyModule/*!*/ self, [NotNull]int/*!*/ nInterval)
+        {
+            int nOldInterval = SyncThread.getInstance().getPollInterval();
+            SyncThread.getInstance().setPollInterval(nInterval);
+            return nOldInterval;
+        }
+
+        [RubyMethod("stop_sync", RubyMethodAttributes.PublicSingleton)]
+        public static void set_pollinterval(RubyModule/*!*/ self)
+        {
+            SyncThread.stopSync();
+        }
+
+        [RubyMethod("set_source_property", RubyMethodAttributes.PublicSingleton)]
+        public static void set_source_property(RubyModule/*!*/ self, [NotNull]int/*!*/ nSrcID, [NotNull]String/*!*/ strPropName, [NotNull]String/*!*/ strPropValue)
+        {
+            SyncEngine.getSourceOptions().setProperty(nSrcID, strPropName, strPropValue);
+        }
+
+        [RubyMethod("set_objectnotify_url", RubyMethodAttributes.PublicSingleton)]
+        public static void set_objectnotify_url(RubyModule/*!*/ self, [DefaultProtocol, NotNull]string/*!*/ url)
+        {
+            SyncNotify.setObjectNotifyUrl(url);
+        }
+
+        [RubyMethod("add_objectnotify", RubyMethodAttributes.PublicSingleton)]
+        public static void add_objectnotify(RubyModule/*!*/ self, [NotNull]int/*!*/ nSrcID, [NotNull]string/*!*/ strObject)
+        {
+            SyncThread.getSyncEngine().getNotify().addObjectNotify(nSrcID, strObject);
+        }
+
+        [RubyMethod("clean_objectnotify", RubyMethodAttributes.PublicSingleton)]
+        public static void clean_objectnotify(RubyModule/*!*/ self)
+        {
+            SyncThread.getSyncEngine().getNotify().cleanObjectNotifications();
+        }
+    }
+}

data/platform/wp7/RhoRubyLib/rubyext/RhoWebView.cs

@@ -0,0 +1,49 @@
+using Microsoft.Scripting.Utils;
+using Microsoft.Scripting.Runtime;
+using IronRuby.Runtime;
+using IronRuby.Builtins;
+using System;
+using System.Runtime.InteropServices;
+using rho.common;
+
+namespace rho.rubyext
+{
+    [RubyModule("WebView")]
+    public static class RhoWebView
+    {
+        private static CRhoRuby RhoRuby { get { return CRhoRuby.Instance; } }
+        private static CRhodesApp RHODESAPP() { return CRhodesApp.Instance; }
+
+        #region Private Implementation Details
+
+        #endregion
+
+        #region Private Instance & Singleton Methods
+
+        [RubyMethodAttribute("navigate", RubyMethodAttributes.PublicSingleton)]
+        public static void Navigate(RubyModule/*!*/ self, [NotNull]String/*!*/ url)
+        {
+            RHODESAPP().processWebNavigate(url);
+        }
+
+        [RubyMethodAttribute("execute_js", RubyMethodAttributes.PublicSingleton)]
+        public static void execute_js(RubyModule/*!*/ self, [NotNull]String/*!*/ strScript)
+        {
+            RHODESAPP().processInvokeScript(strScript);
+        }
+
+        [RubyMethodAttribute("current_location", RubyMethodAttributes.PublicSingleton)]
+        public static String currentLocation(RubyModule/*!*/ self)
+        {
+            return RHODESAPP().getCurrentUrl(0);   
+        }
+
+        [RubyMethodAttribute("set_menu_items", RubyMethodAttributes.PublicSingleton)]
+        public static void setMenuItems(RubyModule/*!*/ self, Hash valMenu)
+        {
+            RHODESAPP().setMenuItems(valMenu);
+        }
+
+        #endregion
+    }
+}

data/platform/wp7/RhoRubyLib/sync/ClientRegister.cs

@@ -0,0 +1,142 @@
+using System;
+using rho.common;
+using rho.db;
+using rho.net;
+
+namespace rho.sync
+{
+    public class ClientRegister : CRhoThread
+    {
+        private static RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() : 
+		    new RhoLogger("ClientRegister");
+        private static CRhodesApp RHODESAPP() { return CRhodesApp.Instance; }
+	
+	    private static int WAIT_BEFOREKILL_SECONDS  = 3;
+	    private static int POLL_INTERVAL_SECONDS = 60;
+	    private static int POLL_INTERVAL_INFINITE = int.MaxValue/1000;	
+        public static  int DEFAULT_PUSH_PORT = 100;
+
+	    static ClientRegister m_pInstance;
+	    NetRequest      m_NetRequest;
+        String          m_strDevicePin;
+        int             m_nPollInterval;
+    
+        private NetRequest getNet() { return m_NetRequest;}
+    
+	    public static ClientRegister Create(String device_pin)
+	    {
+	        if ( m_pInstance != null) 
+	            return m_pInstance;
+	
+	        m_pInstance = new ClientRegister(device_pin);
+	        return m_pInstance;
+	    }
+
+	    public void Destroy()
+	    {
+		    m_NetRequest.cancel();
+		
+	        stop(WAIT_BEFOREKILL_SECONDS);
+	        m_pInstance = null;
+	    }
+    
+	    private ClientRegister(String device_pin)
+	    {
+		    m_strDevicePin = device_pin;
+		    m_NetRequest = RhoClassFactory.createNetRequest();
+		    m_nPollInterval = POLL_INTERVAL_SECONDS;
+		
+		    startUp();
+	    }
+	
+	    public static ClientRegister getInstance(){ return m_pInstance; }
+	
+	    public void startUp() 
+	    {	
+		    if ( RhoConf.getInstance().getString("syncserver").length() > 0 )
+		    {
+			    start(epLow);	
+	            stopWait();
+	        }
+	    }
+	
+        public override void run() 
+        {
+    	    LOG.INFO("ClientRegister start");    	
+    	    while(!isStopping()) 
+    	    {
+    		    try
+    		    {
+    			    if ( SyncThread.getInstance() != null )
+    			    {
+	    			    if ( doRegister(SyncThread.getSyncEngine()) )
+	    			    {
+	    				    m_nPollInterval = POLL_INTERVAL_INFINITE;
+	    				    //break;
+	    			    }
+    			    }
+    			
+    		    }catch(Exception exc)
+    		    {
+    			    LOG.ERROR("doRegister failed", exc);
+    		    }
+    		
+			    LOG.INFO("Waiting for "+ m_nPollInterval+ " sec to try again to register client");
+			    wait(m_nPollInterval);
+		    }
+            LOG.INFO( "ClientRegister thread shutdown" );
+        }
+
+        public String getRegisterBody(String strClientID)
+        {
+		    int port = RhoConf.getInstance().getInt("push_port");
+
+            return SyncThread.getSyncEngine().getProtocol().getClientRegisterBody( strClientID, m_strDevicePin, 
+                port > 0 ? port : DEFAULT_PUSH_PORT, RHODESAPP().getPlatform());
+        }
+    
+        private boolean doRegister(	SyncEngine oSync )
+        {
+    	    String session = oSync.loadSession();
+    	    if ( session == null || session.length() == 0 )
+    	    {
+    		    m_nPollInterval = POLL_INTERVAL_INFINITE;    		
+    		    return false;
+    	    }
+		    m_nPollInterval = POLL_INTERVAL_SECONDS;    		
+    	
+		    String client_id = oSync.loadClientID();
+		    if ( client_id == null || client_id.length() == 0 )
+			    return false;
+    	
+		    IDBResult res = DBAdapter.getUserDB().executeSQL("SELECT token,token_sent from client_info");
+            if ( !res.isEnd() ) {
+			    String token = res.getStringByIdx(0); 
+			    int token_sent = res.getIntByIdx(1);
+			    if ( m_strDevicePin.equals(token) && token_sent > 0 ) 
+			    {
+				    //token in db same as new one and it was already send to the server
+				    //so we do nothing
+				    return true; 
+			    }
+            }
+
+	        String strBody = getRegisterBody(client_id);
+            NetResponse resp = getNet().pushData( oSync.getProtocol().getClientRegisterUrl(), strBody, oSync );
+		    if( resp.isOK() ) 
+		    {
+			    try {
+				    DBAdapter.getUserDB().executeSQL("UPDATE client_info SET token_sent=?, token=?", 1, m_strDevicePin );
+			    } catch(Exception ex) {
+				    LOG.ERROR("Error saving token_sent to the DB...", ex);
+			    }	
+			    LOG.INFO("Registered client sucessfully...");
+			    return true;
+		    } else {
+			    LOG.INFO("Network error POST-ing device pin to the server...");
+		    }
+		
+		    return false;
+        }
+    }
+}