rho-tau-extensions 5.5.17

data/libs/crosswalk/ext/platform/android/src/com/rho/crosswalk/CrosswalkSingleton.java

@@ -0,0 +1,24 @@
+package com.rho.crosswalk;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import com.rhomobile.rhodes.api.IMethodResult;
+
+class CrosswalkSingleton extends CrosswalkSingletonBase implements ICrosswalkSingleton {
+    public CrosswalkSingleton(CrosswalkFactory factory) {
+        super(factory);
+    }
+
+    List<Object> getIDs() {
+        List<Object> ids = new LinkedList<Object>();
+        ids.add("SCN1");
+        ids.add("SCN2");
+        return ids;
+    }
+    
+    @Override
+    protected String getInitialDefaultID() {
+        return (String)(getIDs().get(0));
+    }
+}

data/libs/crosswalk/ext/platform/android/src/com/tautechnologies/tau/crosswalk/CrosswalkExtension.java

@@ -0,0 +1,16 @@
+package com.tautechnologies.tau.crosswalk;
+
+import com.rhomobile.rhodes.extmanager.AbstractRhoExtension;
+import com.rhomobile.rhodes.extmanager.IRhoWebView;
+import com.rhomobile.rhodes.extmanager.IRhoExtManager;
+import android.content.Context;
+
+
+public class CrosswalkExtension extends AbstractRhoExtension {
+
+    @Override
+    public IRhoWebView onCreateWebView(IRhoExtManager extManager, int tabIndex) {
+        return new TauXWalkWebView( extManager.getContext() );
+    }
+
+}

data/libs/crosswalk/ext/platform/android/src/com/tautechnologies/tau/crosswalk/RhodesListener.java

@@ -0,0 +1,18 @@
+package com.tautechnologies.tau.crosswalk;
+
+import com.rhomobile.rhodes.extmanager.AbstractRhoListener;
+import com.rhomobile.rhodes.extmanager.IRhoExtManager;
+import com.rhomobile.rhodes.extmanager.RhoExtManager;
+import com.rhomobile.rhodes.extmanager.IRhoListener;
+
+import com.tautechnologies.tau.crosswalk.CrosswalkExtension;
+
+public class RhodesListener extends AbstractRhoListener implements IRhoListener {
+
+
+    @Override
+    public void onCreateApplication(IRhoExtManager extManager) {
+        RhoExtManager.getInstance().registerExtension("crosswalk", new CrosswalkExtension() );
+    }
+
+}

data/libs/crosswalk/ext/platform/android/src/com/tautechnologies/tau/crosswalk/TauXWResourceClient.java

