android.app.AppOpsManager#MODE_ERRORED源码实例Demo

private static boolean isPermissionDenied() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        return !Settings.canDrawOverlays(getContext());
    } else {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            AppOpsManager appOpsMgr = (AppOpsManager) CONTEXT.getSystemService(Context.APP_OPS_SERVICE);
            try {
                int mode = appOpsMgr.checkOpNoThrow("android:system_alert_window",
                        android.os.Process.myUid(), CONTEXT.getPackageName());
                if (mode == AppOpsManager.MODE_ERRORED) {
                    return true;
                }
            } catch (Throwable t) {
                // Unknown operation string: android:system_alert_window
            }
        }
        if (!Config.ifPermissionChecked()) {
            Config.setPermissionChecked();
            return true;
        }
    }
    return false;
}
 

/**
 * Checks whether the package has usage access permission.
 *
 * @return {@code true} if has usage access.
 *
 * @see Manifest.permission#PACKAGE_USAGE_STATS
 */
public boolean hasUsageAccess() {
    if (DynamicSdkUtils.is21()) {
        try {
            PackageManager packageManager = mContext.getPackageManager();
            ApplicationInfo applicationInfo = packageManager
                    .getApplicationInfo(mContext.getPackageName(), 0);
            AppOpsManager appOpsManager = (AppOpsManager) mContext
                    .getSystemService(Context.APP_OPS_SERVICE);

            int mode = AppOpsManager.MODE_ERRORED;
            if (appOpsManager != null) {
                mode = appOpsManager.checkOpNoThrow(AppOpsManager.OPSTR_GET_USAGE_STATS,
                        applicationInfo.uid, applicationInfo.packageName);
            }

            return (mode == AppOpsManager.MODE_ALLOWED);
        } catch (Exception e) {
            return false;
        }
    }

    return true;
}
 

@GuardedBy("mLock")
private void startVibrationLocked(final Vibration vib) {
    Trace.traceBegin(Trace.TRACE_TAG_VIBRATOR, "startVibrationLocked");
    try {
        if (!isAllowedToVibrateLocked(vib)) {
            return;
        }

        final int intensity = getCurrentIntensityLocked(vib);
        if (intensity == Vibrator.VIBRATION_INTENSITY_OFF) {
            return;
        }

        if (vib.isRingtone() && !shouldVibrateForRingtone()) {
            if (DEBUG) {
                Slog.e(TAG, "Vibrate ignored, not vibrating for ringtones");
            }
            return;
        }

        final int mode = getAppOpMode(vib);
        if (mode != AppOpsManager.MODE_ALLOWED) {
            if (mode == AppOpsManager.MODE_ERRORED) {
                // We might be getting calls from within system_server, so we don't actually
                // want to throw a SecurityException here.
                Slog.w(TAG, "Would be an error: vibrate from uid " + vib.uid);
            }
            return;
        }
        applyVibrationIntensityScalingLocked(vib, intensity);
        startVibrationInnerLocked(vib);
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_VIBRATOR);
    }
}
 

@Override
public int checkPackage(int uid, String packageName) {
    Preconditions.checkNotNull(packageName);
    synchronized (this) {
        Ops ops = getOpsRawLocked(uid, packageName, true /* edit */,
                true /* uidMismatchExpected */);
        if (ops != null) {
            return AppOpsManager.MODE_ALLOWED;
        } else {
            return AppOpsManager.MODE_ERRORED;
        }
    }
}
 

