电量伪装

android.os.ServiceManager.getService("batterystats").setBatteryLevel(250, true); 
// 伪装指定电量，强制更新

充电伪装

android.os.ServiceManager.getService("batterystats").unplugBattery(true);
//伪装成未充电

恢复伪装

android.os.ServiceManager.getService("batterystats").resetBattery(true);
// 一键恢复伪装

充电判断

android.os.ServiceManager.getService("batterystats").isCharging();
// 判断是否充电

通知清除

android.os.ServiceManager.getService("statusbar").onClearAllNotifications(0);
// 清除指定用户的所有通知

定位判断

android.os.ServiceManager.getService("location").isLocationEnabledForUser(0);
// 判断指定用户定位是否开启

蓝牙判断

android.os.ServiceManager.getService("bluetooth_manager").getState() == 12;
// 判断蓝牙是否开启

禁用屏幕截图

android.os.ServiceManager.getService("device_policy").setScreenCaptureDisabled(null, "android", true, false);
// 禁用屏幕截图

启用屏幕截图

android.os.ServiceManager.getService("device_policy").setScreenCaptureDisabled(null, "android", false, false);
// 启用屏幕截图

屏幕截图状态

android.os.ServiceManager.getService("device_policy").getScreenCaptureDisabled(null, 0, false);
// 判断屏幕截图是否禁用

密码错误次数

Service = android.os.ServiceManager.getService("device_policy");

if (android.os.Build.VERSION.SDK_INT > 33) {
    Service.getCurrentFailedPasswordAttempts("android", 0, true);
} else {
    Service.getCurrentFailedPasswordAttempts(0, true);
}
// 获取锁屏密码错误次数

获取最近按键码

android.os.ServiceManager.getService("statusbar").getLastSystemKey();
// 获取最近按键事件的按键码

阻止应用卸载

android.os.ServiceManager.getService("package").setBlockUninstallForUser("tornaco.apps.shortx", true, 0)
// 阻止指定用户指定包名的卸载

清除应用缓存数据

android.os.ServiceManager.getService("package").deleteApplicationCacheFilesAsUser("包名", 0, null)
// 清除指定用户的指定包名的缓存数据

清除应用全部数据

android.os.ServiceManager.getService("package").clearApplicationUserData("包名", null, 0)
// 清除指定用户的指定包名的全部数据

无锁屏状态

android.os.ServiceManager.getService("lock_settings").getBoolean("lockscreen.disabled", true, 0)
// 获取指定用户是否为无锁屏

设置无锁屏

android.os.ServiceManager.getService("lock_settings").setBoolean("lockscreen.disabled", true, 0)
// 设置指定用户为无锁屏
// 无锁屏!=滑动

热点判断

android.os.ServiceManager.getService("wifi").getWifiApEnabledState() == 13;
// 获取热点是否开启

关机

android.os.ServiceManager.getService("power").shutdown(false, null, true);
// 关机

获取导航栏模式

m=android.os.ServiceManager.getService("statusbar").getNavBarMode();
m==0?"手势导航":m==1?"三段式导航":"未知:"+m;
// 获取导航栏模式

设置导航栏模式

android.os.ServiceManager.getService("statusbar").setNavBarMode(1);
// 1代表三段式导航栏
// 0代表手势导航

弹出输入法选择器

android.os.ServiceManager.getService("input_method").showInputMethodPickerFromSystem(0 ,0);
// 调用输入法选择器

隐藏应用

android.os.ServiceManager.getService("package").setApplicationHiddenSettingAsUser("包名", true, 0);
// （伪装卸载，尽量让别的软件扫不到，额外会冻结应用）！
// 设置隐藏指定用户的指定包名应用 
// 这个隐藏应用还挺神奇的，隐藏后真的在各大软件应用列表搜不到这个应用了，感觉好像真的被卸载了一样。🫡

取消隐藏应用

android.os.ServiceManager.getService("package").setApplicationHiddenSettingAsUser("包名", false, 0);
// 设置取消隐藏指定用户的指定包名应用

获取应用隐藏状态

android.os.ServiceManager.getService("package").getApplicationHiddenSettingAsUser("包名", 0);
// 获取隐藏指定用户的指定包名应用状态

获取应用防卸载状态

android.os.ServiceManager.getService("package").getBlockUninstallForUser("包名", true, 0)
// 获取阻止指定用户指定包名的卸载状态

获取应用冻结状态

android.os.ServiceManager.getService("package").isPackageAvailable("包名", 0)
// 获取指定用户指定包名的冻结状态

获取剪贴板访问通知的状态

android.os.ServiceManager.getService("clipboard").areClipboardAccessNotificationsEnabledForUser(0);
// 获取指定用户剪贴板访问通知是否启用
// 例如已将剪贴板中内容粘贴到**的吐司通知

关闭剪贴板访问通知

android.os.ServiceManager.getService("clipboard").setClipboardAccessNotificationsEnabledForUser(false, 0);
// 设置指定用户剪贴板访问通知关闭
// 例如已将剪贴板中内容粘贴到**的吐司通知

开启剪贴板访问通知

android.os.ServiceManager.getService("clipboard").setClipboardAccessNotificationsEnabledForUser(true, 0);
// 设置指定用户剪贴板访问通知开启
// 例如已将剪贴板中内容粘贴到**的吐司通知

获取USB功能启用状态

android.os.ServiceManager.getService("usb").isFunctionEnabled("adb");
 /*
rndis → USB共享网络
none → 仅充电
mtp → 文件传输
ptp → 图片传输
adb → 设备调试
*/
// 检查USB功能是否启用（如adb、mtp）

清除ADB调试密钥

android.os.ServiceManager.getService("adb").clearDebuggingKeys();
// 清除ADB调试密钥

获取ADB无线端口

android.os.ServiceManager.getService("adb").getAdbWirelessPort();
// 获取ADB无线端口

无线ADB调试授权

android.os.ServiceManager.getService("adb").allowWirelessDebugging(true, "**:**:**:**:**:**")
// 无线调试授权指定公钥
/*
写入非当前wifi的BSSID前，需关闭无线调试开关。
如果写入的是当前WiFi的BSSID会自动打开无线ADB调试
具体观察/data/misc/adb/adb_temp_keys.xml
**:**这个参数是指wifi的BSSID，一般都是授权当前WiFi
*/

无线ADB调试授权

bssid = android.os.ServiceManager.getService("wifi").getConnectionInfo("android", null).getBSSID();
android.os.ServiceManager.getService("adb").allowWirelessDebugging(true, bssid)
// 无线ADB授权当前WiFi并启动无线ADB调试

获取当前WiFi的BSSID

android.os.ServiceManager.getService("wifi").getConnectionInfo("android", null).getBSSID();
// 获取当前WiFi的BSSID

获取当前WiFi的名称

android.os.ServiceManager.getService("wifi").getConnectionInfo("android", null).getSSID();
// 获取当前WiFi的名称

获取WiFi MAC地址

android.os.ServiceManager.getService("wifi").getConnectionInfo("android", null).getMacAddress();
// 获取当前WiFi的MAC地址

获取WiFi IP

ip = android.os.ServiceManager.getService("wifi").getConnectionInfo("android", null).getIpAddress();
(ip & 0xff) + "." + ((ip >> 8) & 0xff) + "." +
            ((ip >> 16) & 0xff) + "." + ((ip >> 24) & 0xff);
// 获取当前WiFi IP

获取WiFi全部信息

android.os.ServiceManager.getService("wifi").getConnectionInfo("android", null);
// 获取当前WiFi 全部信息
// 我就不一个一个弄了，有些我自己也不需要

隐藏状态栏内容显示

statusbar = context.getSystemService("statusbar");
// 设置禁用标志（禁用通知图标、系统信息、时钟）
statusbar.disable(statusbar.DISABLE_NOTIFICATION_ICONS | statusbar.DISABLE_SYSTEM_INFO | statusbar.DISABLE_CLOCK);
// 设置隐藏状态栏基本内容显示
/*
禁用后台多任务界面
DISABLE_RECENT
禁用导航栏
DISABLE_NAVIGATION
全家桶（禁用所有能禁用的组件）（慎用）
DISABLE_MASK
禁用下拉状态栏(个别系统恢复下拉状态栏，执行恢复命令后需锁屏一次)
DISABLE_EXPAND

详情查看https://blog.csdn.net/qq_45146250/article/details/131088228
*/

恢复状态栏内容显示

context.getSystemService("statusbar").disable(0);
//设置显示状态栏所有内容

息屏运行（屏幕电源）

Build = android.os.Build;
IBinder = android.os.IBinder;
Parcel = android.os.Parcel;
ServiceManager = android.os.ServiceManager;
SurfaceControl = android.view.SurfaceControl;

displayMode = 0; // 直接设置电源模式  2: 开启, 0: 关闭

if (Build.VERSION.SDK_INT < 34) { // Android 14 之前的版本
    // 获取 SurfaceControl 类（旧版本需要实例化）
    surfaceControl = new SurfaceControl();

    // 根据 Android 版本获取显示器 Token 方法
    displayToken = (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) ?
        surfaceControl.getBuiltInDisplay(0) : SurfaceControl.getInternalDisplayToken();

    // 直接调用 SurfaceControl 的方法，设置电源模式
    SurfaceControl.setDisplayPowerMode(displayToken, displayMode);

} else { // Android 14 及以上版本
    // 获取 SurfaceFlinger 服务（AIDL 方式）
    surfaceFlingerService = ServiceManager.getService("SurfaceFlingerAIDL");

    // 获取显示器 ID 列表
    parcelData = Parcel.obtain();
    parcelReply = Parcel.obtain();
    parcelData.writeInterfaceToken("android.gui.ISurfaceComposer");
    surfaceFlingerService.transact(IBinder.FIRST_CALL_TRANSACTION + 5, parcelData, parcelReply, 0);
    parcelReply.readException();
    displayCount = parcelReply.readInt();

    // 创建 long[] 数组存储显示器 ID
    displayIds = java.lang.reflect.Array.newInstance(java.lang.Long.TYPE, displayCount);

    // 读取显示器 ID
    for (var i = 0; i < displayCount; i++) {
        displayIds[i] = parcelReply.readLong();
    }
    parcelData.recycle();
    parcelReply.recycle();

    // 遍历每个显示器，设置电源模式
    for (var i = 0; i < displayIds.length; i++) {
        displayId = displayIds[i];

        // 获取单个显示器的 Token
        parcelData = Parcel.obtain();
        parcelReply = Parcel.obtain();
        parcelData.writeInterfaceToken("android.gui.ISurfaceComposer");
        parcelData.writeLong(displayId);
        surfaceFlingerService.transact(IBinder.FIRST_CALL_TRANSACTION + 6, parcelData, parcelReply, 0);
        parcelReply.readException();
        displayToken = parcelReply.readStrongBinder();
        parcelData.recycle();
        parcelReply.recycle();

        // 直接调用 SurfaceControl 的方法，设置电源模式（0=强制息屏，2=开启电源模式）
        SurfaceControl.setDisplayPowerMode(displayToken, displayMode);
    }
}
// Extinguish 息屏挂机 息屏运行 听剧模式 仅关屏 息屏不锁屏 息屏不锁屏 游戏挂机 开屏伪装FakeSceen

息屏运行（屏幕电源）

// 只对与手机分辨率相同的显示设备生效，可避免导致全部显示设备同时关闭屏幕电源
Build = android.os.Build;
IBinder = android.os.IBinder;
Parcel = android.os.Parcel;
ServiceManager = android.os.ServiceManager;
SurfaceControl = android.view.SurfaceControl;
Context = android.content.Context;
DisplayMetrics = android.util.DisplayMetrics;

// 设置电源模式，0: 关闭，2: 开启
displayMode = 0;

// 获取 DisplayManager 服务
displayManager = context.getSystemService("display");
// 获取手机的分辨率
metrics = new DisplayMetrics();
context.getSystemService(Context.WINDOW_SERVICE).getDefaultDisplay().getMetrics(metrics);
phoneWidth = metrics.widthPixels;
phoneHeight = metrics.heightPixels;

if (Build.VERSION.SDK_INT < 34) { // Android 14 之前的版本
    // 获取 SurfaceControl 类（旧版本需要实例化）
    surfaceControl = new SurfaceControl();

    // 根据 Android 版本获取显示器 Token 方法
    displayToken = (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) ?
        surfaceControl.getBuiltInDisplay(0) : SurfaceControl.getInternalDisplayToken();

    // 直接调用 SurfaceControl 的方法，设置电源模式
    SurfaceControl.setDisplayPowerMode(displayToken, displayMode);

} else { // Android 14 及以上版本
    // 获取 SurfaceFlinger 服务（AIDL 方式）
    surfaceFlingerService = ServiceManager.getService("SurfaceFlingerAIDL");

    // 获取显示器 ID 列表
    parcelData = Parcel.obtain();
    parcelReply = Parcel.obtain();
    parcelData.writeInterfaceToken("android.gui.ISurfaceComposer");
    surfaceFlingerService.transact(IBinder.FIRST_CALL_TRANSACTION + 5, parcelData, parcelReply, 0);
    parcelReply.readException();
    displayCount = parcelReply.readInt();

    // 创建 long[] 数组存储显示器 ID
    displayIds = java.lang.reflect.Array.newInstance(java.lang.Long.TYPE, displayCount);

    // 读取显示器 ID 并获取每个显示器分辨率
    for (var i = 0; i < displayCount; i++) {
        displayIds[i] = parcelReply.readLong();
        parcelData.recycle();
        parcelReply.recycle();

        // 获取每个显示器的分辨率
        display = displayManager.getDisplay(i);
        display.getMetrics(metrics);
        displayWidth = metrics.widthPixels;
        displayHeight = metrics.heightPixels;

        // 只有当显示器分辨率与手机屏幕相同，才设置电源模式
        if (displayWidth == phoneWidth && displayHeight == phoneHeight) {
            // 获取显示器的 Token
            parcelData = Parcel.obtain();
            parcelReply = Parcel.obtain();
            parcelData.writeInterfaceToken("android.gui.ISurfaceComposer");
            parcelData.writeLong(displayIds[i]);
            surfaceFlingerService.transact(IBinder.FIRST_CALL_TRANSACTION + 6, parcelData, parcelReply, 0);
            parcelReply.readException();
            displayToken = parcelReply.readStrongBinder();
            parcelData.recycle();
            parcelReply.recycle();

            // 设置电源模式（0=强制息屏，2=开启电源模式）
            SurfaceControl.setDisplayPowerMode(displayToken, displayMode);
        } else {
            // 如果分辨率不匹配，跳过该显示器，继续遍历下一个显示器
            continue;
        }
    }
}
// 只对与手机分辨率相同的显示设备生效，可避免导致全部显示设备同时关闭屏幕电源

