एंड्रॉइड एप्लिकेशन को प्रोग्रामेटिक रूप से कैसे छोड़ें

Question

मुझे प्रोग्राम के लिए एंड्रॉइड एप्लिकेशन छोड़ने के लिए कुछ कोड मिले। OnDestroy () में निम्नलिखित में से किसी एक कोड को कॉल करके क्या यह पूरी तरह से एप्लिकेशन छोड़ देगा?

1. System.runFinalizersOnExit(true)
   (या)
2. android.os.Process.killProcess(android.os.Process.myPid());

मैं छोड़ दिया बटन पर क्लिक करने के बाद पृष्ठभूमि में अपना आवेदन नहीं चलाना चाहता। Pls मुझे सुझाव है कि क्या मैं अपना ऐप छोड़ने के लिए इनमें से किसी एक कोड का उपयोग कर सकता हूं? यदि हां, तो मैं किस कोड का उपयोग कर सकता हूं? क्या एंड्रॉइड में ऐप को छोड़ना अच्छा तरीका है?

Comments

यहाँ पहले से ही बहुत सारे पद हैं। stackoverflow.com/search?q=how+to+exit+an+android+app

— मुदस्सिर

एक आवेदन छोड़ने

— कॉमन्सवेयर

'System.exit (0);' जब आप वास्तव में ऐप से बाहर निकलना चाहते हैं। मैंने उपयोगकर्ता को एक संदेश दिखाने के बाद एक अपरिवर्तनीय त्रुटि पर ऐसा किया है। आप की जरूरत है, तो आप भी स्वचालित रूप से एप्लिकेशन का उपयोग कर सकते हैं। देखें: blog.janjonas.net/2010-12-20/…

— किसी को कहीं

Answer 1

एपीआई 16 के बाद से आप फिनिशएफ़िनिटी पद्धति का उपयोग कर सकते हैं, जो कि इसके नाम और जेवोकॉपी द्वारा सभी संबंधित गतिविधियों को बंद करने के लिए काफी करीब लगती है:

this.finishAffinity ();

इस गतिविधि को समाप्त करें और साथ ही साथ वर्तमान कार्य में इसके नीचे की सभी गतिविधियाँ समान आत्मीयता के साथ समाप्त करें। यह आमतौर पर तब उपयोग किया जाता है जब किसी एप्लिकेशन को किसी अन्य कार्य पर लॉन्च किया जा सकता है (जैसे कि एक सामग्री के ACTION_VIEW से जो इसे समझता है) और उपयोगकर्ता ने वर्तमान कार्य से बाहर और अपने कार्य में स्विच करने के लिए अप नेविगेशन का उपयोग किया है। इस मामले में, यदि उपयोगकर्ता ने दूसरे एप्लिकेशन की किसी अन्य गतिविधियों में नेविगेट किया है, तो उन सभी को कार्य स्विच के भाग के रूप में मूल कार्य से हटा दिया जाना चाहिए।

ध्यान दें कि यह खत्म आपको पिछली गतिविधि के लिए परिणाम देने की अनुमति नहीं देता है, और यदि आप ऐसा करने की कोशिश कर रहे हैं तो एक अपवाद फेंक दिया जाएगा।

एपीआई 21 के बाद से आप बहुत समान कमांड का उपयोग कर सकते हैं

finishAndRemoveTask ();

इस कार्य में सभी गतिविधियों को समाप्त करता है और इसे हाल ही के कार्य सूची से निकालता है।

Comments

निश्चित रूप से यह सही उत्तर है! किसी ऐप को इस्तेमाल करके खत्म करना अच्छा उपाय नहीं है System.exit(0);। आपके उत्तर के लिए धन्यवाद! अंत में मुझे एक अच्छा समाधान मिल गया है।

— एंटोनियो

क्या आपको पता है कि एपीआई 14 पर एक और समाधान है? धन्यवाद

— पटकथा किटी २

