So, you want to start using StrictMode in your Android app, but you need it to run (that is, not crash) on pre-2.3 versions of Android.  A wrapper class seems like the way to go, and there are a couple of solutions floating around the web, but they didn’t quite work like I wanted, so I’ve rolled my own, with inspiration from the Android Developers Blog post entitled “Have your (Cup)cake and eat it too“, which was written by Adam Powell and outlines the “lazy loading” strategy I use here.  My version has the following characterstics:

• In the code that interacts with the wrapper, there is no extra stuff like try/catch blocks or “if (strictmodeavailable)”
• The caller can easily make a temporary change to a thread or VM policy at runtime in order to bracket an existing violation
• The check for debug mode is encapsulated within the wrapper

The solution involved three wrapper interfaces – one for StrictMode, and two more for ThreadPolicy and VmPolicy. There are two implementations of the StrictModeWrapper interface, one for use on Gingerbread or later versions, which passes through to the real StrictMode, and one that’s a noop version for pre-Gingerbread versions. The Gingerbread version of the StrictMode wrapper also makes use of Gingerbread wrappers for ThreadPolicy and VmPolicy.

In practice, it works as follows.  First, wherever you want to initialize StrictMode (e.g. in your Application subclass’ OnCreate() method), you do this:

VersionedStrictModeWrapper.getInstance().init(this);

StrictMode has some convenience methods like allowThreadDiskReads() and allowThreadDiskWrites(), which let you temporarily permit actions that would otherwise  violate the policies you’ve established.  This is useful when you are calling into some other code that you don’t control, or when you consciously decide to do something that violates those policies.  After you’ve finished doing the offending action, you can restore the original policies with setThreadPolicy().  To make this type of interaction possible, I wrote wrappers for the ThreadPolicy and VmPolicy classes also.  Note: StrictMode doesn’t have an allowThreadNetwork() convenience function, but I added one in my wrapper, since I encountered a need for it.

Here’s an example of adjusting the policy temporarily using the wrappers:

// the call below to setContentView will trigger StrictMode disk read and disk write
// violations because the WebView accesses a WebViewDatabase. So, bracket the call
// to setContentView with calls to first permit those actions, and then afterward,
// restore the policy permissions that were previously in place.
StrictModeWrapper strictMode = VersionedStrictModeWrapper.getInstance();
ThreadPolicyWrapper origPolicy = strictMode.allowThreadDiskReads();
strictMode.allowThreadDiskWrites();

setContentView(R.layout.my_web_view); // creates a WebView

strictMode.setThreadPolicy(origPolicy);

Note: since the noop wrapper just returns null for the policy objects returned by allowThreadDiskReads() and allowThreadDiskWrites(), it’s not safe to do anything with them except pass them back in a later call to setThreadPolicy(), but that meets my use cases at the moment. To make things safer, the implementation could be extended with noop versions of the policy wrapper interfaces also.

OK, without further ado, here’s the whole shebang.  Feedback is very welcome.

package com.fizzbuzz.android.versionutil;

import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.os.Build;
import android.os.StrictMode;
import android.os.StrictMode.ThreadPolicy;
import android.os.StrictMode.VmPolicy;

import com.fizzbuzz.android.versionutil.VersionedStrictModeWrapper.StrictModeWrapper.ThreadPolicyWrapper;
import com.fizzbuzz.android.versionutil.VersionedStrictModeWrapper.StrictModeWrapper.VmPolicyWrapper;

public class VersionedStrictModeWrapper {

	public interface StrictModeWrapper {
		public void init(Context context);

		public ThreadPolicyWrapper allowThreadDiskReads();

		public ThreadPolicyWrapper allowThreadDiskWrites();

		public ThreadPolicyWrapper allowThreadNetwork();

		public void setThreadPolicy(ThreadPolicyWrapper wrapper);

		public void setVmPolicy(VmPolicyWrapper wrapper);

		public static interface ThreadPolicyWrapper {
		}

		public static interface VmPolicyWrapper {
		}
	}

	static public StrictModeWrapper getInstance() {
		StrictModeWrapper wrapper = null;
		final int sdkVersion = Build.VERSION.SDK_INT;
		if (sdkVersion >= Build.VERSION_CODES.GINGERBREAD) {
			wrapper = new GingerbreadStrictModeWrapper();
		}
		else {
			wrapper = new NoopStrictModeWrapper();
		}
		return wrapper;
	}

