I've switched all of this over completely to single reliance look at the Venture's Github Page
Mistakes… Our applications sometimes crash for purposes we never expected, in spite of the precautionary measures we take against every one of them. Anyway, rather than continuously showing the client with this exhausting accident exchange during the blunder, couldn't it be superb in the event that we showed our own accident screen?
What we will do is straightforward. First we will make ourselves an Accident Movement and Application Class. Then, with a solitary line that we will add to the Application Class, we will begin our own Accident Action at whatever point our application crashes.
So.. We should begin from the hardest part. We should make ourselves a class named
GlobalExceptionHandler and it will require three fundamental boundaries. Likewise it must be stretched out by Thread.UncaughtExceptionHandler class
The main gander at our group
We will begin the activityToBeLaunched at whatever point our application crashes however we need to change the Expectation a tad to send off our movement so lets make a confidential capability named launchActivity
The Confidential Capability
How about we head back to uncaughtException technique and call our new strategy
Last look of the uncaughtException technique
defaultHandler.uncaughtException(p0, p1) capability's called at whatever point any sort of exemption happens while beginning the Movement. In this present circumstance default blunder exchange will appear rather than activityToBeLaunch
Gson Reliance
We want it to ease up our work. Add the line beneath to your build.gradle(App) record
implementation("com.google.code.gson:gson:2.9.1")
Last step is making a buddy object and making two additional strategies inside.
Friend object of GlobalExceptionHandler
initalize: Most significant capability. It must be run at OnCreate capability at Application class. It will supplant the default ExceptionHandler to our group.
getThrowableFromIntent: It'll retrive Throwable information from the action we will utilize.
We should proceed to our work by making our Action that will show after our application crashes.
Choices under the new menu
Pronouncing name for the Accident Screen
We made our Accident Movement. Presently we should make the plan.
See of Crash Action
You can look at project with all items inside from here
Our plan is finished. Following stage is giving a few activities to these buttons. How about we give them…
We gave the activities to the buttons and last significant thing we will do is seprating the Principal Application process with the Accident Movement by adding single line to show. So at whatever point our application's cycle is crashed the Accident Action will be not contaminated by that blunder
Test Movement
Subsequent to finishing our blunder movement, we should make an action that has just a straightforward plan and will just objective the application to crash. I will alter the Fundamental Action we as of now have.
As a matter of some importance, I will involve a basic TextView and Button as a plan.
The see of Primary Action
In the code part, I will toss a blunder when the button is squeezed.
MainActivity.kt
Making the Application class
In the event that you don't have an application class at your venture. Open your AndroidManifest record and get within Application tag and add the android:name line to your document
It's showing Application name as red true to form.
Click the bulb and select Make class 'Application'
We should call our GlobalExceptionHandler.initalize strategy
Everything is finished!
How about we send off our application and see the outcomes.
With GlobalExceptionHandler/Without GlobalExceptionHandler
Our GlobalExceptionHandler class is functioning true to form! You can likewise see the Throwable information at logs.