@@ -0,0 +1,182 @@
+package com.tautechnologies.tau.crosswalk;
+
+import com.rhomobile.rhodes.extmanager.IRhoWebView;
+import com.rhomobile.rhodes.extmanager.IRhoConfig;
+import com.rhomobile.rhodes.extmanager.RhoExtManager;
+
+
+import org.xwalk.core.XWalkView;
+import org.xwalk.core.XWalkUIClient;
+import org.xwalk.core.XWalkResourceClient;
+import org.xwalk.core.XWalkNavigationHistory;
+import org.xwalk.core.XWalkJavascriptResult;
+
+import android.app.Activity;
+import android.view.View;
+import android.view.ViewGroup;
+
+import android.content.Context;
+
+import com.rhomobile.rhodes.LocalFileProvider;
+import com.rhomobile.rhodes.Logger;
+import com.rhomobile.rhodes.RhodesActivity;
+import com.rhomobile.rhodes.RhodesService;
+import com.rhomobile.rhodes.extmanager.IRhoExtension;
+import com.rhomobile.rhodes.RhoConf;
+
+
+import com.rhomobile.rhodes.util.PerformOnUiThread;
+
+import android.net.Uri;
+
+import android.net.http.SslError;
+import android.webkit.WebResourceResponse;
+
+
+public class TauXWResourceClient extends XWalkResourceClient {
+
+    private static final String TAG = TauXWResourceClient.class.getSimpleName();
+
+
+    public TauXWResourceClient( XWalkView view ) {
+        super(view);
+    }
+
+    @Override
+    public boolean shouldOverrideUrlLoading(XWalkView view, String url) {
+        Logger.I(TAG, ">>>>> shouldOverrideUrlLoading: " + url);
+
+        //RhoElements implementation of "history:back"
+        if(url.equalsIgnoreCase("history:back")) {
+            view.getNavigationHistory().navigate(XWalkNavigationHistory.Direction.BACKWARD, 1);
+            return true;
+        }
+
+        if (url.contains(".HTM")) 
+        {
+            url=url.replace(".HTML", ".html");
+            url=url.replace(".HTM", ".htm");
+            Logger.I(TAG, "Changed to lower case html, url="+ url);
+        }
+
+        boolean res = RhodesService.getInstance().handleUrlLoading(url);
+        if (!res) {
+            Logger.profStart("BROWSER_PAGE");
+
+            RhoExtManager.getImplementationInstance().onBeforeNavigate(view, url);
+
+            Uri localUri = LocalFileProvider.overrideUri(Uri.parse(url));
+            if (localUri != null) {
+                url = Uri.decode(localUri.toString());
+                Logger.T(TAG, "Override URL: " + url);
+                view.load(url,null);
+                return true;
+            }
+        }
+        return res;            
+    }
+
+    @Override
+    public WebResourceResponse shouldInterceptLoadRequest( XWalkView view, String url ) {
+        Logger.I(TAG, ">>>>> shouldInterceptLoadRequest: " + url);
+        return super.shouldInterceptLoadRequest(view, url);
+    }
+
+    @Override
+    public void onLoadStarted( XWalkView view, String url ) {
+        Logger.I(TAG, ">>>>> onLoadStarted: " + url);
+
+        super.onLoadStarted(view, url);
+
+        RhoExtManager.getImplementationInstance().onNavigateStarted(view, url);
+
+                //if (mWebView.getConfig() != null && mWebView.getConfig().getBool(WebViewConfig.ENABLE_PAGE_LOADING_INDICATION))
+                //    RhodesActivity.safeGetInstance().getWindow().setFeatureInt(Window.FEATURE_PROGRESS, 0);
+                //}
+    }
+
+    @Override 
+    public void onLoadFinished( XWalkView view, String url ) {
+        Logger.I(TAG, ">>>>> onLoadFinished: " + url);
+
+
+        Logger.profStop("BROWSER_PAGE");
+
+        // Set title
+        String title = view.getTitle();
+        try {
+            RhodesActivity.safeGetInstance().setTitle(title);
+
+                    //if (mWebView.getConfig() != null && mWebView.getConfig().getBool(WebViewConfig.ENABLE_PAGE_LOADING_INDICATION))
+                    //    RhodesActivity.safeGetInstance().getWindow().setFeatureInt(Window.FEATURE_PROGRESS, RhodesActivity.MAX_PROGRESS);
+        } catch (Throwable ex) {
+                    //Do nothing. Just for case if activity has been destroyed in between.
+        }
+
+        RhoExtManager.getImplementationInstance().onNavigateComplete(view, url);
+        //CookieSyncManager.getInstance().sync();
+
+        super.onLoadFinished(view, url);
+    }
+
+    @Override
+    public void onProgressChanged( XWalkView view, int progressInPercent ) {
+        Logger.I(TAG, ">>>>> onProgressChanged: " + (new Integer(progressInPercent)).toString() );
+
+    }
+
+    @Override 
+    public void onReceivedLoadError( 
+        XWalkView view, 
+        int errorCode,
+        String description,
+        String failingUrl ) {
+
+        super.onReceivedLoadError(view, errorCode, description, failingUrl);
+
+        Logger.I(TAG, ">>>>> onReceivedLoadError: " + description);
+
+
+        Logger.profStop("BROWSER_PAGE");
+
+        StringBuilder msg = new StringBuilder(failingUrl != null ? failingUrl : "null");
+        msg.append(" failed: ");
+        msg.append(errorCode);
+        msg.append(" - " + description);
+        Logger.E(TAG, msg.toString());
+
+        RhoExtManager.getImplementationInstance().onLoadError(view, IRhoExtension.LoadErrorReason.INTERNAL_ERROR);
+    }
+
+    @Override
+    public void onReceivedSslError(
+        XWalkView view, 
+        android.webkit.ValueCallback<Boolean> callback, 
+        SslError error) {
+        
+        if(RhoConf.getBool("no_ssl_verify_peer")) {
+            Logger.D(TAG, "Skip SSL error.");
+            callback.onReceiveValue(true); 
+        } else {
+            StringBuilder msg = new StringBuilder();
+            msg.append("SSL error - ");
+            switch(error.getPrimaryError()) {
+            case SslError.SSL_NOTYETVALID:
+                msg.append("The certificate is not yet valid: ");
+                break;
+            case SslError.SSL_EXPIRED:
+                msg.append("The certificate has expired: ");
+                break;
+            case SslError.SSL_IDMISMATCH:
+                msg.append("Hostname mismatch: ");
+                break;
+            case SslError.SSL_UNTRUSTED:
+                msg.append("The certificate authority is not trusted: ");
+                break;
+            }
+            msg.append(error.getCertificate().toString());
+            Logger.W(TAG, msg.toString());
+            callback.onReceiveValue(false); 
+        }
+    }
+}