NFC判断

android.nfc.INfcAdapter.Stub.asInterface(android.os.ServiceManager.getService("nfc")).getState() == 3;
// 判断NFC是否开启

禁用屏幕触摸

InputDevice = android.view.InputDevice;

inputManager = android.os.ServiceManager.getService("input");

deviceIds = inputManager.getInputDeviceIds();

touchDeviceId = -1;

for (i = 0; i < deviceIds.length; i++) {
    id = deviceIds[i];
    sources = inputManager.getInputDevice(id).getSources();
    if ((sources & InputDevice.SOURCE_TOUCHSCREEN) == InputDevice.SOURCE_TOUCHSCREEN) {
        touchDeviceId = id;
    }
}

inputManager.disableInputDevice(touchDeviceId);
// 禁用触摸设备

恢复屏幕触摸

InputDevice = android.view.InputDevice;

inputManager = android.os.ServiceManager.getService("input");

deviceIds = inputManager.getInputDeviceIds();

touchDeviceId = -1;

for (i = 0; i < deviceIds.length; i++) {
    id = deviceIds[i];
    sources = inputManager.getInputDevice(id).getSources();
    if ((sources & InputDevice.SOURCE_TOUCHSCREEN) == InputDevice.SOURCE_TOUCHSCREEN) {
        touchDeviceId = id;
    }
}

inputManager.enableInputDevice(touchDeviceId);
// 设置启用屏幕触摸

获取当前SIM卡的网络类型

com.android.internal.telephony.ITelephony.Stub.asInterface(android.os.ServiceManager.getService("phone")).getDataNetworkType("android", "");
// 获取当前SIM卡的网络类型

获取指定SIM卡的网络类型

// 获取活动订阅信息
subscriptionManager = android.telephony.SubscriptionManager.from(context);
subscriptionInfoList = subscriptionManager.getActiveSubscriptionInfoList();

// 检查订阅信息是否为空
if (subscriptionInfoList == "[]") {
    false;
} else {
    // 获取卡一 的订阅ID
    subId = subscriptionInfoList.get(0).getSubscriptionId();

    // 获取网络类型
    telephonyManager = com.android.internal.telephony.ITelephony.Stub.asInterface(android.os.ServiceManager.getService("phone"));
    telephonyManager.getNetworkTypeForSubscriber(subId, "android", "");
}
 //获取卡一的网络类型

网络类型对照表

/*
0 - 没插卡
1 - GPRS (2G)
2 - EDGE (2G)
3 - UMTS (3G)
4 - CDMA (3G)
5 - EVDO_0 (3G)
6 - EVDO_A (3G)
7 - EVDO_B (3G)
8 - HSDPA (3G)
9 - HSUPA (3G)
10 - HSPA (3G)
11 - IDEN (2G)
12 - LTE (4G)
13 - LTE_CA (4G+)
14 - HSPAP (3G)
15 - GSM (2G)
16 - TD_SCDMA (3G)
17 - IWLAN (Wi-Fi)
20 - NR (5G)
*/

5G 判断

com.android.internal.telephony.ITelephony.Stub.asInterface(android.os.ServiceManager.getService("phone")).getDataNetworkType("android", "") == 20;
// 判断当前SIM卡网络类型是否为5G

判断设备是否支持某个传感器的硬件开关

android.os.ServiceManager.getService("sensor_privacy").supportsSensorToggle(1, 2);     
// 设备是否支持摄像头硬件开关
/*
   (1, 传感器类型1/2)
 1 - 麦克风使用权限
 2 - 摄像头使用权限
*/

获取指定传感器状态

android.os.ServiceManager.getService("sensor_privacy").isToggleSensorPrivacyEnabled(1, 2);
// 获取摄像头传感器是否禁用
/*
   (1, 传感器类型1/2)
 1 - 麦克风使用权限
 2 - 摄像头使用权限
 */

调用解锁传感器对话框

android.os.ServiceManager.getService("sensor_privacy").showSensorUseDialog(2);
/*
在关闭对应传感器的前提，手动弹一次“解锁传感器开关”的确认对话框
 1 - 麦克风使用权限
 2 - 摄像头使用权限
*/

判断全局传感器状态

android.os.ServiceManager.getService("sensor_privacy").isSensorPrivacyEnabled();       
// 全局传感器隐私是否开启,ShortX 已存在该条件

设置全局传感器

android.os.ServiceManager.getService("sensor_privacy").setSensorPrivacy(true);
// 设置禁用全局传感器 true=关闭传感器，false=开启所有
// ShortX已存在该动作 

设置指定传感器开关

android.os.ServiceManager.getService("sensor_privacy").setToggleSensorPrivacy(0, 0, 1, true);
// 设置指定用户麦克风传感器使用权限
/*
(userId, source, sensor, true);
 *   userId：一般为 0
 *   source：来源，填0即可
 *   sensor：1=麦克风、2=摄像头
 *   enable：true=启用隐私保护,关闭传感器
 *    false = 开启传感器
 */

设置隐私状态提示禁用弹窗

context.getSystemService("sensor_privacy").suppressSensorPrivacyReminders(1, true, 0)
// 设置指定用户麦克风隐私状态提示禁用弹窗
/*
(int sensor, boolean suppress, int userId)
sensor：1=麦克风、2=摄像头
suppress：true=屏蔽弹窗
*/

获取指定传感器状态

android.os.ServiceManager.getService("sensor_privacy").isCombinedToggleSensorPrivacyEnabled(2);
/*
第二种方法
获取摄像头权限开关是否关闭
 1 - 麦克风使用权限
 2 - 摄像头使用权限
 */

单个应用传感器管理

/*
指定用户指定应用传感器管理
支持禁用、解除、查看，重置
*/
ServiceManager = android.os.ServiceManager;
ParcelFileDescriptor = android.os.ParcelFileDescriptor;

function runSensorCmd(args, userId) {

    svc = ServiceManager.getService("sensorservice");

    pin  = ParcelFileDescriptor.createPipe();
    pout = ParcelFileDescriptor.createPipe();
    perr = ParcelFileDescriptor.createPipe();

    pin[1].close();

    // 如果有指定用户，添加 --user 参数
    if (userId != undefined && userId != null) {
        args.push("--user");
        args.push(String(userId));
    }

    svc.shellCommand(
        pin[0].getFileDescriptor(),
        pout[1].getFileDescriptor(),
        perr[1].getFileDescriptor(),
        args,
        null,
        new android.os.ResultReceiver(null)
    );

    pout[1].close();
    perr[1].close();

    function read(p){
        s = new android.os.ParcelFileDescriptor.AutoCloseInputStream(p[0]);
        r = "";
        b = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, 1024);
        n ="";
        while((n = s.read(b)) > 0){
            r += new java.lang.String(b, 0, n, "UTF-8");
        }
        return r;
    }

    result = read(pout) + read(perr);
    result = result.trim();

    if (args[0] == "get-uid-state") {
        if (result.includes("idle")) return true;
        if (result.includes("active")) return false;
        return false;

    }

    return result;
}

// 1) 禁用（设置为 idle，相当于限制传感器）
// runSensorCmd(["set-uid-state", "包名", "idle"], 0);

// 2) 恢复 active（取消限制）
// runSensorCmd(["set-uid-state", "com.liuzh.deviceinfo", "active"], 0);

// 3) 查看状态
// true 已禁用 false 未禁用
runSensorCmd(["get-uid-state", "com.liuzh.deviceinfo"], 0);

// 4) 恢复默认（清除 override）
// runSensorCmd(["reset-uid-state", "包名"], 0);

// 该接口不会禁用摄像头和麦克风，下载类似设备信息APP测试效果
// Android 11-16已测试成功，其他版本未知

获取Color系统的锁屏密码

android.os.ServiceManager.getService("lock_settings").getPassword();
// 获取 Color 系统的锁屏密码，
/* 
设置新密码后，需锁屏输入一次密码
Color16 不可用
*/

Color系统听剧模式（后台模式）

Intent = android.content.Intent;
ComponentName = android.content.ComponentName;

bgStreamIntent = new Intent();
bgStreamIntent.setComponent(new ComponentName("com.oplus.exsystemservice", "com.oplus.backgroundstream.RouteForegroundService"));
bgStreamIntent.setAction("oplus.intent.action.BACKGROUND_STREAM_SERVICE");

context.startService(bgStreamIntent);
// Color系统的听剧模式 | 后台挂机
// Color16 不可用

高德地图步行导航

Intent = android.content.Intent;
UserHandle = android.os.UserHandle;

lat = 39.909187;
// lat - 纬度
lon = 116.397463;
// lon - 经度

myIntent = Intent.parseUri('amapuri://openFeature?featureName=OnFootNavi&sourceApplication=null&lat=' + lat +'&lon=' + lon, 0);

myIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// 指定用户启动
userHandle = UserHandle.of(0);

context.startActivityAsUser(myIntent, userHandle);

// 坐标拾取器 https://lbs.amap.com/tools/picker
// 指定用户高德地图 步行导航

高德地图骑行导航

Intent = android.content.Intent;
UserHandle = android.os.UserHandle;
// ShortX自带高德地图骑行导航无法细分自行车或电动车，该接口可以
lat = 39.909187;
// lat - 纬度
lon = 116.397463;
// lon - 经度
rideType = "bike";
// 骑行类型，elebike 为电动车，bike 或留空为自行车。

myIntent = Intent.parseUri('amapuri://openFeature?featureName=OnRideNavi&rideType=' + rideType + '&sourceApplication=null&lat=' + lat +'&lon=' + lon, 0);

myIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// 指定用户启动
userHandle = UserHandle.of(0);

context.startActivityAsUser(myIntent, userHandle);
// 坐标拾取器 https://lbs.amap.com/tools/picker
// 指定用户高德地图 自行车导航

百度地图步行导航

Intent = android.content.Intent;
UserHandle = android.os.UserHandle;

lat = 39.915119;
// lat - 纬度
lon = 116.403963;
// lon - 经度
coord_type = "bd09ll";
/*
坐标类型
bd09ll（百度经纬度坐标） //用百度坐标拾取器，可避免误差
bd09mc（百度墨卡托坐标）
gcj02（经国测局加密的坐标）
wgs84（gps获取的原始坐标）
*/
// 步行导航
myIntent = Intent.parseUri('baidumap://map/walknavi?destination=' + lat + ',' + lon + '&coord_type=' + coord_type + '&src=andr.baidu.openAPIdemo', 0);

myIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// 指定用户启动
userHandle = UserHandle.of(0);

context.startActivityAsUser(myIntent, userHandle);
// 坐标拾取器 https://lbs.baidu.com/maptool/getpoint
// 指定用户百度地图 步行导航

百度地图骑行导航

Intent = android.content.Intent;
UserHandle = android.os.UserHandle;
// ShortX自带的百度地图骑行导航无法正常使用，该接口可以
lat = 39.915119;
// lat - 纬度
lon = 116.403963;
// lon - 经度
coord_type = "bd09ll";
/*
坐标类型
bd09ll（百度经纬度坐标） //用百度坐标拾取器，可避免误差
bd09mc（百度墨卡托坐标）
gcj02（经国测局加密的坐标）
wgs84（gps获取的原始坐标）
*/
// 电动车导航
myIntent = Intent.parseUri('baidumap://map/bikenavi?destination=' + lat + ',' + lon + '&coord_type=' + coord_type + '&src=andr.baidu.openAPIdemo', 0);

myIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// 指定用户启动
userHandle = UserHandle.of(0);

context.startActivityAsUser(myIntent, userHandle);
// 坐标拾取器 https://lbs.baidu.com/maptool/getpoint
// 指定用户百度地图 电动车导航

设置系统时间

function createTimestamp(year, month, day, hour, minute, second) {
    Calendar = java.util.Calendar;
    cal = Calendar.getInstance();
    cal.set(year, month - 1, day, hour, minute, second);
    cal.set(Calendar.MILLISECOND, 0);
    return cal.getTimeInMillis();
}

// 示例为2023年12月25日 14点30分30秒
timestamp = createTimestamp(2023, 12, 25, 14, 30, 30);

android.os.ServiceManager.getService("alarm").setTime(timestamp); 
// 设置系统时间

恢复系统时间

Settings = android.provider.Settings;
Settings.Global.putString(context.getContentResolver(), 'auto_time', 0);
Settings.Global.putString(context.getContentResolver(), 'auto_time', 1);
// 设置恢复系统时间

获取下一个从空闲唤醒的时间

next = android.os.ServiceManager.getService("alarm").getNextWakeFromIdleTime();

if (next >= 9000000000) {
    "当前没有任何会唤醒设备的闹钟";
} else {
    real = java.lang.System.currentTimeMillis() + next - android.os.SystemClock.elapsedRealtime();
    new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new java.util.Date(real));
}
// 获取下一次从Doze/空闲模式唤醒的时间

获取当前音量

audioManager = context.getSystemService("audio");
// 获取指定音量类型的音量值并返回
function getVolumeInfo(context, streamType) {
     volume = android.os.ServiceManager.getService("audio").getStreamVolume(streamType);
    return volume;
}

getVolumeInfo(context, audioManager.STREAM_RING);
// 获取当前铃声音量
// 获取指定音量类型当前音量

设置音量

audioManager = context.getSystemService("audio");
function getVolumeInfo(context, streamType, targetVolume) {
     volume = android.os.ServiceManager.getService("audio").setStreamVolume(streamType, targetVolume, 0, null);
    return volume;
}

getVolumeInfo(context, audioManager.STREAM_ALARM, 7);
// 设置闹钟音量
// 设置指定音量类型

调节音量

audioManager = context.getSystemService("audio");
audio =android.os.ServiceManager.getService("audio");
function getVolumeInfo(context, streamType, targetVolume) {
    currentVolume = audio.getStreamVolume(streamType);
    newVolume = currentVolume + targetVolume;
    maxVolume = audio.getStreamMaxVolume(streamType);
    minVolume = 0;
    newVolume = Math.max(minVolume, Math.min(newVolume, maxVolume));
    audio.setStreamVolume(streamType, newVolume, 0, null);
    return newVolume;
}

