private static final String TAG = "StrictMode";

private static final boolean LOG_V = Log.isLoggable(TAG, Log.VERBOSE);

private static final boolean IS_USER_BUILD = "user".equals(Build.TYPE);

private static final boolean IS_ENG_BUILD = "eng".equals(Build.TYPE);

/**

public static final String DISABLE_PROPERTY = "persist.sys.strictmode.disable";

/**

public static final String VISUAL_PROPERTY = "persist.sys.strictmode.visual";

// Only log a duplicate stack trace to the logs every second.

private static final long MIN_LOG_INTERVAL_MS = 1000;

// Only show an annoying dialog at most every 30 seconds

private static final long MIN_DIALOG_INTERVAL_MS = 30000;

// How many Span tags (e.g. animations) to report.

private static final int MAX_SPAN_TAGS = 20;

// How many offending stacks to keep track of (and time) per loop

// of the Looper.

private static final int MAX_OFFENSES_PER_LOOP = 10;

// Thread-policy:

/**

public static final int DETECT_DISK_WRITE = 0x01; // for ThreadPolicy

/**

public static final int DETECT_DISK_READ = 0x02; // for ThreadPolicy

/**

public static final int DETECT_NETWORK = 0x04; // for ThreadPolicy

/**

public static final int DETECT_CUSTOM = 0x08; // for ThreadPolicy

private static final int ALL_THREAD_DETECT_BITS =

DETECT_DISK_WRITE | DETECT_DISK_READ | DETECT_NETWORK | DETECT_CUSTOM;

// Process-policy:

/**

public static final int DETECT_VM_CURSOR_LEAKS = 0x200; // for VmPolicy

/**

public static final int DETECT_VM_CLOSABLE_LEAKS = 0x400; // for VmPolicy

/**

public static final int DETECT_VM_ACTIVITY_LEAKS = 0x800; // for VmPolicy

/**

private static final int DETECT_VM_INSTANCE_LEAKS = 0x1000; // for VmPolicy

private static final int ALL_VM_DETECT_BITS =

DETECT_VM_CURSOR_LEAKS | DETECT_VM_CLOSABLE_LEAKS |

DETECT_VM_ACTIVITY_LEAKS | DETECT_VM_INSTANCE_LEAKS;

/**

public static final int PENALTY_LOG = 0x10; // normal android.util.Log

// Used for both process and thread policy:

/**

public static final int PENALTY_DIALOG = 0x20;

/**

public static final int PENALTY_DEATH = 0x40;

/**

public static final int PENALTY_DEATH_ON_NETWORK = 0x200;

/**

public static final int PENALTY_FLASH = 0x800;

/**

public static final int PENALTY_DROPBOX = 0x80;

/**

public static final int PENALTY_GATHER = 0x100;

/**

private static final int THREAD_PENALTY_MASK =

PENALTY_LOG | PENALTY_DIALOG | PENALTY_DEATH | PENALTY_DROPBOX | PENALTY_GATHER |

PENALTY_DEATH_ON_NETWORK | PENALTY_FLASH;

/**

private static final int VM_PENALTY_MASK =

PENALTY_LOG | PENALTY_DEATH | PENALTY_DROPBOX;

// TODO: wrap in some ImmutableHashMap thing.

// Note: must be before static initialization of sVmPolicy.

private static final HashMap<Class, Integer> EMPTY_CLASS_LIMIT_MAP = new HashMap<Class, Integer>();

/**

private static volatile int sVmPolicyMask = 0;

private static volatile VmPolicy sVmPolicy = VmPolicy.LAX;

/**

private static final AtomicInteger sDropboxCallsInFlight = new AtomicInteger(0);

private StrictMode() {}

/**

public static final class ThreadPolicy {

/**

public static final ThreadPolicy LAX = new ThreadPolicy(0);

final int mask;

private ThreadPolicy(int mask) {

this.mask = mask;

}

@Override

public String toString() {

return "[StrictMode.ThreadPolicy; mask=" + mask + "]";

}

/**

public static final class Builder {

private int mMask = 0;

/**

public Builder() {

mMask = 0;

}

/**

public Builder(ThreadPolicy policy) {

mMask = policy.mask;

}

/**

public Builder detectAll() {

return enable(ALL_THREAD_DETECT_BITS);

}

/**

public Builder permitAll() {

return disable(ALL_THREAD_DETECT_BITS);

}

/**

public Builder detectNetwork() {

return enable(DETECT_NETWORK);

}

/**

public Builder permitNetwork() {

return disable(DETECT_NETWORK);

}

/**

public Builder detectDiskReads() {

return enable(DETECT_DISK_READ);

}

/**

public Builder permitDiskReads() {

return disable(DETECT_DISK_READ);

}

/**

public Builder detectCustomSlowCalls() {

return enable(DETECT_CUSTOM);

}

/**

public Builder permitCustomSlowCalls() {

return enable(DETECT_CUSTOM);

}

/**

public Builder detectDiskWrites() {

return enable(DETECT_DISK_WRITE);

}

/**

public Builder permitDiskWrites() {

return disable(DETECT_DISK_WRITE);

}

/**

public Builder penaltyDialog() {

return enable(PENALTY_DIALOG);

}

/**

public Builder penaltyDeath() {

return enable(PENALTY_DEATH);

}

/**

public Builder penaltyDeathOnNetwork() {

return enable(PENALTY_DEATH_ON_NETWORK);

}

/**

public Builder penaltyFlashScreen() {

return enable(PENALTY_FLASH);

}

/**

public Builder penaltyLog() {

return enable(PENALTY_LOG);

}

/**

public Builder penaltyDropBox() {

return enable(PENALTY_DROPBOX);

}

private Builder enable(int bit) {

mMask |= bit;

return this;

}

private Builder disable(int bit) {

mMask &= ~bit;

return this;

}

/**

public ThreadPolicy build() {

// If there are detection bits set but no violation bits

// set, enable simple logging.

if (mMask != 0 &&

(mMask & (PENALTY_DEATH | PENALTY_LOG |

PENALTY_DROPBOX | PENALTY_DIALOG)) == 0) {

penaltyLog();

}

return new ThreadPolicy(mMask);

}

}

}

/**

public static final class VmPolicy {

/**

public static final VmPolicy LAX = new VmPolicy(0, EMPTY_CLASS_LIMIT_MAP);

final int mask;

// Map from class to max number of allowed instances in memory.

final HashMap<Class, Integer> classInstanceLimit;

private VmPolicy(int mask, HashMap<Class, Integer> classInstanceLimit) {

if (classInstanceLimit == null) {

throw new NullPointerException("classInstanceLimit == null");

}

this.mask = mask;

this.classInstanceLimit = classInstanceLimit;

}

@Override

public String toString() {

return "[StrictMode.VmPolicy; mask=" + mask + "]";

}

/**

public static final class Builder {

private int mMask;

private HashMap<Class, Integer> mClassInstanceLimit; // null until needed

private boolean mClassInstanceLimitNeedCow = false; // need copy-on-write

public Builder() {

mMask = 0;

}

/**

public Builder(VmPolicy base) {

mMask = base.mask;

mClassInstanceLimitNeedCow = true;

mClassInstanceLimit = base.classInstanceLimit;

}

/**

public Builder setClassInstanceLimit(Class klass, int instanceLimit) {

if (klass == null) {

throw new NullPointerException("klass == null");

}

if (mClassInstanceLimitNeedCow) {

if (mClassInstanceLimit.containsKey(klass) &&

mClassInstanceLimit.get(klass) == instanceLimit) {

// no-op; don't break COW

return this;

}

mClassInstanceLimitNeedCow = false;

mClassInstanceLimit = (HashMap<Class, Integer>) mClassInstanceLimit.clone();

} else if (mClassInstanceLimit == null) {

mClassInstanceLimit = new HashMap<Class, Integer>();

}

mMask |= DETECT_VM_INSTANCE_LEAKS;

mClassInstanceLimit.put(klass, instanceLimit);

return this;

}

/**

public Builder detectActivityLeaks() {

return enable(DETECT_VM_ACTIVITY_LEAKS);

}

/**

public Builder detectAll() {

return enable(DETECT_VM_ACTIVITY_LEAKS |

DETECT_VM_CURSOR_LEAKS | DETECT_VM_CLOSABLE_LEAKS);

}

/**

public Builder detectLeakedSqlLiteObjects() {

return enable(DETECT_VM_CURSOR_LEAKS);

}

/**

public Builder detectLeakedClosableObjects() {

return enable(DETECT_VM_CLOSABLE_LEAKS);

}

/**

public Builder penaltyDeath() {

return enable(PENALTY_DEATH);

}

/**

public Builder penaltyLog() {

return enable(PENALTY_LOG);

}

/**

public Builder penaltyDropBox() {

return enable(PENALTY_DROPBOX);

}

private Builder enable(int bit) {

mMask |= bit;

return this;

}

/**

public VmPolicy build() {

// If there are detection bits set but no violation bits

// set, enable simple logging.

if (mMask != 0 &&

(mMask & (PENALTY_DEATH | PENALTY_LOG |

PENALTY_DROPBOX | PENALTY_DIALOG)) == 0) {

penaltyLog();

}

return new VmPolicy(mMask,

mClassInstanceLimit != null ? mClassInstanceLimit : EMPTY_CLASS_LIMIT_MAP);

}

}

}

/**

private static final ThreadLocal<ArrayList<ViolationInfo>> gatheredViolations =

new ThreadLocal<ArrayList<ViolationInfo>>() {

@Override protected ArrayList<ViolationInfo> initialValue() {

// Starts null to avoid unnecessary allocations when

// checking whether there are any violations or not in

// hasGatheredViolations() below.

return null;

}

};

/**

public static void setThreadPolicy(final ThreadPolicy policy) {

setThreadPolicyMask(policy.mask);

}

private static void setThreadPolicyMask(final int policyMask) {

// In addition to the Java-level thread-local in Dalvik's

// BlockGuard, we also need to keep a native thread-local in

// Binder in order to propagate the value across Binder calls,

// even across native-only processes. The two are kept in

// sync via the callback to onStrictModePolicyChange, below.

setBlockGuardPolicy(policyMask);

// And set the Android native version...

Binder.setThreadStrictModePolicy(policyMask);

}

// Sets the policy in Dalvik/libcore (BlockGuard)

private static void setBlockGuardPolicy(final int policyMask) {

if (policyMask == 0) {

BlockGuard.setThreadPolicy(BlockGuard.LAX_POLICY);

return;

}

BlockGuard.Policy policy = BlockGuard.getThreadPolicy();

if (!(policy instanceof AndroidBlockGuardPolicy)) {

BlockGuard.setThreadPolicy(new AndroidBlockGuardPolicy(policyMask));

} else {

AndroidBlockGuardPolicy androidPolicy = (AndroidBlockGuardPolicy) policy;

androidPolicy.setPolicyMask(policyMask);

}

}

// Sets up CloseGuard in Dalvik/libcore

private static void setCloseGuardEnabled(boolean enabled) {

if (!(CloseGuard.getReporter() instanceof AndroidCloseGuardReporter)) {

CloseGuard.setReporter(new AndroidCloseGuardReporter());

}

CloseGuard.setEnabled(enabled);

}

/**

public static class StrictModeViolation extends BlockGuard.BlockGuardPolicyException {

public StrictModeViolation(int policyState, int policyViolated, String message) {

super(policyState, policyViolated, message);

}

}

/**

public static class StrictModeNetworkViolation extends StrictModeViolation {

public StrictModeNetworkViolation(int policyMask) {

super(policyMask, DETECT_NETWORK, null);

}

}

/**

private static class StrictModeDiskReadViolation extends StrictModeViolation {

public StrictModeDiskReadViolation(int policyMask) {

super(policyMask, DETECT_DISK_READ, null);

}

}

/**

private static class StrictModeDiskWriteViolation extends StrictModeViolation {

public StrictModeDiskWriteViolation(int policyMask) {

super(policyMask, DETECT_DISK_WRITE, null);

}

}

/**

private static class StrictModeCustomViolation extends StrictModeViolation {

public StrictModeCustomViolation(int policyMask, String name) {

super(policyMask, DETECT_CUSTOM, name);

}

}

/**

public static int getThreadPolicyMask() {

return BlockGuard.getThreadPolicy().getPolicyMask();

}

/**

public static ThreadPolicy getThreadPolicy() {

// TODO: this was a last minute Gingerbread API change (to

// introduce VmPolicy cleanly) but this isn't particularly

// optimal for users who might call this method often. This

// should be in a thread-local and not allocate on each call.

return new ThreadPolicy(getThreadPolicyMask());

}

/**

public static ThreadPolicy allowThreadDiskWrites() {

int oldPolicyMask = getThreadPolicyMask();

int newPolicyMask = oldPolicyMask & ~(DETECT_DISK_WRITE | DETECT_DISK_READ);

if (newPolicyMask != oldPolicyMask) {

setThreadPolicyMask(newPolicyMask);

}

return new ThreadPolicy(oldPolicyMask);

}

/**

public static ThreadPolicy allowThreadDiskReads() {

int oldPolicyMask = getThreadPolicyMask();

int newPolicyMask = oldPolicyMask & ~(DETECT_DISK_READ);

if (newPolicyMask != oldPolicyMask) {

setThreadPolicyMask(newPolicyMask);

}

return new ThreadPolicy(oldPolicyMask);

}

// We don't want to flash the screen red in the system server

// process, nor do we want to modify all the call sites of

// conditionallyEnableDebugLogging() in the system server,

// so instead we use this to determine if we are the system server.

private static boolean amTheSystemServerProcess() {

// Fast path. Most apps don't have the system server's UID.

if (Process.myUid() != Process.SYSTEM_UID) {

return false;

}

// The settings app, though, has the system server's UID so

// look up our stack to see if we came from the system server.

Throwable stack = new Throwable();

stack.fillInStackTrace();

for (StackTraceElement ste : stack.getStackTrace()) {

String clsName = ste.getClassName();

if (clsName != null && clsName.startsWith("com.android.server.")) {

return true;

}

}

return false;

}

/**

public static boolean conditionallyEnableDebugLogging() {

boolean doFlashes = SystemProperties.getBoolean(VISUAL_PROPERTY, false)

&& !amTheSystemServerProcess();

final boolean suppress = SystemProperties.getBoolean(DISABLE_PROPERTY, false);

// For debug builds, log event loop stalls to dropbox for analysis.

// Similar logic also appears in ActivityThread.java for system apps.

if (!doFlashes && (IS_USER_BUILD || suppress)) {

setCloseGuardEnabled(false);

return false;

}

// Eng builds have flashes on all the time. The suppression property

// overrides this, so we force the behavior only after the short-circuit

// check above.

if (IS_ENG_BUILD) {

doFlashes = true;

}

// Thread policy controls BlockGuard.

int threadPolicyMask = StrictMode.DETECT_DISK_WRITE |

StrictMode.DETECT_DISK_READ |

StrictMode.DETECT_NETWORK;

if (!IS_USER_BUILD) {

threadPolicyMask |= StrictMode.PENALTY_DROPBOX;

}

if (doFlashes) {

threadPolicyMask |= StrictMode.PENALTY_FLASH;

}

StrictMode.setThreadPolicyMask(threadPolicyMask);

// VM Policy controls CloseGuard, detection of Activity leaks,

// and instance counting.

if (IS_USER_BUILD) {

setCloseGuardEnabled(false);

} else {

VmPolicy.Builder policyBuilder = new VmPolicy.Builder().detectAll().penaltyDropBox();

if (IS_ENG_BUILD) {

policyBuilder.penaltyLog();

}

setVmPolicy(policyBuilder.build());

setCloseGuardEnabled(vmClosableObjectLeaksEnabled());

}

return true;

}

/**

public static void enableDeathOnNetwork() {

int oldPolicy = getThreadPolicyMask();

int newPolicy = oldPolicy | DETECT_NETWORK | PENALTY_DEATH_ON_NETWORK;

setThreadPolicyMask(newPolicy);

}

/**

private static int parsePolicyFromMessage(String message) {

if (message == null || !message.startsWith("policy=")) {

return 0;

}

int spaceIndex = message.indexOf(' ');

if (spaceIndex == -1) {

return 0;

}

String policyString = message.substring(7, spaceIndex);

try {

return Integer.valueOf(policyString).intValue();

} catch (NumberFormatException e) {

return 0;

}

}

/**

private static int parseViolationFromMessage(String message) {

if (message == null) {

return 0;

}

int violationIndex = message.indexOf("violation=");

if (violationIndex == -1) {

return 0;

}