diff --git a/app/android.c b/app/android.c
index 30b4083..c0f57d2 100644
--- a/app/android.c
+++ b/app/android.c
@@ -180,30 +180,6 @@
 	return NULL;
 }
 
-char* attachJNI(JNIEnv** envp) {
-	if (current_vm == NULL) {
-		return "current_vm not set";
-	}
-
-	switch ((*current_vm)->GetEnv(current_vm, (void**)envp, JNI_VERSION_1_6)) {
-	case JNI_OK:
-		return NULL;
-	case JNI_EDETACHED:
-		// AttachCurrentThread is typically paired with a call to
-		// DetachCurrentThread, however attachJNI is called for
-		// the duration of the main function, which exits when the
-		// process exits. We let Unix take care of thread cleanup.
-		if ((*current_vm)->AttachCurrentThread(current_vm, envp, 0) != 0) {
-			return "cannot attach JVM";
-		}
-		return NULL;
-	case JNI_EVERSION:
-		return "bad JNI version";
-	default:
-		return "unknown GetEnv error";
-	}
-}
-
 int32_t getKeyRune(JNIEnv* env, AInputEvent* e) {
 	return (int32_t)(*env)->CallIntMethod(
 		env,
diff --git a/app/android.go b/app/android.go
index 80cce58..0ddbd38 100644
--- a/app/android.go
+++ b/app/android.go
@@ -45,7 +45,6 @@
 char* initEGLDisplay();
 char* createEGLSurface(ANativeWindow* window);
 char* destroyEGLSurface();
-char* attachJNI(JNIEnv**);
 int32_t getKeyRune(JNIEnv* env, AInputEvent* e);
 */
 import "C"
@@ -53,7 +52,6 @@
 	"fmt"
 	"log"
 	"os"
-	"runtime"
 	"time"
 	"unsafe"
 
@@ -248,21 +246,23 @@
 }
 
 func main(f func(App)) {
+	mainUserFn = f
 	// Preserve this OS thread for:
 	//	1. the attached JNI thread
 	//	2. the GL context
-	runtime.LockOSThread()
-
-	// Calls into NativeActivity functions must be made from
-	// a thread attached to the JNI.
-	var env *C.JNIEnv
-	if errStr := C.attachJNI(&env); errStr != nil {
-		log.Fatalf("app: %s", C.GoString(errStr))
+	if err := mobileinit.RunOnJVM(mainUI); err != nil {
+		log.Fatalf("app: %v", err)
 	}
+}
+
+var mainUserFn func(App)
+
+func mainUI(vm, jniEnv, ctx uintptr) error {
+	env := (*C.JNIEnv)(unsafe.Pointer(jniEnv)) // not a Go heap pointer
 
 	donec := make(chan struct{})
 	go func() {
-		f(app{})
+		mainUserFn(app{})
 		close(donec)
 	}()
 
@@ -291,15 +291,14 @@
 		case <-windowCreated:
 		case q = <-inputQueue:
 		case <-donec:
-			return
+			return nil
 		case cfg := <-windowConfigChange:
 			pixelsPerPt = cfg.pixelsPerPt
 			orientation = cfg.orientation
 		case w := <-windowRedrawNeeded:
 			if C.surface == nil {
 				if errStr := C.createEGLSurface(w); errStr != nil {
-					log.Printf("app: %s (%s)", C.GoString(errStr), eglGetError())
-					return
+					return fmt.Errorf("%s (%s)", C.GoString(errStr), eglGetError())
 				}
 			}
 			sendLifecycle(lifecycle.StageFocused)
@@ -318,8 +317,7 @@
 		case <-windowDestroyed:
 			if C.surface != nil {
 				if errStr := C.destroyEGLSurface(); errStr != nil {
-					log.Printf("app: %s (%s)", C.GoString(errStr), eglGetError())
-					return
+					return fmt.Errorf("%s (%s)", C.GoString(errStr), eglGetError())
 				}
 			}
 			C.surface = nil
diff --git a/asset/asset_android.go b/asset/asset_android.go
index 0476baf..e654fba 100644
--- a/asset/asset_android.go
+++ b/asset/asset_android.go
@@ -5,35 +5,18 @@
 package asset
 
 /*
-#cgo LDFLAGS: -llog -landroid
-#include <android/log.h>
+#cgo LDFLAGS: -landroid
 #include <android/asset_manager.h>
 #include <android/asset_manager_jni.h>
 #include <jni.h>
 #include <stdlib.h>
 
-#define LOG_FATAL(...) __android_log_print(ANDROID_LOG_FATAL, "Go/asset", __VA_ARGS__)
-
 // asset_manager is the asset manager of the app.
 AAssetManager* asset_manager;
 
-void asset_manager_init(void* java_vm, void* ctx) {
-	JavaVM* vm = (JavaVM*)(java_vm);
-	JNIEnv* env;
-	int err;
-	int attached = 0;
-
-	err = (*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_6);
-	if (err != JNI_OK) {
-		if (err == JNI_EDETACHED) {
-			if ((*vm)->AttachCurrentThread(vm, &env, 0) != 0) {
-				LOG_FATAL("cannot attach JVM");
-			}
-			attached = 1;
-		} else {
-			LOG_FATAL("GetEnv unexpected error: %d", err);
-		}
-	}
+void asset_manager_init(uintptr_t java_vm, uintptr_t jni_env, uintptr_t ctx) {
+	JavaVM* vm = (JavaVM*)java_vm;
+	JNIEnv* env = (JNIEnv*)jni_env;
 
 	// Equivalent to:
 	//	assetManager = ctx.getResources().getAssets();
@@ -47,16 +30,13 @@
 	// Pin the AssetManager and load an AAssetManager from it.
 	am = (*env)->NewGlobalRef(env, am);
 	asset_manager = AAssetManager_fromJava(env, am);
-
-	if (attached) {
-		(*vm)->DetachCurrentThread(vm);
-	}
 }
 */
 import "C"
 import (
 	"fmt"
 	"io"
+	"log"
 	"os"
 	"sync"
 	"unsafe"
@@ -67,8 +47,13 @@
 var assetOnce sync.Once
 
 func assetInit() {
-	ctx := mobileinit.Context{}
-	C.asset_manager_init(ctx.JavaVM(), ctx.AndroidContext())
+	err := mobileinit.RunOnJVM(func(vm, env, ctx uintptr) error {
+		C.asset_manager_init(C.uintptr_t(vm), C.uintptr_t(env), C.uintptr_t(ctx))
+		return nil
+	})
+	if err != nil {
+		log.Fatalf("asset: %v", err)
+	}
 }
 
 func openAsset(name string) (File, error) {
diff --git a/exp/audio/al/al_android.go b/exp/audio/al/al_android.go
index a076a9c..1113562 100644
--- a/exp/audio/al/al_android.go
+++ b/exp/audio/al/al_android.go
@@ -13,30 +13,9 @@
 #include <AL/al.h>
 #include <AL/alc.h>
 
-typedef enum {
-  AL_INIT_RESULT_OK,
-  AL_INIT_RESULT_CANNOT_ATTACH_JVM,
-  AL_INIT_RESULT_BAD_JNI_VERSION,
-  AL_INIT_RESULT_CANNOT_LOAD_SO
-} ALInitResult;
-
-ALInitResult al_init(void* vm, void* context, void** handle) {
-  JavaVM* current_vm = (JavaVM*)(vm);
-  JNIEnv* env;
-
-  int attached = 0;
-  switch ((*current_vm)->GetEnv(current_vm, (void**)&env, JNI_VERSION_1_6)) {
-  case JNI_OK:
-    break;
-  case JNI_EDETACHED:
-    if ((*current_vm)->AttachCurrentThread(current_vm, &env, 0) != 0) {
-      return AL_INIT_RESULT_CANNOT_ATTACH_JVM;
-    }
-    attached = 1;
-    break;
-  case JNI_EVERSION:
-    return AL_INIT_RESULT_BAD_JNI_VERSION;
-  }
+void al_init(uintptr_t java_vm, uintptr_t jni_env, uintptr_t context, void** handle) {
+  JavaVM* vm = (JavaVM*)java_vm;
+  JNIEnv* env = (JNIEnv*)jni_env;
 
   jclass android_content_Context = (*env)->FindClass(env, "android/content/Context");
   jmethodID get_package_name = (*env)->GetMethodID(env, android_content_Context, "getPackageName", "()Ljava/lang/String;");
@@ -48,13 +27,6 @@
   strlcat(lib_path, "/lib/libopenal.so", sizeof(lib_path));
   *handle = dlopen(lib_path, RTLD_LAZY);
   (*env)->ReleaseStringUTFChars(env, package_name, cpackage_name);
-  if (attached) {
-    (*current_vm)->DetachCurrentThread(current_vm);
-  }
-  if (!*handle) {
-    return AL_INIT_RESULT_CANNOT_LOAD_SO;
-  }
-  return AL_INIT_RESULT_OK;
 }
 
 void call_alEnable(LPALENABLE fn, ALenum capability) {
@@ -195,6 +167,7 @@
 */
 import "C"
 import (
+	"errors"
 	"log"
 	"unsafe"
 
@@ -247,18 +220,15 @@
 )
 
 func initAL() {
-	ctx := mobileinit.Context{}
-	switch C.al_init(ctx.JavaVM(), ctx.AndroidContext(), &alHandle) {
-	case C.AL_INIT_RESULT_OK:
-		// No-op.
-	case C.AL_INIT_RESULT_CANNOT_ATTACH_JVM:
-		log.Fatal("al: cannot attach JVM")
-	case C.AL_INIT_RESULT_BAD_JNI_VERSION:
-		log.Fatal("al: bad JNI version")
-	case C.AL_INIT_RESULT_CANNOT_LOAD_SO:
-		log.Fatal("al: cannot load libopenal.so")
-	default:
-		log.Fatal("al: cannot initialize OpenAL library")
+	err := mobileinit.RunOnJVM(func(vm, env, ctx uintptr) error {
+		C.al_init(C.uintptr_t(vm), C.uintptr_t(env), C.uintptr_t(ctx), &alHandle)
+		if alHandle == nil {
+			return errors.New("al: cannot load libopenal.so")
+		}
+		return nil
+	})
+	if err != nil {
+		log.Fatalf("al: %v", err)
 	}
 
 	alEnableFunc = C.LPALENABLE(fn("alEnable"))
diff --git a/internal/mobileinit/ctx_android.go b/internal/mobileinit/ctx_android.go
index 753a2c8..559f918 100644
--- a/internal/mobileinit/ctx_android.go
+++ b/internal/mobileinit/ctx_android.go
@@ -19,43 +19,106 @@
 // current_ctx is Android's android.context.Context. May be NULL.
 jobject current_ctx;
 
-// Set current_vm and current_ctx. The ctx passed in must be a global
-// reference instance.
-void set_vm_ctx(JavaVM* vm, jobject ctx) {
-	current_vm = vm;
-	current_ctx = ctx;
-	// TODO: check leak
+char* lockJNI(uintptr_t* envp, int* attachedp) {
+	JNIEnv* env;
+
+	if (current_vm == NULL) {
+		return "no current JVM";
+	}
+
+	*attachedp = 0;
+	switch ((*current_vm)->GetEnv(current_vm, (void**)&env, JNI_VERSION_1_6)) {
+	case JNI_OK:
+		break;
+	case JNI_EDETACHED:
+		if ((*current_vm)->AttachCurrentThread(current_vm, &env, 0) != 0) {
+			return "cannot attach to JVM";
+		}
+		*attachedp = 1;
+		break;
+	case JNI_EVERSION:
+		return "bad JNI version";
+	default:
+		return "unknown JNI error from GetEnv";
+	}
+
+	*envp = (uintptr_t)env;
+	return NULL;
+}
+
+char* checkException(uintptr_t jnienv) {
+	jthrowable exc;
+	JNIEnv* env = (JNIEnv*)jnienv;
+
+	if (!(*env)->ExceptionCheck(env)) {
+		return NULL;
+	}
+
+	exc = (*env)->ExceptionOccurred(env);
+	(*env)->ExceptionClear(env);
+
+	jclass clazz = (*env)->FindClass(env, "java/lang/Throwable");
+	jmethodID toString = (*env)->GetMethodID(env, clazz, "toString", "()Ljava/lang/String;");
+	jobject msgStr = (*env)->CallObjectMethod(env, exc, toString);
+	return (char*)(*env)->GetStringUTFChars(env, msgStr, 0);
+}
+
+void unlockJNI() {
+	(*current_vm)->DetachCurrentThread(current_vm);
 }
 */
 import "C"
 
-import "unsafe"
+import (
+	"errors"
+	"runtime"
+	"unsafe"
+)
 
 // SetCurrentContext populates the global Context object with the specified
 // current JavaVM instance (vm) and android.context.Context object (ctx).
 // The android.context.Context object must be a global reference.
 func SetCurrentContext(vm, ctx unsafe.Pointer) {
-	C.set_vm_ctx((*C.JavaVM)(vm), (C.jobject)(ctx))
+	C.current_vm = (*C.JavaVM)(vm)
+	C.current_ctx = (C.jobject)(ctx)
 }
 
-// TODO(hyangah): should the app package have Context? It may be useful for
-// external packages that need to access android context and vm.
-
-// Context holds global OS-specific context.
+// RunOnJVM runs fn on a new goroutine locked to an OS thread with a JNIEnv.
 //
-// Its extra methods are deliberately difficult to access because they must be
-// used with care. Their use implies the use of cgo, which probably requires
-// you understand the initialization process in the app package. Also care must
-// be taken to write both Android, iOS, and desktop-testing versions to
-// maintain portability.
-type Context struct{}
+// RunOnJVM blocks until the call to fn is complete. Any Java
+// exception or failure to attach to the JVM is returned as an error.
+//
+// The function fn takes vm, the current JavaVM*,
+// env, the current JNIEnv*, and
+// ctx, a jobject representing the global android.context.Context.
+func RunOnJVM(fn func(vm, env, ctx uintptr) error) error {
+	errch := make(chan error)
+	go func() {
+		runtime.LockOSThread()
+		defer runtime.UnlockOSThread()
 
-// AndroidContext returns a jobject for the app android.context.Context.
-func (Context) AndroidContext() unsafe.Pointer {
-	return unsafe.Pointer(C.current_ctx)
-}
+		env := C.uintptr_t(0)
+		attached := C.int(0)
+		if errStr := C.lockJNI(&env, &attached); errStr != nil {
+			errch <- errors.New(C.GoString(errStr))
+			return
+		}
+		if attached != 0 {
+			defer C.unlockJNI()
+		}
 
-// JavaVM returns a JNI *JavaVM.
-func (Context) JavaVM() unsafe.Pointer {
-	return unsafe.Pointer(C.current_vm)
+		vm := uintptr(unsafe.Pointer(C.current_vm))
+		if err := fn(vm, uintptr(env), uintptr(C.current_ctx)); err != nil {
+			errch <- err
+			return
+		}
+
+		if exc := C.checkException(env); exc != nil {
+			errch <- errors.New(C.GoString(exc))
+			C.free(unsafe.Pointer(exc))
+			return
+		}
+		errch <- nil
+	}()
+	return <-errch
 }