getVolumeInfo(context, audioManager.STREAM_ALARM, 2);
// 调整闹钟音量（比如2 或 -2）
// 调节指定音量类型

获取音量上限

audioManager = context.getSystemService("audio");
audio =android.os.ServiceManager.getService("audio");
function getVolumeInfo(context, streamType, targetVolume) {
    currentVolume = audio.getStreamVolume(streamType);
    maxVolume = audio.getStreamMaxVolume(streamType);
    return maxVolume;
}

getVolumeInfo(context, audioManager.STREAM_ALARM);
// 获取指定音量类型的上限

音量类型

/*
// 通话音量
audioManager.STREAM_VOICE_CALL
// 系统音量
audioManager.STREAM_SYSTEM
// 铃声音量
audioManager.STREAM_RING
// 媒体音量
audioManager.STREAM_MUSIC
// 闹钟音量
audioManager.STREAM_ALARM
// 通知音量
audioManager.STREAM_NOTIFICATION
// 蓝牙 SCO 音频流
audioManager.STREAM_BLUETOOTH_SCO
// 强制可听音频流
audioManager.STREAM_ENFORCED_AUDIBLE
// DTMF 音频流
audioManager.STREAM_DTMF
// TTS 音频流
audioManager.STREAM_TTS
// 辅助功能音频流
audioManager.STREAM_ACCESSIBILITY
// 助理音频流
audioManager.STREAM_ASSISTANT
*/

显示屏刷新率显示管理

/*
 * 显示刷新率开关控制函数
 *     0 = 关闭
 *     1 = 开启  
 *     2 = 查询当前状态（返回 true/false）
 *     3 = 切换（打开→关 / 关→开）
 */
function showRefreshRate(mode) {
    sf = android.os.ServiceManager.getService("SurfaceFlinger");

    function call(flag, needReply) {
        data = android.os.Parcel.obtain();
        reply = needReply ? android.os.Parcel.obtain() : null;
        data.writeInterfaceToken("android.ui.ISurfaceComposer");
        data.writeInt(flag);
        sf.transact(1034, data, reply, 0);
        return reply;
    }

    if (mode == 3) {
        current = call(2, true).readBoolean();
        call(current ? 0 : 1, false);
        return !current;
    }

    // mode: 0=关 1=开 2=查
    if (mode == 2) {
        return call(2, true).readBoolean();
    } else {
        call(mode, false);
        return mode == 1;
    }
}

// 切换显示屏刷新率显示开关
showRefreshRate(3);

刷新率支持状态

modes = (android.os.ServiceManager.getService("display").getDisplayInfo(android.view.Display.DEFAULT_DISPLAY)).supportedModes;
s = "";
for (i = 0; i < modes.length; i++) {
    m = modes[i];
    s += "id=" + m.getModeId() + ": " + m.getRefreshRate() + "Hz\n";
}
s.trim();
// 获取当前显示屏支持的刷新率以及对应ID

锁定刷新率

/*
 * 强制锁定指定刷新率
 */
function lockRefreshRate(modeId) {
    realMode = modeId - 1;

    sf = android.os.ServiceManager.getService("SurfaceFlinger");

    data = android.os.Parcel.obtain();
    data.writeInterfaceToken("android.ui.ISurfaceComposer");
    data.writeInt(realMode);
    sf.transact(1035, data, null, 0);
}
// 重启需重新设置，个别系统锁屏后也会失效，自己测试。
// 改成自己想锁定的刷新率对应ID，不要乱填
lockRefreshRate(1);

创建Thanox应用集

importClass(Packages.github.tornaco.android.thanos.core.app.ThanosManagerNative);

var iThanos = ThanosManagerNative.getDefault();

var pkgManager = iThanos.getPkgManager();

result = pkgManager.createPackageSet("测试创建集合");

动态快捷方式

//给指定应用动态快捷方式添加指定Intent URI
importClass(android.content.Context);
importClass(android.content.pm.ShortcutInfo);
importClass(android.graphics.drawable.Icon);
importClass(android.content.Intent);
importClass(java.util.ArrayList);
importClass(java.util.Collections);
// ===== 目标包名 =====
var targetPackage = "tornaco.apps.shortx";

// ===== 指定要写入的 Intent URI =====
var intentUri = `intent:#Intent;action=com.tmessages.openchat0;component=org.telegram.messenger/.OpenChatReceiver;l.chatId=1604486631;end`;

try {
    var otherContext = context.createPackageContext(
        targetPackage,
        Context.CONTEXT_IGNORE_SECURITY
    );
    var shortcutManager =
        otherContext.getSystemService(Context.SHORTCUT_SERVICE);

    if (!shortcutManager) {
        throw "ShortcutManager 不可用";
    }
    var targetIntent = Intent.parseUri(intentUri, 0);
    targetIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    
    // ===== 新快捷方式ID=====
    //ID用来区分不同的快捷方式,删除也必须使用同样ID
    var shortcutId = "shortcut_0001";

    var newShortcut =
        new ShortcutInfo.Builder(otherContext, shortcutId)
             //快捷方式 桌面显示名称
            .setShortLabel("ShortX群组")
            //长名称 
            .setLongLabel("ShortX群组")
            .setIcon(
                Icon.createWithResource(
                    otherContext,
                    otherContext.getApplicationInfo().icon
                )
            )
            .setIntent(targetIntent)
            .build();
    var existing = shortcutManager.getDynamicShortcuts();
    if (existing.size() >= shortcutManager.getMaxShortcutCountPerActivity()) {
        throw "动态快捷方式数量已达系统上限";
    }
    shortcutManager.addDynamicShortcuts(
        Collections.singletonList(newShortcut)
    );
      shortcutId;
} catch (e) {
    "写入失败: " + e;
}

删掉动态快捷方式

// 删掉指定应用指定动态快捷方式
importClass(android.content.Context);
importClass(android.content.pm.ShortcutManager);
importClass(java.util.Collections);

// ================= 目标应用包名 =================
var targetPackage = "包名"; // ← 可修改为任意 app 包名

try {
    // 获取目标应用上下文
    var otherContext = context.createPackageContext(
        targetPackage,
        Context.CONTEXT_INCLUDE_CODE |
        Context.CONTEXT_IGNORE_SECURITY |
        Context.CONTEXT_DEVICE_PROTECTED_STORAGE |
        Context.CONTEXT_REGISTER_PACKAGE
    );

    // 获取系统服务 ShortcutManager
    var shortcutManager = otherContext.getSystemService(Context.SHORTCUT_SERVICE);

    if (shortcutManager == null) {
        console.log("❌ 此设备不支持 ShortcutManager。");
        JSON.stringify([]);
    }

    // ================= 删除指定 ID 的动态快捷方式 =================
    var shortcutId = "shortcut_1759818721903"; // ← 只删这个 ID
    var list = java.util.Collections.singletonList(shortcutId);
    shortcutManager.removeDynamicShortcuts(list);

    "✅ 已删除 " + targetPackage + " 的快捷方式 ID: " + shortcutId;

} catch (e) {
    console.log("❌ 删除快捷方式出错: " + e);
    JSON.stringify([]);
}

HTML解析

// 使用指定语法解析HTML
importPackage(Packages.org.jsoup);

var htmlContent = `<html><body><h1>这是一个标题</h1><p>这是段落内容。</p></body></html>`;

// 解析 HTML
var document = Jsoup.parse(htmlContent);

// 获取 p 标签
var pElement = document.select("p").first();

// 提取 p 标签的文本内容
pText = pElement.text();

ShortX OCR

importClass(Packages.tornaco.apps.shortx.core.proto.action.OcrDetect);
importClass(Packages.tornaco.apps.shortx.core.proto.common.RectSourceRect);
importClass(Packages.tornaco.apps.shortx.core.proto.common.Rect);
importClass(com.google.protobuf.Any);

var action = OcrDetect.newBuilder()
    .setRectSrc(
        Any.pack(
            RectSourceRect.newBuilder()
                .setRect(
                    Rect.newBuilder()
                        .setLeft("")
                        .setTop("")
                        .setRight("")
                        .setBottom("")
                        .build()
                )
                .build()
        )
    )
    .build();

var result = shortx.executeAction(action);

result.contextData.get("ocrResult")
// 输入屏幕区域

蓝牙共享网络

importPackage(android.bluetooth);
importPackage(android.content);
importClass(java.util.concurrent.CountDownLatch);
importClass(java.util.concurrent.TimeUnit);

function enableBt() {
    var a = BluetoothAdapter.getDefaultAdapter();
    if (a == null) throw new Error("不支持蓝牙");
    a.enable();
    return a;
}

function withPan(adapter, fn) {
    var latch = new CountDownLatch(1);
    var out = { v: false };

    adapter.getProfileProxy(context, new BluetoothProfile.ServiceListener({
        onServiceConnected: function(p, proxy) {
            if (p == BluetoothProfile.PAN) {
                out.v = fn(proxy);
                adapter.closeProfileProxy(BluetoothProfile.PAN, proxy);
            }
            latch.countDown();
        },
        onServiceDisconnected: function() {
            latch.countDown();
        }
    }), BluetoothProfile.PAN);

    latch.await(2, TimeUnit.SECONDS);
    return out.v;
}

function toggleBluetoothTethering(context) {
    var adapter = enableBt();
    var state = withPan(adapter, function(p) { return p.isTetheringOn(); });
    withPan(adapter, function(p) { p.setBluetoothTethering(!state); });
    return state ? "蓝牙网络共享已关闭" : "蓝牙网络共享已开启";
}

toggleBluetoothTethering(context);
// 通过蓝牙共享手机的网络连接

以太网网络共享

android.os.ServiceManager.getService("ethernet").setEthernetEnabled(true);
// false 关闭
// 通过以太网共享手机的网络连接

USB网络共享

android.os.ServiceManager.getService("usb").setCurrentFunctions(32, 0);
// 通过 USB 共享手机的网络连接

设置USB功能

android.os.ServiceManager.getService("usb").setCurrentFunctions(4, 0);
// 开启USB文件传输模式

/*
none         → 仅充电        → 0
adb          → 设备调试      → 1
accessory    → 外设模式      → 2
mtp          → 文件传输      → 4
midi         → MIDI          → 8
ptp          → 图片传输      → 16
rndis        → USB共享网络   → 32
audio_source → USB音频       → 64
uvc          → USB摄像头     → 128
ncm          → USB网络(NCM)  → 1024
*/

列表对话框 JSON格式

importPackage(Packages.tornaco.apps.shortx.core.proto.action);
importClass(Packages.tornaco.apps.shortx.core.proto.common.DialogUiStyleSettings);

var dataJson = `[
    {
        "name": "Android",
        "version": 16,
        "__value": "android",
        "__icon": "android-fill"
    }
]`;

// ShowListDialog Action
var action = ShowListDialog.newBuilder()
    .setTitle("列表对话框")
    .setData(dataJson)
    .setDataType(ShowListDialogDataType.ShowListDialogDataType_Json)
    .setStyle(
        DialogUiStyleSettings.newBuilder()
            .setFontScale(1.0)
            .build()
    )
    .setIsMultipleChoice(true)
    // 显示底部确认按钮
    .setNeedConfirmAction(true)
    // 支持多选
    .setCancelable(true)
    // 是否可取消
    .build();

var result = shortx.executeAction(action);

result.contextData.get("selectedListItem");
// 列表对话框JSON格式

配置热点策略

importClass(android.net.wifi.SoftApConfiguration);
importClass(android.net.MacAddress);
importClass(android.os.ServiceManager);
// ---------- 热点名称（SSID） ----------
var HOTSPOT_SSID = "66666";

// ---------- 热点密码 ----------
// - OPEN（开放热点）时必须为 null
var HOTSPOT_PASSWORD = "55555";

// ---------- 安全类型 ----------
// SoftApConfiguration.SECURITY_TYPE_OPEN
// SoftApConfiguration.SECURITY_TYPE_WPA2_PSK
// SoftApConfiguration.SECURITY_TYPE_WPA3_SAE_TRANSITION
// SoftApConfiguration.SECURITY_TYPE_WPA3_SAE
var SECURITY_TYPE = SoftApConfiguration.SECURITY_TYPE_WPA3_SAE;

// ---------- 是否隐藏 SSID ----------
// true  = 隐藏热点
var HIDDEN_SSID = false;

// ---------- 频段模式 ----------
// "2.4G" | "5G" | "6G" | "DUAL" | "AUTO"
var BAND_MODE = "5G";

// ---------- 信道（0 = 自动） ----------
var CHANNEL_2G = 0;   // 1 ~ 14
var CHANNEL_5G = 36;  // 34 ~ 196
var CHANNEL_6G = 0;   // 1 ~ 253

// ---------- 最大客户端数 ----------
// 0 = 系统默认
var MAX_CLIENTS = 0;
// ---------- 自动关闭 ----------
var AUTO_SHUTDOWN = false;
// 单位：毫秒
// 600000 = 10 分钟
// 300000 = 5 分钟
// 60000  = 1 分钟
var SHUTDOWN_TIMEOUT_MS = 600000;

// ---------- 用户控制 ----------
var CLIENT_CONTROL_BY_USER = false;

// ---------- 白名单 ----------
var ALLOWED_MAC_LIST = [
    // "AA:BB:CC:DD:EE:FF",
    // "11:22:33:44:55:66"
];

// ---------- 黑名单 ----------
var BLOCKED_MAC_LIST = [
    // "99:88:77:66:55:44",
    // "22:33:44:55:66:77"
];

