androidシステムapiツールクラス
47428 ワード
public class SystemManager {
private static final String TAG = "fly235";
/**
* op ， AppOpsManager
*/
public static final int OP_NONE = -1;
public static final int OP_COARSE_LOCATION = 0;
public static final int OP_FINE_LOCATION = 1;
public static final int OP_GPS = 2;
public static final int OP_VIBRATE = 3;
public static final int OP_READ_CONTACTS = 4;
public static final int OP_WRITE_CONTACTS = 5;
public static final int OP_READ_CALL_LOG = 6;
public static final int OP_WRITE_CALL_LOG = 7;
public static final int OP_READ_CALENDAR = 8;
public static final int OP_WRITE_CALENDAR = 9;
public static final int OP_WIFI_SCAN = 10;
public static final int OP_POST_NOTIFICATION = 11;
public static final int OP_NEIGHBORING_CELLS = 12;
public static final int OP_CALL_PHONE = 13;
public static final int OP_READ_SMS = 14;
public static final int OP_WRITE_SMS = 15;
public static final int OP_RECEIVE_SMS = 16;
public static final int OP_RECEIVE_EMERGECY_SMS = 17;
public static final int OP_RECEIVE_MMS = 18;
public static final int OP_RECEIVE_WAP_PUSH = 19;
public static final int OP_SEND_SMS = 20;
public static final int OP_READ_ICC_SMS = 21;
public static final int OP_WRITE_ICC_SMS = 22;
public static final int OP_WRITE_SETTINGS = 23;
public static final int OP_SYSTEM_ALERT_WINDOW = 24;
public static final int OP_ACCESS_NOTIFICATIONS = 25;
public static final int OP_CAMERA = 26;
public static final int OP_RECORD_AUDIO = 27;
public static final int OP_PLAY_AUDIO = 28;
public static final int OP_READ_CLIPBOARD = 29;
public static final int OP_WRITE_CLIPBOARD = 30;
public static final int OP_TAKE_MEDIA_BUTTONS = 31;
public static final int OP_TAKE_AUDIO_FOCUS = 32;
public static final int OP_AUDIO_MASTER_VOLUME = 33;
public static final int OP_AUDIO_VOICE_VOLUME = 34;
public static final int OP_AUDIO_RING_VOLUME = 35;
public static final int OP_AUDIO_MEDIA_VOLUME = 36;
public static final int OP_AUDIO_ALARM_VOLUME = 37;
public static final int OP_AUDIO_NOTIFICATION_VOLUME = 38;
public static final int OP_AUDIO_BLUETOOTH_VOLUME = 39;
public static final int OP_WAKE_LOCK = 40;
public static final int OP_MONITOR_LOCATION = 41;
public static final int OP_MONITOR_HIGH_POWER_LOCATION = 42;
public static final int OP_GET_USAGE_STATS = 43;
public static final int OP_MUTE_MICROPHONE = 44;
public static final int OP_TOAST_WINDOW = 45;
public static final int OP_PROJECT_MEDIA = 46;
public static final int OP_ACTIVATE_VPN = 47;
public static final int OP_WRITE_WALLPAPER = 48;
public static final int OP_ASSIST_STRUCTURE = 49;
public static final int OP_ASSIST_SCREENSHOT = 50;
public static final int OP_READ_PHONE_STATE = 51;
public static final int OP_ADD_VOICEMAIL = 52;
public static final int OP_USE_SIP = 53;
public static final int OP_PROCESS_OUTGOING_CALLS = 54;
public static final int OP_USE_FINGERPRINT = 55;
public static final int OP_BODY_SENSORS = 56;
public static final int OP_READ_CELL_BROADCASTS = 57;
public static final int OP_MOCK_LOCATION = 58;
public static final int OP_READ_EXTERNAL_STORAGE = 59;
public static final int OP_WRITE_EXTERNAL_STORAGE = 60;
public static final int OP_TURN_SCREEN_ON = 61;
public static final int OP_GET_ACCOUNTS = 62;
public static final int OP_RUN_IN_BACKGROUND = 63;
public static final int OP_AUDIO_ACCESSIBILITY_VOLUME = 64;
public static final int OP_READ_PHONE_NUMBERS = 65;
public static final int OP_REQUEST_INSTALL_PACKAGES = 66;
public static final int OP_PICTURE_IN_PICTURE = 67;
public static final int OP_INSTANT_APP_START_FOREGROUND = 68;
public static final int OP_ANSWER_PHONE_CALLS = 69;
public static final int STATUS_SUCCESS = 0;
public static final int STATUS_FAILURE = 1;
public static final String USB_FUNCTION_NONE = "none";
public static final String USB_FUNCTION_ADB = "adb";
public static final String USB_FUNCTION_RNDIS = "rndis";
public static final String USB_FUNCTION_MTP = "mtp";
public static final String USB_FUNCTION_PTP = "ptp";
public static final int ERROR_COMPONENT_STATE = -1;
private static final int INSTALL_SUCCEEDED = 1;
private static final int DELETE_SUCCEEDED = 1;
private static final int INSTALL_REPLACE_EXISTING = 0x00000002;
private static final int DELETE_SYSTEM_APP = 0x00000004;
private static final int OP_MODE_INVALID = -1;
private static final String ACTION_MASTER_CLEAR = "android.intent.action.MASTER_CLEAR";
private static final String EXTRA_REASON = "android.intent.extra.REASON";
private static final String EXTRA_WIPE_EXTERNAL_STORAGE = "android.intent.extra.WIPE_EXTERNAL_STORAGE";
private static final String ACTION_FACTORY_RESET = "android.intent.action.FACTORY_RESET"; //8.0
private static final int STATUS_BAR_DISABLE_EXPAND = 0x00010000;
private Context mContext;
private Handler mHandler;
public SystemManager(Context context) {
this.mContext = context;
}
/**
*
*
* @param packageName
* @param permissions
* @return
*/
public SystemManager allowPermission(String packageName, String... permissions) {
if (permissions == null || permissions.length == 0) return this;
if (!needRuntimePermission()) return this;
for (String permission : permissions) {
allowPermissionInner(packageName, permission);
}
return this;
}
public SystemManager allowPermission(String packageName, Collection permissions) {
if (permissions == null || permissions.isEmpty()) return this;
String[] array = new String[permissions.size()];
permissions.toArray(array);
return allowPermission(packageName, array);
}
/**
*
*
* @param packageName
* @param permissions
* @return
*/
public SystemManager denyPermission(String packageName, String... permissions) {
if (permissions == null || permissions.length == 0) return this;
if (!needRuntimePermission()) return this;
for (String permission : permissions) {
denyPermissionInner(packageName, permission);
}
return this;
}
public SystemManager denyPermission(String packageName, Collection permissions) {
if (permissions == null || permissions.isEmpty()) return this;
String[] array = new String[permissions.size()];
permissions.toArray(array);
return denyPermission(packageName, array);
}
/**
*
*
* @param packageName
* @param permissions
* @return
*/
public boolean isPermissionAllowed(String packageName, String... permissions) {
if (permissions == null || permissions.length == 0) return true;
if (!needRuntimePermission()) return true;
Set mDeniedPermissionList = getDeniedPermissionList(packageName, permissions);
return mDeniedPermissionList.isEmpty();
}
/**
* OP
*
* @param packageName
* @param opCode
* @param mode
* @return
*/
public SystemManager setOpMode(String packageName, int opCode, int mode) {
try {
Method method = AppOpsManager.class.getMethod("setMode", int.class, int.class, String.class, int.class);
AppOpsManager mAppOps = (AppOpsManager) mContext.getSystemService(Service.APP_OPS_SERVICE);
method.invoke(mAppOps, opCode, getPackageUid(packageName), packageName, mode);
} catch (Exception e) {
printError(e);
}
return this;
}
/**
* OP
*
* @param packageName
* @param opCode
* @return
*/
public SystemManager allowOp(String packageName, int opCode) {
setOpMode(packageName, opCode, AppOpsManager.MODE_ALLOWED);
return this;
}
/**
* OP
*
* @param packageName
* @param opCode
* @return
*/
public SystemManager denyOp(String packageName, int opCode) {
setOpMode(packageName, opCode, AppOpsManager.MODE_IGNORED);
return this;
}
/**
* OP
*
* @param packageName
* @param opCode
* @return
*/
public boolean isOpAllowed(String packageName, int opCode) {
return getOpMode(packageName, opCode) == AppOpsManager.MODE_ALLOWED;
}
/**
* OP
*
* @param packageName
* @param opCode
* @return
*/
public int getOpMode(String packageName, int opCode) {
try {
Object object = mContext.getSystemService(Context.APP_OPS_SERVICE);
if (object == null) {
return AppOpsManager.MODE_ALLOWED;
}
Class localClass = object.getClass();
Class[] arrayOfClass = new Class[3];
arrayOfClass[0] = Integer.TYPE;
arrayOfClass[1] = Integer.TYPE;
arrayOfClass[2] = String.class;
Method method = localClass.getMethod("checkOpNoThrow", arrayOfClass);
if (method == null) {
return OP_MODE_INVALID;
}
Object[] arrayOfObject = new Object[3];
arrayOfObject[0] = Integer.valueOf(opCode);
arrayOfObject[1] = Integer.valueOf(getPackageUid(packageName));
arrayOfObject[2] = packageName;
int m = ((Integer) method.invoke(object, arrayOfObject)).intValue();
print("m=" + m);
return m;
} catch (Exception e) {
e.printStackTrace();
printError(e);
}
return OP_MODE_INVALID;
}
/**
*
*
* @param packageName
* @return
*/
public SystemManager allowDrawOverlays(String packageName, boolean isAllow) {
if (needRuntimePermission()) {
setOpState(packageName, OP_SYSTEM_ALERT_WINDOW, isAllow);
}
return this;
}
/**
*
*
* @param packageName
* @return
*/
public boolean isDrawOverlaysAllowed(String packageName) {
return isOpAllowed(packageName, OP_SYSTEM_ALERT_WINDOW);
}
/**
*
*
* @param packageName
* @return
*/
public SystemManager allowWriteSettings(String packageName, boolean isAllow) {
if (needRuntimePermission()) {
setOpState(packageName, OP_WRITE_SETTINGS, isAllow);
}
return this;
}
/**
*
*
* @param packageName
* @return
*/
public boolean isWriteSettingsAllowed(String packageName) {
return isOpAllowed(packageName, OP_WRITE_SETTINGS);
}
/**
*
*
* @param packageName
* @return
*/
public SystemManager allowUsageStats(String packageName, boolean isAllow) {
setOpState(packageName, OP_GET_USAGE_STATS, isAllow);
return this;
}
/**
*
*
* @param packageName
* @return
*/
public boolean isUsageStatsAllowed(String packageName) {
return isOpAllowed(packageName, OP_GET_USAGE_STATS);
}
/**
*
*
* @param packageName
* @return
*/
public SystemManager allowProjectMedia(String packageName, boolean isAllow) {
setOpState(packageName, OP_PROJECT_MEDIA, isAllow);
return this;
}
/**
*
*
* @param packageName
* @return
*/
public boolean isProjectMediaAllowed(String packageName) {
return isOpAllowed(packageName, OP_PROJECT_MEDIA);
}
/**
*
*
* @param packageName
* @param className
* @param allow
* @return
*/
public SystemManager allowAccessibility(String packageName, String className, boolean allow) {
if (!isSupportAccessibility()) return this;
boolean hasService = isAccessibilityServiceEnabled(packageName, className);
String srcServiceName = Settings.Secure.getString(mContext.getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES);
String myServiceName = packageName + "/" + className;
if (allow) {
if (!hasService) {
int enabled = 0;
try {
enabled = Settings.Secure.getInt(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED);
} catch (Settings.SettingNotFoundException e) {
e.printStackTrace();
}
if (enabled == 0) {
try {
Settings.Secure.putInt(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 1);
} catch (Exception e) {
e.printStackTrace();
}
}
if (srcServiceName == null || srcServiceName.trim().isEmpty()) {
srcServiceName = myServiceName;
} else {
srcServiceName = srcServiceName + ":" + myServiceName;
}
try {
Settings.Secure.putString(mContext.getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES, makeSettingsValue(srcServiceName));
} catch (Exception e) {
e.printStackTrace();
}
}
} else {
if (hasService) {
if (srcServiceName.equals(myServiceName)) {
srcServiceName = "";
} else {
if (srcServiceName.endsWith(myServiceName)) {
srcServiceName = srcServiceName.replace(":" + myServiceName, "");
} else {
srcServiceName = srcServiceName.replace(myServiceName + ":", "");
}
}
if (srcServiceName.isEmpty()) {
srcServiceName = "\"\"";
}
try {
Settings.Secure.putString(mContext.getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES, makeSettingsValue(srcServiceName));
} catch (Exception e) {
e.printStackTrace();
}
}
}
return this;
}
/**
*
*
* @param service
* @param allow
* @return
*/
public SystemManager allowAccessibility(Class extends AccessibilityService> service, boolean allow) {
allowAccessibility(mContext.getPackageName(), service.getName(), allow);
return this;
}
/**
*
*
* @param service
* @param allow
* @return
*/
public SystemManager allowAccessibility(ComponentName service, boolean allow) {
allowAccessibility(service.getPackageName(), service.getClassName(), allow);
return this;
}
/**
*
*
* @param packageName
* @param className
* @param allow
* @return
*/
public SystemManager allowDeviceAdmin(String packageName, String className, boolean allow) {
allowDeviceAdmin(new ComponentName(packageName, className), allow);
return this;
}
/**
*
*
* @param activeAdmin
* @param allow
* @return
*/
public SystemManager allowDeviceAdmin(Class extends DeviceAdminReceiver> activeAdmin, boolean allow) {
allowDeviceAdmin(new ComponentName(mContext, activeAdmin), allow);
return this;
}
/**
*
*
* @param activeAdmin
* @param allow
* @return
*/
public SystemManager allowDeviceAdmin(ComponentName activeAdmin, boolean allow) {
if (!isSupportDeviceAdmin()) return this;
if (allow) {
try {
Method method = DevicePolicyManager.class.getMethod("setActiveAdmin", ComponentName.class, boolean.class);
DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(Service.DEVICE_POLICY_SERVICE);
method.invoke(dpm, activeAdmin, true);
} catch (Exception e) {
printError(e);
}
} else {
try {
DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(Service.DEVICE_POLICY_SERVICE);
dpm.removeActiveAdmin(activeAdmin);
} catch (Exception e) {
printError(e);
}
}
return this;
}
/**
*
*
* @return
*/
public static boolean isSupportDeviceAdmin() {
return Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO;
}
/**
*
*
* @return
*/
public static boolean isSupportAccessibility() {
return Build.VERSION.SDK_INT >= Build.VERSION_CODES.DONUT;
}
/**
*
*
* @return
*/
public static boolean needRuntimePermission() {
return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M;
}
/**
*
*
* @param pkgName
* @param className
* @return
*/
public boolean isAccessibilityServiceEnabled(String pkgName, String className) {
if (!isSupportAccessibility()) {
return false;
}
if (isEmpty(pkgName) || isEmpty(className)) {
return false;
}
try {
int enabled = Settings.Secure.getInt(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED);
if (enabled == 1) {
String service = Settings.Secure.getString(mContext.getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES);
if (className.startsWith(".")) {
className = pkgName + className;
}
String myServiceName = pkgName + "/" + className;
boolean hasService = service != null && service.contains(myServiceName);
return hasService;
}
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/**
*
*
* @param serviceClass
* @return
*/
public boolean isAccessibilityServiceEnabled(Class extends AccessibilityService> serviceClass) {
return isAccessibilityServiceEnabled(mContext.getPackageName(), serviceClass.getCanonicalName());
}
/**
*
*
* @param service
* @return
*/
public boolean isAccessibilityServiceEnabled(ComponentName service) {
return isAccessibilityServiceEnabled(service.getPackageName(), service.getClassName());
}
/**
*
*
* @param admin
* @return
*/
public boolean isDeviceAdmin(ComponentName admin) {
if (!isSupportDeviceAdmin()) {
return false;
}
DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(Service.DEVICE_POLICY_SERVICE);
return dpm.isAdminActive(admin);
}
/**
*
*
* @param pkgName
* @param className
* @return
*/
public boolean isDeviceAdmin(String pkgName, String className) {
return isDeviceAdmin(new ComponentName(pkgName, className));
}
/**
*
*
* @param receiverClass
* @return
*/
public boolean isDeviceAdmin(Class extends DeviceAdminReceiver> receiverClass) {
return isDeviceAdmin(new ComponentName(mContext, receiverClass));
}
/**
*
*
* @param pkgName
* @return
*/
public boolean setDeviceOwner(String pkgName) {
if (!isSupportDeviceAdmin()) {
return false;
}
ComponentName admin = getDeviceAdminClass(mContext, pkgName);
if (admin == null) {
return false;
}
DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(Service.DEVICE_POLICY_SERVICE);
try {
Method method = dpm.getClass().getMethod("setDeviceOwner", ComponentName.class);
return (boolean) method.invoke(dpm, admin);
} catch (Exception e) {
printError(e);
}
return false;
}
/**
*
*
* @param pkgName
*/
public void removeDeviceOwner(String pkgName) {
DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(Service.DEVICE_POLICY_SERVICE);
try {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
dpm.clearDeviceOwnerApp(pkgName);
}
} catch (Exception e) {
printError(e);
}
}
/**
*
*
* @param pkgName
* @return
*/
public boolean isDeviceOwner(String pkgName) {
if (!isSupportDeviceAdmin()) {
return false;
}
DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(Service.DEVICE_POLICY_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
return dpm.isDeviceOwnerApp(pkgName);
}
return false;
}
/**
*
*
* @param packageName
* @param state PackageManager.COMPONENT_
*/
public boolean setPackageState(String packageName, int state) {
try {
mContext.getPackageManager().setApplicationEnabledSetting(packageName, state, 0);
return true;
} catch (Exception e) {
printError(e);
}
return false;
}
/**
*
*
* @param packageName
* @return
*/
public int getPackageState(String packageName) {
try {
return mContext.getPackageManager().getApplicationEnabledSetting(packageName);
} catch (Exception e) {
printError(e);
}
return ERROR_COMPONENT_STATE;
}
/**
*
*
* @param componentName
* @param state:PackageManager.COMPONENT_
*/
public boolean setComponentState(ComponentName componentName, int state) {
try {
mContext.getPackageManager().setComponentEnabledSetting(componentName, state, 0);
return true;
} catch (Exception e) {
printError(e);
}
return false;
}
/**
*
*
* @param componentName
* @return
*/
public int getComponentState(ComponentName componentName) {
try {
return mContext.getPackageManager().getComponentEnabledSetting(componentName);
} catch (Exception e) {
printError(e);
}
return ERROR_COMPONENT_STATE;
}
/**
*
*
* @param packageName
* @param className
* @param state:PackageManager.COMPONENT_
*/
public boolean setComponentState(String packageName, String className, int state) {
return setComponentState(new ComponentName(packageName, className), state);
}
/**
*
*
* @param packageName
* @param disable
*/
public boolean disablePackage(String packageName, boolean disable) {
return setPackageState(packageName, disable ? PackageManager.COMPONENT_ENABLED_STATE_DISABLED : PackageManager.COMPONENT_ENABLED_STATE_ENABLED);
}
/**
*
*
* @param packageName
* @return
*/
public boolean isPackageDisabled(String packageName) {
int state = getPackageState(packageName);
return state == PackageManager.COMPONENT_ENABLED_STATE_DISABLED
|| state == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER;
}
/**
*
*
* @param componentName
* @param disable
*/
public boolean disableComponent(ComponentName componentName, boolean disable) {
return setComponentState(componentName, disable ? PackageManager.COMPONENT_ENABLED_STATE_DISABLED : PackageManager.COMPONENT_ENABLED_STATE_ENABLED);
}
/**
*
*
* @param packageName
* @param className
* @param disable
*/
public boolean disableComponent(String packageName, String className, boolean disable) {
return disableComponent(new ComponentName(packageName, className), disable);
}
/**
*
*
* @param componentName
* @return
*/
public boolean isComponentDisabled(ComponentName componentName) {
int state = getComponentState(componentName);
return state == PackageManager.COMPONENT_ENABLED_STATE_DISABLED
|| state == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER;
}
/**
*
*
* @param packageName
* @param className
* @return
*/
public boolean isComponentDisabled(String packageName, String className) {
return isComponentDisabled(new ComponentName(packageName, className));
}
/**
*
*
* @param packageName
*/
public void killApplication(String packageName) {
try {
Method method = ActivityManager.class.getMethod("forceStopPackage", String.class);
ActivityManager am = (ActivityManager) mContext.getSystemService(Service.ACTIVITY_SERVICE);
method.invoke(am, packageName);
} catch (Exception e) {
printError(e);
}
}
/**
*
*
* @param packageName
* @return
*/
public boolean clearApplicationData(String packageName) {
boolean isSuccess = false;
IPackageDataObserver.Stub mStub = new IPackageDataObserver.Stub() {
public void onRemoveCompleted(String paramAnonymousString, boolean paramAnonymousBoolean) {
}
};
try {
Method method = ActivityManager.class.getMethod("clearApplicationUserData", String.class, IPackageDataObserver.class);
ActivityManager am = (ActivityManager) mContext.getSystemService(Service.ACTIVITY_SERVICE);
isSuccess = (boolean) method.invoke(am, packageName, mStub);
} catch (Exception e) {
printError(e);
}
return isSuccess;
}
/**
*
*
* @param packageName
*/
public void clearApplicationCache(String packageName) {
IPackageDataObserver.Stub mStub = new IPackageDataObserver.Stub() {
public void onRemoveCompleted(String paramAnonymousString, boolean paramAnonymousBoolean) {
}
};
try {
Method method = PackageManager.class.getMethod("deleteApplicationCacheFiles", String.class, IPackageDataObserver.class);
PackageManager pm = mContext.getPackageManager();
method.invoke(pm, packageName, mStub);
} catch (Exception e) {
printError(e);
}
}
/**
*
*
* @param path
*/
public void installPackage(final String path, final OnPackageInstallListener listener) {
if (Build.VERSION.SDK_INT < 28) {
IPackageInstallObserver.Stub mStub = new IPackageInstallObserver.Stub() {
@Override
public void packageInstalled(String packageName, int returnCode) throws RemoteException {
if (listener != null)
listener.onPackageInstalled(packageName, returnCode == INSTALL_SUCCEEDED ? STATUS_SUCCESS : STATUS_FAILURE);
}
};
try {
Method method = PackageManager.class.getMethod("installPackage", Uri.class, IPackageInstallObserver.class, int.class, String.class);
PackageManager pm = mContext.getPackageManager();
Uri uri = Uri.fromFile(new File(path));
method.invoke(pm, uri, mStub, INSTALL_REPLACE_EXISTING, null);
} catch (Exception e) {
printError(e);
}
} else {
installPackageFromQ(path, listener);
}
}
/**
*
*
* @param path
*/
public void installPackage(String path) {
installPackage(path, null);
}
public boolean launchApplication(String packageName) {
try {
Intent intent = mContext.getPackageManager().getLaunchIntentForPackage(packageName);
if (intent != null) {
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
mContext.startActivity(intent);
return true;
}
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/**
*
*
* @param packageName
*/
public void deletePackage(String packageName, final OnPackageDeleteListener listener) {
IPackageDeleteObserver.Stub mStub = new IPackageDeleteObserver.Stub() {
@Override
public void packageDeleted(String packageName, int returnCode) throws RemoteException {
if (listener != null) {
listener.onPackageDeleted(packageName, returnCode == DELETE_SUCCEEDED ? STATUS_SUCCESS : STATUS_FAILURE);
}
}
};
try {
Method method = PackageManager.class.getMethod("deletePackage", String.class, IPackageDeleteObserver.class, int.class);
PackageManager pm = mContext.getPackageManager();
method.invoke(pm, packageName, mStub, DELETE_SYSTEM_APP);
} catch (Exception e) {
printError(e);
}
}
/**
*
*
* @param packageName
*/
public void deletePackage(String packageName) {
deletePackage(packageName, null);
}
/**
*
*/
public void reboot() {
PowerManager pm = (PowerManager) mContext.getSystemService(Service.POWER_SERVICE);
pm.reboot("");
}
/**
*
*/
public void shutdown() {
try {
Method method = PowerManager.class.getMethod("shutdown", boolean.class, String.class, boolean.class);
PowerManager pm = (PowerManager) mContext.getSystemService(Service.POWER_SERVICE);
method.invoke(pm, false, "", false);
} catch (Exception e) {
printError(e);
}
}
/**
*
*/
public void wipeData() {
if (Build.VERSION.SDK_INT >= 26) {
//8.0
Intent intent = new Intent(ACTION_FACTORY_RESET);
intent.setPackage("android");
intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
intent.putExtra(EXTRA_REASON, "MasterClearConfirm");
intent.putExtra(EXTRA_WIPE_EXTERNAL_STORAGE, true);
mContext.sendBroadcast(intent);
} else {
Intent intent = new Intent(ACTION_MASTER_CLEAR);
intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
intent.putExtra(EXTRA_REASON, "MasterClearConfirm");
intent.putExtra(EXTRA_WIPE_EXTERNAL_STORAGE, true);
mContext.sendBroadcast(intent);
}
}
/**
*
*
* @param time
*/
public void setSystemTime(long time) {
AlarmManager am = (AlarmManager) mContext.getSystemService(Service.ALARM_SERVICE);
am.setTime(time);
//SystemClock.setCurrentTimeMillis(time);
}
/**
* shell
* @param command
*/
public void execSync(String command) {
Process process = null;
try {
process = Runtime.getRuntime().exec(command);
process.waitFor();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (process != null) {
process.destroy();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* shell
* @param command
*/
public void exec(final String command) {
new Thread() {
@Override
public void run() {
super.run();
execSync(command);
}
}.start();
}
/**
*
*
* @param mHandler
*/
public void setUiHandler(Handler mHandler) {
this.mHandler = mHandler;
}
/**
*
*
* @param disable
*/
public void disableStatusBarExpand(boolean disable) {
try {
Object service = mContext.getSystemService("statusbar");
Class> c = Class.forName("android.app.StatusBarManager");
Method method = c.getMethod("disable", int.class);
method.invoke(service, disable ? STATUS_BAR_DISABLE_EXPAND : 0);
} catch (Exception e) {
printError(e);
}
}
/**
* usb
*
* @param function
*/
public void setUsbFunction(String function) {
UsbManager um = (UsbManager) mContext.getSystemService(Service.USB_SERVICE);
if (Build.VERSION.SDK_INT < 26) {
//8.0
try {
Method setCurrentFunction = um.getClass().getMethod("setCurrentFunction", String.class);
setCurrentFunction.invoke(um, function);
Method setUsbDataUnlocked = um.getClass().getMethod("setUsbDataUnlocked", boolean.class);
if (function != null && function.equals("none")) {
setUsbDataUnlocked.invoke(um, false);
} else {
setUsbDataUnlocked.invoke(um, true);
}
} catch (Exception e) {
printError(e);
}
} else {
//8.0
try {
Method setCurrentFunction = um.getClass().getMethod("setCurrentFunction", String.class, boolean.class);
if (function != null && function.equals("none")) {
setCurrentFunction.invoke(um, function, false);
} else {
setCurrentFunction.invoke(um, function, true);
}
} catch (Exception e) {
printError(e);
}
}
}
/**
*
*
* @param key
* @param value
*/
public void setUserRestriction(String key, boolean value) {
UserManager um = (UserManager) mContext.getSystemService(Service.USER_SERVICE);
try {
Method method = um.getClass().getMethod("setUserRestriction", String.class, boolean.class);
method.invoke(um, key, value);
} catch (Exception e) {
printError(e);
}
}
/**
*
*
* @param key
* @return
*/
public boolean hasUserRestriction(String key) {
UserManager um = (UserManager) mContext.getSystemService(Service.USER_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
return um.hasUserRestriction(key);
}
return false;
}
/*
*
*
*/
private static boolean hasElement(Collection c) {
return c != null && !c.isEmpty();
}
private static boolean hasElement(Object[] array) {
return array != null && array.length > 0;
}
private static boolean hasElement(Map map) {
return map != null && !map.isEmpty();
}
private static boolean hasValue(String value) {
return value != null && !value.isEmpty();
}
private static boolean isEmpty(String value) {
return !hasValue(value);
}
private static boolean isNumeric(String str) {
Pattern pattern = Pattern.compile("[0-9]*");
return pattern.matcher(str).matches();
}
private static boolean equalsValue(String v1, String v2) {
return v1 != null && v2 != null && v1.equals(v2);
}
private SystemManager setOpState(String packageName, int opCode, boolean isAllow) {
if (isAllow) {
setOpMode(packageName, opCode, AppOpsManager.MODE_ALLOWED);
} else {
setOpMode(packageName, opCode, AppOpsManager.MODE_IGNORED);
}
return this;
}
private void allowPermissionInner(String packageName, String permission) {
try {
Method method = PackageManager.class.getMethod("grantRuntimePermission", String.class, String.class, UserHandle.class);
UserHandle userHandle = (UserHandle) newInstance(UserHandle.class, new Class[]{int.class}, 0);
method.invoke(mContext.getPackageManager(), packageName, permission, userHandle);
} catch (Exception e) {
printError(e);
}
}
private void denyPermissionInner(String packageName, String permission) {
try {
Method method = PackageManager.class.getMethod("revokeRuntimePermission", String.class, String.class, UserHandle.class);
UserHandle userHandle = (UserHandle) newInstance(UserHandle.class, new Class[]{int.class}, 0);
method.invoke(mContext.getPackageManager(), packageName, permission, userHandle);
} catch (Exception e) {
printError(e);
}
}
private int getPackageUid(String packageName) {
try {
PackageInfo info = mContext.getPackageManager().getPackageInfo(packageName, 0);
if (info != null && info.applicationInfo != null) {
return info.applicationInfo.uid;
}
} catch (Exception e) {
e.printStackTrace();
}
return 0;
}
private String makeSettingsValue(String value) {
return value != null && !value.trim().isEmpty() ? value : "\"\"";
}
public interface OnPackageInstallListener {
void onPackageInstalled(String packageName, int returnCode);
}
public interface OnPackageDeleteListener {
void onPackageDeleted(String packageName, int returnCode);
}
private Set getDeniedPermissionList(String packageName, String[] permissions) {
Set mDeniedPermissionList = new HashSet<>();
PackageManager pm = mContext.getPackageManager();
for (String permission : permissions) {
if (pm.checkPermission(permission, packageName) != PackageManager.PERMISSION_GRANTED) {
mDeniedPermissionList.add(permission);
}
}
return mDeniedPermissionList;
}
private Object newInstance(Class clazz, Class[] argsType, Object... args) {
Object instance = null;
try {
Constructor constructor = clazz.getConstructor(argsType);
constructor.setAccessible(true);
instance = constructor.newInstance(args);
} catch (Exception e) {
e.printStackTrace();
}
return instance;
}
private void print(Object... info) {
if (info == null || info.length == 0) {
return;
}
StringBuilder sb = new StringBuilder();
for (Object o : info) {
sb.append(o != null ? o.toString() + ", " : ", ");
}
String msg = sb.toString();
if (msg.endsWith(",")) msg = sb.deleteCharAt(sb.length() - 1).toString();
Log.e(TAG, msg);
}
private void printError(Throwable e) {
if (e.getCause() != null) {
Log.e(TAG, e.getCause().toString());
} else {
Log.e(TAG, e.toString());
}
}
/**
* android9.0
*
* @param path
* @param listener
*/
private void installPackageFromQ(final String path, final OnPackageInstallListener listener) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
return;
}
PackageManager pm = mContext.getPackageManager();
String packageName = null;
PackageInfo packageInfo = pm.getPackageArchiveInfo(path, PackageManager.GET_ACTIVITIES | PackageManager.GET_SERVICES);
if (packageInfo != null) {
packageName = packageInfo.packageName;
}
PackageInstaller packageInstaller = pm.getPackageInstaller();
PackageInstaller.SessionParams sessionParams = new PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL);
File apkFile = new File(path);
print("apkFile length" + apkFile.length());
sessionParams.setSize(apkFile.length());
int mSessionId = -1;
try {
mSessionId = packageInstaller.createSession(sessionParams);
} catch (IOException e) {
e.printStackTrace();
}
if (mSessionId != -1) {
final int finalMSessionId = mSessionId;
final String finalPackageName = packageName;
new Thread() {
@Override
public void run() {
super.run();
boolean copySuccess = onTransfesApkFile(path, finalMSessionId);
if (copySuccess) {
if (mHandler != null) {
mHandler.post(new Runnable() {
@Override
public void run() {
execInstallAPP(finalMSessionId, finalPackageName, listener);
}
});
} else {
execInstallAPP(finalMSessionId, finalPackageName, listener);
}
} else {
if (mHandler != null) {
mHandler.post(new Runnable() {
@Override
public void run() {
if (listener != null) {
listener.onPackageInstalled(finalPackageName, STATUS_FAILURE);
}
}
});
} else {
if (listener != null) {
listener.onPackageInstalled(finalPackageName, STATUS_FAILURE);
}
}
}
}
}.start();
} else {
if (listener != null) {
listener.onPackageInstalled(packageName, STATUS_FAILURE);
}
}
}
private boolean onTransfesApkFile(String apkFilePath, int mSessionId) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
InputStream in = null;
OutputStream out = null;
PackageInstaller.Session session = null;
boolean success = false;
try {
File apkFile = new File(apkFilePath);
session = mContext.getPackageManager().getPackageInstaller().openSession(mSessionId);
out = session.openWrite("base.apk", 0, apkFile.length());
in = new FileInputStream(apkFile);
int total = 0, c;
byte[] buffer = new byte[1024 * 1024];
while ((c = in.read(buffer)) != -1) {
total += c;
out.write(buffer, 0, c);
}
session.fsync(out);
success = true;
} catch (Exception e) {
e.printStackTrace();
} finally {
if (null != session) {
session.close();
}
try {
if (null != out) {
out.close();
}
if (null != in) {
in.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
return success;
}
return false;
}
/**
*
*/
private void execInstallAPP(int mSessionId, final String packageName, final OnPackageInstallListener listener) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
PackageInstaller.Session session = null;
try {
session = mContext.getPackageManager().getPackageInstaller().openSession(mSessionId);
Intent intent = new Intent(mContext, new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (intent != null) {
int status = intent.getIntExtra(PackageInstaller.EXTRA_STATUS, PackageInstaller.STATUS_FAILURE);
if (listener != null) {
listener.onPackageInstalled(packageName, status);
}
}
}
}.getClass());
PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext,
1, intent,
PendingIntent.FLAG_UPDATE_CURRENT);
session.commit(pendingIntent.getIntentSender());
} catch (Exception e) {
e.printStackTrace();
if (listener != null) {
listener.onPackageInstalled(packageName, STATUS_FAILURE);
}
} finally {
if (null != session) {
session.close();
}
}
}
}
private ComponentName getDeviceAdminClass(Context context, String pkgName) {
List infos = context.getPackageManager().queryBroadcastReceivers(
new Intent(DeviceAdminReceiver.ACTION_DEVICE_ADMIN_ENABLED),
PackageManager.GET_DISABLED_UNTIL_USED_COMPONENTS);
if (infos != null) {
for (ResolveInfo info : infos) {
if (info.activityInfo.packageName.equals(pkgName)) {
return new ComponentName(pkgName, info.activityInfo.name);
}
}
}
return null;
}
private boolean isAppInstalled(String pkgName) {
try {
PackageInfo info = mContext.getPackageManager().getPackageInfo(pkgName, 0);
return info != null;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
}
完全なコード:https://github.com/yuanfang235/systemmanagerlib