package com.seewo.vcommons.utils;

import android.app.ActivityManager;
import android.content.ActivityNotFoundException;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.net.Uri;
import android.os.UserHandle;
import android.text.TextUtils;
import android.util.Log;
import android.widget.Toast;
import com.seewo.hiddenapi.ContextInsider;
import com.seewo.hiddenapi.UserHandleInsider;
import com.seewo.vcommons.constants.Platform;
import com.seewo.vcommons.constants.SeewoConstants;
import com.seewo.vcommons.constants.SeewoIntent;
import com.seewo.vcommons.constants.SeewoPackages;
import com.seewo.vcommons.data.PropertiesUtils;
import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
public class ActivityUtils {
    private static final String DOES_NOT_GET_PACKAGE_INFO = "doesn't get package info";
    private static final String DOES_NOT_HAVE_LABEL = " doesn't have label";
    private static final String TAG = "ActivityUtils";

    private ActivityUtils() {
    }

    public static boolean isActivityOnTop(Context context, String str) {
        String topActivityName = getTopActivityName(context);
        if (topActivityName == null || topActivityName.isEmpty()) {
            return false;
        }
        return topActivityName.equals(str);
    }

    public static boolean isPackageVisiable(Context context, String str) {
        String topNoTranslucentPackage = getTopNoTranslucentPackage();
        if (topNoTranslucentPackage != null && !topNoTranslucentPackage.isEmpty()) {
            return topNoTranslucentPackage.equals(str);
        }
        for (ActivityManager.RunningAppProcessInfo runningAppProcessInfo : ((ActivityManager) context.getSystemService("activity")).getRunningAppProcesses()) {
            if (str.equals(runningAppProcessInfo.processName) && (runningAppProcessInfo.importance == 200 || runningAppProcessInfo.importance == 100)) {
                return true;
            }
        }
        return false;
    }

    public static String getTopPackageName(Context context) {
        String topPackageName = getTopPackageName();
        if (topPackageName != null && !topPackageName.isEmpty()) {
            return topPackageName;
        }
        List<ActivityManager.RunningTaskInfo> runningTasks = ((ActivityManager) context.getSystemService("activity")).getRunningTasks(1);
        if (runningTasks == null || runningTasks.isEmpty()) {
            return null;
        }
        return runningTasks.get(0).topActivity.getPackageName();
    }

    public static String getTopActivityName(Context context) {
        String topActivityName = getTopActivityName();
        if (topActivityName != null && !topActivityName.isEmpty()) {
            return topActivityName;
        }
        List<ActivityManager.RunningTaskInfo> runningTasks = ((ActivityManager) context.getSystemService("activity")).getRunningTasks(1);
        if (runningTasks == null || runningTasks.isEmpty()) {
            return null;
        }
        return runningTasks.get(0).topActivity.getClassName();
    }

    public static String getTopAppName(Context context) {
        PackageManager packageManager = context.getPackageManager();
        String topPackageName = getTopPackageName(context);
        if (topPackageName == null) {
            return null;
        }
        try {
            ApplicationInfo applicationInfo = packageManager.getApplicationInfo(topPackageName, 0);
            if (applicationInfo != null) {
                return packageManager.getApplicationLabel(applicationInfo).toString();
            }
            return null;
        } catch (PackageManager.NameNotFoundException unused) {
            Log.i(TAG, topPackageName + DOES_NOT_HAVE_LABEL);
            return null;
        }
    }

    public static boolean isMarkRunning(Context context) {
        return (PropertiesUtils.getWorkingWriteApp() & 2) == 2;
    }

    public static boolean isFreezeRunning(Context context) {
        return isActivityOnTop(context, SeewoPackages.FREEZESCREEN_ACTIVITY) || isServiceRunning(context, SeewoPackages.FREEZESCREEN_SERVICE);
    }

    public static boolean isEasiNoteRunning(Context context) {
        return isActivityOnTop(context, SeewoPackages.EASINOTE_ACTIVITY) || isActivityOnTop(context, SeewoPackages.EASINOTE_BOARD_ACTIVITY) || isActivityOnTop(context, SeewoPackages.EASINOTE_PAIR_ACTIVITY) || (PropertiesUtils.getWorkingWriteApp() & 1) == 1;
    }

    public static boolean isEasiPalletRunning(Context context) {
        return isActivityOnTop(context, "com.seewo.easipallet.MainActivity") || (PropertiesUtils.getWorkingWriteApp() & 32) == 32;
    }