function startCustomHotspot() {
    // 创建配置构建器
    var builder = new SoftApConfiguration.Builder();
    // 1. SSID
    builder.setSsid(HOTSPOT_SSID);
    // 2. 密码 & 安全类型
    builder.setPassphrase(HOTSPOT_PASSWORD, SECURITY_TYPE);
    // 3. 是否隐藏
    builder.setHiddenSsid(HIDDEN_SSID);
    // 4. 频段
    if (BAND_MODE == "2.4G") {
        builder.setBand(SoftApConfiguration.BAND_2GHZ);
    } else if (BAND_MODE == "5G") {
        builder.setBand(SoftApConfiguration.BAND_5GHZ);
    } else if (BAND_MODE == "6G") {
        builder.setBand(SoftApConfiguration.BAND_6GHZ);
    } else if (BAND_MODE == "DUAL") {
        builder.setBand(
            SoftApConfiguration.BAND_2GHZ |
            SoftApConfiguration.BAND_5GHZ
        );
    } else {
        builder.setBand(SoftApConfiguration.BAND_ANY);
    }
    // 5. 信道（仅单频有效）
    if (BAND_MODE == "2.4G" && CHANNEL_2G > 0) {
        builder.setChannel(CHANNEL_2G, SoftApConfiguration.BAND_2GHZ);
    }
    if (BAND_MODE == "5G" && CHANNEL_5G > 0) {
        builder.setChannel(CHANNEL_5G, SoftApConfiguration.BAND_5GHZ);
    }
    if (BAND_MODE == "6G" && CHANNEL_6G > 0) {
        builder.setChannel(CHANNEL_6G, SoftApConfiguration.BAND_6GHZ);
    }
    // 6. 最大客户端
    builder.setMaxNumberOfClients(MAX_CLIENTS);

    // 7. 自动关闭
    builder.setAutoShutdownEnabled(AUTO_SHUTDOWN);
    builder.setShutdownTimeoutMillis(SHUTDOWN_TIMEOUT_MS);
    // ================= 客户端控制 =================
    // 8. 用户确认模式
    builder.setClientControlByUserEnabled(CLIENT_CONTROL_BY_USER);
    // 9. 白名单
    if (CLIENT_CONTROL_BY_USER && ALLOWED_MAC_LIST.length > 0) {
        var allowedList = [];
        for (var i = 0; i < ALLOWED_MAC_LIST.length; i++) {
            allowedList.push(
                MacAddress.fromString(ALLOWED_MAC_LIST[i])
            );
        }
        builder.setAllowedClientList(allowedList);
    }
    // 10. 黑名单
    if (BLOCKED_MAC_LIST.length > 0) {
        var blockedList = [];
        for (var j = 0; j < BLOCKED_MAC_LIST.length; j++) {
            blockedList.push(
                MacAddress.fromString(BLOCKED_MAC_LIST[j])
            );
        }
        builder.setBlockedClientList(blockedList);
    }
    var config = builder.build();
    try {
        var wifiService = ServiceManager.getService("wifi");
        if (!wifiService) {
            console.log("无法获取 wifi service");
        }
        // 设置配置
        wifiService.setSoftApConfiguration(config, "android");
        // 启动热点
        shortx.executeAction(Packages.tornaco.apps.shortx.core.proto.action.SetHotSpotEnabled.newBuilder().setEnable(true).build()
);

    } catch (e) {
        console.log("设置失败: " + e);
       
    }
}
startCustomHotspot();

/*
可选项包括：热点标识（SSID、是否隐藏）、安全认证（加密类型、密码）、无线参数（频段、信道）、连接策略（最大客户端数、是否自动关闭）、客户端管控（用户确认、白名单、黑名单）
*/

固定指定应用

android.os.ServiceManager.getService("activity_task").startSystemLockTaskMode(taskId);
// 固定指定应用

固定前台应用

android.os.ServiceManager.getService("activity_task").startSystemLockTaskMode((android.os.ServiceManager.getService("activity_task")).getTasks(1)[0].taskId);
// 固定前台应用

取消固定应用

android.os.ServiceManager.getService("activity_task").stopSystemLockTaskMode()
// 取消固定应用

运行内存详情

// 运行内存详情
MemoryInfo = android.app.ActivityManager.MemoryInfo;
memInfo = new MemoryInfo();
activityService = android.os.ServiceManager.getService("activity");
activityService.getMemoryInfo(memInfo);

availGB = memInfo.availMem / 1024.0 / 1024 / 1024;
totalGB = memInfo.totalMem / 1024.0 / 1024 / 1024;
thresholdMB = memInfo.threshold / 1024.0 / 1024;

usedGB = totalGB - availGB;
usedPercent  = (usedGB  / totalGB) * 100;
availPercent = (availGB / totalGB) * 100;

availGB2 = Math.floor(availGB * 100) / 100;
totalGB2 = Math.floor(totalGB * 100) / 100;
usedGB2  = Math.floor(usedGB  * 100) / 100;

usedPercent2  = Math.floor(usedPercent  * 100) / 100;
availPercent2 = Math.floor(availPercent * 100) / 100;
thresholdMB2 = Math.floor(thresholdMB * 100) / 100;


"可用内存: " + availGB2 + " GB (" + availPercent2 + " %)\n" +
"已用内存: " + usedGB2  + " GB (" + usedPercent2  + " %)\n" +
"总内存: " + totalGB2 + " GB\n" +
"低内存模式: " + memInfo.lowMemory + "\n" +
"低内存阈值: " + thresholdMB2 + " MB";

内部存储详情

// 内部存储详情
StatFs = android.os.StatFs;
stat = new StatFs("/data");

totalGB = stat.getTotalBytes() / 1024.0 / 1024 / 1024;
availGB = stat.getAvailableBytes() / 1024.0 / 1024 / 1024;

usedGB = totalGB - availGB;
usedPercent  = (usedGB  / totalGB) * 100;
availPercent = (availGB / totalGB) * 100;

"总存储: " + (Math.floor(totalGB * 100) / 100) + " GB\n" +
"已用存储: " + (Math.floor(usedGB * 100) / 100) + " GB\n" +
"可用存储: " + (Math.floor(availGB * 100) / 100) + " GB\n" +
"已用比例: " + (Math.floor(usedPercent * 100) / 100) + " %\n" +
"可用比例: " + (Math.floor(availPercent * 100) / 100) + " %";

夜间模式判断

(context.getResources().getConfiguration().uiMode & 48) == 32;

//android.os.ServiceManager.getService("uimode").getNightMode() == 2;

// 
((android.os.ServiceManager.getService("activity").getConfiguration()).uiMode & 48) == 32;

// 三种方式
// 深色主题(夜间模式)判断

获取陀螺仪数据

importClass(android.content.Context);
importClass(android.hardware.Sensor);
importClass(android.hardware.SensorManager);
importClass(android.hardware.SensorEventListener);
importClass(android.hardware.SensorEvent);
importClass(java.lang.Thread);
importClass(java.lang.Runnable);
importClass(android.os.Looper);
importClass(android.os.Handler);
importClass(java.util.concurrent.CountDownLatch);
importClass(java.util.concurrent.TimeUnit);

function getGyroscopeData() {
    var sensorManager = context.getSystemService(Context.SENSOR_SERVICE);
    var gyroscope = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);

    if (gyroscope == null) {
        return "设备不支持陀螺仪传感器";
    }

    var x = 0, y = 0, z = 0;
    var latch = new CountDownLatch(1);

    var listener = new SensorEventListener({
        onSensorChanged: function (event) {
            x = event.values[0];
            y = event.values[1];
            z = event.values[2];
            latch.countDown(); // 收到数据后释放
        },
        onAccuracyChanged: function (sensor, accuracy) {}
    });

    // 注册监听器，必须在主线程
    new Handler(Looper.getMainLooper()).post(new Runnable({
        run: function () {
            sensorManager.registerListener(listener, gyroscope, SensorManager.SENSOR_DELAY_NORMAL);
        }
    }));

    // 最多等待 2 秒获取数据
    var received = latch.await(2, TimeUnit.SECONDS);

    // 无论成功与否都要注销监听器
    sensorManager.unregisterListener(listener);

    if (!received) {
        return "未能获取陀螺仪数据";
    }

    return "陀螺仪数据:\nX: " + x + "\nY: " + y + "\nZ: " + z;
}

getGyroscopeData();

获取设备屏幕方向

// 根据加速度传感器获取设备屏幕方向
importClass(android.content.Context);
importClass(android.hardware.Sensor);
importClass(android.hardware.SensorManager);
importClass(android.hardware.SensorEventListener);
importClass(android.os.Looper);
importClass(android.os.Handler);
importClass(java.util.concurrent.CountDownLatch);
importClass(java.util.concurrent.TimeUnit);
importClass(java.lang.Runnable);

function getPhoneOrientation() {
    var sensorManager = context.getSystemService(Context.SENSOR_SERVICE);
    var accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

    if (accelerometer == null) {
        return "设备不支持加速度传感器";
    }

    var x = 0, y = 0, z = 0;
    var latch = new CountDownLatch(1);

    var listener = new SensorEventListener({
        onSensorChanged: function(event) {
            x = event.values[0];
            y = event.values[1];
            z = event.values[2];
            latch.countDown();
        },
        onAccuracyChanged: function(sensor, accuracy) {}
    });

    new Handler(Looper.getMainLooper()).post(new Runnable({
        run: function() {
            sensorManager.registerListener(listener, accelerometer, SensorManager.SENSOR_DELAY_NORMAL);
        }
    }));

    var received = latch.await(2, TimeUnit.SECONDS);
    sensorManager.unregisterListener(listener);

    if (!received) {
        return "未能获取加速度传感器数据";
    }

    // 判断朝向
    var absX = Math.abs(x), absY = Math.abs(y), absZ = Math.abs(z);

    if (absZ > absX && absZ > absY) {
        return z > 0 ? "屏幕朝上" : "屏幕朝下";
    } else if (absY > absX && absY > absZ) {
        return y > 0 ? "顶部朝上" : "底部朝上";
    } else if (absX > absY && absX > absZ) {
        return x > 0 ? "右侧朝上" : "左侧朝上";
    } else {
        return "无法判断";
    }
}

getPhoneOrientation();

获取数据传感器数据

importClass(android.content.Context);
importClass(android.hardware.Sensor);
importClass(android.hardware.SensorManager);
importClass(android.hardware.SensorEventListener);
importClass(android.hardware.SensorEvent);
importClass(java.lang.Thread);
importClass(java.lang.Runnable);
importClass(android.os.Looper);
importClass(android.os.Handler);
importClass(java.util.concurrent.CountDownLatch);
importClass(java.util.concurrent.TimeUnit);

function getProximityData() {
    var sensorManager = context.getSystemService(Context.SENSOR_SERVICE);
    var proximitySensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);

    if (proximitySensor == null) {
        return "设备不支持距离传感器";
    }

    var maxRange = proximitySensor.getMaximumRange();
    var distance = -1;

    var latch = new CountDownLatch(1);

    var listener = new SensorEventListener({
        onSensorChanged: function (event) {
            distance = event.values[0];
            latch.countDown(); // 一旦收到数据就释放等待
        },
        onAccuracyChanged: function (sensor, accuracy) {
            // 可选：处理精度变化
        }
    });

    // 在主线程中注册监听器
    new Handler(Looper.getMainLooper()).post(new Runnable({
        run: function () {
            sensorManager.registerListener(listener, proximitySensor, SensorManager.SENSOR_DELAY_NORMAL);
        }
    }));

    // 最多等待2秒
    var received = latch.await(2, TimeUnit.SECONDS);

    // 不管成功与否都注销监听器
    sensorManager.unregisterListener(listener);

    if (!received || distance < 0) {
        return "未能获取距离传感器数据";
    }

    // 判断是否接近（通常 0 表示接近）
    var isNear = distance <= 1.0;  // 兼容某些 maxRange 比较小的设备

    return "距离传感器数据: " + distance + " 厘米\n是否接近: " + (isNear ? "是" : "否");
}

getProximityData();

获取手电筒状态

importClass(android.content.Context);
importClass(android.hardware.camera2.CameraManager);
importClass(android.os.Build);
importClass(android.os.Looper);
importClass(android.os.Handler);
importClass(java.util.concurrent.CountDownLatch);
importClass(java.util.concurrent.TimeUnit);

function getTorchState() {
    if (Build.VERSION.SDK_INT < 24) {
        return "当前 Android 版本不支持监听手电筒状态（需要 Android 7.0+）";
    }

    try {
        var latch = new CountDownLatch(1);
        var torchOn = null;

        var cameraManager = context.getSystemService(Context.CAMERA_SERVICE);
        var handler = new Handler(Looper.getMainLooper()); // 使用主线程的 Looper

        var torchCallback = new android.hardware.camera2.CameraManager.TorchCallback({
            onTorchModeChanged: function (cameraId, enabled) {
                torchOn = enabled;
                latch.countDown(); // 获取到状态后退出等待
            },
            onTorchModeUnavailable: function (cameraId) {
                torchOn = null;
                latch.countDown(); // 无法获取状态也退出
            }
        });

        cameraManager.registerTorchCallback(torchCallback, handler);

        latch.await(1, TimeUnit.SECONDS);

        cameraManager.unregisterTorchCallback(torchCallback);

        if (torchOn === null) {
            return "无法获取手电筒状态";
        }

        return torchOn;
    } catch (e) {
        return "发生错误: " + e;
    }
}

getTorchState();

获取加速度传感器数据

importClass(android.content.Context);
importClass(android.hardware.Sensor);
importClass(android.hardware.SensorManager);
importClass(android.hardware.SensorEventListener);
importClass(android.hardware.SensorEvent);
importClass(java.lang.Thread);
importClass(java.lang.Runnable);
importClass(android.os.Looper);
importClass(android.os.Handler);
importClass(java.util.concurrent.CountDownLatch);
importClass(java.util.concurrent.TimeUnit);

function getAccelerometerData() {
    var sensorManager = context.getSystemService(Context.SENSOR_SERVICE);
    var accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

    if (accelerometer == null) {
        return "设备不支持加速度传感器";
    }

    var x = 0, y = 0, z = 0;
    var latch = new CountDownLatch(1);

    var listener = new SensorEventListener({
        onSensorChanged: function (event) {
            x = event.values[0];
            y = event.values[1];
            z = event.values[2];
            latch.countDown(); // 收到数据后释放
        },
        onAccuracyChanged: function (sensor, accuracy) {}
    });

    // 注册监听器，必须在主线程
    new Handler(Looper.getMainLooper()).post(new Runnable({
        run: function () {
            sensorManager.registerListener(listener, accelerometer, SensorManager.SENSOR_DELAY_NORMAL);
        }
    }));

    // 最多等待 2 秒获取数据
    var received = latch.await(2, TimeUnit.SECONDS);

    // 无论成功与否都要注销监听器
    sensorManager.unregisterListener(listener);

    if (!received) {
        return "未能获取加速度传感器数据";
    }

    return "加速度传感器数据:\nX: " + x + "\nY: " + y + "\nZ: " + z;
}

