Code to check whether device is rooted or not in android

a.kt

import java.util.ArrayList;
import java.util.Arrays;

class a {

    static final String[] f56685a = {"com.noshufou.android.su", "com.noshufou.android.su.elite", "eu.chainfire.supersu", "com.koushikdutta.superuser", "com.thirdparty.superuser", "com.yellowes.su", "com.topjohnwu.magisk", "com.kingroot.kinguser", "com.kingo.root", "com.smedialink.oneclickroot", "com.zhiqupk.root.global", "com.alephzain.framaroot"};

    public static final String[] f56686b = {"com.koushikdutta.rommanager", "com.koushikdutta.rommanager.license", "com.dimonvideo.luckypatcher", "com.chelpus.lackypatch", "com.ramdroid.appquarantine", "com.ramdroid.appquarantinepro", "com.android.vending.billing.InAppBillingService.COIN", "com.android.vending.billing.InAppBillingService.LUCK", "com.chelpus.luckypatcher", "com.blackmartalpha", "org.blackmart.market", "com.allinone.free", "com.repodroid.app", "org.creeplays.hack", "com.baseappfull.fwd", "com.zmapp", "com.dv.marketmod.installer", "org.mobilism.android", "com.android.wp.net.log", "com.android.camera.update", "cc.madkite.freedom", "com.solohsu.android.edxp.manager", "org.meowcat.edxposed.manager", "com.xmodgame", "com.cih.game_cih", "com.charles.lpoqasert", "catch_.me_.if_.you_.can_"};

    public static final String[] f56687c = {"com.devadvance.rootcloak", "com.devadvance.rootcloakplus", "de.robv.android.xposed.installer", "com.saurik.substrate", "com.zachspong.temprootremovejb", "com.amphoras.hidemyroot", "com.amphoras.hidemyrootadfree", "com.formyhm.hiderootPremium", "com.formyhm.hideroot"};

    private static final String[] f56688d = {"/data/local/", "/data/local/bin/", "/data/local/xbin/", "/sbin/", "/su/bin/", "/system/bin/", "/system/bin/.ext/", "/system/bin/failsafe/", "/system/sd/xbin/", "/system/usr/we-need-root/", "/system/xbin/", "/cache/", "/data/", "/dev/"};

    static final String[] f56689e = {"/system", "/system/bin", "/system/sbin", "/system/xbin", "/vendor/bin", "/sbin", "/etc"};

    public static String[] a() {
        ArrayList arrayList = new ArrayList(Arrays.asList(f56688d));
        String str = System.getenv("PATH");
        if (str == null || "".equals(str)) {
            return (String[]) arrayList.toArray(new String[0]);
        }
        String[] split = str.split(":");
        int length = split.length;
        for (int i11 = 0; i11 < length; i11++) {
            String str2 = split[i11];
            if (!str2.endsWith("/")) {
                str2 = str2 + '/';
            }
            if (!arrayList.contains(str2)) {
                arrayList.add(str2);
            }
        }
        return (String[]) arrayList.toArray(new String[0]);
    }
}

b.kt

import android.content.pm.PackageManager;
import android.os.Build;

import com.google.android.exoplayer2.metadata.icy.IcyHeaders;
import com.scottyab.rootbeer.RootBeerNative;

import android.content.Context;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Scanner;

public class b {

    private final Context f56690a;

    private boolean f56691b = true;

    public b(Context context) {
        this.f56690a = context;
    }

    private boolean m(List<String> list) {
        PackageManager packageManager = this.f56690a.getPackageManager();
        boolean z11 = false;
        for (String str : list) {
            try {
                packageManager.getPackageInfo(str, 0);
                c.b(str + " ROOT management app detected!");
                z11 = true;
            } catch (PackageManager.NameNotFoundException unused) {
            }
        }
        return z11;
    }

    private String[] p() {
        try {
            InputStream inputStream = Runtime.getRuntime().exec("mount").getInputStream();
            if (inputStream == null) {
                return null;
            }
            return new Scanner(inputStream).useDelimiter("\\A").next().split("\n");
        } catch (IOException | NoSuchElementException e11) {
            c.a(e11);
            return null;
        }
    }

    private String[] q() {
        try {
            InputStream inputStream = Runtime.getRuntime().exec("getprop").getInputStream();
            if (inputStream == null) {
                return null;
            }
            return new Scanner(inputStream).useDelimiter("\\A").next().split("\n");
        } catch (IOException | NoSuchElementException e11) {
            //az.a.a(e11);
            c.e();
            return null;
        }
    }