    public static boolean startEasiNoteSafely(Context context) {
        Intent intent = new Intent("com.seewo.easinote");
        intent.setFlags(SeewoIntent.DRAWER_STATE_LEFT);
        try {
            context.startActivity(intent);
            return true;
        } catch (ActivityNotFoundException e) {
            Log.d(TAG, "catch a ActivityNotFoundException when start ", e);
            return false;
        } catch (SecurityException e2) {
            Log.d(TAG, "catch a SecurityException when startActivitySafely", e2);
            return false;
        }
    }

    public static boolean isNoteVersionLargeThan2() {
        float f;
        try {
            f = Float.parseFloat(PropertiesUtils.getProperty(PropertiesUtils.PERSIST_SYS_EASINOTE_VERSION));
        } catch (Exception e) {
            Log.e(TAG, "isNoteVersionLargeThan2 parse noteVersion fail ", e);
            f = 0.0f;
        }
        return Float.compare(f, 2.0f) >= 0;
    }

    public static boolean startActivitySafely(Context context, String str, String str2) {
        ComponentName componentName = new ComponentName(str, str2);
        Intent intent = new Intent("android.intent.action.MAIN");
        intent.addCategory("android.intent.category.LAUNCHER");
        intent.setComponent(componentName);
        intent.setFlags(270532608);
        try {
            context.startActivity(intent);
            return true;
        } catch (ActivityNotFoundException e) {
            Log.d(TAG, "catch a ActivityNotFoundException when start " + str + " activity: " + str2, e);
            return false;
        } catch (SecurityException e2) {
            Log.d(TAG, "catch a SecurityException when startActivitySafely", e2);
            return false;
        }
    }

    public static boolean startActivitySafelyAsUser(Context context, String str, String str2, UserHandle userHandle) {
        ComponentName componentName = new ComponentName(str, str2);
        Intent intent = new Intent("android.intent.action.MAIN");
        intent.addCategory("android.intent.category.LAUNCHER");
        intent.setComponent(componentName);
        intent.setFlags(270532608);
        try {
            ContextInsider.startActivityAsUser(context, intent, userHandle);
            return true;
        } catch (ActivityNotFoundException e) {
            Log.d(TAG, "catch a ActivityNotFoundException when start " + str + " activity: " + str2, e);
            return false;
        } catch (SecurityException e2) {
            Log.d(TAG, "catch a SecurityException when startActivitySafely", e2);
            return false;
        }
    }

    public static boolean startActivitySafely(Context context, String str) {
        Intent intent = new Intent(str);
        intent.setFlags(270532608);
        try {
            context.startActivity(intent);
            return true;
        } catch (ActivityNotFoundException e) {
            Log.d(TAG, "ActivityNotFoundException when startActivitySafely", e);
            return false;
        }
    }

    public static boolean startActivitySafely(Context context, Intent intent) {
        intent.setFlags(270532608);
        try {
            context.startActivity(intent);
            return true;
        } catch (ActivityNotFoundException e) {
            Log.d(TAG, "ActivityNotFoundException when startActivitySafely", e);
            return false;
        }
    }

    public static boolean startActivitySafelyAsUser(Context context, String str, UserHandle userHandle) {
        Intent intent = new Intent(str);
        intent.setFlags(270532608);
        try {
            ContextInsider.startActivityAsUser(context, intent, userHandle);
            return true;
        } catch (ActivityNotFoundException e) {
            Log.d(TAG, "ActivityNotFoundException when startActivitySafely", e);
            return false;
        }
    }

    public static boolean startVideoPresenter(Context context) {
        return startActivitySafely(context, SeewoPackages.VIDEOPRESENTER_PACKAGE, SeewoPackages.VIDEOPRESENTER_ACTIVITY);
    }

    public static boolean startWidgetSticker(Context context) {
        Intent intent = new Intent();
        intent.setComponent(new ComponentName(SeewoPackages.STICKER_PACKAGE, SeewoPackages.STICKER_ACTIVITY));
        intent.addFlags(268500992);
        try {
            context.startActivity(intent);
            return true;
        } catch (ActivityNotFoundException e) {
            Log.d(TAG, "Activity not found!", e);
            return false;
        }
    }