getAccelerometerData();

获取磁场传感器数据

importClass(android.content.Context);
importClass(android.hardware.Sensor);
importClass(android.hardware.SensorManager);
importClass(android.hardware.SensorEventListener);
importClass(android.hardware.SensorEvent);
importClass(java.lang.Thread);
importClass(java.lang.Runnable);
importClass(android.os.Looper);
importClass(android.os.Handler);
importClass(java.util.concurrent.CountDownLatch);
importClass(java.util.concurrent.TimeUnit);

function getMagneticFieldData() {
    var sensorManager = context.getSystemService(Context.SENSOR_SERVICE);
    var magneticField = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);

    if (magneticField == null) {
        return "设备不支持磁力计传感器";
    }

    var x = 0, y = 0, z = 0;
    var latch = new CountDownLatch(1);

    var listener = new SensorEventListener({
        onSensorChanged: function (event) {
            x = event.values[0];
            y = event.values[1];
            z = event.values[2];
            latch.countDown(); // 收到数据后释放
        },
        onAccuracyChanged: function (sensor, accuracy) {}
    });

    // 注册监听器，必须在主线程
    new Handler(Looper.getMainLooper()).post(new Runnable({
        run: function () {
            sensorManager.registerListener(listener, magneticField, SensorManager.SENSOR_DELAY_NORMAL);
        }
    }));

    // 最多等待 2 秒获取数据
    var received = latch.await(2, TimeUnit.SECONDS);

    // 无论成功与否都要注销监听器
    sensorManager.unregisterListener(listener);

    if (!received) {
        return "未能获取磁力计传感器数据";
    }

    return "磁力计传感器数据:\nX: " + x + "\nY: " + y + "\nZ: " + z;
}

getMagneticFieldData();

获取方向传感器数据

importClass(android.content.Context);
importClass(android.hardware.Sensor);
importClass(android.hardware.SensorManager);
importClass(android.hardware.SensorEventListener);
importClass(android.hardware.SensorEvent);
importClass(java.lang.Thread);
importClass(java.lang.Runnable);
importClass(android.os.Looper);
importClass(android.os.Handler);
importClass(java.util.concurrent.CountDownLatch);
importClass(java.util.concurrent.TimeUnit);

function getOrientationData() {
    var sensorManager = context.getSystemService(Context.SENSOR_SERVICE);
    var orientationSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);

    if (orientationSensor == null) {
        return "设备不支持方向传感器";
    }

    var azimuth = 0, pitch = 0, roll = 0;
    var latch = new CountDownLatch(1);

    var listener = new SensorEventListener({
        onSensorChanged: function (event) {
            azimuth = event.values[0];  // 方位角（0°-360°，朝北为0°）
            pitch = event.values[1];    // 俯仰角（-90° 到 90°，0° 为水平）
            roll = event.values[2];     // 滚转角（-90° 到 90°，0° 为水平）
            latch.countDown(); // 收到数据后释放
        },
        onAccuracyChanged: function (sensor, accuracy) {}
    });

    // 注册监听器，必须在主线程
    new Handler(Looper.getMainLooper()).post(new Runnable({
        run: function () {
            sensorManager.registerListener(listener, orientationSensor, SensorManager.SENSOR_DELAY_NORMAL);
        }
    }));

    // 最多等待 2 秒获取数据
    var received = latch.await(2, TimeUnit.SECONDS);

    // 无论成功与否都要注销监听器
    sensorManager.unregisterListener(listener);

    if (!received) {
        return "未能获取方向传感器数据";
    }

    return "方向传感器数据:\nX: " + azimuth + "°\nY: " + pitch + "°\nZ: " + roll + "°";
}

getOrientationData();

获取重力传感器数据

importClass(android.content.Context);
importClass(android.hardware.Sensor);
importClass(android.hardware.SensorManager);
importClass(android.hardware.SensorEventListener);
importClass(android.hardware.SensorEvent);
importClass(java.lang.Thread);
importClass(java.lang.Runnable);
importClass(android.os.Looper);
importClass(android.os.Handler);
importClass(java.util.concurrent.CountDownLatch);
importClass(java.util.concurrent.TimeUnit);

function getGravityData() {
    var sensorManager = context.getSystemService(Context.SENSOR_SERVICE);
    var gravitySensor = sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY);

    if (gravitySensor == null) {
        return "设备不支持重力传感器";
    }

    var x = 0, y = 0, z = 0;
    var latch = new CountDownLatch(1);

    var listener = new SensorEventListener({
        onSensorChanged: function (event) {
            x = event.values[0];
            y = event.values[1];
            z = event.values[2];
            latch.countDown(); // 收到数据后释放
        },
        onAccuracyChanged: function (sensor, accuracy) {}
    });

    // 注册监听器，必须在主线程
    new Handler(Looper.getMainLooper()).post(new Runnable({
        run: function () {
            sensorManager.registerListener(listener, gravitySensor, SensorManager.SENSOR_DELAY_NORMAL);
        }
    }));

    // 最多等待 2 秒获取数据
    var received = latch.await(2, TimeUnit.SECONDS);

    // 无论成功与否都要注销监听器
    sensorManager.unregisterListener(listener);

    if (!received) {
        return "未能获取重力传感器数据";
    }

    return "重力传感器数据:\nX: " + x + "\nY: " + y + "\nZ: " + z;
}

getGravityData();

获取光线传感器数据

importClass(android.content.Context);
importClass(android.hardware.Sensor);
importClass(android.hardware.SensorManager);
importClass(android.hardware.SensorEventListener);
importClass(android.hardware.SensorEvent);
importClass(java.lang.Thread);
importClass(java.lang.Runnable);
importClass(android.os.Looper);
importClass(android.os.Handler);
importClass(java.util.concurrent.CountDownLatch);
importClass(java.util.concurrent.TimeUnit);

function getLightData() {
    var sensorManager = context.getSystemService(Context.SENSOR_SERVICE);
    var lightSensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);

    if (lightSensor == null) {
        return "设备不支持光线传感器";
    }

    var lightLevel = 0;
    var latch = new CountDownLatch(1);

    var listener = new SensorEventListener({
        onSensorChanged: function (event) {
            lightLevel = event.values[0];  // 光线强度（单位：勒克斯 lux）
            latch.countDown(); // 收到数据后释放
        },
        onAccuracyChanged: function (sensor, accuracy) {}
    });

    // 注册监听器，必须在主线程
    new Handler(Looper.getMainLooper()).post(new Runnable({
        run: function () {
            sensorManager.registerListener(listener, lightSensor, SensorManager.SENSOR_DELAY_NORMAL);
        }
    }));

    // 最多等待 2 秒获取数据
    var received = latch.await(2, TimeUnit.SECONDS);

    // 无论成功与否都要注销监听器
    sensorManager.unregisterListener(listener);

    if (!received) {
        return "未能获取光线传感器数据";
    }

    return "光线传感器数据:\n光照强度: " + lightLevel + " lux";
}

getLightData();

获取摇一摇状态

// 根据加速度传感器获取摇一摇状态
importClass(android.content.Context);
importClass(android.hardware.Sensor);
importClass(android.hardware.SensorManager);
importClass(android.hardware.SensorEventListener);
importClass(android.os.Looper);
importClass(android.os.Handler);
importClass(java.util.concurrent.CountDownLatch);
importClass(java.util.concurrent.TimeUnit);
importClass(java.lang.Runnable);

function simulateShake() {
    var sensorManager = context.getSystemService(Context.SENSOR_SERVICE);
    var accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

    if (accelerometer == null) {
        return "设备不支持加速度传感器";
    }

    var latch = new CountDownLatch(1);
    var isShaked = false;

    var listener = new SensorEventListener({
        onSensorChanged: function(event) {
            var x = event.values[0];
            var y = event.values[1];
            var z = event.values[2];

            // 计算三轴加速度的合力大小（去掉重力后相对变化）
            var magnitude = Math.sqrt(x * x + y * y + z * z);

            // 简单阈值判断：加速度变化超过 15（m/s²）认为是摇动
            if (magnitude > 15) {
                isShaked = true;
                latch.countDown();
            }
        },
        onAccuracyChanged: function(sensor, accuracy) {}
    });

    new Handler(Looper.getMainLooper()).post(new Runnable({
        run: function() {
            sensorManager.registerListener(listener, accelerometer, SensorManager.SENSOR_DELAY_GAME);
        }
    }));

    // 最多等 3 秒
    latch.await(3, TimeUnit.SECONDS);
    sensorManager.unregisterListener(listener);

    if (isShaked) {
        return "检测到摇一摇";
    } else {
        return "未检测到摇一摇";
    }
}

simulateShake();

展开快捷设置面板

ServiceManager = android.os.ServiceManager;

ServiceManager.getService("statusbar").expandSettingsPanel(null);
// 展开快捷设置面板

//ServiceManager.getService("statusbar").collapsePanels();
// 收起所有面板
// 如果当前使用的是定制化系统的快捷设置与通知分离面板的话，需要把第二段代码解除注释状态

收起所有面板

android.os.ServiceManager.getService("statusbar").collapsePanels();
// 包括通知与快捷设置面板

切换面板状态

android.os.ServiceManager.getService("statusbar").togglePanel();

重启

android.os.ServiceManager.getService("power").reboot(false, null, true);
// 重启设备

显示输入法

importClass(Packages.tornaco.apps.shortx.core.proto.action.ShowHideInsets);
importClass(Packages.tornaco.apps.shortx.core.proto.common.WindowInsetType);

shortx.executeAction(ShowHideInsets.newBuilder().setIsHide(false).addType(WindowInsetType.WindowInsetType_Ime).build());

隐藏输入法

importClass(Packages.tornaco.apps.shortx.core.proto.action.ShowHideInsets);
importClass(Packages.tornaco.apps.shortx.core.proto.common.WindowInsetType);

shortx.executeAction(ShowHideInsets.newBuilder().setIsHide(true).addType(WindowInsetType.WindowInsetType_Ime).build());

音频焦点判断

android.os.ServiceManager.getService("audio").getCurrentAudioFocus() != 0;
// 判断当前是否有音频焦点

判断指定音频静音状态

android.os.ServiceManager.getService("audio").isStreamMute(3);

// 判断媒体音量静音状态

音量类型

/*
通话音量       → 0
系统音量       → 1
铃声音量       → 2
媒体音量       → 3
闹钟音量       → 4
通知音量       → 5
蓝牙 SCO 音频流 → 6
强制系统音量   → 7
DTMF 音频流     → 8
TTS 音频流      → 9
辅助功能音量   → 10
助理音频流   → 11
*/

系统崩溃

android.os.ServiceManager.getService("power").crash(null);
// 引发设备崩溃

进入安全模式

android.os.ServiceManager.getService("power").rebootSafeMode(false, true);
// 设备重启并进入安全模式

省电模式判断

android.os.ServiceManager.getService("power").isPowerSaveMode();
// 判断是否处于省电模式

设置省电模式

android.os.ServiceManager.getService("power").setPowerSaveModeEnabled(true);
// 设置省电模式

设置指定显示屏的窗口模式

android.os.ServiceManager.getService("window").setWindowingMode(0, 5);
// 该命令有点问题，暂时不要运行。
// 设置指定显示屏为小窗

// (int displayId, int mode)
/* 小窗模式
Color →  100
默认  →  5
/*

查看指定显示屏窗口模式

android.os.ServiceManager.getService("window").getWindowingMode(0);
// 该命令暂时不要用。
// 查看指定显示屏当前窗口模式

获取当前应用的窗口模式

(android.os.ServiceManager.getService("activity_task").getTasks(1))[0].configuration.windowConfiguration.getWindowingMode();
// 获取当前应用的窗口模式数值

获取输入法区域

android.os.ServiceManager.getService("window").getCurrentImeTouchRegion();
//获取当前输入法的显示(触摸)区域

获取主显示设备的Token

Build = android.os.Build;
SurfaceControl = android.view.SurfaceControl;
DisplayControl = com.android.server.display.DisplayControl;

if (Build.VERSION.SDK_INT < 34) { // 
    surfaceControl = new SurfaceControl();
    displayToken = (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) ?
        surfaceControl.getBuiltInDisplay(0) : SurfaceControl.getInternalDisplayToken();

} else {
    displayToken = DisplayControl.getPhysicalDisplayToken(DisplayControl.getPhysicalDisplayIds()[0]);

}

息屏运行（屏幕电源）

// 仅对主显示设备生效
Build = android.os.Build;
SurfaceControl = android.view.SurfaceControl;
DisplayControl = com.android.server.display.DisplayControl;

displayMode = 0;  // 直接设置电源模式  2: 开启, 0: 关闭

if (Build.VERSION.SDK_INT < 34) { 
    surfaceControl = new SurfaceControl();

    displayToken = (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) ?
        surfaceControl.getBuiltInDisplay(0) : SurfaceControl.getInternalDisplayToken();

    SurfaceControl.setDisplayPowerMode(displayToken, displayMode);

} else {
    displayToken = DisplayControl.getPhysicalDisplayToken(DisplayControl.getPhysicalDisplayIds()[0]);

        SurfaceControl.setDisplayPowerMode(displayToken, displayMode);
}
// Extinguish 息屏挂机 息屏运行 听剧模式 仅关屏 息屏不锁屏 息屏不锁屏 游戏挂机 开屏伪装FakeSceen

设置电源模式

Service = android.os.ServiceManager.getService("display");

if (android.os.Build.VERSION.SDK_INT > 35) {
    Service.requestDisplayPower(0, 1);
} else {
    Service.requestDisplayPower(0, true);
}
// Android 15及以上方可使用
// 设置指定显示器电源模式
// Android 16+(int displayId, int state)
/*
state 模式
电源关闭         → 1
电源开启         → 2
待机模式         → 3
深度待机模式     → 4
*/
// Android 15 (int displayId, boolean on)

获取主设备显示ID

(android.hardware.display.DisplayManagerGlobal.getInstance()).getDisplayInfo(0).address.getPhysicalDisplayId();
// 获取主设备ID

获取距离上一次触摸的时间差

