Android: "बलपूर्वक बंद" होने के बाद किसी एप्लिकेशन को ऑटो-रिस्टार्ट कैसे करें?

Question

यदि हम अपवादों को ठीक से नहीं संभालते हैं, तो एंड्रॉइड एप्लिकेशन में, हमें आमतौर पर "फोर्स बंद" त्रुटि मिलती है।

बल बंद होने पर मैं अपने आवेदन को स्वचालित रूप से कैसे पुनः आरंभ कर सकता हूं?

क्या इसके लिए किसी विशिष्ट अनुमति का उपयोग किया गया है?

Comments

अपवादों को सही करने की कोशिश करें। ऐसा एप्लिकेशन जो अपने आप पुनरारंभ हो जाता है, उपयोगकर्ताओं के लिए कष्टप्रद हो सकता है।

— टॉमस आंद्रेल

मैं बस अपने आवेदन को फिर से शुरू करना चाहता हूं अगर यह दुर्घटनाग्रस्त हो गया। मुझे लगता है कि यह कष्टप्रद से अधिक अनुकूल होगा, खासकर जब उपयोगकर्ता मेरे आवेदन में है। और हां, मैं हर अपवाद को सही पाने की कोशिश कर रहा हूं। :)

— जॉनी

@ जॉनी: कृपया अपनी समस्या के लिए समाधान साझा करें।

— Code_Life

किसी भी अपवाद पर अपने आवेदन को पुनः आरंभ करने के लिए इस लेख की जाँच करें ।

— चिंतन राठौड़

Answer 1

इसे पूरा करने के लिए आपको दो काम करने होंगे:

1. "फोर्स क्लोज़" से बचें - एप्लिकेशन क्रैश का मानक तरीका।
2. किसी भी तरह क्रैश होने पर रीस्टार्ट मैकेनिज्म सेट करें।

नीचे देखें कि ये कैसे करना है:

1. Thread.setDefaultUncaughtExceptionHandler()सभी अनकैप्ड अपवाद को पकड़ने के लिए कॉल करें , जिसमें केस uncaughtException()विधि कहा जाएगा। "फोर्स क्लोज़" दिखाई नहीं देगा और एप्लिकेशन अनुत्तरदायी होगा, जो कि बहुत अच्छी बात नहीं है। अपने एप्लिकेशन को पुनरारंभ करने के लिए जब यह दुर्घटनाग्रस्त हो जाए तो आपको निम्न कार्य करना चाहिए:

2. में onCreateविधि, अपने मुख्य गतिविधि में एक प्रारंभ PendingIntentसदस्य:

   Intent intent = PendingIntent.getActivity(
       YourApplication.getInstance().getBaseContext(),
       0,
       new Intent(getIntent()),
       getIntent().getFlags());
   

फिर अपनी uncaughtException()विधि में निम्नलिखित डालें :

AlarmManager mgr = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
mgr.set(AlarmManager.RTC, System.currentTimeMillis() + 2000, intent);
System.exit(2);

आपको भी बुलाना System.exit()होगा, नहीं तो काम नहीं होगा। इस तरह आपका आवेदन 2 सेकंड के बाद पुनः आरंभ होगा।

आखिरकार आप अपने इरादे में कुछ झंडा लगा सकते हैं कि आवेदन दुर्घटनाग्रस्त हो गया और आपकी onCreate()विधि में आप "मैं माफी चाहता हूं, आवेदन दुर्घटनाग्रस्त हो गया, आशा है कि फिर कभी नहीं दिखा सकता है :)"।

Comments

मुझे लगा कि बाहर है। अब समस्या यह है कि बिना किसी अपवाद के विधि को कहां लागू किया जाए ?? plz मदद। धन्यवाद।

— Jay Mayu

@MayuMayooresan आप या तो एप्लिकेशन क्लास या गतिविधि का विस्तार कर सकते हैं और ऑनक्रिएट () में निम्नलिखित कर सकते हैं: Thread.setDefaultUncaughtExceptionHandler (नया अनक्रेडसेप्शनहैंडलर () ... ...});

— AgentKnopf