    public boolean a() {
        //return new RootBeerNative().a();
        return false;
    }

    public boolean b(String str) {
        String[] a11;
        boolean z11 = false;
        for (String str2 : a.a()) {
            String str3 = str2 + str;
            if (new File(str2, str).exists()) {
                //az.a.f(str3 + " binary detected!");
                c.f(str3 + " binary detected!");
                z11 = true;
            }
        }
        return z11;
    }

    public boolean c() {
        HashMap hashMap = new HashMap();
        hashMap.put("ro.debuggable", IcyHeaders.REQUEST_HEADER_ENABLE_METADATA_VALUE);
//        hashMap.put("ro.secure", SessionDescription.SUPPORTED_SDP_VERSION);
       // hashMap.put("ro.secure", SessionDescription.SUPPORTED_SDP_VERSION);
        String[] q11 = q();
        if (q11 == null) {
            return false;
        }
        boolean z11 = false;
        for (String str : q11) {
            for (Object str2 : hashMap.keySet()) {
                if (str.contains((CharSequence) str2)) {
                    String str3 = "[" + ((String) hashMap.get(str2)) + "]";
                    if (str.contains(str3)) {
                        //az.a.f(str2 + " = " + str3 + " detected!");
                        c.f(str2 + " = " + str3 + " detected!");
                        z11 = true;
                    }
                }
            }
        }
        return z11;
    }

    public boolean d() {
        return b("magisk");
    }

    public boolean e() {
        String[] p11 = p();
        int i11 = 0;
        if (p11 == null) {
            return false;
        }
        int length = p11.length;
        int i12 = 0;
        boolean z11 = false;
        while (i12 < length) {
            String str = p11[i12];
            String[] split = str.split(" ");
            if (split.length < 6) {
                //az.a.b("Error formatting mount line: " + str);
                c.b("Error formatting mount line: " + str);
            } else {
                String str2 = split[2];
                String str3 = split[5];
                String[] strArr = a.f56689e;
                int length2 = strArr.length;
                int i13 = i11;
                while (i13 < length2) {
                    String str4 = strArr[i13];
                    if (str2.equalsIgnoreCase(str4)) {
                        str3 = str3.replace("(", "").replace(")", "");
                        String[] split2 = str3.split(",");
                        int length3 = split2.length;
                        int i14 = i11;
                        while (true) {
                            if (i14 >= length3) {
                                break;
                            } else if (split2[i14].equalsIgnoreCase("rw")) {
                                c.f(str4 + " path is mounted with rw permissions! " + str);
                                z11 = true;
                                break;
                            } else {
                                i14++;
                            }
                        }
                    }
                    i13++;
                    i11 = 0;
                }
            }
            i12++;
            i11 = 0;
        }
        return z11;
    }

    public boolean f() {
        String[] a11 = new String[0];
        if (!a()) {
//            az.a.b("We could not load the native library to test for root");
            c.b("We could not load the native library to test for root");
            return false;
        }
        int length = a.a().length;
        String[] strArr = new String[length];
        for (int i11 = 0; i11 < length; i11++) {
            strArr[i11] = a11[i11] + "su";
        }
        RootBeerNative rootBeerNative = new RootBeerNative();
        try {
            rootBeerNative.setLogDebugMessages(this.f56691b);
            return rootBeerNative.checkForRoot(strArr) > 0;
        } catch (UnsatisfiedLinkError unused) {
            return false;
        }
    }

    public boolean g() {
        Process process = null;
        try {
            process = Runtime.getRuntime().exec(new String[]{"which", "su"});
            boolean z11 = new BufferedReader(new InputStreamReader(process.getInputStream())).readLine() != null;
            process.destroy();
            return z11;
        } catch (Throwable unused) {
            if (process != null) {
                process.destroy();
            }
            return false;
        }
    }

    public boolean h() {
        return i(null);
    }

    public boolean i(String[] strArr) {
        ArrayList arrayList = new ArrayList();
        arrayList.addAll(Arrays.asList(a.f56686b));
        if (strArr != null && strArr.length > 0) {
            arrayList.addAll(Arrays.asList(strArr));
        }
        return m(arrayList);
    }

    public boolean j() {
        return k(null);
    }

