570 lines
23 KiB
Java
570 lines
23 KiB
Java
/*
|
|
* Apple // emulator for *nix
|
|
*
|
|
* This software package is subject to the GNU General Public License
|
|
* version 3 or later (your choice) as published by the Free Software
|
|
* Foundation.
|
|
*
|
|
* Copyright 2015 Aaron Culliney
|
|
*
|
|
*/
|
|
|
|
package org.deadc0de.apple2ix;
|
|
|
|
import android.app.AlertDialog;
|
|
import android.content.DialogInterface;
|
|
import android.content.Intent;
|
|
import android.net.Uri;
|
|
import android.os.Build;
|
|
import android.os.Environment;
|
|
import android.util.Log;
|
|
import android.view.View;
|
|
import android.widget.Button;
|
|
import android.widget.ProgressBar;
|
|
|
|
import org.deadc0de.apple2ix.basic.BuildConfig;
|
|
import org.deadc0de.apple2ix.basic.R;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.BufferedWriter;
|
|
import java.io.File;
|
|
import java.io.FileReader;
|
|
import java.io.FileWriter;
|
|
import java.io.FilenameFilter;
|
|
import java.io.IOException;
|
|
import java.io.InterruptedIOException;
|
|
import java.util.concurrent.atomic.AtomicBoolean;
|
|
|
|
public class Apple2CrashHandler {
|
|
|
|
public final static String javaCrashFileName = "jcrash.txt";
|
|
|
|
public static Apple2CrashHandler getInstance() {
|
|
return sCrashHandler;
|
|
}
|
|
|
|
public enum CrashType {
|
|
JAVA_CRASH {
|
|
@Override
|
|
public final String getTitle(Apple2Activity activity) {
|
|
return activity.getResources().getString(R.string.crash_java_npe);
|
|
}
|
|
},
|
|
NULL_DEREF {
|
|
@Override
|
|
public final String getTitle(Apple2Activity activity) {
|
|
return activity.getResources().getString(R.string.crash_null);
|
|
}
|
|
},
|
|
STACKCALL_OVERFLOW {
|
|
@Override
|
|
public final String getTitle(Apple2Activity activity) {
|
|
return activity.getResources().getString(R.string.crash_stackcall_overflow);
|
|
}
|
|
},
|
|
STACKBUF_OVERFLOW {
|
|
@Override
|
|
public final String getTitle(Apple2Activity activity) {
|
|
return activity.getResources().getString(R.string.crash_stackbuf_overflow);
|
|
}
|
|
};
|
|
|
|
|
|
public static final int size = CrashType.values().length;
|
|
|
|
public abstract String getTitle(Apple2Activity activity);
|
|
|
|
public static String[] titles(Apple2Activity activity) {
|
|
String[] titles = new String[size];
|
|
int i = 0;
|
|
for (CrashType setting : values()) {
|
|
titles[i++] = setting.getTitle(activity);
|
|
}
|
|
return titles;
|
|
}
|
|
}
|
|
|
|
public synchronized void initializeAndSetCustomExceptionHandler(Apple2Activity activity) {
|
|
synchronized (this) {
|
|
if (homeDir == null) {
|
|
homeDir = Apple2DisksMenu.getDataDir(activity);
|
|
}
|
|
}
|
|
if (mDefaultExceptionHandler != null) {
|
|
return;
|
|
}
|
|
mDefaultExceptionHandler = Thread.getDefaultUncaughtExceptionHandler();
|
|
|
|
final Thread.UncaughtExceptionHandler defaultExceptionHandler = mDefaultExceptionHandler;
|
|
|
|
Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
|
|
@Override
|
|
public void uncaughtException(Thread thread, Throwable t) {
|
|
try {
|
|
Apple2CrashHandler.onUncaughtException(thread, t);
|
|
} catch (Throwable terminator2) {
|
|
// Yo dawg, I hear you like exceptions in your exception handler! ...
|
|
}
|
|
defaultExceptionHandler.uncaughtException(thread, t);
|
|
}
|
|
});
|
|
}
|
|
|
|
public void abandonAllHope(Apple2Activity activity, Throwable nativeBarfed) {
|
|
// write out the early link crash and send this through the main crash processing code
|
|
onUncaughtException(Thread.currentThread(), nativeBarfed);
|
|
checkForCrashes(activity);
|
|
}
|
|
|
|
public boolean areJavaCrashesPresent(Apple2Activity activity) {
|
|
File javaCrash = _javaCrashFile(activity);
|
|
return javaCrash.exists();
|
|
}
|
|
|
|
public boolean areNativeCrashesPresent(Apple2Activity activity) {
|
|
File[] nativeCrashes = _nativeCrashFiles(activity);
|
|
return nativeCrashes != null && nativeCrashes.length > 0;
|
|
}
|
|
|
|
public boolean areCrashesPresent(Apple2Activity activity) {
|
|
return areJavaCrashesPresent(activity) || areNativeCrashesPresent(activity);
|
|
}
|
|
|
|
public void checkForCrashes(final Apple2Activity activity) {
|
|
if (!areCrashesPresent(activity)) {
|
|
return;
|
|
}
|
|
|
|
if (!Apple2Preferences.CRASH_CHECK.booleanValue(activity)) {
|
|
return;
|
|
}
|
|
|
|
boolean previouslyRanCrashCheck = mAlreadyRanCrashCheck.getAndSet(true);
|
|
|
|
boolean previouslySentReport = mAlreadySentReport.get();
|
|
if (previouslySentReport) {
|
|
|
|
// here we assume that the crash data was previously sent via email ... if not then we lost it =P
|
|
|
|
Log.d(TAG, "Cleaning up crash data ...");
|
|
int idx = 0;
|
|
File[] nativeCrashes = _nativeCrashFiles(activity);
|
|
for (File crash : nativeCrashes) {
|
|
|
|
if (!crash.delete()) {
|
|
Log.d(TAG, "Could not unlink crash : " + crash);
|
|
}
|
|
|
|
File processed = new File(_dumpPath2ProcessedPath(crash.getAbsolutePath()));
|
|
if (!processed.delete()) {
|
|
Log.d(TAG, "Could not unlink processed : " + processed);
|
|
}
|
|
}
|
|
|
|
File javaCrashFile = _javaCrashFile(activity);
|
|
if (!javaCrashFile.delete()) {
|
|
Log.d(TAG, "Could not unlink java crash : " + javaCrashFile);
|
|
}
|
|
|
|
// remove previous log file
|
|
_writeTempLogFile(activity, new StringBuilder());
|
|
return;
|
|
}
|
|
|
|
if (previouslyRanCrashCheck) {
|
|
// don't keep asking on return from backgrounding
|
|
return;
|
|
}
|
|
|
|
final AlertDialog crashDialog = new AlertDialog.Builder(activity).setIcon(R.drawable.ic_launcher).setCancelable(true).setTitle(R.string.crasher_send).setMessage(R.string.crasher_send_message).setNegativeButton(R.string.no, null).setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
|
|
@Override
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
dialog.dismiss();
|
|
|
|
final Apple2SplashScreen splashScreen = activity.getSplashScreen();
|
|
if (splashScreen != null) {
|
|
splashScreen.setDismissable(false);
|
|
}
|
|
final ProgressBar bar = (ProgressBar) activity.findViewById(R.id.crash_progressBar);
|
|
try {
|
|
bar.setVisibility(View.VISIBLE);
|
|
} catch (NullPointerException npe) {
|
|
/* could happen on early lifecycle crashes */
|
|
}
|
|
|
|
new Thread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
|
|
android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND);
|
|
|
|
final int sampleRate = DevicePropertyCalculator.getRecommendedSampleRate(activity);
|
|
final int monoBufferSize = DevicePropertyCalculator.getRecommendedBufferSize(activity, /*isStereo:*/false);
|
|
final int stereoBufferSize = DevicePropertyCalculator.getRecommendedBufferSize(activity, /*isStereo:*/true);
|
|
|
|
StringBuilder summary = new StringBuilder();
|
|
StringBuilder allCrashData = new StringBuilder();
|
|
|
|
// prepend information about this device
|
|
summary.append("BRAND: ").append(Build.BRAND).append("\n");
|
|
summary.append("MODEL: ").append(Build.MODEL).append("\n");
|
|
summary.append("MANUFACTURER: ").append(Build.MANUFACTURER).append("\n");
|
|
summary.append("DEVICE: ").append(Build.DEVICE).append("\n");
|
|
summary.append("SAMPLE RATE: ").append(sampleRate).append("\n");
|
|
summary.append("MONO BUFSIZE: ").append(monoBufferSize).append("\n");
|
|
summary.append("STEREO BUFSIZE: ").append(stereoBufferSize).append("\n");
|
|
summary.append("GPU VENDOR: ").append(Apple2Preferences.GL_VENDOR.stringValue(activity)).append("\n");
|
|
summary.append("GPU RENDERER: ").append(Apple2Preferences.GL_RENDERER.stringValue(activity)).append("\n");
|
|
summary.append("GPU VERSION: ").append(Apple2Preferences.GL_VERSION.stringValue(activity)).append("\n");
|
|
|
|
allCrashData.append(summary);
|
|
|
|
File[] nativeCrashes = _nativeCrashFiles(activity);
|
|
if (nativeCrashes == null) {
|
|
nativeCrashes = new File[0];
|
|
}
|
|
|
|
final int len = nativeCrashes.length + 1/* maybe Java crash */ + 1/* exposeSymbols */;
|
|
|
|
activity.runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (bar != null) {
|
|
bar.setMax(len);
|
|
}
|
|
}
|
|
});
|
|
|
|
if (len > 0) {
|
|
Apple2DisksMenu.exposeSymbols(activity);
|
|
}
|
|
|
|
activity.runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (bar != null) {
|
|
bar.setProgress(1);
|
|
}
|
|
}
|
|
});
|
|
|
|
boolean summarizedHeader = false;
|
|
|
|
// iteratively process native crashes
|
|
for (File crash : nativeCrashes) {
|
|
|
|
String crashPath = crash.getAbsolutePath();
|
|
Log.d(TAG, "Processing crash : " + crashPath);
|
|
|
|
String processedPath = _dumpPath2ProcessedPath(crashPath);
|
|
try {
|
|
nativeProcessCrash(crashPath, processedPath); // Run Breakpad minidump_stackwalk
|
|
} catch (UnsatisfiedLinkError ule) {
|
|
/* could happen on early lifecycle crashes */
|
|
}
|
|
|
|
StringBuilder crashData = new StringBuilder();
|
|
if (!_readFile(new File(processedPath), crashData)) {
|
|
Log.e(TAG, "Error processing crash : " + crashPath);
|
|
}
|
|
allCrashData.append(">>>>>>> NATIVE CRASH [").append(crashPath).append("]\n");
|
|
allCrashData.append(crashData);
|
|
summary.append("NATIVE CRASH:\n");
|
|
|
|
// append succinct information about crashing thread
|
|
String[] lines = crashData.toString().split("[\\n\\r][\\n\\r]*");
|
|
for (int i = 0, j = 0; i < lines.length; i++) {
|
|
|
|
// 2 lines of minidump summary
|
|
if (i < 2) {
|
|
if (!summarizedHeader) {
|
|
summary.append(lines[i]);
|
|
summary.append("\n");
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// 1 line of crashing thread and reason
|
|
if (i == 2) {
|
|
summarizedHeader = true;
|
|
summary.append(lines[i]);
|
|
summary.append("\n");
|
|
continue;
|
|
}
|
|
|
|
// whole lotta modules
|
|
if (lines[i].startsWith("Module")) {
|
|
continue;
|
|
}
|
|
|
|
// one apparently empty line
|
|
if (lines[i].matches("^[ \\t]*$")) {
|
|
continue;
|
|
}
|
|
|
|
// append crashing thread backtrace
|
|
|
|
summary.append(lines[i]);
|
|
summary.append("\n");
|
|
final int maxSummaryBacktrace = 8;
|
|
if (j++ >= maxSummaryBacktrace) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
activity.runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (bar != null) {
|
|
bar.setProgress(bar.getProgress() + 1);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
StringBuilder javaCrashData = new StringBuilder();
|
|
File javaCrashFile = _javaCrashFile(activity);
|
|
if (javaCrashFile.exists()) {
|
|
Log.d(TAG, "Reading java crashes file");
|
|
if (!_readFile(javaCrashFile, javaCrashData)) {
|
|
Log.e(TAG, "Error processing java crash : " + javaCrashFileName);
|
|
}
|
|
}
|
|
|
|
allCrashData.append(">>>>>>> JAVA CRASH DATA\n");
|
|
allCrashData.append(javaCrashData);
|
|
|
|
summary.append("JAVA CRASH:\n");
|
|
summary.append(javaCrashData);
|
|
|
|
activity.runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (bar != null) {
|
|
bar.setProgress(bar.getProgress() + 1);
|
|
}
|
|
}
|
|
});
|
|
|
|
Apple2DisksMenu.unexposeSymbols(activity);
|
|
activity.runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
bar.setVisibility(View.INVISIBLE);
|
|
splashScreen.setDismissable(true);
|
|
} catch (NullPointerException npe) {
|
|
/* could happen on early lifecycle crashes */
|
|
}
|
|
}
|
|
});
|
|
|
|
// send report with all the data
|
|
_sendEmailToDeveloperWithCrashData(activity, summary, allCrashData);
|
|
}
|
|
}).start();
|
|
}
|
|
}).create();
|
|
activity.registerAndShowDialog(crashDialog);
|
|
}
|
|
|
|
public void performCrash(int crashType) {
|
|
if (BuildConfig.DEBUG) {
|
|
nativePerformCrash(crashType);
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
// privates
|
|
|
|
private Apple2CrashHandler() {
|
|
/* ... */
|
|
}
|
|
|
|
private static void onUncaughtException(Thread thread, Throwable t) {
|
|
StackTraceElement[] stackTraceElements = t.getStackTrace();
|
|
StringBuffer traceBuffer = new StringBuffer();
|
|
|
|
// append the Java stack trace
|
|
traceBuffer.append("NAME: ").append(t.getClass().getName()).append("\n");
|
|
traceBuffer.append("MESSAGE: ").append(t.getMessage()).append("\n");
|
|
final int maxTraceSize = 2048 + 1024 + 512; // probably should keep this less than a standard Linux PAGE_SIZE
|
|
for (StackTraceElement elt : stackTraceElements) {
|
|
traceBuffer.append(elt.toString());
|
|
traceBuffer.append("\n");
|
|
if (traceBuffer.length() >= maxTraceSize) {
|
|
break;
|
|
}
|
|
}
|
|
traceBuffer.append("\n");
|
|
|
|
final int maxAttempts = 5;
|
|
int attempts = 0;
|
|
do {
|
|
try {
|
|
BufferedWriter writer = new BufferedWriter(new FileWriter(new File(sCrashHandler.homeDir, javaCrashFileName), /*append:*/true));
|
|
writer.append(traceBuffer);
|
|
writer.flush();
|
|
writer.close();
|
|
break;
|
|
} catch (InterruptedIOException ie) {
|
|
/* EINTR, EAGAIN ... */
|
|
} catch (IOException e) {
|
|
Log.e(TAG, "Exception attempting to write data : " + e);
|
|
}
|
|
|
|
try {
|
|
Thread.sleep(100, 0);
|
|
} catch (InterruptedException e) {
|
|
/* ... */
|
|
}
|
|
++attempts;
|
|
} while (attempts < maxAttempts);
|
|
}
|
|
|
|
private File _javaCrashFile(Apple2Activity activity) {
|
|
return new File(homeDir, javaCrashFileName);
|
|
}
|
|
|
|
private File[] _nativeCrashFiles(Apple2Activity activity) {
|
|
FilenameFilter dmpFilter = new FilenameFilter() {
|
|
public boolean accept(File dir, String name) {
|
|
File file = new File(dir, name);
|
|
if (file.isDirectory()) {
|
|
return false;
|
|
}
|
|
|
|
// check file extensions ... sigh ... no String.endsWithIgnoreCase() ?
|
|
|
|
final String extension = ".dmp";
|
|
final int nameLen = name.length();
|
|
final int extLen = extension.length();
|
|
if (nameLen <= extLen) {
|
|
return false;
|
|
}
|
|
|
|
String suffix = name.substring(nameLen - extLen, nameLen);
|
|
return (suffix.equalsIgnoreCase(extension));
|
|
}
|
|
};
|
|
|
|
return new File(homeDir).listFiles(dmpFilter);
|
|
}
|
|
|
|
private String _dumpPath2ProcessedPath(String crashPath) {
|
|
return crashPath.substring(0, crashPath.length() - 4) + ".txt";
|
|
}
|
|
|
|
private boolean _readFile(File file, StringBuilder fileData) {
|
|
final int maxAttempts = 5;
|
|
int attempts = 0;
|
|
do {
|
|
try {
|
|
BufferedReader reader = new BufferedReader(new FileReader(file));
|
|
char[] buf = new char[1024];
|
|
int numRead = 0;
|
|
while ((numRead = reader.read(buf)) != -1) {
|
|
String readData = String.valueOf(buf, 0, numRead);
|
|
fileData.append(readData);
|
|
}
|
|
reader.close();
|
|
break;
|
|
} catch (InterruptedIOException ie) {
|
|
/* EINTR, EAGAIN ... */
|
|
} catch (IOException e) {
|
|
Log.d(TAG, "Error reading file at path : " + file.toString());
|
|
}
|
|
|
|
try {
|
|
Thread.sleep(100, 0);
|
|
} catch (InterruptedException e) {
|
|
/* ... */
|
|
}
|
|
++attempts;
|
|
} while (attempts < maxAttempts);
|
|
|
|
return attempts < maxAttempts;
|
|
}
|
|
|
|
private File _writeTempLogFile(Apple2Activity activity, StringBuilder allCrashData) {
|
|
|
|
File allCrashFile = null;
|
|
|
|
String storageState = Environment.getExternalStorageState();
|
|
if (storageState.equals(Environment.MEDIA_MOUNTED)) {
|
|
allCrashFile = new File(Environment.getExternalStorageDirectory(), "apple2ix_crash.txt");
|
|
} else {
|
|
allCrashFile = new File(Apple2DisksMenu.getDataDir(activity), "apple2ix_crash.txt");
|
|
}
|
|
|
|
Log.d(TAG, "Writing all crashes to temp file : " + allCrashFile.getAbsolutePath());
|
|
final int maxAttempts = 5;
|
|
int attempts = 0;
|
|
do {
|
|
try {
|
|
BufferedWriter writer = new BufferedWriter(new FileWriter(allCrashFile));
|
|
writer.append(allCrashData);
|
|
writer.flush();
|
|
writer.close();
|
|
break;
|
|
} catch (InterruptedIOException ie) {
|
|
/* EINTR, EAGAIN ... */
|
|
} catch (IOException e) {
|
|
Log.e(TAG, "Exception attempting to write data : " + e);
|
|
}
|
|
|
|
try {
|
|
Thread.sleep(100, 0);
|
|
} catch (InterruptedException e) {
|
|
/* ... */
|
|
}
|
|
++attempts;
|
|
} while (attempts < maxAttempts);
|
|
|
|
if (!allCrashFile.setReadable(true, /*ownerOnly:*/false)) {
|
|
Log.d(TAG, "Oops, could not set all crash data readable!");
|
|
}
|
|
|
|
return allCrashFile;
|
|
}
|
|
|
|
private void _sendEmailToDeveloperWithCrashData(Apple2Activity activity, StringBuilder summary, StringBuilder allCrashData) {
|
|
mAlreadySentReport.set(true);
|
|
|
|
// <sigh> ... the disaster that is early Android ... there does not appear to be a reliable way to start an
|
|
// email Intent to send both text and an attachment, but we make a valiant (if futile) effort to do so here.
|
|
// And the reason to send an attachment is that you trigger an android.os.TransactionTooLargeException with too
|
|
// much text data in the EXTRA_TEXT ... </sigh>
|
|
|
|
Intent emailIntent = new Intent(Intent.ACTION_SENDTO, Uri.fromParts("mailto", "apple2ix_crash@deadcode.org"/*non-zero variant is correct endpoint at the moment*/, null));
|
|
emailIntent.putExtra(Intent.EXTRA_SUBJECT, "Crasher");
|
|
|
|
final int maxCharsEmail = 4096;
|
|
int len = summary.length();
|
|
len = len < maxCharsEmail ? len : maxCharsEmail;
|
|
String summaryData = summary.substring(0, len);
|
|
emailIntent.putExtra(Intent.EXTRA_TEXT, "The app crashed, please help!\n\n"+summaryData);
|
|
|
|
File allCrashFile = _writeTempLogFile(activity, allCrashData);
|
|
emailIntent.putExtra(Intent.EXTRA_STREAM, Uri.fromFile(allCrashFile));
|
|
|
|
Log.d(TAG, "STARTING CHOOSER FOR EMAIL ...");
|
|
activity.startActivity(Intent.createChooser(emailIntent, "Send email"));
|
|
Log.d(TAG, "AFTER START ACTIVITY ...");
|
|
}
|
|
|
|
|
|
private final static String TAG = "Apple2CrashHandler";
|
|
private final static Apple2CrashHandler sCrashHandler = new Apple2CrashHandler();
|
|
|
|
private String homeDir;
|
|
private Thread.UncaughtExceptionHandler mDefaultExceptionHandler;
|
|
private AtomicBoolean mAlreadyRanCrashCheck = new AtomicBoolean(false);
|
|
private AtomicBoolean mAlreadySentReport = new AtomicBoolean(false);
|
|
|
|
private static native void nativePerformCrash(int crashType); // testing
|
|
|
|
private static native void nativeProcessCrash(String crashFilePath, String crashProcessedPath);
|
|
|
|
}
|