jimu-decompiled/sources/com/ubt/jimu/base/UbtActivityStack.java

package com.ubt.jimu.base;

import android.app.Activity;
import android.app.ActivityManager;
import android.app.Application;
import android.content.Context;
import android.os.Process;
import com.ubt.jimu.JimuApplication;
import com.ubt.jimu.unity.bluetooth.UnityActivity;
import com.ubtech.utils.XLog;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Stack;

/* loaded from: classes.dex */
public class UbtActivityStack {
    private int mResumedCount;
    private Stack<Activity> mStack;

    private static class NotesActivityStackHelper {
        private static final UbtActivityStack INSTANCE = new UbtActivityStack();

        private NotesActivityStackHelper() {
        }
    }

    public static UbtActivityStack getInstance() {
        return NotesActivityStackHelper.INSTANCE;
    }

    public void addActivity(Activity activity) {
        Iterator<Activity> it = this.mStack.iterator();
        while (it.hasNext()) {
            Activity next = it.next();
            if (activity.getClass().equals(UnityActivity.class) || activity.getClass().equals(next.getClass())) {
                this.mStack.remove(next);
                break;
            }
        }
        this.mStack.add(activity);
    }

    public void closeActivity(Class cls) {
        for (int i = 0; i < this.mStack.size(); i++) {
            if (this.mStack.get(i) != null && !this.mStack.get(i).isFinishing() && this.mStack.get(i).getClass().equals(cls.getClass())) {
                this.mStack.get(i).finish();
                this.mStack.remove(i);
                return;
            }
        }
    }

    public void decrement() {
        this.mResumedCount--;
    }

    public void finishAllActivity() {
        for (int i = 0; i < this.mStack.size(); i++) {
            if (this.mStack.get(i) != null && !this.mStack.get(i).isFinishing()) {
                this.mStack.get(i).finish();
            }
        }
        this.mStack.clear();
        killProgress();
    }

    public Activity getActivity(int i) {
        Stack<Activity> stack = this.mStack;
        if (stack == null || stack.size() <= 0 || this.mStack.size() <= i + 1) {
            return null;
        }
        return this.mStack.get((r0.size() - 1) - i);
    }

    public Activity getActivityByClassName(String str) {
        for (Activity activity : getActivityTask(JimuApplication.l())) {
            if (activity.getClass().getSimpleName().equals(str)) {
                return activity;
            }
        }
        return null;
    }

    public List<Activity> getActivityTask(Application application) {
        ArrayList arrayList = new ArrayList();
        try {
            Field declaredField = Application.class.getDeclaredField("mLoadedApk");
            declaredField.setAccessible(true);
            Object obj = declaredField.get(application);
            Field declaredField2 = obj.getClass().getDeclaredField("mActivityThread");
            declaredField2.setAccessible(true);
            Object obj2 = declaredField2.get(obj);
            Field declaredField3 = obj2.getClass().getDeclaredField("mActivities");
            declaredField3.setAccessible(true);
            Object obj3 = declaredField3.get(obj2);
            if (obj3 instanceof Map) {
                Iterator it = ((Map) obj3).entrySet().iterator();
                while (it.hasNext()) {
                    Object value = ((Map.Entry) it.next()).getValue();
                    Field declaredField4 = value.getClass().getDeclaredField("activity");
                    declaredField4.setAccessible(true);
                    arrayList.add((Activity) declaredField4.get(value));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return arrayList;
    }

    public int getResumedCount() {
        return this.mResumedCount;
    }

    public Activity getTopActivity() {
        if (this.mStack.size() <= 0) {
            return null;
        }
        return this.mStack.get(r0.size() - 1);
    }

    public void increment() {
        this.mResumedCount++;
    }

    public boolean isActivityStack(Context context) {
        ActivityManager activityManager = (ActivityManager) context.getSystemService("activity");
        List<ActivityManager.RunningTaskInfo> runningTasks = activityManager.getRunningTasks(3);
        activityManager.getRunningAppProcesses();
        activityManager.getAppTasks();
        return runningTasks.size() <= 2;
    }

    public boolean isAppForeground() {
        return this.mResumedCount > 0;
    }

    public boolean isExistUnityActivity() {
        Iterator<Activity> it = getActivityTask(JimuApplication.l()).iterator();
        while (it.hasNext()) {
            if (it.next().getClass().getSimpleName().equals(UnityActivity.class.getSimpleName())) {
                return true;
            }
        }
        return false;
    }

    public boolean isTargetClass(Class cls, int i) {
        Activity activity = getActivity(i);
        return activity != null && activity.getClass().equals(cls);
    }

    public boolean isTopStack(Class cls) {
        XLog.a("act_life", "size is %s", Integer.valueOf(this.mStack.size()));
        if (this.mStack.size() == 0) {
            return false;
        }
        Stack<Activity> stack = this.mStack;
        if (!stack.get(stack.size() - 1).getClass().equals(cls)) {
            return false;
        }
        Object[] objArr = new Object[1];
        objArr[0] = cls != null ? cls.getSimpleName() : "null";
        XLog.a("act_life", "top stack clz %s", objArr);
        return true;
    }

    public void killProgress() {
        Process.killProcess(Process.myPid());
        System.exit(0);
    }

    public void removeActivity(Activity activity) {
        this.mStack.remove(activity);
    }

    public void returnPreActivity(Context context) {
        ((Activity) context).finish();
    }

    public Stack<Activity> stack() {
        return this.mStack;
    }

    private UbtActivityStack() {
        this.mStack = new Stack<>();
        this.mResumedCount = 0;
    }
}