package com.dss.tpservice.controller;

import android.app.TaskStackListener;
import android.content.ComponentName;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.os.RemoteException;
import android.text.TextUtils;
import android.util.Log;
import com.dss.tpservice.WindowInfo;
import com.dss.tpservice.bean.DataBean;
import com.dss.tpservice.bean.TaskInfo;
import com.dss.tpservice.bean.WindowBean;
import com.dss.tpservice.utils.ATMSHookUtils;
import com.dss.tpservice.utils.ActionsManager;
import com.dss.tpservice.utils.GsonUtil;
import com.dss.tpservice.utils.ResourceUtil;
import com.google.gson.reflect.TypeToken;
import com.seewo.vcommons.utils.ShellCommandUtils;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/* JADX INFO: loaded from: classes.dex */
public class MonitorAppController {
    private static final String TAG = "MonitorAppController";
    private Handler mActionHandler;
    private Handler mDataHandler;
    private final Map<String, Map<String, DataBean>> mDataMap;
    private HandlerThread mHandlerActionThread;
    private HandlerThread mHandlerDataThread;
    private HandlerThread mHandlerShellThread;
    private Handler mShellHandler;
    private TaskStackListener mTaskListener;
    private final int WINDOW_ADD = 1011;
    private final int WINDOW_REMOVE = 1012;
    private final int TASK_ADD = 1013;
    private final int TASK_REMOVE = 1014;
    private final String TYPE_ACTIVITY = "Activity";
    private final String TYPE_WINDOW = "Window";
    private final int mDelayMillis = 600;