आप प्रत्येक गतिविधि को व्यक्तिगत रूप से समाप्त कर सकते हैं (या तो जब आप ऐप को बंद कर देते हैं या गतिविधि जीवनचक्र के अंदर।

— 6

चेतावनी! this.finishAffinity () मेमोरी से इसे हटाते हुए ऐप को बंद कर देता है, जिससे आपको पुश मैसेज नहीं मिलेंगे।

— टिनचो .२५

यह समाधान 99% मामलों में काम करता है। हालांकि, यह प्रक्रिया को नष्ट नहीं करेगा, इसलिए उदाहरण के लिए डैगर को मंजूरी नहीं दी जाएगी। उन दुर्लभ मामलों में, जहां प्रक्रिया को मारना आवश्यक System.exit(0)है, एकमात्र समाधान है जो मेरे लिए काम करता है।

— स्लैव

Answer 2

getActivity().finish();
System.exit(0);

यह आपके ऐप से बाहर निकलने का सबसे अच्छा तरीका है। !!!

मेरे लिए सबसे अच्छा समाधान।

Comments

हाँ, महान काम करता है! इसे काम करने के लिए MainActivity से बुलाना होगा!

— mz87

सही समाधान। प्रक्रिया को समाप्त करने की आवश्यकता नहीं है, क्योंकि एंड्रॉइड मेमोरी प्रबंधन के लिए सबसे अच्छा जानता है। हालांकि, यह गतिविधि को खत्म करने के लिए एक समाधान प्रदान करता है, साथ ही उपयोगकर्ता की सुविधा के लिए ऐप से बाहर निकलता है।

— IAmTheSquidward

सही समाधान वास्तव में। बहुत सारी समस्याओं का समाधान किया। धन्यवाद।

— सुपरसुर्दो

मुझे नहीं लगता कि यह एक अच्छा समाधान है। आप oughtn't का उपयोग कर अपने कार्यक्रम खत्म System.exit(0);। सही समाधान @sivi द्वारा पोस्ट किया गया था (उसका जवाब ऊपर है)

— एंटोनियो

यह समाधान नहीं है, यह काम नहीं करता है यदि आपके पास गतिविधियों का ढेर है

— user3290180

Answer 3

finishAffinity();

System.exit(0);

यदि आप finishAffinity();बिना उपयोग किए केवल System.exit(0);अपने एप्लिकेशन को छोड़ देंगे, लेकिन आवंटित मेमोरी अभी भी आपके फोन के उपयोग में होगी, इसलिए ... यदि आप एक ऐप की साफ और वास्तव में छुट्टी चाहते हैं, तो उन दोनों का उपयोग करें।

यह सबसे सरल तरीका है और कहीं भी काम करता है, असली के लिए ऐप छोड़ दें, आपके पास बहुत सारी गतिविधि खोली जा सकती है, फिर भी कोई समस्या नहीं है।

एक बटन क्लिक पर उदाहरण

public void exitAppCLICK (View view) {

    finishAffinity();
    System.exit(0);

}

या यदि आप कुछ अच्छा चाहते हैं, तो 3 बटन YES NO और CANCEL के साथ एक चेतावनी संवाद के साथ उदाहरण दें

// alertdialog for exit the app
AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);

// set the title of the Alert Dialog
alertDialogBuilder.setTitle("your title");

// set dialog message
alertDialogBuilder
        .setMessage("your message")
        .setCancelable(false)
        .setPositiveButton("YES"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // what to do if YES is tapped
                        finishAffinity();
                        System.exit(0);
                    }
                })

        .setNeutralButton("CANCEL"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // code to do on CANCEL tapped
                        dialog.cancel();
                    }
                })

        .setNegativeButton("NO"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // code to do on NO tapped
                        dialog.cancel();
                    }
                });

AlertDialog alertDialog = alertDialogBuilder.create();

alertDialog.show();

Comments

यह सही उत्तर है, मैं ढूंढ रहा था। धन्यवाद

— Driftwood

अगर मैं अपने एप्लिकेशन में FCM, या पृष्ठभूमि कार्यों का उपयोग करता हूं, तो मुझे कोई समस्या नहीं होगी?

— रोघैह होसैनी

यह वही था जो मुझे मेमोरी से एप्लिकेशन को पोंछने के लिए आवश्यक था

— ए

कृपया उपयोग न करें System.exit(0);आप उस मेमोरी को मुक्त न करें, यदि आवश्यक हो तो सिस्टम आपके लिए यह करेगा। यह अभीष्ट व्यवहार है।

— crgarridos

Answer 4