    public boolean k(String[] strArr) {
        ArrayList arrayList = new ArrayList(Arrays.asList(a.f56685a));
        if (strArr != null && strArr.length > 0) {
            arrayList.addAll(Arrays.asList(strArr));
        }
        return m(arrayList);
    }

    public boolean l() {
        String str = Build.TAGS;
        return str != null && str.contains("test-keys");
    }

    public boolean n() {
        return j() || h() || b("su") || c() || e() || l() || g() || f() || d();
    }

    @Deprecated
    public boolean o() {
        return n();
    }

    public void r(boolean z11) {
        this.f56691b = z11;
        c.f6954a = z11 ? 5 : 0;
    }
}

c.kt

import android.util.Log;

public  class c {

    public static int f6954a = 5;

    public static void a(Exception exc) {
        if (d()) {
            exc.printStackTrace();
        }
    }

    public static void b(Object obj) {
        if (d()) {
            Log.e("RootBeer", c() + String.valueOf(obj));
            Log.e("QLog", c() + String.valueOf(obj));
        }
    }

    private static String c() {
        StackTraceElement[] stackTrace = new Throwable().getStackTrace();
        String methodName = stackTrace[2].getMethodName();
        String className = stackTrace[2].getClassName();
        int lineNumber = stackTrace[2].getLineNumber();
        String substring = className.substring(className.lastIndexOf(46) + 1);
        return substring + ": " + methodName + "() [" + lineNumber + "] - ";
    }

    public static boolean d() {
        return f6954a > 0;
    }

    public static boolean e() {
        return f6954a > 4;
    }

    public static void f(Object obj) {
        if (e()) {
            Log.v("RootBeer", c() + String.valueOf(obj));
        }
    }
}

RootUtil.kt

import android.animation.ObjectAnimator
import android.animation.PropertyValuesHolder
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.os.Build
import android.util.Log
import android.view.View
import android.view.animation.AccelerateDecelerateInterpolator
import com.prepladder.medical.prepladder.model.DataItem
import com.scottyab.rootbeer.RootBeer
import java.io.BufferedReader
import java.io.File
import java.io.InputStreamReader
import java.util.*

object RootUtil {
    val isDeviceRooted: Boolean
        get() {
            Log.d("RootUtil=", "1 " + checkRootMethod1())
            Log.d("RootUtil=", "2 " + checkRootMethod2())
            Log.d("RootUtil=", "3 " + checkRootMethod3())
            return checkRootMethod1() || checkRootMethod2() || checkRootMethod3()
        }

    private fun checkRootMethod1(): Boolean {
        val buildTags = Build.TAGS
        return buildTags != null && buildTags.contains("test-keys")
    }

    /**
     * Using this method to check the root device using root beer library.
     *
     * @return true if device is rooted else false
     */
    fun checkRootByRootBeer(context: Context?): Boolean {
        val rootBeer = RootBeer(context)
        return (rootBeer.detectRootManagementApps()
                || rootBeer.detectPotentiallyDangerousApps()
                || rootBeer.detectRootCloakingApps()
                || rootBeer.detectTestKeys()
                || rootBeer.checkForBusyBoxBinary()
                || rootBeer.checkForSuBinary()
                || rootBeer.checkSuExists()
                || rootBeer.checkForRWPaths()
                || rootBeer.checkForDangerousProps()
                || rootBeer.checkForRootNative()
                || rootBeer.checkForMagiskBinary())
    }

    fun checkRootMethod2(): Boolean {
        val paths = arrayOf(
            "/xposed.prop",
            "/system/bin/app_process.orig",
            "/system/lib/libxposed_art.so",
            "/system/lib64/libxposed_art.so",
            "/system/bin/app_process32_xposed",
            "/system/bin/app_process64_xposed" /*,
                "/data/data/de.robv.android.xposed.installer",
                "/data/user/0/de.robv.android.xposed.installer",
                "/data/user_de/0/de.robv.android.xposed.installer",
                "/data/data/org.meowcat.edxposed.manager",
                "/data/data/moe.riru.manager",
                "/data/data/com.varuns2002.disable_flag_secure"*/
        )
        for (path in paths) {
            if (File(path).exists()) {
                return true
            }
        }
        return false
    }