    public static void startCMail(Context context, String str) {
        Intent intent = new Intent(SeewoIntent.ACTION_SEND_BY_CMAIL);
        intent.putExtra(SeewoIntent.KEY_SEND_BY_CMAIL_PATH, str);
        intent.setFlags(SeewoIntent.DRAWER_STATE_LEFT);
        try {
            context.startActivity(intent);
        } catch (ActivityNotFoundException e) {
            Log.d(TAG, "Activity not found!", e);
        }
    }

    public static boolean startKeeper(Context context) {
        return startActivitySafely(context, SeewoPackages.SEEWO_KEEPER_PACKAGE, SeewoPackages.SEEWO_KEEPER_ACTIVITY);
    }

    public static boolean isSettingMenuRunning(Context context) {
        return PropertiesUtils.isSettingMenuVisible();
    }

    public static boolean isAgingModeRunning(Context context) {
        return isActivityOnTop(context, SeewoPackages.AGINGMODE_ACTIVITY);
    }

    public static boolean isHidUpgradeRunning(Context context) {
        return isActivityOnTop(context, SeewoPackages.HID_UPGRADE_ACTIVITY);
    }

    public static boolean isSystemGuideRunning(Context context) {
        return isActivityOnTop(context, SeewoPackages.VS_SYSTEMGUIDE_ACTIVITY);
    }

    public static boolean isTvSettingActivityRunning(Context context) {
        List<ActivityManager.RunningTaskInfo> runningTasks = ((ActivityManager) context.getSystemService("activity")).getRunningTasks(10);
        if (runningTasks == null || runningTasks.isEmpty()) {
            return false;
        }
        for (ActivityManager.RunningTaskInfo runningTaskInfo : runningTasks) {
            if ("com.cvte.tv.setting".equals(runningTaskInfo.baseActivity.getPackageName()) || "com.cvte.tv.setting".equals(runningTaskInfo.topActivity.getPackageName())) {
                return true;
            }
        }
        return false;
    }

    public static boolean isLauncherRunning(Context context) {
        List<ActivityManager.RunningTaskInfo> runningTasks;
        List<String> launchers = getLaunchers(context);
        if (!launchers.isEmpty() && (runningTasks = ((ActivityManager) context.getSystemService("activity")).getRunningTasks(50)) != null && !runningTasks.isEmpty()) {
            for (ActivityManager.RunningTaskInfo runningTaskInfo : runningTasks) {
                if (launchers.contains(runningTaskInfo.baseActivity.getPackageName()) || launchers.contains(runningTaskInfo.topActivity.getPackageName())) {
                    return true;
                }
            }
        }
        return false;
    }

    private static List<String> getLaunchers(Context context) {
        ArrayList arrayList = new ArrayList();
        PackageManager packageManager = context.getPackageManager();
        Intent intent = new Intent("android.intent.action.MAIN");
        intent.addCategory("android.intent.category.HOME");
        for (ResolveInfo resolveInfo : packageManager.queryIntentActivities(intent, 65536)) {
            if (resolveInfo.activityInfo != null) {
                arrayList.add(resolveInfo.activityInfo.packageName);
            }
        }
        return arrayList;
    }

    public static boolean isLaucherOnTop(Context context) {
        return "com.seewo.launcher".equals(getTopPackageName(context));
    }

    public static boolean isLauncherVisible(Context context) {
        Iterator<String> it = getLaunchers(context).iterator();
        while (it.hasNext()) {
            if (isPackageVisiable(context, it.next())) {
                return true;
            }
        }
        return false;
    }

    public static boolean isTvSettingOnTop(Context context) {
        return isActivityOnTop(context, SeewoPackages.TVSETTING_ACTIVITY);
    }

    public static boolean isAndroidDisplayRunning(Context context) {
        return isActivityOnTop(context, SeewoPackages.ANDROID_DISPLAY_ACTIVITY);
    }

    public static boolean isServiceRunning(Context context, String str) {
        List<ActivityManager.RunningServiceInfo> runningServices = ((ActivityManager) context.getSystemService("activity")).getRunningServices(Platform.UNKNOWN);
        for (int i = 0; i < runningServices.size(); i++) {
            if (runningServices.get(i).service.getClassName().equals(str)) {
                return true;
            }
        }
        return false;
    }

