Is there a way to have an Android process produce a heap dump on an OutOfMemoryError?

To expand upon CommonsWare's answer:

I have no idea if this works, but you might try adding a top-level exception handler, and in there asking for a heap dump if it is an OutOfMemoryError.

I followed his suggestion successfully in my own Android app with the following code:

public class MyActivity extends Activity {    public static class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {        @Override        public void uncaughtException(Thread thread, Throwable ex) {            Log.e("UncaughtException", "Got an uncaught exception: "+ex.toString());            if(ex.getClass().equals(OutOfMemoryError.class))            {                try {                    android.os.Debug.dumpHprofData("/sdcard/dump.hprof");                } catch (IOException e) {                    e.printStackTrace();                }            }            ex.printStackTrace();        }    }    @Override    public void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        Thread.currentThread().setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());    }}

After the dump is created, you need to copy it from your phone to your PC: Click "Turn on USB storage" on the phone, find the file and copy it to your hard drive.

Then, if you want to use the Eclipse Memory Analyzer (MAT) to analyze the file, you will need to covert the file: hprof-conv.exe dump.hprof dump-conv.hprof (hprof-conv is located under android-sdk/tools)

Finally, open the dump-conv.hprof file with MAT

I have no idea if this works, but you might try adding a top-level exception handler, and in there asking for a heap dump if it is an OutOfMemoryError.

Here is an improved version. On top of the original implementation this implementation also supports:

• Catching Out of Memory errors on all threads (not only on the main thread)
• Identifying Out of Memory errors even when it's hidden inside a different error. On some instances the Out of Memory error is encapsulated inside a Runtime error.
• Invoking the original default uncaught exception handler too.
• Only works in DEBUG builds.

Usage: Call the static initialize method in your Application class in the onCreate method.

package test;import java.io.File;import java.io.IOException;import java.lang.Thread.UncaughtExceptionHandler;import android.os.Environment;import android.util.Log;import com.example.test1.BuildConfig;public class OutOfMemoryDumper implements Thread.UncaughtExceptionHandler {    private static final String TAG = "OutOfMemoryDumper";    private static final String FILE_PREFIX = "OOM-";    private static final OutOfMemoryDumper instance = new OutOfMemoryDumper();    private UncaughtExceptionHandler oldHandler;    /**     * Call this method to initialize the OutOfMemoryDumper when your     * application is first launched.     */    public static void initialize() {        // Only works in DEBUG builds        if (BuildConfig.DEBUG) {            instance.setup();        }    }    /**     * Keep the constructor private to ensure we only have one instance     */    private OutOfMemoryDumper() {    }    private void setup() {        // Checking if the dumper isn't already the default handler        if (!(Thread.getDefaultUncaughtExceptionHandler() instanceof OutOfMemoryDumper)) {            // Keep the old default handler as we are going to use it later            oldHandler = Thread.getDefaultUncaughtExceptionHandler();            // Redirect uncaught exceptions to this class            Thread.setDefaultUncaughtExceptionHandler(this);        }        Log.v(TAG, "OutOfMemoryDumper is ready");    }    @Override    public void uncaughtException(Thread thread, Throwable ex) {        Log.e(TAG, "Uncaught exception: " + ex);        Log.e(TAG, "Caused by: " + ex.getCause());        // Checking if the exception or the original cause for the exception is        // an out of memory error        if (ex.getClass().equals(OutOfMemoryError.class)                || (ex.getCause() != null && ex.getCause().getClass()                        .equals(OutOfMemoryError.class))) {            // Checking if the external storage is mounted and available            if (isExternalStorageWritable()) {                try {                    // Building the path to the new file                    File f = Environment                            .getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);                    long time = System.currentTimeMillis();                    String dumpPath = f.getAbsolutePath() + "/" + FILE_PREFIX                            + time + ".hprof";                    Log.i(TAG, "Dumping hprof data to: " + dumpPath);                    android.os.Debug.dumpHprofData(dumpPath);                } catch (IOException ioException) {                    Log.e(TAG,"Failed to dump hprof data. " + ioException.toString());                    ioException.printStackTrace();                }            }        }        // Invoking the original default exception handler (if exists)        if (oldHandler != null) {            Log.v(TAG, "Invoking the original uncaught exception handler");            oldHandler.uncaughtException(thread, ex);        }    }    /**     * Checks if external storage is available for read and write     *      * @return true if the external storage is available     */    private boolean isExternalStorageWritable() {        String state = Environment.getExternalStorageState();        if (Environment.MEDIA_MOUNTED.equals(state)) {            return true;        }        Log.w(TAG,"The external storage isn't available. hprof data won't be dumped! (state=" + state + ")");        return false;    }}