कृपया वास्तव में कठिन सोचें कि क्या आपको एप्लिकेशन को मारने की आवश्यकता है: क्यों नहीं ओएस को यह पता लगाने दें कि संसाधनों को कहाँ और कब मुक्त करना है?

अन्यथा, यदि आप वास्तव में निश्चित हैं, तो उपयोग करें

finish();

@Dave ऐपलटन की टिप्पणी पर प्रतिक्रिया के रूप में: पहली बात बड़े प्रश्न / उत्तर पढ़ें कॉम्बो @gabriel पोस्ट किया गया: क्या किसी एप्लिकेशन को छोड़ दिया गया है?

अब यह मानते हुए कि हमारे पास इस प्रश्न का एक उत्तर है, यह होने के नाते कि कोड की आवश्यकता है यदि आप छोड़ने के साथ कुछ भी कर रहे हैं finish()। जाहिर है कि आपके पास एक से अधिक गतिविधियां आदि हो सकती हैं, लेकिन यह बात नहीं है। कुछ उपयोग-मामलों से चलते हैं

1. आप उपयोगकर्ता को मेमोरी के उपयोग और "पृष्ठभूमि में नहीं चलने" के कारण सबकुछ छोड़ देना चाहते हैं? संदेह है। उपयोगकर्ता को पृष्ठभूमि में कुछ गतिविधियों को रोकने दें, लेकिन ओएस को किसी भी अनावश्यक पुनरावर्ती को मारने दें।
2. आप चाहते हैं कि कोई उपयोगकर्ता आपके ऐप की पिछली गतिविधि पर न जाए? ठीक है, या तो इसे कॉन्फ़िगर करें ताकि यह न हो, या आपको एक अतिरिक्त विकल्प की आवश्यकता है। यदि अधिकांश समय पीछे = पिछली-गतिविधि काम करती है, तो क्या उपयोगकर्ता घर पर प्रेस नहीं करेगा यदि वह कुछ और करना चाहता है?
3. यदि आपको किसी प्रकार के रीसेट की आवश्यकता है, तो आप पता लगा सकते हैं कि क्या / कैसे / आदि आपके आवेदन को छोड़ दिया गया था, और यदि आपकी गतिविधि फिर से केंद्रित हो जाती है, तो आप उस पर कार्रवाई कर सकते हैं, जहां आप थे, फिर से शुरू करने के बजाय एक ताज़ा स्क्रीन दिखा सकते हैं।

तो अंत में, टोर्च, कुछ finish()भी नहीं मारता है, लेकिन यह अभी भी उपकरण है जो आपको चाहिए मुझे लगता है। अगर "सभी गतिविधियों को मार डालो" के लिए एक usecase है, तो मैंने इसे अभी तक नहीं पाया है।

Comments

कॉल finish()करने से एप्लिकेशन की हत्या नहीं होगी। finish()हर समय उपयोग किया जाता है: Call this when your activity is done and should be closed.यह "बैक" बटन को हिट करने के समान है।

— टान्नर पेरीयन

खत्म गतिविधि को मार देगा। यह कैसे अलग है तो तालियां मार रहा है?

— नन्ने

"परिष्करण" या "हत्या" Activity(नहीं Application) के साथ कुछ भी गलत नहीं है । उदाहरण के लिए, आप उपयोगकर्ता को कुछ जानकारी दिखाने के लिए एक नई गतिविधि शुरू कर सकते हैं। टाइमआउट या 'ओके' दबाने के बाद आप finish()कॉलिंग गतिविधि पर वापस आ सकते हैं ।

— टान्नर पेरिएन

अधिकांश Android अनुप्रयोगों में एक से अधिक गतिविधियाँ होती हैं।

— कॉमन्सवेअर

@Nanne - लॉक स्क्रीन एक उदाहरण है जब आप सभी गतिविधियों को रोकना चाहते हैं। मान लीजिए आप एक बैंकिंग ऐप में लॉग इन करते हैं। उपयोगकर्ता से कोई इंटरैक्शन नहीं होने के बाद एक निश्चित अवधि के बाद, लॉक स्क्रीन लॉन्च होती है। यदि कोई लॉक स्क्रीन से बैक बटन दबाता है तो आप सभी गतिविधियों को रोकना चाहते हैं!

— जाबरी

Answer 5