    public static boolean isServiceRunning(Context context, Class<?> cls) {
        Iterator<ActivityManager.RunningServiceInfo> it = ((ActivityManager) context.getSystemService("activity")).getRunningServices(Platform.UNKNOWN).iterator();
        while (it.hasNext()) {
            if (cls.getName().equals(it.next().service.getClassName())) {
                return true;
            }
        }
        return false;
    }

    public static boolean startServiceIfNotRunning(Context context, String str, String str2) {
        if (isServiceRunning(context, str2)) {
            return false;
        }
        try {
            context.startService(new Intent().setComponent(new ComponentName(str, str2)));
            return true;
        } catch (SecurityException e) {
            Log.e(TAG, e.getMessage(), e);
            return false;
        }
    }

    public static boolean startServiceIfNotRunningAsUser(Context context, String str, String str2, UserHandle userHandle) {
        if (isServiceRunning(context, str2)) {
            return false;
        }
        try {
            ContextInsider.startServiceAsUser(context, new Intent().setComponent(new ComponentName(str, str2)), userHandle);
            return true;
        } catch (SecurityException e) {
            Log.e(TAG, e.getMessage(), e);
            return false;
        }
    }

    @Deprecated
    public static boolean startServiceSafely(Context context, String str) {
        Intent explicitIntent;
        if (isServiceRunning(context, str) || (explicitIntent = getExplicitIntent(context, new Intent(str))) == null) {
            return false;
        }
        context.startService(explicitIntent);
        return true;
    }

    public static boolean startServiceSafely(Context context, String str, String str2) {
        Intent intent = new Intent(str2);
        intent.setPackage(str);
        context.startService(intent);
        return false;
    }

    public static boolean stopServiceSafely(Context context, String str, String str2) {
        if (!isServiceRunning(context, str2)) {
            return false;
        }
        try {
            context.stopService(new Intent().setComponent(new ComponentName(str, str2)));
            return true;
        } catch (SecurityException e) {
            Log.e(TAG, e.getMessage(), e);
            return false;
        }
    }

    public static boolean stopServiceSafelyAsUser(Context context, String str, String str2, UserHandle userHandle) {
        if (!isServiceRunning(context, str2)) {
            return false;
        }
        try {
            ContextInsider.stopServiceAsUser(context, new Intent().setComponent(new ComponentName(str, str2)), userHandle);
            return true;
        } catch (SecurityException e) {
            Log.e(TAG, e.getMessage(), e);
            return false;
        }
    }

    @Deprecated
    public static boolean stopServiceSafely(Context context, String str) {
        Intent explicitIntent;
        if (!isServiceRunning(context, str) || (explicitIntent = getExplicitIntent(context, new Intent(str))) == null) {
            return false;
        }
        context.stopService(explicitIntent);
        return true;
    }

    private static Intent getExplicitIntent(Context context, Intent intent) {
        List<ResolveInfo> listQueryIntentServices = context.getPackageManager().queryIntentServices(intent, 0);
        if (listQueryIntentServices == null || listQueryIntentServices.size() != 1) {
            Log.e(TAG, "Make sure there is one and only one component matches this action");
            return null;
        }
        ResolveInfo resolveInfo = listQueryIntentServices.get(0);
        ComponentName componentName = new ComponentName(resolveInfo.serviceInfo.packageName, resolveInfo.serviceInfo.name);
        Intent intent2 = new Intent(intent);
        intent2.setComponent(componentName);
        return intent2;
    }

    public static String getAppNameByPackageName(Context context, String str) {
        PackageManager packageManager = context.getPackageManager();
        if (str == null) {
            return null;
        }
        try {
            ApplicationInfo applicationInfo = packageManager.getApplicationInfo(str, 0);
            if (applicationInfo != null) {
                return packageManager.getApplicationLabel(applicationInfo).toString();
            }
            return null;
        } catch (PackageManager.NameNotFoundException e) {
            Log.e(TAG, str + DOES_NOT_HAVE_LABEL, e);
            return null;
        }
    }

    @Deprecated
    public static boolean isApkExist(Context context, String str) {
        if (str != null && !"".equals(str)) {
            try {
                return context.getPackageManager().getApplicationEnabledSetting(str) != 2;
            } catch (Exception unused) {
                Log.i(TAG, str + DOES_NOT_HAVE_LABEL);
            }
        }
        return false;
    }

    public static boolean isAppExist(Context context, String str) {
        if (context != null && !TextUtils.isEmpty(str)) {
            try {
                context.getPackageManager().getApplicationEnabledSetting(str);
                return true;
            } catch (IllegalArgumentException unused) {
            }
        }
        return false;
    }