	static class NoopStrictModeWrapper implements StrictModeWrapper {
		@Override
		public void init(final Context context) {
		}

		@Override
		public ThreadPolicyWrapper allowThreadDiskReads() {
			return null;
		}

		@Override
		public ThreadPolicyWrapper allowThreadDiskWrites() {
			return null;
		}

		@Override
		public ThreadPolicyWrapper allowThreadNetwork() {
			return null;
		}

		@Override
		public void setThreadPolicy(final ThreadPolicyWrapper wrapper) {
		};

		@Override
		public void setVmPolicy(final VmPolicyWrapper wrapper) {
		};

	}

	static class GingerbreadStrictModeWrapper implements StrictModeWrapper {
		@Override
		public void init(final Context context) {
			if ((context.getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
				StrictMode.enableDefaults();
			}
		}

		@Override
		public ThreadPolicyWrapper allowThreadDiskReads() {
			return new GingerbreadThreadPolicyWrapper(StrictMode.allowThreadDiskReads());
		}

		@Override
		public ThreadPolicyWrapper allowThreadDiskWrites() {
			return new GingerbreadThreadPolicyWrapper(StrictMode.allowThreadDiskWrites());
		}

		@Override
		public ThreadPolicyWrapper allowThreadNetwork() {
			ThreadPolicy origPolicy = StrictMode.getThreadPolicy();
			ThreadPolicy newPolicy = new ThreadPolicy.Builder(origPolicy).permitNetwork().build();
			StrictMode.setThreadPolicy(newPolicy);
			return new GingerbreadThreadPolicyWrapper(origPolicy);
		}

		@Override
		public void setThreadPolicy(final ThreadPolicyWrapper wrapper) {
			StrictMode.setThreadPolicy(((GingerbreadThreadPolicyWrapper) wrapper).getPolicy());
		}

		@Override
		public void setVmPolicy(final VmPolicyWrapper wrapper) {
			StrictMode.setVmPolicy(((GingerbreadVmPolicyWrapper) wrapper).getPolicy());
		}
	}

	static class GingerbreadThreadPolicyWrapper implements ThreadPolicyWrapper {
		private final ThreadPolicy mPolicy;

		public GingerbreadThreadPolicyWrapper(final StrictMode.ThreadPolicy policy) {
			mPolicy = policy;
		}

		public StrictMode.ThreadPolicy getPolicy() {
			return mPolicy;
		}
	}

	static class GingerbreadVmPolicyWrapper implements VmPolicyWrapper {
		private final VmPolicy mPolicy;

		public GingerbreadVmPolicyWrapper(final StrictMode.VmPolicy policy) {
			mPolicy = policy;
		}

		public StrictMode.VmPolicy getPolicy() {
			return mPolicy;
		}
	}
}

When using this code on pre-honeycomb devices, you’ll see stuff like the following in your logcat output, which is harmless:

Could not find class 'android.os.StrictMode$ThreadPolicy$Builder', referenced from method [...]
VFY: unable to resolve static method 11475: Landroid/os/StrictMode;.allowThreadDiskWrites ()Landroid/os/StrictMode$ThreadPolicy;

For comparison, here are some other approaches to the problem I’ve encountered:

• Manfred Moser wrote a blog post describing a solution that leverages the fact that a runtime exception is thrown if the StrictMode class cannot be loaded: Android StrictMode for all platform versions
• Dave McLean offered a similar approach that encapsulated the FLAG_DEBUGGABLE check in the wrapper’s init() method in this StackOverflow thread (started by Manfred Moser).  It also appears in the book Pro Android 3, which he co-authored.
• Mark Murphy (author of several Android books, see CommonsWare.com) describes a lazy-loading approach in “The Busy Coder’s Guide to Android Development”.  His approach, which hews closely to the design described in the Android Developers Blog post mentioned earlier, uses an abstract base class with a static init() method that instantiates one of two static inner classes (depending on the value of SDK_INT) that extend the outer class.  [Since it appears we came at the problem from the same viewpoint, I intend to study Mark's approach a bit more.]

The code appearing in  this article is available under the terms of the Apache License, v2.0.