मुझे लगता है कि आवेदन को किसी मामले में मार दिया जाना चाहिए। उदाहरण के लिए, एक ऐप है जिसका उपयोग लॉगिन के बाद ही किया जा सकता है। लॉगिन गतिविधि में दो बटन होते हैं, 'लॉगिन' और 'रद्द'। जब आप 'रद्द करें' बटन पर क्लिक करते हैं, तो इसका निश्चित रूप से अर्थ है 'एप्लिकेशन को समाप्त करें'। कोई भी नहीं चाहता कि ऐप पृष्ठभूमि में जीवित हो। इसलिए मैं मानता हूं कि कुछ मामलों में ऐप को बंद करने की आवश्यकता है।

Comments

मैं कुल मिलाकर इस उपयोग-मामले से सहमत हूं। मेरे सुरक्षित ऐप पर भी विचार करें जो एक निश्चित स्थान पर उपलब्ध होना चाहिए और यदि उपयोगकर्ता उस स्थान पर नहीं है तो उसे बंद करना सबसे अच्छा है। मैं क्या करूं?

— सेडवेल

Answer 6

एक बनाएँ ExitActivityऔर इसे प्रकट में घोषित करें। और ExitActivity.exit(context)ऐप से बाहर निकलने के लिए कॉल करें ।

public class ExitActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        finish();
    }

    public static void exit(Context context) {
        Intent intent = new Intent(context, ExitActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
        context.startActivity(intent);
    }

}

Comments

यह सबसे अधिक मतदान का जवाब है, लेकिन यह एक हैक है। ऑन्क्रीट में कॉलिंग खत्म होने पर ग्लिची सबसे ज्यादा दिखेगी, अगर सभी नहीं तो डिवाइस।

— डोरुसीडियन

हम्म एक हैक लेकिन एक गड़बड़ नहीं। पहले बाहर निकलें () आप कॉल करेंगे, यह स्पष्ट शीर्ष और कार्यों के साथ सभी गतिविधियों में सबसे ऊपर आता है और फिर खुद को समाप्त करता है। यहाँ आप बाहर निकलें।

— विवेक

अपने घोषणापत्र में इस वर्ग को घोषित करना याद रखें। हालांकि चतुर हैक के लिए +1।

— तस्लीम ओसेनी

यह काम किया! वोट दिया

— TuanDPH

Answer 7

Android में कोई एप्लिकेशन छोड़ने नहीं है , SampleActivity.this.finish (); वर्तमान गतिविधि को पूरा करेगा।

जब आप एक गतिविधि से दूसरे पर स्विच करते हैं तो पिछले एक को खत्म करते रहें

Intent homeintent = new Intent(SampleActivity.this,SecondActivity.class);
startActivity(homeintent);
SampleActivity.this.finish();

Answer 8

सबसे पहले, इस दृष्टिकोण को न्यूनतम अपी 16 की आवश्यकता है।

मैं इस समस्या को अधिक व्यापक रूप से हल करने के लिए इस भाग को 3 भागों में विभाजित करूंगा।

1. यदि आप किसी गतिविधि में आवेदन छोड़ना चाहते हैं तो इस कोड स्निपेट का उपयोग करें:

if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
    finishAffinity();
} else if(Build.VERSION.SDK_INT>=21){
    finishAndRemoveTask();
}

2. यदि आप गैर-गतिविधि वर्ग में आवेदन को छोड़ना चाहते हैं जिसकी गतिविधि तक पहुँच है तो इस कोड का उपयोग करें स्निपेट:

if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
    getActivity().finishAffinity();
} else if(Build.VERSION.SDK_INT>=21){
    getActivity().finishAndRemoveTask();
}

3. यदि आप गैर-गतिविधि वर्ग में आवेदन छोड़ना चाहते हैं और सेवा तक पहुंच नहीं कर सकते हैं जैसे कि मैं आपको ब्रॉडकास्टसीवर का उपयोग करने की सलाह देता हूं। आप अपने प्रोजेक्ट में अपनी सभी गतिविधियों के लिए इस दृष्टिकोण को जोड़ सकते हैं।

LocalBroadcastManager और BroadcastReceiver उदाहरण चर बनाएँ। यदि आप चाहते हैं तो आप getPackageName () + "। बंद करें" को बदल सकते हैं।