    public static boolean isAppEnable(Context context, String str) {
        if (str != null && !"".equals(str)) {
            try {
                int applicationEnabledSetting = context.getPackageManager().getApplicationEnabledSetting(str);
                return (applicationEnabledSetting == 2 || applicationEnabledSetting == 3) ? false : true;
            } catch (Exception unused) {
                Log.i(TAG, str + DOES_NOT_HAVE_LABEL);
            }
        }
        return false;
    }

    public static void setAppEnable(Context context, String str, boolean z) {
        try {
            context.getPackageManager().setApplicationEnabledSetting(str, z ? 0 : 2, 0);
        } catch (Exception unused) {
            Log.i(TAG, str + DOES_NOT_HAVE_LABEL);
        }
    }

    public static void setActivityEnabled(Context context, String str, String str2, boolean z) {
        context.getPackageManager().setComponentEnabledSetting(new ComponentName(str, str2), z ? 1 : 2, 1);
    }

    public static boolean isTaskRunning(Context context, String str) {
        Iterator<ActivityManager.RunningTaskInfo> it = ((ActivityManager) context.getSystemService("activity")).getRunningTasks(15).iterator();
        while (it.hasNext()) {
            if (str.equals(it.next().topActivity.getPackageName())) {
                return true;
            }
        }
        return false;
    }

    public static void startMarkApp(Context context, Intent intent) {
        if (isMarkRunning(context)) {
            handleFakeAcceleratorMark(context, intent);
            return;
        }
        intent.setComponent(new ComponentName(SeewoPackages.EASIMARK_PACKAGE, SeewoPackages.EASIMARK_SERVICE));
        try {
            ContextInsider.startServiceAsUser(context, intent, UserHandleInsider.CURRENT);
        } catch (Exception e) {
            Log.e(TAG, "Exception", e);
            Toast.makeText(context, "can't start application.", 0).show();
        }
    }

    private static void handleFakeAcceleratorMark(Context context, Intent intent) {
        if (3 == intent.getIntExtra(SeewoIntent.KEY_MARK_START_TYPE, 4)) {
            context.sendBroadcast(new Intent(SeewoIntent.ACTION_RESUME_ANYMARK));
        }
    }

    public static void exitMarkApp(Context context) {
        ContextInsider.sendBroadcastAsUser(context, new Intent(SeewoIntent.ACTION_CLOSE_ANYMARK), UserHandleInsider.CURRENT);
    }

    private static String getTopActivityName() {
        if (isMarkRunning(null)) {
            return SeewoPackages.EASIMARK_ACTIVITY;
        }
        return PropertiesUtils.getProperty(SeewoConstants.SYSTEM_CURRENT_VISIBLE_ACTIVITY, (String) null);
    }

    private static String getTopPackageName() {
        if (isMarkRunning(null)) {
            return SeewoPackages.EASIMARK_PACKAGE;
        }
        return PropertiesUtils.getProperty(SeewoConstants.SYSTEM_CURRENT_VISIBLE_PACKAGE, (String) null);
    }

    private static String getTopNoTranslucentActivity() {
        return PropertiesUtils.getProperty("sys.visible.activity", (String) null);
    }

    private static String getTopNoTranslucentPackage() {
        return PropertiesUtils.getProperty("sys.visible.package", (String) null);
    }

    public static void insertPicToEasiNote(Context context, String str, boolean z, int i) {
        if (TextUtils.isEmpty(str)) {
            return;
        }
        Intent intent = new Intent();
        intent.setComponent(new ComponentName("com.seewo.easinote", SeewoPackages.EASINOTE_ACTIVITY));
        intent.setDataAndType(Uri.fromFile(new File(str)), "image/*");
        intent.setFlags(SeewoIntent.DRAWER_STATE_LEFT);
        if (z) {
            intent.putExtra(SeewoIntent.KEY_INSERT_IMG_AT_NEW_PAGE, true);
        }
        if (i > 0) {
            intent.putExtra(SeewoIntent.KEY_INSERT_IMG_SIZE, i);
        }
        try {
            context.startActivity(intent);
        } catch (Exception e) {
            Log.e(TAG, "Exception", e);
            Toast.makeText(context, "can't start application.", 0).show();
        }
    }
}