rhodes 7.4.1 → 7.6.0

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

@@ -0,0 +1,230 @@
+package com.rhomobile.rhodes.kioskservices;
+
+import java.util.Arrays;
+import java.util.List;
+
+import android.accessibilityservice.AccessibilityService;
+import android.util.Log;
+import android.view.accessibility.AccessibilityEvent;
+import android.widget.Toast;
+import android.app.Notification;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+import android.view.KeyEvent;
+
+import com.rhomobile.rhodes.R;
+import com.rhomobile.rhodes.RhoConf;
+import com.rhomobile.rhodes.webview.RhoInputListener;
+import com.rhomobile.rhodes.Logger;
+
+
+public class MyAccessibilityService extends AccessibilityService {
+
+    private static final String TAG = MyAccessibilityService.class.getSimpleName();
+
+    private CharSequence oldEvent = null;
+    private BroadcastReceiver receiver = null;
+    private static final int NOTIFICATION_ID = 1234;
+    private boolean filter = true;
+    private CharSequence powerPackageName;
+    public static boolean isPowerProcessing = false;
+    private static List<String> ignorePackets = null;
+    private static boolean isEnabled = false;
+
+    public static void setPowerProcessing(boolean value) {
+        isPowerProcessing = value;
+    }
+
+    public static void setIgnoreEventsFromPackets(String packets){
+        try {
+            ignorePackets = Arrays.asList(packets.split(";"));
+        } catch(Exception e) {
+            Logger.E(TAG, "Exception in AccessibilityService : " + e.getMessage() + "\n");
+            e.printStackTrace();
+        }
+    }
+
+    private boolean isIgnorPackages(CharSequence eventPackageName){
+        try {
+            if(ignorePackets != null && ignorePackets.size() > 0){
+                if(ignorePackets.indexOf(eventPackageName.toString()) >= 0)
+                    return false;
+            }
+        } catch(Exception e) {
+            Logger.E(TAG, "Exception in AccessibilityService : " + e.getMessage() + "\n");
+            e.printStackTrace();
+        }
+
+        return true;
+    }
+
+    @Override
+    protected void onServiceConnected() {
+        try {
+            super.onServiceConnected();
+
+            receiver = new BroadcastReceiver(){
+                @Override
+                public void onReceive(Context context, Intent intent){
+                    String action = intent.getAction();
+                    if( action != null &&
+                        action.equals("com.rhobrowser.poweroff") &&
+                        isPowerProcessing)
+                    {
+                        powerOff();
+                    }
+                }
+            };
+            IntentFilter filter = new IntentFilter("com.rhobrowser.poweroff");
+            LocalBroadcastManager.getInstance(this).registerReceiver(receiver, filter);
+
+        } catch(Exception e) {
+            Logger.E(TAG, "Exception in AccessibilityService : " + e.getMessage() + "\n");
+            e.printStackTrace();
+        }
+
+        isEnabled = true;
+
+
+        //Toast.makeText(this, "Accessibility Service connected", Toast.LENGTH_LONG).show();
+    }
+
+    public static boolean getStatus(){
+        return isEnabled;
+    }
+
+    @Override
+    public void onAccessibilityEvent(AccessibilityEvent event) {
+        try {
+
+
+            if (event == null) {
+                Logger.T(this.TAG, "===================== onAccessibilityEvent ====================");
+                Logger.T(this.TAG, "event == null !");
+                Logger.T(this.TAG, "filter: " + filter);
+                Logger.T(this.TAG, "================================================================");
+                return;
+            }
+            //Log.d("myLog", "Kiosk status: "+(KioskManager.getKioskModeStatus()?"true":"false")+"; event: "+ event.toString());
+            Logger.T(this.TAG, "===================== onAccessibilityEvent ====================");
+            Logger.T(this.TAG, event.toString());
+            Logger.T(this.TAG, "filter: " + filter);
+            Logger.T(this.TAG, "================================================================");
+
+            if (filter){
+
+                if( event.getEventType() == AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED ||
+                    event.getEventType() == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED)
+                {
+
+                    if( KioskManager.getKioskModeStatus() &&
+                        event.getPackageName() != null &&
+                        !event.getPackageName().equals(getPackageName()) &&
+                        isIgnorPackages(event.getPackageName()))
+                    {
+                        Logger.T(this.TAG, "====================    GLOBAL_ACTION_HOME    =======================");
+                        performGlobalAction(GLOBAL_ACTION_HOME);
+                        if(event.getPackageName().equals(oldEvent)) {
+                            //Toast.makeText(this, "package: " + event.getPackageName(), Toast.LENGTH_SHORT).show();
+                            oldEvent = event.getPackageName();
+                        }
+                    }
+                }
+
+            } else {
+                if (powerPackageName == null && event.getEventType() == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED){
+                    powerPackageName = event.getPackageName();
+                }
+
+                Logger.T(this.TAG, "Package name = "+getPackageName());
+
+                if( (event.getEventType() == AccessibilityEvent.TYPE_VIEW_CLICKED &&
+                    !event.getPackageName().equals(getPackageName()) && !event.getPackageName().equals(powerPackageName)) ||
+                    (event.getEventType() == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED &&
+                    event.getPackageName() != powerPackageName ))
+                {
+                    Logger.T(this.TAG, "FILTER ON");
+                    filter = true;
+                    powerPackageName = null;
+                }
+            }
+
+            if( RhoConf.isExist("click_sound_with_accessibility_service") &&
+                RhoConf.getBool("click_sound_with_accessibility_service")){
+                Logger.T(this.TAG, "click_sound_with_accessibility_service");
+                Logger.T(this.TAG, "event.getClassName() = "+event.getClassName());
+                Logger.T(this.TAG, "Package name = "+getPackageName());
+                if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED &&
+                    event.getSource() != null &&
+                    event.getPackageName().equals(getPackageName()) &&
+                    event.getClassName().equals("android.widget.EditText")){
+                        playSound(event);
+                }
+            }
+        } catch(Exception e) {
+            Logger.E(TAG, "Exception in AccessibilityService : " + e.getMessage() + "\n");
+            e.printStackTrace();
+        }
+
+    }
+
+    protected boolean onKeyEvent (KeyEvent event) {
+        try {
+            if (event != null) {
+                Logger.E(this.TAG, "$$$## KEY CODE = ["+String.valueOf(event.getKeyCode())+"]");
+            }
+            else {
+                Logger.E(this.TAG, "$$$## KEY CODE = [event is null !]");
+            }
+            return super.onKeyEvent(event);
+        } catch(Exception e) {
+            Logger.E(TAG, "Exception in AccessibilityService : " + e.getMessage() + "\n");
+            e.printStackTrace();
+        }
+        return false;
+    }
+
+    private void playSound(AccessibilityEvent event){
+        try {
+            RhoInputListener.IRhoInputListener listener = RhoInputListener.getListener();
+            if (listener != null) {
+                listener.onTextInput();
+                listener.onAccessibitityEvent(event);
+            }
+        } catch(Exception e) {
+            Logger.E(TAG, "Exception in AccessibilityService : " + e.getMessage() + "\n");
+            e.printStackTrace();
+        }
+    }
+
+    private void powerOff(){
+        try {
+            Log.d("myLog1", "FILTER OFF");
+            filter = false;
+            performGlobalAction(GLOBAL_ACTION_POWER_DIALOG);
+        } catch(Exception e) {
+            Logger.E(TAG, "Exception in AccessibilityService : " + e.getMessage() + "\n");
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void onInterrupt() {
+
+    }
+
+    @Override
+    public void onDestroy() {
+        try {
+            super.onDestroy();
+            if(isPowerProcessing)
+                LocalBroadcastManager.getInstance(this).unregisterReceiver(receiver);
+        } catch(Exception e) {
+            Logger.E(TAG, "Exception in AccessibilityService : " + e.getMessage() + "\n");
+            e.printStackTrace();
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.rhomobile.rhodes.kioskservices;
+
+import android.service.notification.NotificationListenerService;
+import android.service.notification.StatusBarNotification;
+import android.widget.Toast;
+
+public class MyNotificationListenerService extends NotificationListenerService {
+    @Override
+    public void onNotificationPosted(StatusBarNotification sbn) {
+        if(KioskManager.getKioskModeStatus()){
+            //Toast.makeText(this,"kiosk mode enable", Toast.LENGTH_LONG).show();
+            cancelNotification(sbn.getKey());
+        }else
+            super.onNotificationPosted(sbn);
+    }
+}

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);
+    }
+}