LocalBroadcastManager mLocalBroadcastManager;
BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        if(intent.getAction().equals(getPackageName()+".closeapp")){
            if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
                finishAffinity();
            } else if(Build.VERSION.SDK_INT>=21){
                finishAndRemoveTask();
            }
        }
    }
};

गतिविधि के onCreate () विधि में इन्हें जोड़ें।

mLocalBroadcastManager = LocalBroadcastManager.getInstance(this);
IntentFilter mIntentFilter = new IntentFilter();
mIntentFilter.addAction(getPackageName()+".closeapp");
mLocalBroadcastManager.registerReceiver(mBroadcastReceiver, mIntentFilter);

इसके अलावा, OnDestroy () गतिविधि के तरीके पर अपंजीकृत रिसीवर को कॉल करना न भूलें

mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);

पद छोड़ने के आवेदन के लिए, आपको लोकलब्रॉडकास्टमैनेजर का उपयोग करके प्रसारण भेजना होगा, जिसका उपयोग मैं अपने PlayService वर्ग में करता हूं जो सेवा प्रदान करता है।

LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(PlayService.this);
localBroadcastManager.sendBroadcast(new Intent(getPackageName() + ".closeapp"));

Answer 9

आप finishAndRemoveTask ()एपीआई 21 से उपयोग कर सकते हैं

सार्वजनिक शून्य खत्म

इस कार्य में सभी गतिविधियों को समाप्त करता है और इसे हाल ही के कार्य सूची से निकालता है।

Answer 10

यह इस बात पर निर्भर करता है कि आप कितनी तेजी से अपने ऐप को बंद करना चाहते हैं।

अपने ऐप को बंद करने का एक सुरक्षित तरीका है फिनिशएफ़िनिटी ();

सभी प्रक्रिया समाप्त होने के बाद यह आपको ऐप बंद कर देता है। इसके लिए कुछ समय चाहिए। यदि आप अपना ऐप इस तरह से बंद करते हैं, और थोड़े समय के बाद इसे फिर से शुरू करते हैं, तो संभव है कि आपका नया एप्लिकेशन उसी प्रक्रिया में चलता हो। सभी समाप्त प्रक्रियाओं और पुराने एप्लिकेशन के सिंगलटन ऑब्जेक्ट्स के साथ नहीं।

यदि आप सुनिश्चित होना चाहते हैं, कि आपका ऐप पूरी तरह से बंद हो गया है तो System.exit (0) का उपयोग करें ;

यह आपके ऐप को तुरंत बंद कर देगा। लेकिन यह संभव है, कि आप उन फ़ाइलों को नुकसान पहुँचाएँ जिन्हें आपके ऐप ने खोला है या साझा प्राथमिकताओं पर एक संपादन खत्म नहीं हुआ है। इसलिए इसका प्रयोग सावधानी से करें।

यदि आप एक लंबे चलने वाले कार्य के साथ संयोजन में वॉचडॉग का उपयोग करते हैं, तो आप विभिन्न तरीकों के प्रभावों को देख सकते हैं।

new ANRWatchDog(2000).setANRListener(new ANRWatchDog.ANRListener() {
    public void onAppNotResponding(ANRError error) {
        MainActivity.this.finishAffinity();
        System.exit(0);
    }
}).start();
for(int i = 0; i < 10; ++i){
    --i;
}

यह एएनआर संवाद या ऐसा कुछ प्रदर्शित किए बिना 2 सेकंड के बाद आपके ऐप को मार देता है। यदि आप System.exit (0) को हटाते हैं , तो इस कोड को चलाएं और ऐप को बंद करने के बाद पुनः आरंभ करें, आपको कुछ अजीब व्यवहार का अनुभव होगा, क्योंकि अंतहीन लूप अभी भी चल रहा है।

Answer 11

finish()यदि आप अंदर हैं Activity, या getActivity().finish()यदि आप अंदर हैं तो आपका बेहतर उपयोग था Fragment।

यदि आप ऐप को पूरी तरह से छोड़ना चाहते हैं, तो उपयोग करें:

getActivity().finish();
System.exit(0);

Answer 12

आवेदन से बाहर निकलने का आसान और सरल तरीका

Intent homeIntent = new Intent(Intent.ACTION_MAIN);
homeIntent.addCategory(Intent.CATEGORY_HOME);
homeIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(homeIntent);