यदि आप गतिविधि का विस्तार करते हैं, तो यह ध्यान देने योग्य है कि आपको प्रत्येक गतिविधि के लिए वही करने की आवश्यकता है जो आपके आवेदन के लिए एक प्रवेश बिंदु के रूप में कार्य कर सकती है (इनमें से जो एंड्रॉइड ओएस शुरू करने का निर्णय ले सकते हैं - उदाहरण के लिए जब एक खिड़की मर जाती है आदि)

— मिक

यह एप्लिकेशन मेनू के माध्यम से प्रक्रिया को रोकने के लिए मजबूर करने के बाद आईसीएस में काम नहीं करता है।

— सूर्योदय

YourApplication का मतलब क्या है? मैंने @ मेश सलाह का उपयोग किया, लेकिन यह काम नहीं किया। कृपया कोई इसे समझाए।

— शेरविन ग़रीब

Answer 2

चाल सुनिश्चित करें कि यह पहली जगह में फोर्स क्लोज नहीं करता है।

यदि आप उस Thread.setDefaultUncaughtExceptionHandler()विधि का उपयोग करते हैं जो आप अपवादों को पकड़ सकते हैं जो आपके एप्लिकेशन को फोर्स क्लोज कर रहे हैं।

किसी एप्लिकेशन द्वारा उठाए गए अपवादों को लॉग इन करने के लिए उपयोग करने के उदाहरण के लिए इस प्रश्न पर एक नज़र डालें UncaughtExceptionHandler।

Comments

सुराग के लिए धन्यवाद। एक अनुवर्ती सवाल यह है कि UncaughtExceptionHandler.uncaughtException कब कहा जाएगा? यदि उपयोगकर्ता ने "फोर्स क्लोज़" बटन पर क्लिक नहीं किया है, तो क्या UncaughtExceptionHandler.uncaughtException अभी भी कहा जाएगा?

— जॉनी

@ जॉनी आपको एक बल मिलता है जब अनुप्रयोग एक अपवाद उठाता है जिसे संभाला नहीं जाता है। यदि आप एक अनक्रेडिसेप्शनहैंडलर का उपयोग करते हैं तो आपका एप्लिकेशन इसके सभी अपवादों को संभाल सकता है और उपयोगकर्ता कभी भी फोर्स क्लोज संवाद नहीं देख पाएंगे। दूसरे शब्दों में, UncaughtExceptionHandler उस समय कहा जाता है जब फोर्स क्लोज़ संवाद प्रदर्शित किया गया होता। हालांकि, आप सावधान रहना चाहेंगे कि आप किसी भी अप्रत्याशित अपवाद को कैसे संभालते हैं जिसे आप पकड़ते हैं; कुछ भी नहीं होने का ढोंग करना और जाहिर करना जोखिम भरा है।

— डेव वेब

स्पष्टीकरण के लिए धन्यवाद। यह अनक्रेडिसेप्शनहैंडलर के बारे में अच्छी तरह से समझाता है। लेकिन मैंने ऐसे एप्लिकेशन देखे हैं जो बल-बंद होने के बाद ऑटो-रिस्टार्ट होंगे। उदाहरण के लिए। लॉन्चर (शायद एक अच्छा उदाहरण नहीं है, लेकिन मैंने देखा है कि तृतीय-पक्ष एप्लिकेशन इस तरह से भी काम करता है)। अगर मैं चाहता हूं कि मेरा ऐप इस तरह काम करे? क्या मुझे किसी प्रकार की सिस्टम अनुमतियों का उपयोग करना होगा?

— जॉनी

Answer 3

यदि आप Crittercism या किसी अन्य त्रुटि रिपोर्ट सेवा का उपयोग करते हैं, तो स्वीकृत उत्तर लगभग सही है।

final UncaughtExceptionHandler defaultHandler = Thread.getDefaultUncaughtExceptionHandler();
Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
            public void uncaughtException(Thread thread, Throwable ex) {
              Intent launchIntent = new Intent(activity().getIntent());
              PendingIntent pending = PendingIntent.getActivity(CSApplication.getContext(), 0,
                    launchIntent, activity().getIntent().getFlags());
              getAlarmManager().set(AlarmManager.RTC, System.currentTimeMillis() + 2000, pending);
              defaultHandler.uncaughtException(thread, ex);
            }
});

Answer 4

public class ForceCloseExceptionHandalingActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        setContentView(MyLayout());
        Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread paramThread, Throwable paramThrowable) {
                myHandaling(paramThread, paramThrowable);
            }
        });
    }

    private ViewGroup MyLayout(){
        LinearLayout mainLayout = new LinearLayout(this);
        mainLayout.setOrientation(LinearLayout.VERTICAL);  
        Button btnHello =new Button(this);
        btnHello.setText("Show all button");
        btnHello.setOnClickListener(new OnClickListener() {         
            @Override
            public void onClick(View v) {                   
                setContentView(MyLayout2());            
            }
        });             
        mainLayout.addView(btnHello);       
        return mainLayout;
    }

    private ViewGroup MyLayout2(){
        LinearLayout mainLayout = new LinearLayout(this);
        mainLayout.setOrientation(LinearLayout.VERTICAL);  
        Button btnHello =new Button(this);
        btnHello.setText("I am a EEROR uncaughtException");
        btnHello.setOnClickListener(new OnClickListener() {         
            @Override
            public void onClick(View v) {                   
                Log.e("Alert","btn  uncaughtException::");
                Toast.makeText(ForceCloseExceptionHandalingActivity.this, "Alert uncaughtException222",Toast.LENGTH_LONG).show();
                View buttone = null;
                setContentView(buttone);            
            }
        });     
        Button btnHello2 =new Button(this);
        btnHello2.setText("I am a EEROR Try n catch");
        btnHello2.setOnClickListener(new OnClickListener() {            
            @Override
            public void onClick(View v) {   

                try{
                    View buttone = null;
                    setContentView(buttone);
                }
                catch (Exception e) {
                    Log.e("Alert","Try n catch:::");
                    Toast.makeText(ForceCloseExceptionHandalingActivity.this, "Alert Try n catch",Toast.LENGTH_LONG).show();
                    setContentView(MyLayout());
                }

            }
        });     
        mainLayout.addView(btnHello);
        mainLayout.addView(btnHello2);
        return mainLayout;
    }
    public void myHandaling(Thread paramThread, Throwable paramThrowable){
        Log.e("Alert","Lets See if it Works !!!" +"paramThread:::" +paramThread +"paramThrowable:::" +paramThrowable);
        Toast.makeText(ForceCloseExceptionHandalingActivity.this, "Alert uncaughtException111",Toast.LENGTH_LONG).show();
        Intent in =new Intent(ForceCloseExceptionHandalingActivity.this,com.satya.ForceCloseExceptionHandaling.ForceCloseExceptionHandalingActivity.class);
        startActivity(in);
        finish();
        android.os.Process.killProcess(android.os.Process.myPid()); 
    }
    @Override
    protected void onDestroy() {
        Log.e("Alert","onDestroy:::");
        Toast.makeText(ForceCloseExceptionHandalingActivity.this, "Alert onDestroy",Toast.LENGTH_LONG).show();
        super.onDestroy();  
    }

Comments

इस कोड को "Thread.setDefaultUncaughtExceptionHandler" प्राप्त करें और इसे बंद करने के बाद कॉल करें ..

— Satya

Answer 5

इस वर्ग को अपने पैकेज में जोड़ें

public class MyExceptionHandler implements
    java.lang.Thread.UncaughtExceptionHandler {
private final Context myContext;
private final Class<?> myActivityClass;

public MyExceptionHandler(Context context, Class<?> c) {
    myContext = context;
    myActivityClass = c;
}

public void uncaughtException(Thread thread, Throwable exception) {
    StringWriter stackTrace = new StringWriter();
    exception.printStackTrace(new PrintWriter(stackTrace));
    System.err.println(stackTrace);// You can use LogCat too
    Intent intent = new Intent(myContext, myActivityClass);
    String s = stackTrace.toString();
    //you can use this String to know what caused the exception and in which Activity
    intent.putExtra("uncaughtException", "Exception is: " + stackTrace.toString());
    intent.putExtra("stacktrace", s);
    myContext.startActivity(intent);
    //for restarting the Activity
    Process.killProcess(Process.myPid());
    System.exit(0);
}}

अपने आवेदन में या हर गतिविधि वर्ग में, ऑनक्रीट () विधि के अंदर फिर कॉल करें:

Thread.setDefaultUncaughtExceptionHandler(new MyExceptionHandler(this,
            SplashScreenActivity.class));