rhodes 7.5.1 → 7.6.0

data/platform/android/Rhodes/src/com/rhomobile/rhodes/kioskservices/MyOverlayService.java

@@ -0,0 +1,197 @@
+package com.rhomobile.rhodes.kioskservices;
+
+import android.app.Service;
+import android.content.Intent;
+import android.graphics.PixelFormat;
+import android.os.IBinder;
+import android.view.View;
+import android.view.WindowManager;
+import android.widget.Button;
+import android.widget.LinearLayout;
+import android.widget.FrameLayout;
+import android.util.Log;
+
+import com.rhomobile.rhodes.RhodesActivity;
+import com.rhomobile.rhodes.mainview.MainView;
+
+import android.view.Gravity;
+import java.util.Vector;
+
+import com.rhomobile.rhodes.Logger;
+
+import androidx.annotation.Nullable;
+
+import com.rhomobile.rhodes.R;
+
+public class MyOverlayService extends Service {
+
+    private final static String TAG = "MyOverlayService";
+
+    private WindowManager wm;
+    private LinearLayout overlayLayout;
+    private FrameLayout mFrameLayout = null;
+
+    private MainView mMainView = null;
+
+    private static MyOverlayService ourInstance = null;
+
+    private static boolean ourIsOverlayModeEnabled = false;
+
+
+
+    public interface MyOverlayServiceListener {
+        void onOverlayStart(MyOverlayService overlayService, FrameLayout mainLayout);
+        void onOverlayStop(MyOverlayService overlayService, FrameLayout mainLayout);
+    }
+
+    private static Vector<MyOverlayServiceListener> ourListeners = new Vector<MyOverlayServiceListener>(1);
+
+    public static MyOverlayService getInstance() {
+        return ourInstance;
+    }
+
+    public static void addListener(MyOverlayServiceListener listener) {
+        ourListeners.addElement(listener);
+    }
+
+    private void callListsnersOnStart() {
+        for(int i=0; i < ourListeners.size(); ++i) {
+            ourListeners.get(i).onOverlayStart(this, mFrameLayout);
+        }
+    }
+
+    @Nullable
+    @Override
+    public IBinder onBind(Intent intent) {
+        Logger.T(TAG, "$$$ onBind() ");
+        return null;
+    }
+
+
+    public static boolean isOverlayMode() {
+        return ourIsOverlayModeEnabled;
+    }
+
+
+
+    public void stopOverlayMode() {
+        Logger.T(TAG, "$$$ stopOverlayMode() ");
+        ourInstance = null;
+        ourIsOverlayModeEnabled = false;
+        if (mMainView != null) {
+            mFrameLayout.removeAllViews();
+            overlayLayout.removeAllViews();
+            RhodesActivity.safeGetInstance().setMainView(mMainView);
+            mMainView = null;
+        }
+        stopSelf();
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        Logger.T(TAG, "$$$ onStartCommand() ");
+        if (ourInstance != null) {
+            //return super.onStartCommand(intent, flags, startId);
+        }
+        ourInstance = this;
+        ourIsOverlayModeEnabled = true;
+
+        wm = (WindowManager) getSystemService(WINDOW_SERVICE);
+
+        if (overlayLayout != null) {
+            wm.removeView(overlayLayout);
+            overlayLayout = null;
+        }
+
+        overlayLayout = new LinearLayout(this);
+        overlayLayout.setOrientation(LinearLayout.VERTICAL);
+        overlayLayout.setBackgroundColor(0xFFFFFFFF);
+
+        // Button btnClose = new Button(this);
+        // btnClose.setText("STOP OVERLAY");
+        // btnClose.setOnClickListener(new View.OnClickListener() {
+        //     @Override
+        //     public void onClick(View v){
+        //         stopOverlayMode();
+        //     }
+        // });
+
+        LinearLayout.LayoutParams lparams = new LinearLayout.LayoutParams(
+            FrameLayout.LayoutParams.WRAP_CONTENT,
+            FrameLayout.LayoutParams.WRAP_CONTENT
+        );
+        lparams.topMargin = 8;
+        lparams.bottomMargin = 8;
+        lparams.leftMargin = 8;
+        lparams.rightMargin = 8;
+
+        // overlayLayout.addView(btnClose, lparams);
+
+/*
+        |
+                WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED |
+                WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
+*/
+
+        WindowManager.LayoutParams params = new WindowManager.LayoutParams(
+            WindowManager.LayoutParams.MATCH_PARENT,
+            WindowManager.LayoutParams.MATCH_PARENT,
+            WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY,
+            WindowManager.LayoutParams.FLAG_FULLSCREEN,
+            PixelFormat.TRANSLUCENT
+        );
+
+        mFrameLayout = new FrameLayout(this);
+
+
+        FrameLayout.LayoutParams wvlparams = new FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            FrameLayout.LayoutParams.MATCH_PARENT
+        );
+
+        mMainView = RhodesActivity.extractMainView();
+        if(mMainView != null){
+            if(mMainView != null){
+                Logger.T(TAG, "$$$ mMainView != NULL ! class = "+mMainView.getClass().getSimpleName());
+            }else{
+                Logger.T(TAG, "$$$ mMainView == NULL ! ");
+            }
+
+            mFrameLayout.addView(mMainView.getView(), wvlparams);
+        }
+
+        callListsnersOnStart();
+
+        overlayLayout.addView(RhodesActivity.onOverlayStarted(mFrameLayout), lparams);
+
+
+        wm.addView(overlayLayout, params);
+
+        return super.onStartCommand(intent, flags, startId);
+    }
+
+    @Override
+    public void onDestroy() {
+        Log.d("myLog", "Overlay stop");
+        Logger.T(TAG, "onDestroy()");
+        ourInstance = null;
+        ourIsOverlayModeEnabled = false;
+        super.onDestroy();
+        try {
+            if (mMainView != null) {
+                mFrameLayout.removeAllViews();
+                overlayLayout.removeAllViews();
+                RhodesActivity.safeGetInstance().setMainView(mMainView);
+                mMainView = null;
+            }
+            if (overlayLayout != null) {
+                wm.removeView(overlayLayout);
+                overlayLayout = null;
+            }
+        }
+        catch(Exception e) {
+
+        }
+        overlayLayout = null;
+    }
+}