Comments

क्या यह सिर्फ होम स्क्रीन लाता है या वास्तव में ऐप को मारता है?

— rpattabi

Answer 13

मुझे लगता है कि आप जो खोज रहे हैं वह यह है

activity.moveTaskToBack(Boolean nonRoot);

Answer 14

public void quit() {
        int pid = android.os.Process.myPid();
        android.os.Process.killProcess(pid);
        System.exit(0);
    }

Comments

System.exit () एंड्रॉइड एप्लिकेशन को नहीं मारता है अगर एक से अधिक गतिविधि है

— 030

Answer 15

हम ऐसा कोड चाहते हैं जो मजबूत और सरल हो। यह समाधान पुराने उपकरणों और नए उपकरणों पर काम करता है।

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
        getActivity().finishAffinity();
    } else{
        getActivity().finish();
        System.exit( 0 );
    }

Answer 16

@MobileMateo की तरह, लेकिन में Kotlin

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
    this.finishAffinity()
} else{
    this.finish()
    System.exit(0)
}

Answer 17

मुझे यकीन नहीं हो रहा है कि यह फेक है या नहीं, लेकिन यह है कि मैं इसे कैसे करता हूं ...

चरण 1 - मेरे पास आमतौर पर एक वर्ग होता है जिसमें विधियाँ और चर होते हैं जिन्हें मैं विश्व स्तर पर पहुँचाना चाहता हूँ। इस उदाहरण में मैं इसे "ऐप" वर्ग कहूंगा। प्रत्येक गतिविधि जो आपके ऐप में है, उसके लिए कक्षा के अंदर एक स्थिर गतिविधि चर बनाएं। फिर "करीब" नामक एक स्थिर विधि बनाएं जो finish()उन गतिविधि चर में से प्रत्येक पर विधि चलाएगा यदि वे शून्य नहीं हैं । यदि आपके पास एक मुख्य / मूल गतिविधि है, तो इसे अंतिम रूप से बंद करें:

public class App
{
    ////////////////////////////////////////////////////////////////
    // INSTANTIATED ACTIVITY VARIABLES
    ////////////////////////////////////////////////////////////////

        public static Activity activity1;
        public static Activity activity2;
        public static Activity activity3;

    ////////////////////////////////////////////////////////////////
    // CLOSE APP METHOD
    ////////////////////////////////////////////////////////////////

        public static void close()
        {
            if (App.activity3 != null) {App.activity3.finish();}
            if (App.activity2 != null) {App.activity2.finish();}
            if (App.activity1 != null) {App.activity1.finish();}
        }
}

चरण 2 - आपकी प्रत्येक गतिविधि में, विधियों onStart()और onDestroy()विधियों को ओवरराइड करें । में onStart(), अपने अनुप्रयोग वर्ग में " this" के बराबर स्थैतिक चर सेट करें । में onDestroy(), इसके बराबर सेट करें null। उदाहरण के लिए, "एक्टिविटी 1" वर्ग में:

@Override
public void onStart()
{
    // RUN SUPER | REGISTER ACTIVITY AS INSTANTIATED IN APP CLASS

        super.onStart();
        App.activity1 = this;
}

@Override
public void onDestroy()
{
    // RUN SUPER | REGISTER ACTIVITY AS NULL IN APP CLASS

        super.onDestroy();
        App.activity1 = null;
}

चरण 3 - जब आप अपना ऐप बंद करना चाहते हैं, तो बस App.close()कहीं से भी कॉल करें । सभी त्वरित गतिविधियां बंद हो जाएंगी! चूंकि आप केवल गतिविधियों को बंद कर रहे हैं और ऐप को खुद नहीं मार रहे हैं (जैसा कि आपके उदाहरणों में), एंड्रॉइड वहां से लेने और किसी भी क्लीनअप को करने के लिए स्वतंत्र है।

फिर, मुझे नहीं पता कि क्या यह किसी भी कारण से डूब जाएगा। यदि हां, तो मुझे इस पर टिप्पणी पढ़ना पसंद है कि यह क्यों है और इसे कैसे सुधार किया जा सकता है!

Comments

दिलचस्प है, मुझे भी दिलचस्पी होगी कि अन्य अनुभवी एंड्रॉइड डेवलपर्स ने इसके बारे में क्या सोचा है।

