/** 初始化 */ public void init(Context context) { this.context = context; // 获取系统默认的UncaughtException处理器 mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler(); // 设置该CrashHandler为程序的默认处理器 Thread.setDefaultUncaughtExceptionHandler(this); }
private void handleTaskEvents(PropertyChangeEvent evt) { String taskId = null; if (evt.getSource() instanceof SolaTask) { taskId = ((SolaTask) evt.getSource()).getId(); } if (evt.getPropertyName().equals(SolaTask.EVENT_STATE)) { StateValue state = (StateValue) evt.getNewValue(); if (state.name().equalsIgnoreCase(SolaTask.TASK_DONE)) { tasks.remove(taskId); } } if (evt.getPropertyName().equals(SolaTask.REMOVE_TASK)) { tasks.remove(taskId); } if (evt.getPropertyName().equals(SolaTask.EXCEPTION_RISED)) { if (Throwable.class.isAssignableFrom(evt.getNewValue().getClass())) { UncaughtExceptionHandler defaultHandler = Thread.getDefaultUncaughtExceptionHandler(); if (defaultHandler != null) { Thread.getDefaultUncaughtExceptionHandler() .uncaughtException(Thread.currentThread(), (Throwable) evt.getNewValue()); } else { DefaultExceptionHandler.handleException((Throwable) evt.getNewValue()); } } if (taskId != null) { tasks.remove(taskId); } } propertySupport.firePropertyChange(evt); }
/** * 異常處理初始化 * * @param context */ public void init(Context context) { this.mContext = context; // 獲取系統默認的UncaughtException處理器 defalutHandler = Thread.getDefaultUncaughtExceptionHandler(); // 設置該CrashHandler為程序的默認處理器 Thread.setDefaultUncaughtExceptionHandler(this); }
public void Init(Context context) { Log.d(LOG, "init"); PreviousHandler = Thread.getDefaultUncaughtExceptionHandler(); Thread.setDefaultUncaughtExceptionHandler(this); RecoltInformations(context); CurContext = context; }
/** * 初始化,注册Context对象, 获取系统默认的UncaughtException处理器, 设置该CrashHandler为程序的默认处理器 * * @param ctx */ public void init(Context ctx) { mContext = ctx; mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler(); Thread.setDefaultUncaughtExceptionHandler(this); SharedPreferences userInfo = ctx.getSharedPreferences("userInfo", 0); userName = userInfo.getString("username", null); }
public static void regist() { UncaughtExceptionHandler cur_handler = Thread.getDefaultUncaughtExceptionHandler(); if (cur_handler instanceof ExceptionHandler) return; orig_handler = cur_handler; Thread.setDefaultUncaughtExceptionHandler(new ExceptionHandler()); log.d("setDefaultUncaughtExceptionHandler"); }
@Override public void onCreate() { super.onCreate(); Thread.setDefaultUncaughtExceptionHandler( new MyUncaughtExceptionHandler(Thread.getDefaultUncaughtExceptionHandler())); }
private void setUncaughtExceptionHandler() { Thread.UncaughtExceptionHandler handler = Thread.getDefaultUncaughtExceptionHandler(); if (!(handler instanceof SubsonicActivity.SubsonicUncaughtExceptionHandler)) { Thread.setDefaultUncaughtExceptionHandler( new SubsonicActivity.SubsonicUncaughtExceptionHandler(this)); } }
/** * 初始化 * * @param context */ public void initialize(Context context) { if (mInitialized) { return; } Set<String> neededPermissions = new TreeSet<>(); neededPermissions.add(Manifest.permission.WRITE_EXTERNAL_STORAGE); if (!checkPermissions(context, neededPermissions)) { StringBuilder sb = new StringBuilder(); for (String permission : neededPermissions) { sb.append(permission).append("\n"); } throw new IllegalArgumentException("Permissions needed:\n " + sb.toString()); } // 在单例中使用全局Application Context mContext = context.getApplicationContext(); // 获取系统默认的UncaughtException处理器 mLocalExceptionHandler = Thread.getDefaultUncaughtExceptionHandler(); // 设置该CrashHandler为程序的默认处理器 Thread.setDefaultUncaughtExceptionHandler(this); mInitialized = true; }
/** Set own uncaught exception handler to log crashes */ public static void init() { new SendTask(false).start(); sDefaultHandler = Thread.getDefaultUncaughtExceptionHandler(); if (!(sDefaultHandler instanceof RemoteLog)) { Thread.setDefaultUncaughtExceptionHandler(new RemoteLog()); } }
@SuppressLint("NewApi") public static final void init(Application application) { if (Thread.getDefaultUncaughtExceptionHandler() instanceof CrashHelper) { return; } CrashHelper helper = new CrashHelper(); Thread.setDefaultUncaughtExceptionHandler(helper); }
public DefaultExceptionHandler() { defaultHandler = Thread.getDefaultUncaughtExceptionHandler(); intent = PendingIntent.getActivity( OsmandApplication.this.getBaseContext(), 0, new Intent( OsmandApplication.this.getBaseContext(), getAppCustomization().getMapActivity()), 0); }
/** * Send @param t and any exception wrapped by @param r to the default uncaught exception handler, * or log them if none such is set up */ public static void logExceptionsAfterExecute(Runnable r, Throwable t) { Throwable hiddenThrowable = extractThrowable(r); if (hiddenThrowable != null) handleOrLog(hiddenThrowable); // ThreadPoolExecutor will re-throw exceptions thrown by its Task (which // will be seen by // the default uncaught exception handler) so we only need to do // anything if that handler // isn't set up yet. if (t != null && Thread.getDefaultUncaughtExceptionHandler() == null) handleOrLog(t); }
@Override public void onSuccess(Object result) { if (isShutdown.get()) { LOG.info("Wait queue scheduler worker exited with success!"); } else { LOG.error("Wait queue scheduler worker exited with success!"); Thread.getDefaultUncaughtExceptionHandler() .uncaughtException( Thread.currentThread(), new IllegalStateException("WaitQueue worked exited before shutdown")); } }
@Test public void testPiwikExceptionHandler() throws Exception { Tracker tracker = createTracker(); assertFalse(Thread.getDefaultUncaughtExceptionHandler() instanceof PiwikExceptionHandler); QuickTrack.trackUncaughtExceptions(tracker); assertTrue(Thread.getDefaultUncaughtExceptionHandler() instanceof PiwikExceptionHandler); try { int i = 1 / 0; assertNotEquals(i, 0); } catch (Exception e) { (Thread.getDefaultUncaughtExceptionHandler()).uncaughtException(Thread.currentThread(), e); } QueryHashMap<String, String> queryParams = parseEventUrl(tracker.getLastEvent()); validateDefaultQuery(queryParams); assertEquals(queryParams.get(QueryParams.EVENT_CATEGORY), "Exception"); assertTrue( queryParams .get(QueryParams.EVENT_ACTION) .startsWith("org.piwik.sdk.QuickTrackTest/testPiwikExceptionHandler:")); assertEquals(queryParams.get(QueryParams.EVENT_NAME), "/ by zero"); assertEquals(queryParams.get(QueryParams.EVENT_VALUE), "1"); }
private ExceptionHandler(Context context, boolean chained) { PackageManager mPackManager = context.getPackageManager(); PackageInfo mPackInfo; try { mPackInfo = mPackManager.getPackageInfo(context.getPackageName(), 0); versionName = mPackInfo.versionName; versionCode = mPackInfo.versionCode; } catch (PackageManager.NameNotFoundException e) { // ignore } if (chained) previousHandler = Thread.getDefaultUncaughtExceptionHandler(); else previousHandler = null; stacktraceDir = String.format("/Android/data/%s/files/", context.getPackageName()); }
@Override public final void run() { try { if (!mGifDrawable.isRecycled()) { doWork(); } } catch (Throwable throwable) { final Thread.UncaughtExceptionHandler uncaughtExceptionHandler = Thread.getDefaultUncaughtExceptionHandler(); if (uncaughtExceptionHandler != null) { uncaughtExceptionHandler.uncaughtException(Thread.currentThread(), throwable); } // throw throwable; } }
/** * This test creates three empty files and lets their leases expire. This triggers release of the * leases. The empty files are supposed to be closed by that without causing * ConcurrentModificationException. */ public void testLeaseExpireEmptyFiles() throws Exception { final Thread.UncaughtExceptionHandler oldUEH = Thread.getDefaultUncaughtExceptionHandler(); Thread.setDefaultUncaughtExceptionHandler( new Thread.UncaughtExceptionHandler() { public void uncaughtException(Thread t, Throwable e) { if (e instanceof ConcurrentModificationException) { FSNamesystem.LOG.error("t=" + t, e); isConcurrentModificationException = true; } } }); System.out.println("testLeaseExpireEmptyFiles start"); final long leasePeriod = 1000; final int DATANODE_NUM = 3; final Configuration conf = new HdfsConfiguration(); conf.setInt(DFSConfigKeys.DFS_NAMENODE_HEARTBEAT_RECHECK_INTERVAL_KEY, 1000); conf.setInt("dfs.heartbeat.interval", 1); // create cluster MiniDFSCluster cluster = new MiniDFSCluster.Builder(conf).numDataNodes(DATANODE_NUM).build(); try { cluster.waitActive(); DistributedFileSystem dfs = (DistributedFileSystem) cluster.getFileSystem(); // create a new file. TestFileCreation.createFile(dfs, new Path("/foo"), DATANODE_NUM); TestFileCreation.createFile(dfs, new Path("/foo2"), DATANODE_NUM); TestFileCreation.createFile(dfs, new Path("/foo3"), DATANODE_NUM); // set the soft and hard limit to be 1 second so that the // namenode triggers lease recovery cluster.setLeasePeriod(leasePeriod, leasePeriod); // wait for the lease to expire try { Thread.sleep(5 * leasePeriod); } catch (InterruptedException e) { } assertFalse(isConcurrentModificationException); } finally { Thread.setDefaultUncaughtExceptionHandler(oldUEH); cluster.shutdown(); } }
public static HttpErrorCollector registerInVM( Context applicationContext, String version, MyceliumWalletApi api) { // Initialize error collector boolean emailOnErrors = applicationContext.getResources().getBoolean(R.bool.email_on_errors); if (!emailOnErrors) { return null; } Thread.UncaughtExceptionHandler orig = Thread.getDefaultUncaughtExceptionHandler(); if ((orig instanceof HttpErrorCollector)) { return (HttpErrorCollector) orig; } Log.i( Constants.TAG, "registering exception handler from thread " + Thread.currentThread().getName()); HttpErrorCollector ret = new HttpErrorCollector(orig, api, version, buildMetaData(applicationContext)); Thread.setDefaultUncaughtExceptionHandler(ret); return ret; }
/** http://stackoverflow.com/a/26560727 */ private void setupExceptionHandler() { final Thread.UncaughtExceptionHandler oldHandler = Thread.getDefaultUncaughtExceptionHandler(); Thread.setDefaultUncaughtExceptionHandler( new Thread.UncaughtExceptionHandler() { @Override public void uncaughtException(Thread paramThread, Throwable paramThrowable) { // Do your own error handling here // try to write log file to the image path. writeException(paramThread, paramThrowable); if (oldHandler != null) oldHandler.uncaughtException( paramThread, paramThrowable); // Delegates to Android's error handling else System.exit(2); // Prevents the service/app from freezing } }); }
/** * 初始化 * * @param context 上下文 * @return {@code true}: 成功<br> * {@code false}: 失败 */ public boolean init(Context context) { if (mInitialized) return true; if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) { crashDir = context.getExternalCacheDir().getPath() + File.separator + "crash" + File.separator; } else { crashDir = context.getCacheDir().getPath() + File.separator + "crash" + File.separator; } try { PackageInfo pi = context.getPackageManager().getPackageInfo(context.getPackageName(), 0); versionName = pi.versionName; versionCode = pi.versionCode; } catch (PackageManager.NameNotFoundException e) { e.printStackTrace(); return false; } mHandler = Thread.getDefaultUncaughtExceptionHandler(); Thread.setDefaultUncaughtExceptionHandler(this); return mInitialized = true; }
public static void main(String[] args) { // first of all config log configLogFile(); final UncaughtExceptionHandler defaultHandler = Thread.getDefaultUncaughtExceptionHandler(); Thread.setDefaultUncaughtExceptionHandler( new UncaughtExceptionHandler() { @Override public void uncaughtException(Thread t, Throwable e) { if (!(e instanceof ThreadDeath)) { ExceptionHandler.handle("Error in thread " + t.getName(), e); // $NON-NLS-1$ } defaultHandler.uncaughtException(t, e); } }); MAIN_APP = new OsmExtractionUI(); MAIN_APP.frame.setBounds(DataExtractionSettings.getSettings().getWindowBounds()); MAIN_APP.frame.setVisible(true); }
@Override public void onCreate() { super.onCreate(); TiScriptRunner.getInstance().setAppPackageName(getPackageName()); if (DBG) { Log.d(LCAT, "Application onCreate"); } final UncaughtExceptionHandler defaultHandler = Thread.getDefaultUncaughtExceptionHandler(); Thread.setDefaultUncaughtExceptionHandler( new UncaughtExceptionHandler() { public void uncaughtException(Thread t, Throwable e) { String tiVer = buildVersion + "," + buildTimestamp + "," + buildHash; Log.e( "TiUncaughtHandler", "Sending event: exception on thread: " + t.getName() + " msg:" + e.toString() + "; Titanium " + tiVer, e); postAnalyticsEvent(TiAnalyticsEventFactory.createErrorEvent(t, e, tiVer)); defaultHandler.uncaughtException(t, e); } }); baseUrl = "file:///android_asset/Resources/"; File fullPath = new File(baseUrl, getStartFilename("app.js")); baseUrl = fullPath.getParent(); methodMap = new HashMap<Class<?>, HashMap<String, Method>>(25); proxyMap = new HashMap<String, SoftReference<KrollProxy>>(5); appProperties = new TiProperties(getApplicationContext(), APPLICATION_PREFERENCES_NAME, false); systemProperties = new TiProperties(getApplicationContext(), "system", true); // systemProperties.setString("ti.version", buildVersion); // was always setting "1.0" }
/** Define custom ExceptionHandler which takes action on OutOfMemoryError. */ private void setExceptionHandler() { final UncaughtExceptionHandler defaultExceptionHandler = Thread.getDefaultUncaughtExceptionHandler(); UncaughtExceptionHandler customExceptionHandler = new UncaughtExceptionHandler() { @Override public void uncaughtException(final Thread thread, final Throwable ex) { if (ex instanceof OutOfMemoryError) { // Store info about OutOfMemoryError PreferenceUtil.setSharedPreferenceBoolean( R.string.key_internal_outofmemoryerror, true); } // re-throw critical exception further to the os defaultExceptionHandler.uncaughtException(thread, ex); } }; Thread.setDefaultUncaughtExceptionHandler(customExceptionHandler); }
@Override protected void afterExecute(Runnable r, Throwable t) { // We must make sure that we don't swallow exceptions, we must propagate them back. if ((t == null) && (r instanceof Future<?>)) { try { Future<?> future = (Future<?>) r; assert future.isDone(); future.get(); } catch (CancellationException ce) { t = ce; } catch (ExecutionException ee) { t = ee.getCause(); } catch (InterruptedException ie) { Thread.currentThread().interrupt(); // ignore/reset } } if (t != null) { Thread.getDefaultUncaughtExceptionHandler() .uncaughtException(Thread.currentThread(), t); } };
/** * SampleApplication.java * * <p>This file is a part of the Yandex.Metrica for Apps. * * <p>Version for Android © 2013 YANDEX * * <p>You may not use this file except in compliance with the License. You may obtain a copy of the * License at http://legal.yandex.com/metrica_termsofuse/ */ public class SampleApplication extends Application { private static final Thread.UncaughtExceptionHandler mDefaultExceptionHandler = Thread.getDefaultUncaughtExceptionHandler(); @Override public void onCreate() { super.onCreate(); /** Initialize metrica */ Counter.initialize(this); /** Can be set programmatically or into the AndroidManifest.xml */ /** Counter.sharedInstance().setApiKey("1111"); */ /** Can be set programmatically or into the AndroidManifest.xml */ /** Counter.sharedInstance().setCustomAppVersion("1.0"); */ } static Thread.UncaughtExceptionHandler getDefaultExceptionHandler() { return mDefaultExceptionHandler; } }
/** * Can only be constructed from within this class. * * @param context Context for the application in which ACRA is running. * @param prefs SharedPreferences used by ACRA. * @param enabled Whether this ErrorReporter should capture Exceptions and forward their reports. */ ErrorReporter(Application context, SharedPreferences prefs, boolean enabled) { this.mContext = context; this.prefs = prefs; this.enabled = enabled; // Store the initial Configuration state. final String initialConfiguration = ConfigurationCollector.collectConfiguration(mContext); // Sets the application start date. // This will be included in the reports, will be helpful compared to // user_crash date. final Time appStartDate = new Time(); appStartDate.setToNow(); if (Compatibility.getAPILevel() >= 14) { // ActivityLifecycleCallback // only available for API14+ ApplicationHelper.registerActivityLifecycleCallbacks( context, new ActivityLifecycleCallbacksCompat() { @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) { if (ACRA.DEV_LOGGING) ACRA.log.d(ACRA.LOG_TAG, "onActivityCreated " + activity.getClass()); if (!(activity instanceof CrashReportDialog)) { // Ignore CrashReportDialog because we want the last // application Activity that was started so that we can // explicitly kill it off. lastActivityCreated = new WeakReference<Activity>(activity); } } @Override public void onActivityStarted(Activity activity) { if (ACRA.DEV_LOGGING) ACRA.log.d(ACRA.LOG_TAG, "onActivityStarted " + activity.getClass()); } @Override public void onActivityResumed(Activity activity) { if (ACRA.DEV_LOGGING) ACRA.log.d(ACRA.LOG_TAG, "onActivityResumed " + activity.getClass()); } @Override public void onActivityPaused(Activity activity) { if (ACRA.DEV_LOGGING) ACRA.log.d(ACRA.LOG_TAG, "onActivityPaused " + activity.getClass()); } @Override public void onActivityStopped(Activity activity) { if (ACRA.DEV_LOGGING) ACRA.log.d(ACRA.LOG_TAG, "onActivityStopped " + activity.getClass()); } @Override public void onActivitySaveInstanceState(Activity activity, Bundle outState) { if (ACRA.DEV_LOGGING) ACRA.log.i(ACRA.LOG_TAG, "onActivitySaveInstanceState " + activity.getClass()); } @Override public void onActivityDestroyed(Activity activity) { if (ACRA.DEV_LOGGING) ACRA.log.i(ACRA.LOG_TAG, "onActivityDestroyed " + activity.getClass()); } }); } crashReportDataFactory = new CrashReportDataFactory(mContext, prefs, appStartDate, initialConfiguration); // If mDfltExceptionHandler is not null, initialization is already done. // Don't do it twice to avoid losing the original handler. mDfltExceptionHandler = Thread.getDefaultUncaughtExceptionHandler(); Thread.setDefaultUncaughtExceptionHandler(this); }
public VlcCrashHandler() { this.defaultUEH = Thread.getDefaultUncaughtExceptionHandler(); }
protected void init() { mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler(); Thread.setDefaultUncaughtExceptionHandler(this); }
public final void a(Context paramContext) { boolean bool2 = true; if (paramContext == null) { dav.b("Context cannot be null"); } Object localObject; dbd localdbd; dao localdao; do { return; localObject = czv.a(); localdbd = new dbd(paramContext.getApplicationContext()); localdao = dao.a(paramContext.getApplicationContext()); if (paramContext == null) { dav.b("Context cannot be null"); } } while (w != null); w = paramContext.getApplicationContext(); x = localdao; y = ((dbi)localObject); h = localdbd; n = h.a("ga_trackingId"); if (TextUtils.isEmpty(n)) { n = h.a("ga_api_key"); if (TextUtils.isEmpty(n)) { dav.b("EasyTracker requested, but missing required ga_trackingId"); g = new czp(this); return; } } a = true; o = h.a("ga_appName"); p = h.a("ga_appVersion"); r = h.c("ga_debug"); s = h.b("ga_sampleFrequency"); if (s == null) { s = new Double(h.a("ga_sampleRate", 100)); } q = h.a("ga_dispatchPeriod", 1800); d = (h.a("ga_sessionTimeout", 30) * 1000); boolean bool1 = bool2; if (!h.c("ga_autoActivityTracking")) { if (!h.c("ga_auto_activity_tracking")) { break label548; } } label548: for (bool1 = bool2;; bool1 = false) { b = bool1; t = h.c("ga_anonymizeIp"); u = h.c("ga_reportUncaughtExceptions"); g = x.a(n); if (!TextUtils.isEmpty(o)) { dav.c("setting appName to " + o); g.a(o); } if (p != null) { g.b(p); } g.a(t); g.a(s.doubleValue()); paramContext = x; bool1 = r; dam.a.a(dan.L); a = bool1; dav.a = bool1; y.a(q); if (!u) { break; } localObject = v; paramContext = (Context)localObject; if (localObject == null) { paramContext = new czs(g, y, Thread.getDefaultUncaughtExceptionHandler(), w); } Thread.setDefaultUncaughtExceptionHandler(paramContext); return; } }