data/platform/android/Rhodes/src/com/rhomobile/rhodes/kioskservices/PermissionManager.java

@@ -0,0 +1,232 @@
+package com.rhomobile.rhodes.kioskservices;
+
+import android.Manifest;
+import android.accessibilityservice.AccessibilityServiceInfo;
+import android.app.Activity;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import android.provider.Settings;
+import android.view.accessibility.AccessibilityManager;
+import android.widget.Toast;
+
+
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+import java.util.function.Predicate;
+
+import com.rhomobile.rhodes.RhoConf;
+import com.rhomobile.rhodes.extmanager.RhoExtManager;
+import com.rhomobile.rhodes.util.PerformOnUiThread;
+
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class PermissionManager {
+    final static private Integer MY_PERMISSIONS_REQUEST = 343457842;
+
+    static public Boolean checkPermissions(Context context, Activity activity){
+        boolean callPhonePermissionIgnor = RhoConf.isExist("call_phone_permission_ignor") && RhoConf.getBool("call_phone_permission_ignor");
+        boolean callPhonePermission = true;
+        if(!callPhonePermissionIgnor)
+            callPhonePermission = checkCallPhonePermission(context);
+            
+        return checkAccessibilityServicePermission(context)
+                && checkNotificationServicePermission(activity, context)
+                && isMyLauncherDefault(context)
+                && callPhonePermission
+                && checkOverlayPermission(context);
+    }
+
+    static public void setAllPermissions(Context context, Activity activity){
+        if (!checkAccessibilityServicePermission(context))
+            setAccessibilityServicePermission(activity);
+        else if(!checkNotificationServicePermission(activity, context))
+            setNotificationServicePermission(activity);
+        else if(!isMyLauncherDefault(context))
+            setDefaultLauncher(activity);
+        else if(!checkCallPhonePermission(context))
+            setCallPhonePermission(activity);
+        else if(!checkOverlayPermission(context))
+            setOverlayPermission(activity);
+    }
+
+    //===================== ACCESSIBILITY SERVICE =====================
+
+    static public Boolean checkAccessibilityServicePermission(Context context){
+        if (MyAccessibilityService.getStatus()){
+            return true;
+        }
+        
+        AccessibilityManager am = (AccessibilityManager)context.getSystemService(Context.ACCESSIBILITY_SERVICE);
+        List<AccessibilityServiceInfo> enabledService = am.getEnabledAccessibilityServiceList(AccessibilityServiceInfo.FEEDBACK_ALL_MASK);
+        for (AccessibilityServiceInfo service: enabledService){
+            if(service.getId().equals(getAccessibilityServiceName(context.getPackageName(), MyAccessibilityService.class.getName()))){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static public void setAccessibilityServicePermission(Activity activity){
+        Intent intent = new Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS);
+        activity.startActivity(intent);
+    }
+
+
+    static public String getAccessibilityServiceName(String namePackage, String accessibilityService) {
+        String droped = accessibilityService.replace(namePackage, "");
+        System.out.println("WERTYUIOUYTREWERTGYHJKL NamePackage: "+ namePackage+"; accessibilityService"+accessibilityService);
+        System.out.println("WERTYUIOUYTREWERTGYHJKL: "+ namePackage+"/"+droped);
+        return namePackage+"/"+droped;
+    }
+
+    //===================== NOTIFICATION SERVICE =====================
+
+    static public Boolean checkNotificationServicePermission(Activity activity, Context context){
+        String theList = Settings.Secure.getString(activity.getContentResolver(), "enabled_notification_listeners");
+        if (theList == null)
+            theList = "";
+        String[] theListList = theList.split(":", -1);
+
+        List<String> theListListFiltered = new ArrayList<String>();
+        for (String str : theListList){
+            if (!str.isEmpty()) {
+                theListListFiltered.add(str.toString());
+            }
+        }
+
+        for (String str: theListListFiltered){
+            if(str.equals("")){
+                theListListFiltered.add("");
+            }
+        }
+
+        String me = new ComponentName(context, MyNotificationListenerService.class).flattenToString();
+        for (String next : theListListFiltered) {
+            if (me.equals(next))
+                return true;
+        }
+        return false;
+    }
+
+    static public void setNotificationServicePermission(Activity activity){
+        activity.startActivity(new Intent("android.settings.ACTION_NOTIFICATION_LISTENER_SETTINGS"));
+    }
+
+    //===================== DEFAULT LAUNCHER =====================
+
+    static public Boolean isMyLauncherDefault(Context context) {
+        IntentFilter filter = new IntentFilter(Intent.ACTION_MAIN);
+        filter.addCategory(Intent.CATEGORY_HOME);
+        List<IntentFilter> filters = new ArrayList<IntentFilter>();
+        filters.add(filter);
+        String myPackageName = context.getPackageName();
+        List<ComponentName> activities = new ArrayList<ComponentName>();
+        PackageManager packageManager = context.getPackageManager();
+
+        // You can use name of your package here as third argument
+        packageManager.getPreferredActivities(filters, activities, null);
+        for (ComponentName activity : activities) {
+            if (myPackageName.equals(activity.getPackageName())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static public void setDefaultLauncher(Activity activity){
+
+        Intent intent = new Intent(Settings.ACTION_HOME_SETTINGS);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        activity.startActivity(intent);
+        //Toast.makeText(activity.getApplicationContext(), "PLease select Tau browser with default home app", Toast.LENGTH_LONG).show();
+        RhoExtManager.getInstance().quitApp();
+
+        PerformOnUiThread.exec(new Runnable() {
+            @Override
+            public void run() {
+                System.exit(0);
+            }
+        }, 200);
+
+
+
+        /*
+        mActivity = (RhodesActivity) RhodesActivity.safeGetInstance();
+        kioskMode = (IKioskMode) RhodesActivity.safeGetInstance();
+
+        mActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                //stopBrowserServer();
+                mActivity.stopOverlay();
+                PerformOnUiThread.exec(new Runnable() {
+                     @Override
+                     public void run() {
+                         kioskMode.stopKioskMode();
+                         PerformOnUiThread.exec(new Runnable() {
+                              @Override
+                              public void run() {
+                                  Intent intent = new Intent(Settings.ACTION_HOME_SETTINGS);
+                                  intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                                  activity.startActivity(intent);
+                                  Toast.makeText(activity.getApplicationContext(), "PLease select Tau browser with default home app", Toast.LENGTH_LONG).show();
+                                  //RhoExtManager.getInstance().quitApp();
+                                  System.exit(0);
+                              }
+                         }, 500);
+                     }
+                }, 500);
+
+            }
+        });
+        */
+        /*
+        PerformOnUiThread.exec(new Runnable() {
+            @Override
+            public void run() {
+                RhoExtManager.getInstance().quitApp();
+            }
+        }, 500);
+        */
+    }
+
+    static public void setDefaultLauncherSystem(Context context, Class ClassForLauncher){
+        PackageManager pm = context.getPackageManager();
+        ComponentName cn = new ComponentName(context.getApplicationContext(), ClassForLauncher);
+
+        pm.clearPackagePreferredActivities(context.getPackageName());
+
+        pm.setComponentEnabledSetting(cn, PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP);
+        pm.setComponentEnabledSetting(cn, PackageManager.COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP);
+    }
+
+    //===================== CALL PHONE =====================
+
+    static public Boolean checkCallPhonePermission(Context context){
+        return ContextCompat.checkSelfPermission(context, Manifest.permission.CALL_PHONE) == PackageManager.PERMISSION_GRANTED;
+    }
+
+    static public void setCallPhonePermission(Activity activity){
+        String[] permissions = {Manifest.permission.CALL_PHONE};
+        ActivityCompat.requestPermissions(activity, permissions, MY_PERMISSIONS_REQUEST);
+    }
+
+    //===================== OVERLAY PERMISSION =====================
+
+    static public Boolean checkOverlayPermission(Context context){
+        return Settings.canDrawOverlays(context);
+    }
+
+    static public void setOverlayPermission(Activity activity){
+        Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION, Uri.parse("package:"+ activity.getPackageName()));
+        activity.startActivity(intent);
+    }
+}

data/platform/android/Rhodes/src/com/rhomobile/rhodes/mainview/SimpleMainView.java

@@ -35,6 +35,7 @@ import java.io.InputStream;
 import java.util.Map;
 import java.util.Vector;
 import java.util.List;
+import android.os.Looper;
 
 import com.rhomobile.rhodes.R;
 import com.rhomobile.rhodes.Logger;
@@ -679,6 +680,10 @@ public class SimpleMainView implements MainView {
 
     @Override
     public void setWebView(IRhoWebView view, int tabIndex) {
+		IRhoWebView rwv = detachWebView();
+		if (rwv != null) {
+			// destory
+		}
         webView = view;
         addWebViewToMainView(webView, 0, new LinearLayout.LayoutParams(FILL_PARENT, 0, 1));
     }
@@ -729,18 +734,29 @@ public class SimpleMainView implements MainView {
 		}
 	}
 
-	
+
     //@Override
     public void executeJS(String js, int index) {
-    	
+
     	//Utils.platformLog("@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@", "ExecuteJS("+js+")");
     	//((android.webkit.WebView)webView.getView()).executeJS();
     	if ((android.os.Build.VERSION.SDK_INT < 14) || (android.os.Build.VERSION.SDK_INT >= 19)) {    // 14 is 4.0, 19 is 4.4
-    		navigate("javascript:"+js, index);
+			final String js_code = js;
+			if(Looper.getMainLooper().getThread() == Thread.currentThread()) {
+				((WebView)webView.getView()).evaluateJavascript(js_code, null);
+	        }
+	        else {
+				PerformOnUiThread.exec(new Runnable() {
+					public void run() {
+						((WebView)webView.getView()).evaluateJavascript(js_code, null);
+					}
+				});
+			}
+    		//navigate("javascript:"+js, index);
     		return;
     	}
-    	
-    	
+
+
 		Method mStringByEvaluatingJavaScriptFromString = null;
 		Method mSendMessage = null;
 	    Object mWebViewCore = null;
@@ -789,11 +805,21 @@ public class SimpleMainView implements MainView {
 				//e.printStackTrace();
 			}
 	    }
-	    
+
 	    if (!mHasReflectionWasExecutedOK) {
 	        //com.rhomobile.rhodes.WebView.executeJs(js, index);
-	    	navigate("javascript:"+js, index);
-	    	
+			final String js_code = js;
+			if(Looper.getMainLooper().getThread() == Thread.currentThread()) {
+				((WebView)webView.getView()).evaluateJavascript(js_code, null);
+			}
+			else {
+				PerformOnUiThread.exec(new Runnable() {
+					public void run() {
+						((WebView)webView.getView()).evaluateJavascript(js_code, null);
+					}
+				});
+			}
+	    	//navigate("javascript:"+js, index);
 	    }
     }
 

data/platform/android/Rhodes/src/com/rhomobile/rhodes/permissioncheck/CheckDrawable.java

@@ -0,0 +1,53 @@
+package com.rhomobile.rhodes.permissioncheck;
+
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.ColorFilter;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.PixelFormat;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+
+public class CheckDrawable extends Drawable {
+    private Paint mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
+    private Path mPath = new Path();
+
+    @Override
+    public void draw(Canvas canvas) {
+        mPaint.setColor(Color.parseColor("#40FF00"));
+        canvas.drawPath(mPath,mPaint);
+    }
+
+    @Override
+    public int getOpacity() {
+        return PixelFormat.TRANSLUCENT;
+    }
+
+    @Override
+    public void setAlpha(int alpha) {
+        mPaint.setAlpha(alpha);
+    }
+
+    @Override
+    public void setColorFilter(ColorFilter colorFilter) {
+        mPaint.setColorFilter(colorFilter);
+    }
+
+    @Override
+    protected void onBoundsChange(Rect bounds) {
+        super.onBoundsChange(bounds);
+
+        int width = bounds.width();
+        int height = bounds.height();
+
+        mPath.reset();
+        mPath.moveTo(0.375f         * width, 0.67375f       * height);
+        mPath.lineTo(0.20125f       * width, 0.5f           * height);
+        mPath.lineTo(0.142083333f   * width, 0.55875f       * height);
+        mPath.lineTo(0.375f         * width, 0.791666667f   * height);
+        mPath.lineTo(0.875f         * width, 0.291666667f   * height);
+        mPath.lineTo(0.81625f       * width, 0.232916667f   * height);
+        mPath.close();
+    }
+}