private int noteOperationUnchecked(int code, int uid, String packageName,
        int proxyUid, String proxyPackageName) {
    synchronized (this) {
        final Ops ops = getOpsRawLocked(uid, packageName, true /* edit */,
                false /* uidMismatchExpected */);
        if (ops == null) {
            if (DEBUG) Slog.d(TAG, "noteOperation: no op for code " + code + " uid " + uid
                    + " package " + packageName);
            return AppOpsManager.MODE_ERRORED;
        }
        final Op op = getOpLocked(ops, code, true);
        if (isOpRestrictedLocked(uid, code, packageName)) {
            return AppOpsManager.MODE_IGNORED;
        }
        final UidState uidState = ops.uidState;
        if (op.duration == -1) {
            Slog.w(TAG, "Noting op not finished: uid " + uid + " pkg " + packageName
                    + " code " + code + " time=" + op.time[uidState.state]
                    + " duration=" + op.duration);
        }
        op.duration = 0;
        final int switchCode = AppOpsManager.opToSwitch(code);
        // If there is a non-default per UID policy (we set UID op mode only if
        // non-default) it takes over, otherwise use the per package policy.
        if (uidState.opModes != null && uidState.opModes.indexOfKey(switchCode) >= 0) {
            final int uidMode = uidState.evalMode(uidState.opModes.get(switchCode));
            if (uidMode != AppOpsManager.MODE_ALLOWED) {
                if (DEBUG) Slog.d(TAG, "noteOperation: uid reject #" + uidMode + " for code "
                        + switchCode + " (" + code + ") uid " + uid + " package "
                        + packageName);
                op.rejectTime[uidState.state] = System.currentTimeMillis();
                return uidMode;
            }
        } else {
            final Op switchOp = switchCode != code ? getOpLocked(ops, switchCode, true) : op;
            final int mode = switchOp.getMode();
            if (mode != AppOpsManager.MODE_ALLOWED) {
                if (DEBUG) Slog.d(TAG, "noteOperation: reject #" + mode + " for code "
                        + switchCode + " (" + code + ") uid " + uid + " package "
                        + packageName);
                op.rejectTime[uidState.state] = System.currentTimeMillis();
                return mode;
            }
        }
        if (DEBUG) Slog.d(TAG, "noteOperation: allowing code " + code + " uid " + uid
                + " package " + packageName);
        op.time[uidState.state] = System.currentTimeMillis();
        op.rejectTime[uidState.state] = 0;
        op.proxyUid = proxyUid;
        op.proxyPackageName = proxyPackageName;
        return AppOpsManager.MODE_ALLOWED;
    }
}
 

@Override
public int startOperation(IBinder token, int code, int uid, String packageName,
        boolean startIfModeDefault) {
    verifyIncomingUid(uid);
    verifyIncomingOp(code);
    String resolvedPackageName = resolvePackageName(uid, packageName);
    if (resolvedPackageName == null) {
        return  AppOpsManager.MODE_IGNORED;
    }
    ClientState client = (ClientState)token;
    synchronized (this) {
        final Ops ops = getOpsRawLocked(uid, resolvedPackageName, true /* edit */,
                false /* uidMismatchExpected */);
        if (ops == null) {
            if (DEBUG) Slog.d(TAG, "startOperation: no op for code " + code + " uid " + uid
                    + " package " + resolvedPackageName);
            return AppOpsManager.MODE_ERRORED;
        }
        final Op op = getOpLocked(ops, code, true);
        if (isOpRestrictedLocked(uid, code, resolvedPackageName)) {
            return AppOpsManager.MODE_IGNORED;
        }
        final int switchCode = AppOpsManager.opToSwitch(code);
        final UidState uidState = ops.uidState;
        // If there is a non-default per UID policy (we set UID op mode only if
        // non-default) it takes over, otherwise use the per package policy.
        if (uidState.opModes != null && uidState.opModes.indexOfKey(switchCode) >= 0) {
            final int uidMode = uidState.evalMode(uidState.opModes.get(switchCode));
            if (uidMode != AppOpsManager.MODE_ALLOWED
                    && (!startIfModeDefault || uidMode != AppOpsManager.MODE_DEFAULT)) {
                if (DEBUG) Slog.d(TAG, "noteOperation: uid reject #" + uidMode + " for code "
                        + switchCode + " (" + code + ") uid " + uid + " package "
                        + resolvedPackageName);
                op.rejectTime[uidState.state] = System.currentTimeMillis();
                return uidMode;
            }
        } else {
            final Op switchOp = switchCode != code ? getOpLocked(ops, switchCode, true) : op;
            final int mode = switchOp.getMode();
            if (mode != AppOpsManager.MODE_ALLOWED
                    && (!startIfModeDefault || mode != AppOpsManager.MODE_DEFAULT)) {
                if (DEBUG) Slog.d(TAG, "startOperation: reject #" + mode + " for code "
                        + switchCode + " (" + code + ") uid " + uid + " package "
                        + resolvedPackageName);
                op.rejectTime[uidState.state] = System.currentTimeMillis();
                return mode;
            }
        }
        if (DEBUG) Slog.d(TAG, "startOperation: allowing code " + code + " uid " + uid
                + " package " + resolvedPackageName);
        if (op.startNesting == 0) {
            op.startRealtime = SystemClock.elapsedRealtime();
            op.time[uidState.state] = System.currentTimeMillis();
            op.rejectTime[uidState.state] = 0;
            op.duration = -1;
            scheduleOpActiveChangedIfNeededLocked(code, uid, packageName, true);
        }
        op.startNesting++;
        uidState.startNesting++;
        if (client.mStartedOps != null) {
            client.mStartedOps.add(op);
        }
    }

    return AppOpsManager.MODE_ALLOWED;
}