data/libs/crosswalk/ext/platform/android/src/com/tautechnologies/tau/crosswalk/TauXWUIClient.java

@@ -0,0 +1,125 @@
+package com.tautechnologies.tau.crosswalk;
+
+import com.rhomobile.rhodes.extmanager.IRhoWebView;
+import com.rhomobile.rhodes.extmanager.IRhoConfig;
+import com.rhomobile.rhodes.extmanager.IRhoExtManager;
+import com.rhomobile.rhodes.extmanager.RhoExtManager;
+import com.rhomobile.rhodes.extmanager.RhoExtManagerImpl;
+import com.rhomobile.rhodes.extmanager.IRhoExtension;
+
+
+import org.xwalk.core.XWalkView;
+import org.xwalk.core.XWalkUIClient;
+import org.xwalk.core.XWalkUIClient.JavascriptMessageType;
+import org.xwalk.core.XWalkResourceClient;
+import org.xwalk.core.XWalkNavigationHistory;
+import org.xwalk.core.XWalkJavascriptResult;
+
+import android.app.Activity;
+import android.view.View;
+import android.view.ViewGroup;
+
+import android.content.Context;
+
+import com.rhomobile.rhodes.LocalFileProvider;
+import com.rhomobile.rhodes.Logger;
+import com.rhomobile.rhodes.RhodesActivity;
+
+import com.rhomobile.rhodes.util.PerformOnUiThread;
+
+import android.net.Uri;
+
+public class TauXWUIClient extends XWalkUIClient {
+
+    private static final String TAG = TauXWUIClient.class.getSimpleName();
+
+
+    private class ModalResult implements IRhoExtension.IAlertResult,IRhoExtension.IPromptResult {
+        private boolean mPending = false;
+        private XWalkJavascriptResult mResult;
+        public ModalResult(XWalkJavascriptResult result) {
+            mResult = result;
+        }
+        @Override
+        public void setPending() {
+            mPending = true;
+        }
+        @Override
+        public void confirm() {
+            mResult.confirm();
+        }
+        @Override
+        public void confirm(String message) {
+            mResult.confirmWithResult(message);
+        }
+        @Override
+        public void cancel() {
+            mResult.cancel();
+        }
+        public boolean isPending() {
+            return mPending;
+        }
+    }
+
+    public TauXWUIClient( XWalkView view ) {
+        super(view);
+    }
+
+    @Override
+    public boolean onJavascriptModalDialog(
+        XWalkView view, 
+        JavascriptMessageType type, 
+        java.lang.String url, 
+        java.lang.String message, 
+        java.lang.String defaultValue, 
+        XWalkJavascriptResult result) {
+
+        Logger.I(TAG, 
+            ">>>>> onJavascriptModalDialog: " + url + 
+            " type: " + type.toString() +
+            " message: " + message
+        );
+
+        ModalResult rhoResult = new ModalResult(result);
+        RhoExtManagerImpl extMgr = RhoExtManager.getImplementationInstance();
+
+        switch(type) {
+        case JAVASCRIPT_ALERT:
+            extMgr.onAlert(view, message, rhoResult);
+            break;
+
+        case JAVASCRIPT_BEFOREUNLOAD:
+        case JAVASCRIPT_CONFIRM:
+            extMgr.onConfirm(view, message, rhoResult);
+            break;
+
+        case JAVASCRIPT_PROMPT:
+            extMgr.onPrompt(view, message, defaultValue, rhoResult);
+            break;
+
+        default:
+            return false;
+        }
+
+        return rhoResult.isPending();
+
+    }
+
+    @Override
+    public boolean onConsoleMessage(XWalkView view, String message, int lineNumber, String sourceID, XWalkUIClient.ConsoleMessageType messageType) {
+        Logger.I(TAG, message + " -- From line " + lineNumber + " of " + sourceID);
+        return true;
+    }
+
+    @Override
+    public void onPageLoadStarted( XWalkView view, String url ) {
+        Logger.I(TAG, ">>>>> onPageLoadStarted: " + url);
+        super.onPageLoadStarted(view,url);
+    }
+
+    @Override
+    public void onPageLoadStopped( XWalkView view, String url, XWalkUIClient.LoadStatus status ) {
+        Logger.I(TAG, ">>>>> onPageLoadStopped: " + url + " status: " + status.toString() );        
+    }
+
+}