// 全局空闲秒数，即获取距离上一次触摸时间差(秒
var idle = 0;
try {
    var h = {};
    var t = new java.lang.Thread(function () {
        try {
            var im = android.hardware.input.IInputManager.Stub.asInterface(android.os.ServiceManager.getService("input"));
            var p = android.os.ParcelFileDescriptor.createReliablePipe();
            im.dump(p[1].getFileDescriptor(), null);
            p[1].close();

            var s = new android.os.ParcelFileDescriptor.AutoCloseInputStream(p[0]);
            var b = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, 4096);
            var o = new java.io.ByteArrayOutputStream();
            while ((r = s.read(b)) != -1 && o.size() < 999999) o.write(b, 0, r);
            s.close();

            h.t = o.toString("UTF-8");
        } catch (e) {}
    });

    t.start();
    t.join(3000);

    var m = h.t && h.t.match(/age=([0-9.]+)ms/);
    if (m) idle = m[1] / 1000;
} catch (e) {}

if (!idle) {
    var result = shortx.executeAction(Packages.tornaco.apps.shortx.core.proto.action.ShellCommand.newBuilder().setCommand("dumpsys input 2>/dev/null | sed -rn \"/RecentQueue:/ n;/.*age=([0-9]*).*/{s//\\1/p;q}\"").build()).contextData.get("shellOut");

    if (result) idle = result / 1000;
}

idle;

清空Http log

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().clearHttpRequestLogs();
// 清空HTTP请求的日志

清空JS logs

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().clearJSLogs();
// 清空JS执行日志

清空Hook方法的调用日志

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().clearMethodHookLogs();
// 清空Hook方法的调用日志

清空指令记录

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().clearEvaluateRecords();
// 清空指令记录

获取开关指令总数量

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getToggleCount();
// 获取开关指令总数量

获取自动指令总数量

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getRuleCount();
// 获取自动指令总数量

获取一键指令总数量

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getDirectActionCount();
// 获取一键指令总数量

获取代码库总数量

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getCodeLibraryItemCount();
// 获取代码库总数量

获取ShortX日志文件的存储路径

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getLogDir();
// 获取ShortX日志文件的根目录路径

获取JS代码执行日志的存储路径

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getJSLogPath();
// 获取JS代码执行日志的存储路径

获取Hook方法调用日志的存储路径

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getMethodHookLogPath();
// 获取Hook方法调用日志的存储路径

获取ShortX根目录

new java.io.File(Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getLogDir()).getParentFile().getAbsolutePath();
// 获取ShortX根目录

判断ShortX是否正在进行录音

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().isAudioRecording();
// 判断ShortX是否正在进行录音

判断按键紧急停用ShortX功能是否开启

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().isForceDisableShortXByKeyPressEnabled();
// 判断按键紧急停用ShortX功能是否开启

判断ShortX是否正在录制手势

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().isGestureRecording();
// 判断ShortX是否正在录制手势

判断Http请求日志功能是否开启

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().isHttpRequestLogEnabled();
// 判断HTTP请求日志功能是否开启

判断Shell命令引擎-Shell in SystemUI功能是否开启

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().isInjectedShellEnabled();
// 判断Shell命令引擎-Shell in SystemUI功能是否开启

判断按键事件提示功能是否开启

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().isKeyEventPromptEnabled();
// 判断按键事件提示功能是否开启

判断指针位置显示功能是否开启

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().isPointerLocationEnabled();
// 判断指针位置显示功能是否开启

判断ShortX调试(详细)日志功能是否开启

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().isLogDebugEnable();
// 判断ShortX调试(详细)日志功能是否开启

判断ShortX应用通知功能是否开启

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().isPostNByAppEnabled();
// 判断ShortX应用通知功能是否开启

判断磁贴点击优化功能是否开启

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().isQSTileOptEnabled();
// 判断磁贴点击优化功能是否开启

判断ShortX是否出现致命错误

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().hasFatalError();
// 判断ShortX是否出现致命错误

判断指定规则引擎是否开启

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().isRuleEngineEnabled('引擎标识');
// 判断指定规则引擎是否开启
/*
shell  → Shell命令引擎
mvel  →  MVEL表达式引擎
*/

判断自动规则核心功能(总开关)是否开启

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().isRuleFeatureEnabled();
// 判断自动规则核心功能(总开关)是否开启

判断指定开关指令是否开启

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().isToggleEnabled('toggle-84eb65f4-115c-416b-bef2-xxxxxxxxxx');
// 判断指定开关指令是否开启 

判断快捷栏图标是否为深色模式

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().isLightBarTransitionsIconsDark();
// 判断快捷栏图标是否为深色模式

获取所有正在执行的任务

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getActiveJobs();
// 获取所有正在执行的任务                                              

获取所有正在执行的动作列表

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getEvaluatingActions();
// 获取所有正在执行的动作列表

获取设备SIM卡的运营商订阅信息

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getActiveSubscriptionInfoList();
// 获取设备SIM卡的运营商订阅信息

获取ShortX所有音频录制文件数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllAudioRecordFiles();
// 获取ShortX所有音频录制文件数据

获取所有上下文菜单(触发器)的配置列表

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllContextMenuSettings();
// 获取所有上下文菜单(触发器)的配置列表

查询指定App的所有Activity组件

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getActivities(0, "tornaco.apps.shortx");
// 查询指定App的所有Activity组件
// 猜测参数1为筛选状态（0=全部、1=启用），参数2为App包名

获取ShortX所有功能开关的数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllToggles();
// 获取ShortX所有功能开关的数据

获取所有代码库数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllCodeLibraryItems();
// 获取所有代码库数据

获取所有一键指令集

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllDASets(true);
// 获取所有一键指令集

获取所有自动指令集数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllRuleSets(true);
// 获取所有自动指令集数据

关键词查询自动规则

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllDirectAction(String, int, int);
// 关键词查询自动规则
// 猜测参数1为关键词，参数2=分类ID，参数3=状态
// 分类ID（0=全部、1=系统、2=自定义），状态（0=全部、1=启用、2=禁用）

关键词查询一键指令

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllDirectAction(String, int, int);
// 关键词查询一键指令
// 猜测 参数1为模糊关键词，参数2=分类ID，参数3=状态
// 分类ID（0=全部、1=系统、2=自定义），状态（0=全部、1=启用、2=禁用）

查询符合条件的所有一键指令

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllDirectAction(int, int);
// 查询符合条件的所有一键指令
// 猜测参数1为分类ID（0=全部、1=系统、2=自定义），参数2为状态（0=全部、1=启用、2=禁用）

带缓存+关键词查询一键指令，效率更高

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllDirectActionWithQueryCache(String, int, int);
// 带缓存+关键词查询一键指令，效率更高
// 猜测参数1为指令名称关键词（模糊匹配），参数2=分类ID，参数3=状态（同上）

获取所有动态快捷方式的配置列表

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllDynamicShortcutSettings();
// 获取所有动态快捷方式的配置列表

获取所有手势记录数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllGestureRecords(boolean);
// 获取所有手势记录数据
/*
true=具体详情
false=应用集名称
/*

获取所有已创建的全局变量数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllGlobalVars();
// 获取所有已创建的全局变量数据

获取所有应用集数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllPkgSets(true);
// 获取所有应用集数据
/*
true=具体详情
false=应用集名称
*/

获取设备所有铃声、提示音、闹钟音的数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllRingtones();
// 获取设备所有铃声、提示音、闹钟音的数据

获取所有状态栏图标的配置列表

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllStatusBarTileSettings();
// 获取所有状态栏图标的配置列表

获取当前Android系统的所有环境变量、系统参数列表

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllSystemEnv();
// 获取当前Android系统的所有环境变量、系统参数列表

获取设备上所有创建的用户账号列表

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllUsers();
// 获取设备上所有创建的用户账号列表

获取所有已配置的WebDav同步配置列表

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllWebDavProfiles();
// 获取所有已配置的WebDav同步配置列表

获取设备已配对的所有蓝牙设备列表

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getBTBondedDevices();
// 获取设备已配对的所有蓝牙设备列表

获取设备所有已安装App数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getInstalledApps();
// 获取设备所有已安装App数据

查询指定App的BroadcastReceiver组件

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getProviders(int, String);
// 查询指定App的BroadcastReceiver组件
// 参数1为筛选状态，参数2为App包名

删除指定音频录制文件

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().deleteAudioRecordFile(ByteArrayWrapper);
// 删除指定音频录制文件

删除指定代码库片段

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().deleteCodeLibraryItem('id');
// 删除指定代码库片段

删除指定一键指令集

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().deleteDASet('DS-xxxxxxxx-xxxx-xxxx-8943-xxxxxxxxxx');
// 删除指定一键指令集

删除指定一键指令

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().deleteDirectAction('DA-xxxxxxxx-4xxxxx-43ed-bf32-172c0adcxxxxx');
// 删除指定一键指令

删除指定自动指令集

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().deleteRuleSet('RS-xxxxxxx-xxxx-xxxx-be4e-xxxxxxxxx');
// 删除指定自动指令集

删除指定自动指令

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().deleteRule('rule-xxxxxxx-xxxx-xxxxxxx-a19d-xxxxxxxxxx');
// 删除指定自动指令

删除指定开关指令

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().deleteToggle('toggle-xxxxxxx-115c-416b-bef2-xxxxxxxxxx');
// 删除指定开关指令

删除指定手势

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().deleteGestureRecordById('7919aacb-xxxxx-xxxx-xxxx-xxxxxxxxx');
// 删除指定手势

删除指定全局变量

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().deleteGlobalVar('变量名字');
// 删除指定全局变量

删除指定应用集合

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().deletePkgSet('应用集名字');
// 删除指定应用集合

删除指定WebDav配置

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().removeWebDavProfile('配置名字');
// 删除指定WebDav配置

新增代码库片段

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().addCodeLibraryItem(ByteArrayWrapper);
// 新增代码库片段

新增一键指令

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().addDirectAction(ByteArrayWrapper);
// 新增一键指令

新增自动指令

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().addRule(ByteArrayWrapper);
// 新增自动指令

新增开关指令

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().addToggle(ByteArrayWrapper);
// 新增开关指令

新增/更新一键指令集

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().addOrUpdateDASet(ByteArrayWrapper);
// 新增/更新一键指令集

新增/更新自动指令集

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().addOrUpdateRuleSet(ByteArrayWrapper);
// 新增/更新自动指令集

新增应用集

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().addPkgSet(ByteArrayWrapper);
// 新增应用集

新增手势记录

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().addGestureRecord(ByteArrayWrapper);
// 新增手势记录

新增全局变量

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().addGlobalVar(ByteArrayWrapper);
// 新增全局变量

新增WebDav配置

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().addWebDavProfile(ByteArrayWrapper);
// 新增WebDav配置

开启指定Hook功能

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().addHookFlags(String);
// 开启指定Hook功能

触发DeepLink跳转，打开指定App/页面

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().deepLinkTriggerCalled('shortx名字');
// 触发DeepLink跳转，打开指定App/页面

主动触发Android系统服务崩溃

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().crashSystemServer();
// 主动触发Android系统服务崩溃

获取当前设备指纹标识字符串

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().fingerprint();
// 获取当前设备指纹标识字符串

获取下拉快捷设置面板磁贴数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAllQSTiles();
// 获取下拉快捷设置面板磁贴数据

获取指定App的组件信息（Activity/Service等）

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAppComponentInfo(ByteArrayWrapper);
// 获取指定App的组件信息（Activity/Service等）

获取指定App的图标位图

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAppIcon(String, int);
// 获取指定App的图标位图

获取指定App的显示名称

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getAppLabel(ByteArrayWrapper);
// 获取指定App的显示名称

获取指定代码库片段

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getCodeLibraryItemById('codeid') ;
// 获取指定代码库片段

获取指定App组件的启用状态

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getComponentEnabledSetting(ByteArrayWrapper);
// 获取指定App组件的启用状态
// 猜测参数为组件封装对象，返回0=默认、1=启用、2=禁用

获取上下文菜单配置指令名称

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getContextMenuSettingsByMenuNumber(0);
// 获取上下文菜单配置指令名称
// 参数为编号

获取当前已挂载的Root权限实现标识(自定义su路径)

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getCustomSU();
// 获取当前已挂载的Root权限实现标识(自定义su路径)

获取一键指令集数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getDASetById('DS-xxxxxxxx-xxxx-xxxx-8943-xxxxxxxxxx', boolean);
// 获取一键指令集数据
// 参数1为指令集ID，参数2为布尔值，true=查详情、false=基础信息

获取自动指令集数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getRuleSetById('RS-xxxxxxx-xxxx-xxxx-be4e-xxxxxxxxx', boolean);
// 获取自动指令集数据
// 参数1为指令集ID，参数2为布尔值，true=查详情、false=基础信息

获取ShortX弹幕功能的UI配置数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getDanmuUISettings();
// 获取ShortX弹幕功能的UI配置数据

获取指定一键指令数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getDirectActionById('DA-xxxxxxxx-4xxxxx-43ed-bf32-172c0adcxxxxx');
// 获取指定一键指令数据

获取指定自动指令数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getRuleById('rule-xxxxxxx-xxxx-xxxxxxx-a19d-xxxxxxxxxx');
// 获取指定自动指令数据

获取指定开关指令数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getToggleById('toggle-84eb65f4-115c-416b-bef2-xxxxxxxxxx');
// 获取指定开关指令数据

获取指定WebDav配置

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getWebDavProfileById('id');
// 获取指定WebDav配置

获取动态快捷方式配置

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getDynamicShortcutSettingsByNumber(int);
// 获取动态快捷方式配置

获取边缘手势的触摸区域厚度

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getGestureAreaSize();
// 获取边缘手势的触摸区域厚度

获取指定手势记录数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getGestureRecordById('7919aacb-xxxxx-xxxx-xxxx-xxxxxxxxx');
// 获取指定手势记录数据

获取指定全局变量数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getGlobalVarByName('变量名字');
// 获取指定全局变量数据

获取Hook方法调用日志(数据)文件描述符

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getMethodHookLogFD();
// 获取Hook方法调用日志(数据)文件描述符 ParcelFileDescriptor

获取JS代码执行日志(数据)文件描述符

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getJSLogFD();
// 获取JS代码执行日志(数据)文件描述符 ParcelFileDescriptor

获取HTTP请求日志(数据)文件描述符

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getHttpRequestLogFD();
// 获取HTTP请求日志(数据)文件描述符 ParcelFileDescriptor