— रुडी करशॉ

अपनी गतिविधि का संदर्भ रखकर आप वास्तव में मेमोरी लीक कर रहे हैं! गहन चर्चा के लिए इसे देखें ।

— मण्गार्म

@Managarm उस पद के पीछे का आधार यह है कि प्रक्रिया के बाद भी स्थिर चर बना रहेगा (इस मामले में, गतिविधि) नष्ट हो गई है। यदि उचित घर की सफाई की जाती है, तो यह एक गैर-मुद्दा है ... इसलिए मैं इस गतिविधि के onDestroy () विधि में संदर्भ को स्पष्ट करता हूं।

— जाबरी

@ जाबरी आह, मुझे ऑन्डेस्ट्रॉय हिस्सा याद आ गया। उस मामले में यह एक मुद्दा नहीं होना चाहिए, हालांकि यह सबसे अच्छा अभ्यास नहीं है।

— मनगर्म

बिना किसी समस्या के काम किया। के लिए api>=16उपयोग finishAffinity()किसी और इस विधि का उपयोग।

— मि। कोई नहीं।

Answer 18

क्या किसी एप्लिकेशन को छोड़ दिया गया है?। इस लिंक के माध्यम से जाओ। यह आपके प्रश्न का उत्तर देता है। किसी एप्लिकेशन को मारने का काम सिस्टम करता है।

मान लीजिए कि आपके पास दो गतिविधियां हैं ए बी। आप बी से ए पर नेविगेट करते हैं। जब आप बैक बटन पर क्लिक करते हैं तो आपकी गतिविधि बी बैकस्टैक का रूप लेती है और नष्ट हो जाती है। पिछली स्टैक गतिविधि में पिछली गतिविधि A ध्यान केंद्रित करती है।

एप्लिकेशन को कब मारना है यह तय करने के लिए आपको इसे सिस्टम पर छोड़ देना चाहिए।

सार्वजनिक शून्य finish()

जब आपकी गतिविधि हो जाए और इसे बंद कर दिया जाए तो इसे कॉल करें।

मान लीजिए कि आपके पास कई गतिविधियां हैं। आप एक्शन बार का उपयोग कर सकते हैं। अपने आवेदन के MainActivity के लिए होम आइकन पर क्लिक करें। MainActivity एप्लिकेशन से बाहर जाने के लिए वापस बटन पर क्लिक करें।

Answer 19

आप आवेदन से बाहर निकलने के लिए आप निम्नलिखित का उपयोग कर सकते हैं:

getActivity().finish();
Process.killProcess(Process.myPid());
System.exit(1);

सेवाओं को रोकने के लिए भी निम्न विधि को कॉल करें:

private void stopServices() {        
    final ActivityManager activityManager = SystemServices.getActivityManager(context);
    final List<ActivityManager.RunningServiceInfo> runningServices = activityManager.getRunningServices(Integer.MAX_VALUE);
    final int pid = Process.myPid();
    for (ActivityManager.RunningServiceInfo serviceInfo : runningServices) {
        if (serviceInfo.pid == pid && !SenderService.class.getName().equals(serviceInfo.service.getClassName())) {
            try {
                final Intent intent = new Intent();
                intent.setComponent(serviceInfo.service);
                context.stopService(intent);
            } catch (SecurityException e) { 
                 // handle exception
            }
        }
    }
}

Answer 20

यह बहुत देर हो सकती है और दिशानिर्देशों के अनुसार आप अपने द्वारा जीवन चक्र प्रक्रिया को संभालने के लिए नहीं हैं (जैसा कि ओएस आपके लिए है)। एक सुझाव यह होगा कि आप अपनी सभी गतिविधियों में एक प्रसारण रिसीवर को finish()उनके साथ " " में पंजीकृत करें onReceive() और जब भी आप इसे छोड़ना चाहें, तो आप एक इरादे को पास कर सकते हैं जो यह दर्शाता है कि सभी गतिविधियाँ बंद होनी चाहिए ..... हालाँकि सुनिश्चित करें कि आप करते हैं " अपने onDestroy()तरीकों से रिसीवर को अनरजिस्टर्ड करें ।

Answer 21