data/libs/crosswalk/ext/platform/android/src/com/tautechnologies/tau/crosswalk/TauXWalkWebView.java

@@ -0,0 +1,368 @@
+package com.tautechnologies.tau.crosswalk;
+
+import com.tautechnologies.tau.crosswalk.TauXWResourceClient;
+import com.tautechnologies.tau.crosswalk.TauXWUIClient;
+
+import com.rhomobile.rhodes.extmanager.IRhoWebView;
+import com.rhomobile.rhodes.extmanager.IRhoConfig;
+import com.rhomobile.rhodes.extmanager.RhoExtManager;
+
+
+import org.xwalk.core.XWalkView;
+import org.xwalk.core.XWalkUIClient;
+import org.xwalk.core.XWalkResourceClient;
+import org.xwalk.core.XWalkNavigationHistory;
+import org.xwalk.core.XWalkJavascriptResult;
+import org.xwalk.core.XWalkNavigationItem;
+
+
+import android.app.Activity;
+import android.view.View;
+import android.view.ViewGroup;
+
+import android.content.Context;
+
+import com.rhomobile.rhodes.LocalFileProvider;
+import com.rhomobile.rhodes.Logger;
+import com.rhomobile.rhodes.RhodesActivity;
+
+import com.rhomobile.rhodes.util.PerformOnUiThread;
+
+import android.net.Uri;
+
+import android.webkit.WebBackForwardList;
+import android.webkit.WebHistoryItem;
+import android.graphics.Bitmap;
+
+import java.util.List;
+import java.util.ArrayList;
+
+public class TauXWalkWebView implements IRhoWebView {
+    private static final String TAG = XWalkView.class.getSimpleName(); 
+
+    private XWalkView mWebView;
+    private XWalkUIClient mUIClient;
+    private XWalkResourceClient mResourceClient;
+    private IRhoConfig mConfig;
+    private ViewGroup mContainerView;
+    private TextZoom mTextZoom;
+
+    public TauXWalkWebView(Context context) {
+
+        Logger.I(TAG, ">>>>> TauXWalkWebView ctor");
+
+        mWebView = new XWalkView(context);
+        mUIClient = new TauXWUIClient(mWebView);
+        mResourceClient = new TauXWResourceClient(mWebView);
+    }
+    
+    @Override
+    public void setWebClient() {
+
+        Logger.I(TAG, ">>>>> TauXWalkWebView setWebClient");
+
+        PerformOnUiThread.exec(new Runnable() {
+            @Override
+            public void run() {
+                Logger.I(TAG, "Setting TauXWalkUIClient and TauXWalkResourceClient");
+                mWebView.setUIClient(mUIClient);
+                mWebView.setResourceClient(mResourceClient);
+            }
+        });
+    }
+
+    private void applyWebSettings() {
+        Logger.I(TAG, "applyWebSettings");
+/*
+        double z = getConfig().getDouble(WebViewConfig.PAGE_ZOOM);
+        mWebView.setInitialScale((int)(z * 100));
+        mWebView.setVerticalScrollBarEnabled(true);
+        mWebView.setHorizontalScrollBarEnabled(true);
+        mWebView.setVerticalScrollbarOverlay(true);
+        mWebView.setHorizontalScrollbarOverlay(true);
+        mWebView.setFocusableInTouchMode(true);
+
+        IWebSettingsProvider provider = OsVersionManager.getFeature(IWebSettingsProvider.class);
+        provider.fillSettings(mWebView.getSettings(), mConfig);
+*/
+        RhodesActivity.safeGetInstance().notifyUiCreated();
+    }
+    
+    @Override
+    public void setConfig(IRhoConfig config) {
+        Logger.I(TAG, ">>>>> TauXWalkWebView setConfig");
+        mConfig = config;
+        applyWebSettings();
+    }
+    
+    public IRhoConfig getConfig() {
+        Logger.I(TAG, ">>>>> TauXWalkWebView getConfig");
+        return mConfig;
+    }
+
+    @Override
+    public View getView() {
+        Logger.I(TAG, ">>>>> TauXWalkWebView getView");
+        return mWebView;
+    }
+
+    @Override
+    public void setContainerView(ViewGroup view) {
+        Logger.I(TAG, ">>>>> TauXWalkWebView setContainerView");
+        mContainerView = view;
+    }
+
+    @Override
+    public ViewGroup getContainerView() {
+        Logger.I(TAG, ">>>>> TauXWalkWebView getContainerView");
+        return mContainerView;
+    }
+
+    @Override
+    public boolean canGoBack() {
+        Logger.I(TAG, ">>>>> TauXWalkWebView canGoBack");
+
+        return mWebView.getNavigationHistory().canGoBack();
+    }
+
+    @Override
+    public void goBack() {
+        Logger.I(TAG, ">>>>> TauXWalkWebView goBack");
+        mWebView.getNavigationHistory().navigate(XWalkNavigationHistory.Direction.BACKWARD, 1);
+
+    }
+
+    @Override
+    public void goForward() {
+        Logger.I(TAG, ">>>>> TauXWalkWebView goForward");
+        mWebView.getNavigationHistory().navigate(XWalkNavigationHistory.Direction.FORWARD, 1);        
+
+    }
+
+    @Override
+    public void reload() {
+        Logger.I(TAG, ">>>>> TauXWalkWebView reload");
+        mWebView.reload(0);
+
+    }
+
+    @Override
+    public void clear() {
+        Logger.I(TAG, ">>>>> TauXWalkWebView clear");
+        mWebView.clearCache(true);
+        mWebView.load("", "");
+    }
+
+    @Override
+    public String getUrl() {
+        Logger.I(TAG, ">>>>> TauXWalkWebView getUrl");
+
+        return mWebView.getUrl();
+    }
+
+    @Override
+    public void loadUrl(String url) {
+
+        Logger.I(TAG, ">>>>> TauXWalkWebView loadUrl");
+
+        RhoExtManager.getImplementationInstance().onBeforeNavigate(mWebView, url);
+
+        Uri uri = LocalFileProvider.overrideUri(Uri.parse(url));
+        if (uri != null) {
+            url = Uri.decode(uri.toString());
+            Logger.T(TAG, "Override URL: " + url);
+        }
+        mWebView.load(url,null);
+
+    }
+
+    @Override
+    public void loadData(String data, String mime, String encoding) {
+
+        Logger.I(TAG, ">>>>> TauXWalkWebView loadData");
+        mWebView.load(null,data);
+
+    }
+
+    @Override
+    public void loadDataWithBaseURL(String baseUrl, String data, String mimeType, String encoding, String historyUrl) {
+        Logger.I(TAG, ">>>>> TauXWalkWebView loadDataWithBaseURL");
+        mWebView.load(null,data);
+
+    }
+
+    @Override
+    public void stopLoad() {
+        Logger.I(TAG, ">>>>> TauXWalkWebView stopLoad");
+        mWebView.stopLoading();        
+    }
+
+    @Override
+    public void setZoom(double scale) {
+        Logger.I(TAG, ">>>>> TauXWalkWebView setZoom");
+        mWebView.zoomBy((float)scale);
+    }
+
+    @Override
+    public void setTextZoom(TextZoom zoom) {
+        Logger.I(TAG, ">>>>> TauXWalkWebView setTextZoom");
+        mTextZoom = zoom;
+    }
+    
+    @Override
+    public TextZoom getTextZoom()
+    {
+        Logger.I(TAG, ">>>>> TauXWalkWebView getTextZoom");
+        return mTextZoom;
+    }
+
+    @Override
+    public String getEngineId() {
+        Logger.I(TAG, ">>>>> TauXWalkWebView getEngineId");
+        return "XWALK"+mWebView.getXWalkVersion();
+    }
+
+    @Override
+    public void onPause() {
+        Logger.I(TAG, ">>>>> TauXWalkWebView onPause");
+        mWebView.onHide();
+    }
+
+    @Override
+    public void onResume() {
+        Logger.I(TAG, ">>>>> TauXWalkWebView onResume");
+        mWebView.onShow();
+    }
+
+    @Override
+    public void destroy() {
+        Logger.I(TAG, ">>>>> TauXWalkWebView destroy");
+        mWebView.onDestroy();
+    }
+
+    @Override
+    public void capture(CaptureFormat format, String path) {
+        Logger.I(TAG, ">>>>> TauXWalkWebView capture");
+    }
+    
+    private void saveJpeg(String path) {
+        Logger.I(TAG, ">>>>> TauXWalkWebView saveJpeg");
+    }
+
+    @Override
+    public void addJSInterface(Object obj, String name) {
+        Logger.I(TAG, ">>>>> TauXWalkWebView addJSInterface");
+        mWebView.addJavascriptInterface(obj,name);
+    }
+/*
+    public class HistoryItem extends WebHistoryItem {
+
+        public String mOriginalUrl;
+        public String mUrl;
+        public String mTitle;
+
+        public HistoryItem() {
+
+        }
+
+        public HistoryItem( XWalkNavigationItem from ) {
+            mOriginalUrl = from.getOriginalUrl();
+            mUrl = from.getUrl();
+            mTitle = from.getTitle();
+        }
+
+        public HistoryItem( String origUrl, String url, String title ) {
+            mOriginalUrl = origUrl;
+            mUrl = url;
+            mTitle = title;
+        }        
+
+        @Override
+        public Bitmap getFavicon() {
+            return null;
+        }
+
+        @Override
+        public String getOriginalUrl() {
+            return mOriginalUrl;
+        }
+
+        @Override
+        public String getTitle() {
+            return mTitle;
+        }
+
+        @Override
+        public String getUrl() {
+            return mUrl;
+        }
+        
+        @Override
+        protected WebHistoryItem clone() {
+            return new HistoryItem( mOriginalUrl, mUrl, mTitle );
+        }
+    }
+
+    public class NavigationHistory extends WebBackForwardList {
+
+        private List<HistoryItem> mItems = new ArrayList();
+        private int mCurrentIndex;
+
+        public NavigationHistory() {
+
+        }
+
+        public NavigationHistory( XWalkNavigationHistory from ) {
+            mCurrentIndex = from.getCurrentIndex();
+
+            for ( int i = 0; i < from.size(); ++i ) {
+                mItems.add( new HistoryItem( from.getItemAt(i) ) );
+            }
+        }
+
+        public NavigationHistory( NavigationHistory from ) {
+            mCurrentIndex = from.getCurrentIndex();
+
+            for ( int i = 0; i < from.getSize(); ++i ) {
+                WebHistoryItem item = from.getItemAtIndex(i);
+                String origUrl = item.getOriginalUrl();
+                String url = item.getUrl();
+                String title = item.getTitle();
+
+                mItems.add( new HistoryItem( origUrl, url, title ) );
+            }
+        }
+ 
+        @Override
+        public int getCurrentIndex() {
+            return mCurrentIndex;
+        }
+
+        @Override
+        public WebHistoryItem getCurrentItem() {
+            return mItems.get(mCurrentIndex);
+        }
+
+        @Override
+        public WebHistoryItem getItemAtIndex(int index) {
+            return mItems.get(index);
+        }
+
+        @Override
+        public int getSize() {
+            return mItems.size();
+        }
+
+        @Override
+        protected WebBackForwardList clone() {
+            return new NavigationHistory( this );
+        }
+    }
+*/
+    @Override
+    public WebBackForwardList copyBackForwardList() {
+      Logger.I(TAG, ">>>>> TauXWalkWebView copyBackForwardList");
+      
+      return null;//new NavigationHistory( mWebView.getNavigationHistory() );
+    }
+}