获取已安装插件提供的所有自动化动作列表

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getInstalledPluginActions();
// 获取已安装插件提供的所有自动化动作列表

获取已安装插件提供的所有自动化条件列表

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getInstalledPluginConditions();
// 获取已安装插件提供的所有自动化条件列表

获取所有已安装的ShortX拓展插件列表

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getInstalledPluginFacts();
// 获取所有已安装的ShortX拓展插件列表

获取所有已添加快捷方式的App列表

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getInstalledShortcutApps();
// 获取所有已添加快捷方式的App列表

获取按键长按检测的超时时间

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getKeyDetectorLongPressTimeoutMS();
// 获取按键长按检测的超时时间

获取设备移动网络信号的最大强度值

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getMaxSignalLevel();
// 获取设备移动网络信号的最大强度值

获取当前启用的OCR文字识别引擎

// 获取OCR引擎值
var ocrEngine = Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getOCREngine();
// 根据返回值输出对应的OCR引擎名称
if (ocrEngine == 1) {
    "Tesseract";
} else if (ocrEngine == 0) {
    "Paddle";
} else {
    "Unknown";
}
// 获取当前启用的OCR文字识别引擎

获取指定应用集数据

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getPkgSetByLabel('应用集名字');
// 获取指定应用集数据

查询指定状态的运行中App包名

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getRunningAppPkgs(String);
// 查询指定状态的运行中App包名

获取指定App正在运行的服务列表

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getRunningServices(ByteArrayWrapper);
// 获取指定App正在运行的服务列表

获取设备屏幕的分辨率

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getScreenSize();
// 获取设备屏幕的分辨率（宽、高），返回Point对象

获取指定App的Service组件

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getServices(0, 'tornaco.apps.shortx');
// 获取指定App的Service组件

获取ShortX服务的相关目录路径封装对象

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getShortXServerDirs();
// 获取ShortX服务的相关目录路径封装对象

获取状态栏图标配置

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getStatusBarTileSettingsByNumber(int);
// 获取状态栏图标配置

获取状态栏剪贴板的功能配置封装对象

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getStatusbarClipSettings();
// 获取状态栏剪贴板的功能配置封装对象

获取指定音频流的最大音量

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getStreamMaxVolume(int);
// 获取指定音频流的最大音量

获取指定音频流的最小音量

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getStreamMinVolume(int);
// 获取指定音频流的最小音量

获取指定音频流的当前音量

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getStreamVolume(int);
// 获取指定音频流的当前音量

设置滑动手势触发阈值

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().setSwipeDistanceThresholdDp(int);
// 设置滑动手势触发阈值

获取滑动手势的触发阈值

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getSwipeDistanceThresholdDp();
// 获取滑动手势的触发阈值

设置滑动手势长度缩放比例

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().setSwipeLengthScale(float);
// 设置滑动手势长度缩放比例

获取滑动手势的长度缩放比例

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getSwipeLengthScale();
// 获取滑动手势的长度缩放比例

获取当前WiFi扫描列表

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().getWifiScanResults();
// 获取当前WiFi扫描列表

取消(停止)指定执行中的任务

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().cancelJobs(List);
// 取消(停止)指定执行中的任务

执行JS代码

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().executeJS('js代码', 0);
// 执行JS代码
/*
Default    → 0
IO         → 1
UI         → 2
*/

执行MVEL表达式

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().executeMVEL('mvel代码', 0);
// 执行MVEL表达式
/*
Default    → 0
IO         → 1
UI         → 2
*/

执行系统Shell命令

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().executeShellCommand(String, ICallback);
// 执行系统Shell命令
// 返回命令取消信号；参数1为完整Shell命令，参数2为命令执行回调

执行HTTP网络请求

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().executeHttpRequest(ByteArrayWrapper);
// 执行HTTP网络请求

执行指定自动指令的绑定动作

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().directExecuteRuleActions(ByteArrayWrapper, String);
// 跳过条件判断，执行指定自动指令的绑定动作
// 参数1为上下文数据封装，参数2为目标规则ID

执行指定动作

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().executeAction(ByteArrayWrapper, ByteArrayWrapper, ByteArrayWrapper);
// 执行指定动作
// 猜测参数1为动作配置，参数2为上下文数据，参数3为附加参数（如延迟时间）

执行单条自动动作

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().executeActionBlocking(ByteArrayWrapper, ByteArrayWrapper);
// 阻塞式(同步)执行单条自动动作（完成后再执行后续操作）
// 参数1为动作配置，参数2为上下文数据

执行指定自动指令

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().executeDirectionAction(ByteArrayWrapper, ByteArrayWrapper, ByteArrayWrapper);
// 执行指定自动指令
// 参数1为指令配置，参数2为上下文，参数3为附加参数

执行指定一键指令

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().executeDirectionActionById(ByteArrayWrapper, String);
// 执行指定一键指令
// 参数1为上下文数据，参数2为自动指令唯一ID

执行指定代码库片段

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().executeCodeLibraryItem(String, int);
// 执行指定代码库片段

开始录制手势

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().startGestureRecording();
// 开始录制手势

停止手势录制

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().stopGestureRecording(boolean);
// 停止手势录制
// 参数为布尔值，true=保存录制、false=放弃

停止当前音频录制

Packages.tornaco.apps.shortx.core.OooO0O0.OooO00o().stopAudioRecording();
// 停止当前音频录制

获取所有应用集名称

importClass(Packages.tornaco.apps.shortx.core.OooO0O0);
importClass(Packages.tornaco.apps.shortx.core.proto.pkgset.PkgSet);

function getByteData(wrapper) {
    if (!wrapper) return null;
    try { return wrapper.getClass().getMethod("getByteData").invoke(wrapper); } catch(e) {}
    try { var f = wrapper.getClass().getDeclaredField("byteData"); f.setAccessible(true); return f.get(wrapper); } catch(e) {}
    return null;
}

function parsePkgSetFromBytes(bytes) {
    try { return PkgSet.parseFrom(bytes); } catch(e) { return null; }
}

var iShortX = OooO0O0.OooO00o();

var resultList = iShortX.getAllPkgSets(false);
var labels = [];

for (var i = 0; resultList && i < resultList.size(); i++) {
    var wrapper = resultList.get(i);
    var bytes = getByteData(wrapper);
    if (!bytes) continue;
    var pkgSet = parsePkgSetFromBytes(bytes);
    if (!pkgSet) continue;

    var setLabel = pkgSet.getLabel ? pkgSet.getLabel() : null;
    if (setLabel) labels.push(setLabel);
}

labels.join("\n");

判断指定应用集是否存在

importClass(Packages.tornaco.apps.shortx.core.OooO0O0);
importClass(Packages.tornaco.apps.shortx.core.proto.pkgset.PkgSet);

// =================== 工具函数 ===================
function getByteData(wrapper) {
    if (!wrapper) return null;
    try { return wrapper.getClass().getMethod("getByteData").invoke(wrapper); } catch(e) {}
    try { var f = wrapper.getClass().getDeclaredField("byteData"); f.setAccessible(true); return f.get(wrapper); } catch(e) {}
    return null;
}

function parsePkgSetFromBytes(bytes) {
    try { return PkgSet.parseFrom(bytes); } catch(e) { return null; }
}

// =================== 查询指定应用集合名是否存在 ===================
function findLabel(targetLabel) {
    var iShortX = OooO0O0.OooO00o();
    var result = iShortX.getPkgSetByLabel(targetLabel);

    if (result) {
        var bytes = getByteData(result);
        if (!bytes) return false;
        var pkgSet = parsePkgSetFromBytes(bytes);
        return pkgSet ? true : false;
    }
    
    return false; // 如果没有找到对应的集合，返回 false
}

// =================== 使用示例 ===================
var target = "Proxy"; // 要查询的应用集合名
findLabel(target); // true 或 false

获取指定应用集数据

importClass(Packages.tornaco.apps.shortx.core.OooO0O0);
importClass(Packages.tornaco.apps.shortx.core.proto.pkgset.PkgSet);
importClass(java.io.ByteArrayInputStream);

function getByteData(wrapper) {
    if (!wrapper) return null;
    try { return wrapper.getClass().getMethod("getByteData").invoke(wrapper); } catch(e) {}
    try { var f = wrapper.getClass().getDeclaredField("byteData"); f.setAccessible(true); return f.get(wrapper); } catch(e) {}
    return null;
}

function parsePkgSetFromBytes(bytes) {
    try { return PkgSet.parseFrom(bytes); } catch(e) { return null; }
}

var iShortX = OooO0O0.OooO00o();
var installedMap = {};
var installed = iShortX.getInstalledApps();
for (var i = 0; installed && i < installed.size(); i++) {
    var w = installed.get(i);
    var bd = getByteData(w);
    if (!bd) continue;
    var ps = parsePkgSetFromBytes(bd);
    if (!ps) continue;
    var setLabel = ps.getLabel ? ps.getLabel() : null;
    var list = ps.getAppPkgsList();
    for (var j = 0; j < list.size(); j++) {
        var ap = list.get(j);
        var pName = ap.getPkgName ? ap.getPkgName() : null;
        if (!pName) continue;
        var apLabel = ap.getLabel ? ap.getLabel() : setLabel;
        installedMap[pName] = apLabel || pName;
    }
}

function getAppsByLabel(targetLabel) {
    var output = [];
    var result = iShortX.getPkgSetByLabel(targetLabel);

    if (result) {
        var bytes = getByteData(result);
        if (!bytes) return output;
        var pkgSet = parsePkgSetFromBytes(bytes);
        if (!pkgSet) return output;

        var setLabel = pkgSet.getLabel ? pkgSet.getLabel() : null;
        var list = pkgSet.getAppPkgsList();
        for (var j = 0; j < list.size(); j++) {
            var ap = list.get(j);
            var pName = ap.getPkgName ? ap.getPkgName() : null;
            if (!pName) continue;
            var finalName = installedMap[pName] || (ap.getLabel ? ap.getLabel() : setLabel) || pName;
            output.push({
                name: finalName,
                version: pName,
                __value: pName,
                __icon: "app://" + pName
            });
        }
    }

    return output;
}

var targetLabel = "User"; // 你想要查找的应用集名
JSON.stringify(getAppsByLabel(targetLabel), null, 2);

获取指定应用集内应用是否存在

importClass(Packages.tornaco.apps.shortx.core.OooO0O0);
importClass(Packages.tornaco.apps.shortx.core.proto.pkgset.PkgSet);
importClass(java.io.ByteArrayInputStream);

function getByteData(wrapper) {
    if (!wrapper) return null;
    try { return wrapper.getClass().getMethod("getByteData").invoke(wrapper); } catch(e) {}
    try { var f = wrapper.getClass().getDeclaredField("byteData"); f.setAccessible(true); return f.get(wrapper); } catch(e) {}
    return null;
}

function parsePkgSetFromBytes(bytes) {
    try { return PkgSet.parseFrom(bytes); } catch(e) { return null; }
}

var iShortX = OooO0O0.OooO00o();
var installedMap = {};
var installed = iShortX.getInstalledApps();
for (var i = 0; installed && i < installed.size(); i++) {
    var w = installed.get(i);
    var bd = getByteData(w);
    if (!bd) continue;
    var ps = parsePkgSetFromBytes(bd);
    if (!ps) continue;
    var setLabel = ps.getLabel ? ps.getLabel() : null;
    var list = ps.getAppPkgsList();
    for (var j = 0; j < list.size(); j++) {
        var ap = list.get(j);
        var pName = ap.getPkgName ? ap.getPkgName() : null;
        if (!pName) continue;
        var apLabel = ap.getLabel ? ap.getLabel() : setLabel;
        installedMap[pName] = apLabel || pName;
    }
}

// =================== 查找指定应用集名及应用包名 ===================
function findAppInPkgSet(targetLabel, targetPackageName) {
    var result = iShortX.getPkgSetByLabel(targetLabel);

    if (result) {
        var bytes = getByteData(result);
        if (!bytes) return false;
        var pkgSet = parsePkgSetFromBytes(bytes);
        if (!pkgSet) return false;

        // 遍历当前应用集中的所有应用包名
        var list = pkgSet.getAppPkgsList();
        for (var j = 0; j < list.size(); j++) {
            var ap = list.get(j);
            var pName = ap.getPkgName ? ap.getPkgName() : null;
            if (!pName) continue;

            // 如果找到了目标包名，立即返回 true
            if (pName == targetPackageName) {
                return true;
            }
        }
    }

    return false; // 如果没有找到指定应用包名，返回 false
}

var targetLabel = "User"; // 你想要查找的应用集名
var targetPackageName = "tornaco.apps.shortx"; // 你想要查找的应用包名
findAppInPkgSet(targetLabel, targetPackageName);  
// 返回布尔值 (true 或 false)

获取设备所有已安装App数据

importClass(Packages.tornaco.apps.shortx.core.OooO0O0);
importClass(Packages.tornaco.apps.shortx.core.proto.pkgset.PkgSet);
importClass(java.io.ByteArrayInputStream);

var result = [];
var iShortX = OooO0O0.OooO00o();
var pkgManager = iShortX.getInstalledApps();

for (var i = 0; i < pkgManager.size(); i++) {
    var wrapper = pkgManager.get(i);
    var byteData = wrapper.getByteData();
    var byteStream = new ByteArrayInputStream(byteData);
    var pkgSet = PkgSet.parseFrom(byteStream);

    var applabel = pkgSet.getLabel();
    var appPkgsList = pkgSet.getAppPkgsList();

    for (var j = 0; j < appPkgsList.size(); j++) {
        var appPkg = appPkgsList.get(j);
        var packageName = appPkg.getPkgName ? appPkg.getPkgName() : (typeof appPkg === "string" ? appPkg : "");

        result.push({
            name: applabel,
            version: packageName,
            __value: packageName,
            __icon: "app://" + packageName
        });
    }
}

JSON.stringify(result, null, 2);

获取所有全局变量数据

importPackage(Packages.tornaco.apps.shortx.core.proto.gv);
importClass(Packages.tornaco.apps.shortx.core.OooO0O0);
importClass(Packages.com.google.protobuf.Any);