यह एक अच्छा निर्णय नहीं है, क्योंकि यह एंड्रॉइड के एप्लिकेशन प्रोसेसिंग सिद्धांतों के खिलाफ है। Android किसी भी प्रक्रिया को नहीं मारता है जब तक कि यह बिल्कुल अपरिहार्य न हो। इससे ऐप्स को तेज़ी से शुरू करने में मदद मिलती है, क्योंकि वे हमेशा स्मृति में रहते हैं। तो आपको अपने आवेदन की प्रक्रिया को मारने के लिए एक बहुत ही विशेष कारण की आवश्यकता है।

Comments

एप्लिकेशन से साइन आउट करने के लिए वास्तव में ऐप को मारना होगा। इसलिए बाहर साइन अप करने के बाद ऐप को

— मारना

Answer 22

बटन क्लिक पर ऐप को छोड़ने का सही और सटीक समाधान नीचे दिए गए कोड का उपयोग कर रहा है:

// बटन पर वापस दबाया घटना

public void onBackPressed()
{ 
   moveTaskToBack(true);
   finish();
}

Comments

यह काफी वर्तमान एंड्रॉइड घटक (जैसे गतिविधि) है, संपूर्ण ऐप नहीं ।

— लाओगेयोड्रिट

यह बैकग्राउंड में केवल ऐप भेजेगा

— कुमार गौरव

Answer 23

यदि आप कोटलिन का उपयोग कर रहे हैं, तो ऐप से बाहर निकलने का उचित तरीका और विकल्प System.exit()एक अंतर्निहित पद्धति है

exitProcess(0)

दस्तावेज देखें ।

0एक पैरामीटर के रूप में संख्या का मतलब है कि निकास का इरादा है और कोई त्रुटि नहीं हुई।

Answer 24

यह कुछ भी मार देगा;)

int p = android.os.Process.myPid();
android.os.Process.killProcess(p);

Answer 25

इसे इस्तेमाल करे

int pid = android.os.Process.myPid();
android.os.Process.killProcess(pid);

Answer 26

एंड्रॉइड के तर्क को तोड़े बिना और मौजूदा गतिविधियों में अधिक कोड जोड़े बिना और एक्स्ट्रा पासिंग के बिना एक गतिविधि से आवेदन छोड़ने का सबसे आसान तरीका निम्नलिखित है:

public static void quitApplication (Activity currentActivity) {
    Intent intent = new Intent (currentActivity, QuitApplicationActivity.class);
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);

    currentActivity.startActivity (intent);
    currentActivity.finish ();
}

QuitApplicationActivityकिया जा रहा है:

public class QuitApplicationActivity extends AppCompatActivity {

    @Override
    protected void onCreate (Bundle savedInstanceState) {
        super.onCreate (savedInstanceState);

        finish ();
    }
}

Answer 27

@ शिवी का जवाब ऐप बंद कर देता है। लेकिन बदले में, यदि आपके पास कुछ बच्चे की गतिविधियाँ हैं, तो एक और अधूरी गतिविधि खोली जा सकती है। मैंने noHistory:trueअपनी गतिविधियों में शामिल किया ताकि रिटर्न ऑन ऐप मेनएक्टिविटी से शुरू हो।

<activity 
      android:name=".MainActivity"
      android:noHistory="true">
</activity>

Answer 28

ऐप को समाप्त करने के क्रूर तरीकों की सूची में एक जोड़ने के लिए:

Process.sendSignal(Process.myPid(), Process.SIGNAL_KILL);

Comments

Process.killProcess(Process.myPid())एक ही है, लेकिन कम है

— ivan8m8

Answer 29

आप अपना पूरा ऐप छोड़ सकते हैं। इस प्रकार

Intent intent = getBaseContext().getPackageManager()
             .getLaunchIntentForPackage(getBaseContext().getPackageName());
intent .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

यह 100% काम करेगा। शुभकामनाएँ!

Comments

यह इस सवाल का जवाब नहीं लगता है!

— अल-मोताफ़र

Answer 30

बस वापस कुंजी का उपयोग करें () बैक प्रेस पर दबाएं ()

Comments

खत्म () एक गतिविधि को बंद कर देगा, लेकिन निश्चित रूप से पूरे ऐप को निश्चितता के साथ बंद नहीं करेगा।

— 2Dee