    fun checkUnauthorizedPackagesExist(data: List<DataItem?>?): ArrayList<String> {
        val packagesFoundList = ArrayList<String>()
        val packagesList = ArrayList<String>()
        val blackListedMountPaths = arrayOf(
            "/sbin/.magisk/",
            "/sbin/.core/mirror",
            "/sbin/.core/img",
            "/sbin/.core/db-0/magisk.db",
            "/data/local/su",
            "/data/local/bin/su",
            "/data/local/xbin/su",
            "/sbin/su",
            "/su/bin/su",
            "/system/bin/su",
            "/system/bin/.ext/su",
            "/system/bin/failsafe/su",
            "/system/sd/xbin/su",
            "/system/usr/we-need-root/su",
            "/system/xbin/su",
            "/cache/su",
            "/data/su",
            "/dev/su",
            "/data/data/moe.shizuku.redirectstorage",
            "/data/adb/modules/riru_momohider/config/isolated",
            "/data/adb/modules/riru_momohider/config/setns",
            "/data/adb/modules/riru_momohider/config/app_zygote_magic",
            "/data/adb/modules/riru_momohider/config/initrc",
            "data/adb/modules/riru-unshare",
            "/data/adb/lspd",
            "/data/adb/magisk",
            "/data/adb/riru",
            "/data/adb/shamiko",
            "/data/adb/storage-isolation",
            "/data/adb/modules/liboemcryptodisabler",
            "/data/adb/modules/MagiskHidePropsConf",
            "/data/adb/modules/riru-core",
            "/data/adb/modules/riru_lsposed",
            "/data/adb/modules/riru_storage_redirect",
            "/data/adb/modules/zygisk_lsposed",
            "/data/adb/modules/zygisk_shamiko"
        )
        // packagesList.addAll(Arrays.asList(blackListedMountPaths));
        for (i in blackListedMountPaths.indices) {
            packagesList.add(blackListedMountPaths[i])
        }
        if (data != null) {
            for (i in packagesList.indices) {
                val exist = File(Objects.requireNonNull(packagesList[i])).exists()
                val isDirectory = File(Objects.requireNonNull(packagesList[i])).isDirectory
                //Log.d("test_test_e", "" + exist);
                //Log.d("test_test_d", "" + isDirectory + "|" + packagesList.get(i));
                if (File(Objects.requireNonNull<String>(packagesList[i])).exists() || File(
                        Objects.requireNonNull<String>(
                            packagesList[i]
                        )
                    ).isDirectory
                ) {
                    packagesFoundList.add(packagesList[i])
                }
            }
        }
        return packagesFoundList
    }

    private fun checkRootMethod3(): Boolean {
        var process: Process? = null
        return try {
            process = Runtime.getRuntime().exec(arrayOf("/system/xbin/which", "su"))
            val `in` = BufferedReader(InputStreamReader(process.inputStream))
            if (`in`.readLine() != null) true else false
        } catch (t: Throwable) {
            false
        } finally {
            process?.destroy()
        }
    }

    fun setHeartBeatAnimationOnClick(iv: View?) {
        val scaleDown = ObjectAnimator.ofPropertyValuesHolder(
            iv,
            PropertyValuesHolder.ofFloat("scaleX", 0.80f),
            PropertyValuesHolder.ofFloat("scaleY", 0.80f)
        )
        scaleDown.duration = 400
        scaleDown.repeatCount = 1
        scaleDown.interpolator = AccelerateDecelerateInterpolator()
        scaleDown.repeatMode = ObjectAnimator.REVERSE
        scaleDown.start()
    }


    fun findExposedModules(context: Context): MutableList<String> {
        val pm = context.packageManager
        val intent = Intent(Intent.ACTION_MAIN)
        val detectedList = mutableListOf<String>()
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            for (pkg in pm.queryIntentActivities(intent, PackageManager.ResolveInfoFlags.of(PackageManager.GET_META_DATA.toLong()))) {
                val aInfo = pkg.activityInfo.applicationInfo
                if (aInfo.metaData?.get("xposedminversion") != null) {
                    val label = pm.getApplicationLabel(aInfo) as String
                    detectedList.add(label)
                }
            }
        } else {
            for (pkg in pm.queryIntentActivities(intent, PackageManager.GET_META_DATA)) {
                val aInfo = pkg.activityInfo.applicationInfo
                if (aInfo.metaData?.get("xposedminversion") != null) {
                    val label = pm.getApplicationLabel(aInfo) as String
                    detectedList.add(label)
                }
            }
        }
        return detectedList
    }

}