function unpackAny(anyVar) {
    if (!anyVar) return null;
    try {
        var mapping = {
            "Int64Var": Int64Var,
            "StringVar": StringVar,
            "BoolVar": BoolVar,
            "StringListVar": StringListVar,
            "Int64ListVar": Int64ListVar,
            "BoolListVar": BoolListVar,
            "GlobalVarCreatedBy_Rule": GlobalVarCreatedBy_Rule,
            "GlobalVarCreatedBy_User": GlobalVarCreatedBy_User
        };
        for (var key in mapping) {
            var cls = mapping[key];
            if (anyVar.is(cls)) {
                var parsed = cls.parseFrom(anyVar.getValue());
                if (key === "GlobalVarCreatedBy_Rule") return { type: key, value: { srcId: parsed.getSrcId() } };
                if (key === "GlobalVarCreatedBy_User") return { type: key, value: {} };
                if (key.indexOf("ListVar") >= 0) return { type: key, value: parsed.getValuesList().toArray() };
                return { type: key, value: parsed.getValue() };
            }
        }
        return { type: anyVar.getTypeUrl(), value: anyVar.toString() };
    } catch (e) {
        return { type: "Error", value: "解包失败: " + e };
    }
}

function getByteData(wrapper) {
    if (!wrapper) return null;
    try { return wrapper.getClass().getMethod("getByteData").invoke(wrapper); } catch(e) {}
    try { var f = wrapper.getClass().getDeclaredField("byteData"); f.setAccessible(true); return f.get(wrapper); } catch(e) {}

    for (var i = 0; i < methods.length; i++) {
        try { var r = wrapper.getClass().getMethod(methods[i]).invoke(wrapper); if (r instanceof Array) return r; } catch(e) {}
    }
    return null;
}

// =================== 获取 ShortX 全局变量 ===================
var output = [];
try {
    var iShortX = OooO0O0.OooO00o();
    var vars = iShortX.getAllGlobalVars();
    for (var i = 0; i < vars.size(); i++) {
        try {
            var byteData = getByteData(vars.get(i));
            if (!byteData) { output.push({error:"第"+i+"个变量字节数据为 null"}); continue; }

            var gv = GlobalVar.parseFrom(byteData);
            var varObj = unpackAny(gv.getVar());
            var typeObj = unpackAny(gv.getType());
            var createdByObj = unpackAny(gv.getCreatedBy());

            output.push({
                name: gv.getName(),
                value: varObj ? varObj.value : null,
                type: typeObj ? typeObj.type : null,
                isSecret: gv.getIsSecret(),
                note: gv.getNote(),
                createdBy: createdByObj ? createdByObj.value : null
            });
        } catch(e) {
            output.push({error:"解析第"+i+"个变量失败: "+e.toString()});
        }
    }
} catch(e) {
    output.push({error:"脚本执行失败: "+e.toString()});
}

JSON.stringify(output,null,2);

获取HTTP请求日志内容

importClass(Packages.tornaco.apps.shortx.core.OooO0O0);
importPackage(Packages.java.io);
importClass(Packages.java.nio.charset.Charset);

var iShortX = OooO0O0.OooO00o();

// 获取HTTP请求日志的ParcelFileDescriptor
var Httplog = iShortX.getHttpRequestLogFD();

// 获取底层的FileDescriptor
var fileDescriptor = Httplog.getFileDescriptor();
// 创建FileInputStream来读取FileDescriptor
var fileInputStream = new FileInputStream(fileDescriptor);
// 创建Java字节数组（byte[]）
var buffer = new java.lang.reflect.Array.newInstance(Packages.java.lang.Byte.TYPE, 1024);
// 读取数据
var bytesRead = fileInputStream.read(buffer);
// 将字节数组转换为字符串输出
var logContent = "";
if (bytesRead > 0) {
    logContent = new java.lang.String(buffer, 0, bytesRead, Charset.forName("UTF-8"));
}
logContent;

获取JS代码执行日志内容

importClass(Packages.tornaco.apps.shortx.core.OooO0O0);
importPackage(Packages.java.io);
importClass(Packages.java.nio.charset.Charset);

var iShortX = OooO0O0.OooO00o();
// 获取JS日志的ParcelFileDescriptor
var Jslog = iShortX.getJSLogFD();
// 获取底层的FileDescriptor
var fileDescriptor = Jslog.getFileDescriptor();
// 创建FileInputStream来读取FileDescriptor
var fileInputStream = new FileInputStream(fileDescriptor);
// 创建Java字节数组（byte[]）
var buffer = new java.lang.reflect.Array.newInstance(Packages.java.lang.Byte.TYPE, 1024);
// 读取数据
var bytesRead = fileInputStream.read(buffer);
// 将字节数组转换为字符串输出
var logContent = "";
if (bytesRead > 0) {
    logContent = new java.lang.String(buffer, 0, bytesRead, Charset.forName("UTF-8"));
}
logContent;

新增应用集数据

importClass(Packages.tornaco.apps.shortx.core.rule.action.ByteArrayWrapper);
importClass(Packages.tornaco.apps.shortx.core.proto.pkgset.PkgSet);
importClass(Packages.tornaco.apps.shortx.core.proto.common.AppPkg);
importClass(Packages.tornaco.apps.shortx.core.OooO0O0);

// 创建一个应用集合名称为 "测试应用集合" 并设置相同的 userId（为0）
var appPkgNames = [
    "com.yangdai.opennote",
    "com.github.android",
    "FPS.Watcher"
];

var pkgSetBuilder = PkgSet.newBuilder()
    .setLabel("测试应用集合")           // 设置应用集合名称
    .setDescription("")
    .setIsPrebuilt(false);

// 创建多个 AppPkg 对象并添加到 PkgSet 中
for (var i = 0; i < appPkgNames.length; i++) {
    var appPkg = AppPkg.newBuilder()
        .setPkgName(appPkgNames[i])    // 设置每个应用的包名
        .setUserId(0)                  // 设置 userId 为 0
        .build();
    pkgSetBuilder.addAppPkgs(appPkg);   // 将应用包添加到 PkgSet 中
}
// 构建 PkgSet
var pkgSet = pkgSetBuilder.build();

// 将 PkgSet 转换为字节数据
var byteData = pkgSet.toByteArray();

// 将字节数据封装为 ByteArrayWrapper
var byteArrayWrapper = new ByteArrayWrapper(byteData);
// 调用 addPkgSet 方法来添加该 ByteArrayWrapper
var iShortX = OooO0O0.OooO00o();
iShortX.addPkgSet(byteArrayWrapper);

指定App添加动态快捷方式

// 给指定应用指定用户动态快捷方式添加指定Intent URI
importClass(android.content.Context);
importClass(android.content.pm.ShortcutInfo);
importClass(android.graphics.drawable.Icon);
importClass(android.content.Intent);
importClass(android.os.ServiceManager);
importClass(android.content.pm.ParceledListSlice);
importClass(java.util.ArrayList);
importClass(android.os.UserHandle);

// ===== 目标包名 =====
var targetPackage = "tornaco.apps.shortx";

// ===== 指定要写入的 Intent URI =====
var intentUri = `intent:#Intent;action=com.tmessages.openchat0;component=org.telegram.messenger/.OpenChatReceiver;l.chatId=1604486631;end`;

try {
    var context = context.createPackageContext(targetPackage,Context.CONTEXT_IGNORE_SECURITY);
    
    var targetIntent = Intent.parseUri(intentUri, 0);
    targetIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    
    // ===== 新快捷方式ID =====
    var shortcutId = "shortcut_00001";

    var newShortcut = new ShortcutInfo.Builder(context, shortcutId)
        // 快捷方式 桌面显示名称
        .setShortLabel("ShortX群组")
        // 长名称
        .setLongLabel("ShortX群组")
        .setIcon(
            Icon.createWithResource(
                context,
                context.getApplicationInfo().icon
            )
        )
        .setIntent(targetIntent)
        .build();

    // 创建 ParceledListSlice 包装的快捷方式信息列表
    var shortcutInfoList = new ArrayList();
    shortcutInfoList.add(newShortcut);

    // 获取到 "shortcut" 服务
    var shortcutService = ServiceManager.getService("shortcut");

    if (shortcutService) {
        // 使用 addDynamicShortcuts 方法添加动态快捷方式
        shortcutService.addDynamicShortcuts(targetPackage, new ParceledListSlice(shortcutInfoList), 0);
    } else {
        throw "Shortcut 服务不可用";
    }

    shortcutId;
} catch (e) {
    "写入失败: " + e;
}

从指定App中移除指定ID的动态快捷方式

android.os.ServiceManager.getService("shortcut").removeDynamicShortcuts("tornaco.apps.shortx", ["shortcut_00001"], 0);
// 从指定App中移除指定ID的动态快捷方式

清空指定App的所有动态快捷方式

android.os.ServiceManager.getService("shortcut").removeAllDynamicShortcuts("tornaco.apps.shortx", 0);
// 清空指定App的所有动态快捷方式

将指定APP快捷方式请求固定桌面

Intent = android.content.Intent;

targetPackage = "tornaco.apps.shortx";

// 创建一个 Intent
intentUri = `intent:#Intent;action=com.tmessages.openchat0;component=org.telegram.messenger/.OpenChatReceiver;l.chatId=1604486631;end`;

targetIntent = Intent.parseUri(intentUri, 0);
    targetIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    
context = context.createPackageContext(targetPackage, 2);

// 创建一个 ShortcutInfo
shortcut = android.content.pm.ShortcutInfo.Builder(context, "shortcut_001")
        // 快捷方式 桌面显示名称
        .setShortLabel("ShortX群组")
        // 长名称
        .setLongLabel("ShortX群组")
        .setIcon(
            android.graphics.drawable.Icon.createWithResource(
                context,
                context.getApplicationInfo().icon
            )
        )
        .setIntent(targetIntent)
        .build();
shortcutService = android.os.ServiceManager.getService("shortcut").requestPinShortcut(targetPackage, shortcut, null, 0);

获取指定App的所有快捷方式信息

// 获取指定App的所有快捷方式信息
targetPackage = "tornaco.apps.shortx";

// 1. 获取 ShortcutService 的 IBinder
var shortcutService = android.os.ServiceManager.getService("shortcut");
if (!shortcutService) {
    throw "无法获取 shortcut 服务";
}
// ==================== 主流程 ====================
var MATCH_ALL = 0x0000000F; // MATCH_MANIFEST (1) | MATCH_DYNAMIC (2) | MATCH_PINNED (4) | MATCH_CACHED (8)

var slice = shortcutService.getShortcuts(targetPackage, MATCH_ALL, userId);
var shortcutList = slice.getList();

var result = [];

if (shortcutList && shortcutList.size() > 0) {
    for (var i = 0; i < shortcutList.size(); i++) {
        var shortcutItem = shortcutList.get(i);  // 获取每个快捷方式
        
        // 反射所有字段
        var fields = shortcutItem.getClass().getDeclaredFields();
        var shortcut = {};

        // 遍历字段并输出字段名及其值
        for (var j = 0; j < fields.length; j++) {
            var field = fields[j];
            field.setAccessible(true); // 允许访问私有字段
            try {
                var fieldName = field.getName();  // 获取字段名
                var fieldValue = field.get(shortcutItem);  // 获取字段值
                
                // 将字段名和值加入到结果中
                shortcut[fieldName] = fieldValue ? fieldValue.toString() : "null";
            } catch (e) {
                shortcut[fieldName] = "无法获取值";
            }
        }
        
        result.push(shortcut); // 添加到结果数组
    }
}

// 输出结果
JSON.stringify(result, null, 2);

获取指定用户的默认主屏启动器包名

android.os.ServiceManager.getService("shortcut").getDefaultLauncher(0);
// 获取指定用户的默认主屏启动器包名

解锁

android.os.ServiceManager.getService("window").dismissKeyguard(null, null);
// 其实就是Xposed Edge中的解锁动作

输出附件所有的WiFi名称

// 输出附件所有的WiFi名称
scanResults = context.getSystemService("wifi").getScanResults();

// 使用HashSet保证SSID唯一性
uniqueSSIDs = new java.util.HashSet();

for (var i = 0; i < scanResults.size(); i++) {
     result = scanResults.get(i);
    uniqueSSIDs.add(result.SSID); 
}

wifiInfo = "";
iterator = uniqueSSIDs.iterator();
while (iterator.hasNext()) {
    wifiInfo += iterator.next() + "\n";  // 拼接SSID
}

wifiInfo;

输出所有的WiFi Mac地址

// 输出所有的WiFi Mac地址
var scanResults = context.getSystemService("wifi").getScanResults();

// 使用HashSet保证BSSID唯一性
uniqueBSSIDs = new java.util.HashSet();

for (var i = 0; i < scanResults.size(); i++) {
    var result = scanResults.get(i);
    uniqueBSSIDs.add(result.BSSID);  // 只加入BSSID
}

bssidInfo = "";
iterator = uniqueBSSIDs.iterator();
while (iterator.hasNext()) {
    bssidInfo += iterator.next() + "\n";  // 拼接BSSID (Mac地址)
}

bssidInfo;

触发WiFi扫描

context.getSystemService("wifi").startScan();  
 // 触发WiFi扫描

设置强身份验证（禁用生物验证）

// 即单次禁用生物识别(人脸、指纹等)
android.os.ServiceManager.getService("lock_settings").requireStrongAuth(32, 0);
// (int strongAuthReason, int userId)

/*
strongAuthReason 
0 - 不需要强身份验证
1 - 设备启动后需要强身份验证
2 - 设备管理器锁定后需要强身份验证
8 - 设备锁定后需要强身份验证
16 - 超时后需要强身份验证
32 - 用户锁定后需要强身份验证
64 - 无人值守更新时需要强身份验证
128 - 非强生物识别超时后需要强身份验证
256 - 信任代理过期后需要某种身份验证
512 - 适应性认证请求后需要某种身份验证
772 - 允许生物识别身份验证
*/

静默卸载指定用户指定应用

// 静默卸载指定用户指定应用
packageManager = android.os.ServiceManager.getService("package");
packageName = "com.google.android.apps.photos";
userid = 0;
// 获取版本号
version = packageManager.getPackageInfo(packageName, 128, userid).versionCode;

packageManager.deletePackageAsUser(packageName, version, null, userid, 2);

// (String packageName, int versionCode, IPackageDeleteObserver observer, int userId, int flags)
/*
Deletion Flags
1 - 删除应用但保留数据
2 - 删除所有用户的数据
4 - 允许删除系统应用
8 - 删除但不杀死应用进程
16 - 存档应用（而非完全删除）
*/