    public MonitorAppController() {
        Map<String, Map<String, DataBean>> map = (Map) GsonUtil.fromJson(ResourceUtil.readAssets2String("monitor_app_config.json"), new TypeToken<Map<String, Map<String, DataBean>>>() { // from class: com.dss.tpservice.controller.MonitorAppController.1
        }.getType());
        this.mDataMap = map;
        if (map == null) {
            Log.w(TAG, "assets//monitor_app_config.json not exist!");
            return;
        }
        HandlerThread handlerThread = new HandlerThread("Handle_Data_Thread");
        this.mHandlerDataThread = handlerThread;
        handlerThread.start();
        this.mDataHandler = new Handler(this.mHandlerDataThread.getLooper()) { // from class: com.dss.tpservice.controller.MonitorAppController.2
            @Override // android.os.Handler
            public void handleMessage(Message message) {
                if (message.what == 1011) {
                    WindowBean windowBean = (WindowBean) message.obj;
                    String handleType = windowBean.getHandleType();
                    WindowInfo windowInfo = windowBean.getWindowInfo();
                    DataBean dataBean = (DataBean) ((Map) MonitorAppController.this.mDataMap.get(handleType)).get(windowInfo.getAttrs().packageName);
                    if (dataBean.addWindow(windowInfo.getBinder())) {
                        Log.d(MonitorAppController.TAG, "type = WINDOW_ADD，result = New window，packageName = " + windowInfo.getAttrs().packageName + "，binder = " + windowInfo.getBinder());
                    } else {
                        Log.d(MonitorAppController.TAG, "type = WINDOW_ADD，result = Original window Self-increasing 1，packageName = " + windowInfo.getAttrs().packageName + "，binder = " + windowInfo.getBinder());
                    }
                    if (MonitorAppController.this.isExecuteStartOrder(handleType)) {
                        if (!TextUtils.isEmpty(dataBean.getStartShell())) {
                            MonitorAppController.this.sendMessageToShellHandler(handleType, dataBean.getStartShell());
                            return;
                        } else {
                            if (TextUtils.isEmpty(dataBean.getStartAction())) {
                                return;
                            }
                            MonitorAppController.this.sendMessageToActionHandler(handleType, dataBean.getStartAction());
                            return;
                        }
                    }
                    return;
                }
                if (message.what == 1012) {
                    WindowBean windowBean2 = (WindowBean) message.obj;
                    String handleType2 = windowBean2.getHandleType();
                    WindowInfo windowInfo2 = windowBean2.getWindowInfo();
                    DataBean dataBean2 = (DataBean) ((Map) MonitorAppController.this.mDataMap.get(handleType2)).get(windowInfo2.getAttrs().packageName);
                    if (dataBean2.removeWindow(windowInfo2.getBinder())) {
                        Log.d(MonitorAppController.TAG, "type = WINDOW_REMOVE，result = Window remove success，packageName = " + windowInfo2.getAttrs().packageName + "，binder = " + windowInfo2.getBinder());
                    } else {
                        Log.d(MonitorAppController.TAG, "type = WINDOW_REMOVE，result = Window already removed，packageName = " + windowInfo2.getAttrs().packageName + "，binder = " + windowInfo2.getBinder());
                    }
                    if (MonitorAppController.this.isExecuteExitOrder(handleType2)) {
                        if (!TextUtils.isEmpty(dataBean2.getExitShell())) {
                            MonitorAppController.this.sendMessageToShellHandler(handleType2, dataBean2.getExitShell());
                            return;
                        } else {
                            if (TextUtils.isEmpty(dataBean2.getExitAction())) {
                                return;
                            }
                            MonitorAppController.this.sendMessageToActionHandler(handleType2, dataBean2.getExitAction());
                            return;
                        }
                    }
                    return;
                }
                if (message.what == 1013) {
                    TaskInfo taskInfo = (TaskInfo) message.obj;
                    String handleType3 = taskInfo.getHandleType();
                    DataBean dataBean3 = (DataBean) ((Map) MonitorAppController.this.mDataMap.get(handleType3)).get(taskInfo.getPackageName());
                    if (dataBean3.addNewTask(taskInfo.getTaskId())) {
                        Log.d(MonitorAppController.TAG, "type = TASK_ADD，result = New task，packageName = " + taskInfo.getPackageName() + "，taskId = " + taskInfo.getTaskId());
                    } else {
                        Log.d(MonitorAppController.TAG, "type = TASK_ADD，result = Task already exists，packageName = " + taskInfo.getPackageName() + "，taskId = " + taskInfo.getTaskId());
                    }
                    if (MonitorAppController.this.isExecuteStartOrder(handleType3)) {
                        if (!TextUtils.isEmpty(dataBean3.getStartShell())) {
                            MonitorAppController.this.sendMessageToShellHandler(handleType3, dataBean3.getStartShell());
                            return;
                        } else {
                            if (TextUtils.isEmpty(dataBean3.getStartAction())) {
                                return;
                            }
                            MonitorAppController.this.sendMessageToActionHandler(handleType3, dataBean3.getStartAction());
                            return;
                        }
                    }
                    return;
                }
                if (message.what == 1014) {
                    int iIntValue = ((Integer) message.obj).intValue();
                    HashMap map2 = new HashMap();
                    for (String str : MonitorAppController.this.mDataMap.keySet()) {
                        for (String str2 : ((Map) MonitorAppController.this.mDataMap.get(str)).keySet()) {
                            if ("Activity".equals(((DataBean) ((Map) MonitorAppController.this.mDataMap.get(str)).get(str2)).getType()) && ((DataBean) ((Map) MonitorAppController.this.mDataMap.get(str)).get(str2)).isContainTask(iIntValue)) {
                                map2.put(str, str2);
                            }
                        }
                    }
                    if (map2.isEmpty()) {
                        return;
                    }
                    for (String str3 : map2.keySet()) {
                        String str4 = (String) map2.get(str3);
                        if (((DataBean) ((Map) MonitorAppController.this.mDataMap.get(str3)).get(str4)).removeTask(iIntValue)) {
                            Log.d(MonitorAppController.TAG, "type = TASK_REMOVE，result = Task remove success，packageName = " + str4 + "，taskId = " + iIntValue);
                        } else {
                            Log.d(MonitorAppController.TAG, "type = TASK_REMOVE，result = Task already removed，packageName = " + str4 + "，taskId = " + iIntValue);
                        }
                        if (MonitorAppController.this.isExecuteExitOrder(str3)) {
                            if (!TextUtils.isEmpty(((DataBean) ((Map) MonitorAppController.this.mDataMap.get(str3)).get(str4)).getExitShell())) {
                                MonitorAppController monitorAppController = MonitorAppController.this;
                                monitorAppController.sendMessageToShellHandler(str3, ((DataBean) ((Map) monitorAppController.mDataMap.get(str3)).get(str4)).getExitShell());
                            } else if (!TextUtils.isEmpty(((DataBean) ((Map) MonitorAppController.this.mDataMap.get(str3)).get(str4)).getExitAction())) {
                                MonitorAppController monitorAppController2 = MonitorAppController.this;
                                monitorAppController2.sendMessageToActionHandler(str3, ((DataBean) ((Map) monitorAppController2.mDataMap.get(str3)).get(str4)).getExitAction());
                            }
                        }
                    }
                }
            }
        };
        HandlerThread handlerThread2 = new HandlerThread("Handle_Shell_Thread");
        this.mHandlerShellThread = handlerThread2;
        handlerThread2.start();
        this.mShellHandler = new Handler(this.mHandlerShellThread.getLooper()) { // from class: com.dss.tpservice.controller.MonitorAppController.3
            @Override // android.os.Handler
            public void handleMessage(Message message) {
                Log.d(MonitorAppController.TAG, "handle shell command ---> " + message.obj);
                ShellCommandUtils.executeCommand((String) message.obj);
            }
        };
        HandlerThread handlerThread3 = new HandlerThread("Handle_Action_Thread");
        this.mHandlerActionThread = handlerThread3;
        handlerThread3.start();
        this.mActionHandler = new Handler(this.mHandlerActionThread.getLooper()) { // from class: com.dss.tpservice.controller.MonitorAppController.4
            @Override // android.os.Handler
            public void handleMessage(Message message) {
                Log.d(MonitorAppController.TAG, "handle action ---> " + message.obj);
                ActionsManager.getInstance().getAction((String) message.obj).executeAction();
            }
        };
        TaskStackListener taskStackListener = new TaskStackListener() { // from class: com.dss.tpservice.controller.MonitorAppController.5
            @Override // android.app.TaskStackListener, android.app.ITaskStackListener
            public void onTaskCreated(int i, ComponentName componentName) throws RemoteException {
                super.onTaskCreated(i, componentName);
                if (componentName == null || TextUtils.isEmpty(componentName.getPackageName())) {
                    return;
                }
                for (String str : MonitorAppController.this.mDataMap.keySet()) {
                    if (((Map) MonitorAppController.this.mDataMap.get(str)).containsKey(componentName.getPackageName()) && "Activity".equals(((DataBean) ((Map) MonitorAppController.this.mDataMap.get(str)).get(componentName.getPackageName())).getType())) {
                        Message messageObtain = Message.obtain();
                        messageObtain.what = 1013;
                        messageObtain.obj = new TaskInfo(str, componentName.getPackageName(), i);
                        MonitorAppController.this.sendMessageToDataHandler(messageObtain);
                    }
                }
            }

            @Override // android.app.TaskStackListener, android.app.ITaskStackListener
            public void onTaskRemoved(int i) throws RemoteException {
                Message messageObtain = Message.obtain();
                messageObtain.what = 1014;
                messageObtain.obj = Integer.valueOf(i);
                MonitorAppController.this.sendMessageToDataHandler(messageObtain);
            }
        };
        this.mTaskListener = taskStackListener;
        ATMSHookUtils.registerTaskStackListener(taskStackListener);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void sendMessageToDataHandler(Message message) {
        this.mDataHandler.sendMessage(message);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void sendMessageToShellHandler(String str, String str2) {
        int iHashCode = str.hashCode();
        if (this.mShellHandler.hasMessages(iHashCode)) {
            this.mShellHandler.removeMessages(iHashCode);
        }
        if (this.mActionHandler.hasMessages(iHashCode)) {
            this.mActionHandler.removeMessages(iHashCode);
        }
        Message messageObtain = Message.obtain();
        messageObtain.what = iHashCode;
        messageObtain.obj = str2;
        this.mShellHandler.sendMessageDelayed(messageObtain, 600L);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void sendMessageToActionHandler(String str, String str2) {
        int iHashCode = str.hashCode();
        if (this.mActionHandler.hasMessages(iHashCode)) {
            this.mActionHandler.removeMessages(iHashCode);
        }
        if (this.mShellHandler.hasMessages(iHashCode)) {
            this.mShellHandler.removeMessages(iHashCode);
        }
        Message messageObtain = Message.obtain();
        messageObtain.what = iHashCode;
        messageObtain.obj = str2;
        this.mActionHandler.sendMessageDelayed(messageObtain, 600L);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public boolean isExecuteStartOrder(String str) {
        Iterator<DataBean> it = this.mDataMap.get(str).values().iterator();
        while (it.hasNext()) {
            if (it.next().getCount() > 0) {
                return true;
            }
        }
        return false;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public boolean isExecuteExitOrder(String str) {
        Iterator<DataBean> it = this.mDataMap.get(str).values().iterator();
        while (it.hasNext()) {
            if (it.next().getCount() > 0) {
                return false;
            }
        }
        return true;
    }

    private Map<String, Map<String, DataBean>> getDataMap() {
        return this.mDataMap;
    }

    public void handleAppCreate(WindowInfo windowInfo) {
        if (this.mDataMap == null || windowInfo == null || windowInfo.getAttrs() == null || TextUtils.isEmpty(windowInfo.getAttrs().packageName) || !checkedAppNeedHandled(windowInfo)) {
            return;
        }
        for (String str : getDataMap().keySet()) {
            if (getDataMap().get(str).containsKey(windowInfo.getAttrs().packageName) && "Window".equals(getDataMap().get(str).get(windowInfo.getAttrs().packageName).getType())) {
                Message messageObtain = Message.obtain();
                messageObtain.what = 1011;
                messageObtain.obj = new WindowBean(str, windowInfo);
                sendMessageToDataHandler(messageObtain);
            }
        }
    }

    public void handleAppDestroy(WindowInfo windowInfo) {
        if (this.mDataMap == null || windowInfo == null || windowInfo.getAttrs() == null || TextUtils.isEmpty(windowInfo.getAttrs().packageName) || !checkedAppNeedHandled(windowInfo)) {
            return;
        }
        for (String str : getDataMap().keySet()) {
            if (getDataMap().get(str).containsKey(windowInfo.getAttrs().packageName) && "Window".equals(getDataMap().get(str).get(windowInfo.getAttrs().packageName).getType())) {
                Message messageObtain = Message.obtain();
                messageObtain.what = 1012;
                messageObtain.obj = new WindowBean(str, windowInfo);
                sendMessageToDataHandler(messageObtain);
            }
        }
    }

    private boolean checkedAppNeedHandled(WindowInfo windowInfo) {
        int i = windowInfo.getAttrs().type;
        return (2000 <= i && i < 2005) || (2005 < i && i <= 2038);
    }

    public void release() {
        if (this.mDataMap == null) {
            return;
        }
        ATMSHookUtils.unRegisterTaskStackListener(this.mTaskListener);
        this.mDataHandler.removeCallbacksAndMessages(null);
        this.mHandlerDataThread.quitSafely();
        this.mShellHandler.removeCallbacksAndMessages(null);
        this.mHandlerShellThread.quitSafely();
        this.mActionHandler.removeCallbacksAndMessages(null);
        this.mHandlerActionThread.quitSafely();
    }
}