लॉगआउट में, केवल गतिविधि को खोलने से "बैक" बटन को रोकने के लिए, गतिविधि का इतिहास स्टैक साफ़ करें

Question

मेरे एप्लिकेशन की सभी गतिविधियों के लिए उपयोगकर्ता को लॉग-इन करने की आवश्यकता है। उपयोगकर्ता लगभग किसी भी गतिविधि से लॉग आउट कर सकते हैं। यह आवेदन की एक आवश्यकता है। किसी भी बिंदु पर अगर उपयोगकर्ता लॉग-आउट करता है, तो मैं उपयोगकर्ता को लॉगिन पर भेजना चाहता हूं Activity। इस बिंदु पर मैं चाहता हूं कि यह गतिविधि इतिहास स्टैक के निचले भाग पर हो ताकि "बैक" बटन दबाकर उपयोगकर्ता एंड्रॉइड की होम स्क्रीन पर लौट आए।

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

मैंने अपने Intentझंडे सेट करके लॉगिन गतिविधि खोलने की कोशिश की है, FLAG_ACTIVITY_CLEAR_TOPजो ऐसा लगता है जैसे कि प्रलेखन में उल्लिखित है, लेकिन इतिहास स्टैक के निचले भाग में लॉगिन गतिविधि रखने और उपयोगकर्ता को वापस नेविगेट करने से रोकने के मेरे लक्ष्य को प्राप्त नहीं करता है। पहले से देखी गई लॉग-इन गतिविधियों के लिए। मैंने android:launchMode="singleTop"मेनिफ़ेस्ट में लॉगिन गतिविधि का उपयोग करने का भी प्रयास किया , लेकिन यह मेरे लक्ष्य को पूरा नहीं करता है (और वैसे भी इसका कोई प्रभाव नहीं है)।

मेरा मानना ​​है कि मुझे इतिहास स्टैक को या तो साफ करने की जरूरत है, या पहले से खोली गई सभी गतिविधियों को खत्म करना है।

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

अगला विकल्प उन LinkedListसभी खुली गतिविधियों के संदर्भों को बनाए रखना है जो हर जगह से सांख्यिकीय रूप से सुलभ हैं (शायद कमजोर संदर्भों का उपयोग करके)। लॉगआउट करने पर, मैं इस सूची तक पहुंच पाऊंगा और सभी पहले से खोली गई गतिविधियों पर पुनरावृत्ति करूंगा, finish()हर एक पर आह्वान करूंगा । मैं शायद जल्द ही इस विधि को लागू करना शुरू कर दूंगा।

मैं इसे Intentपूरा करने के लिए कुछ ध्वज प्रवंचना का उपयोग करूंगा । मुझे यह जानकर ख़ुशी होगी कि मैं अपने आवेदन की उन आवश्यकताओं को पूरा कर सकता हूँ, जिनका उपयोग मैंने उन दोनों विधियों में से किया है, जिन्हें मैंने ऊपर उल्लिखित किया है।

Intentसेटिंग्स का उपयोग करके या प्रकट करके इसे पूरा करने का एक तरीका है , या मेरा दूसरा विकल्प है, LinkedListखुली गतिविधियों को बनाए रखना सबसे अच्छा विकल्प है? या फिर एक और विकल्प है कि मैं पूरी तरह से देख रहा हूँ?

Answer 1

मैं आपको एक और दृष्टिकोण IMHO और अधिक मजबूत बनाने का सुझाव दे सकता हूं। मूल रूप से आपको लॉग-इन स्थिति के तहत रहने के लिए अपनी सभी गतिविधियों के लिए एक लॉगआउट संदेश प्रसारित करना होगा। तो आप अपने सभी Actvities में sendBroadcastएक का उपयोग और स्थापित कर सकते हैं BroadcastReceiver। कुछ इस तरह:

/** on your logout method:**/
Intent broadcastIntent = new Intent();
broadcastIntent.setAction("com.package.ACTION_LOGOUT");
sendBroadcast(broadcastIntent);

रिसीवर (सुरक्षित गतिविधि):

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    /**snip **/
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction("com.package.ACTION_LOGOUT");
    registerReceiver(new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            Log.d("onReceive","Logout in progress");
            //At this point you should start the login activity and finish this one
            finish();
        }
    }, intentFilter);
    //** snip **//
}

Comments

@ क्रिस्‍टोफर, प्रत्‍येक गतिविधि को प्रसारण के लिए पंजीकृत करता है जब यह बन जाता है। जब यह पृष्ठभूमि पर जाता है (यानी, स्टैक के शीर्ष पर एक नई गतिविधि आती है), इसके ऑनटॉप () को बुलाया जाएगा, लेकिन यह अभी भी प्रसारण प्राप्त कर सकता है। आपको बस यह सुनिश्चित करने की आवश्यकता है कि आप ऑनस्ट्रे () के बजाय onDestroy () में unregisterReceiver () को कॉल करें।

— रसेल डेविस

क्या यह काम करता है अगर मेमोरी को पुनर्प्राप्त करने के लिए ओएस द्वारा स्टैक में कहीं एक गतिविधि को बंद कर दिया गया था? अर्थात। क्या सिस्टम इस पर विचार करेगा कि ऊपर भेजे गए प्रसारण के बाद यह वास्तव में समाप्त हो गया है, और बैक बटन से टकराने पर इसे फिर से नहीं बनाएगा?

— जनवरी Janवॉन्स्की

हालांकि यह एक सुरुचिपूर्ण समाधान की तरह प्रतीत होता है, यह ध्यान रखना महत्वपूर्ण है कि यह समकालिक नहीं है।

— चे जामी

एक अच्छा समाधान है, लेकिन ऊपर दिए गए कोड में वर्णित प्रसारण रिसीवर का उपयोग करने के बजाय, आपको एक LocalBroadcastManager.getInstance (यह) .registerReceiver (...) और LocalBroadcastManager .getInstance (यह) .unregisterReceiver (..) का उपयोग करना चाहिए। । अन्य एप्लिकेशन आपके आवेदन को किसी भी अन्य एप्लिकेशन (सुरक्षा चिंता) से प्राप्त कर सकते हैं

— उकु लोसकिट

@Arlock आप सही हैं। इस दृष्टिकोण के लिए नुकसान तब होता है जब सिस्टम द्वारा बैक स्टैक में एक गतिविधि को नष्ट कर दिया जाता है (विभिन्न कारणों से हो सकता है, जैसे कि विख्यात निम्न-स्मृति परिदृश्य)। उस स्थिति में, प्रसारण प्राप्त करने के लिए गतिविधि का उदाहरण आसपास नहीं होगा। लेकिन सिस्टम अभी भी उस एक्टिविटी के माध्यम से उसे दोबारा से नेविगेट करेगा। डेवलपर सेटिंग "

— डोन्ट

Answer 2

यह पारित होने का एक संस्कार लगता है कि एक नया एंड्रॉइड प्रोग्रामर इस मुद्दे पर शोध करने और इन सभी स्टैकऑवरफ्लो थ्रेड्स को पढ़ने में एक दिन खर्च करता है। अब मैं नई शुरुआत कर रहा हूं और भविष्य के तीर्थयात्री की मदद करने के लिए अपने विनम्र अनुभव का पता लगाता हूं।

सबसे पहले, अपना शोध के अनुसार यह करने के लिए कोई स्पष्ट या तत्काल तरीका है (as of September 2012).आप लगता है कि आप सरल कर सकते थे startActivity(new Intent(this, LoginActivity.class), CLEAR_STACK)लेकिन नहीं ।

आप कर सकते हैं startActivity(new Intent(this, LoginActivity.class))के साथ FLAG_ACTIVITY_CLEAR_TOP- और इस ढेर नीचे खोज करने के लिए, LoginActivity के अपने पहले मूल उदाहरण मिल जाए, इसे पुन: और (ऊपर की ओर) ढेर के बाकी स्पष्ट रूपरेखा का कारण होगा। और चूंकि लॉगिन निश्चित रूप से स्टैक के निचले भाग में है, अब आपके पास एक खाली स्टैक है और बैक बटन सिर्फ एप्लिकेशन को बाहर निकालता है।

लेकिन - यह केवल तभी काम करता है जब आपने पहले अपने स्टाॅक के आधार पर LoginActivity के मूल उदाहरण को छोड़ दिया हो। यदि, कई प्रोग्रामर की तरह, आपने इसे चुना है finish()कि LoginActivityएक बार उपयोगकर्ता सफलतापूर्वक लॉग इन कर लेता है, तो यह अब स्टैक के आधार पर नहीं है और FLAG_ACTIVITY_CLEAR_TOPशब्दार्थ लागू नहीं होता है ... आप LoginActivityमौजूदा स्टैक के शीर्ष पर एक नया बनाते हैं । जो लगभग निश्चित रूप से नहीं है कि आप क्या चाहते हैं (अजीब व्यवहार जहां उपयोगकर्ता पिछली स्क्रीन में लॉगिन से अपने तरीके से 'वापस' कर सकता है)।

इसलिए यदि आपके पास पहले finish()है LoginActivity, तो आपको अपने स्टैक को साफ करने और फिर एक नया शुरू करने के लिए कुछ तंत्र को आगे बढ़ाने की आवश्यकता है LoginActivity। ऐसा लगता है कि @doreamonइस धागे का उत्तर सबसे अच्छा समाधान है (कम से कम मेरी विनम्र आंख के लिए):

https://stackoverflow.com/a/9580057/614880

मुझे दृढ़ता से संदेह है कि क्या आप लॉगिनएक्टिविटी को जिंदा छोड़ते हैं या नहीं, इस भ्रम के बहुत सारे निहितार्थ हैं।

शुभ लाभ।

Comments

अच्छा उत्तर। FLAG_ACTIVITY_CLEAR_TOP ट्रिक, जिसे अधिकतर लोग उपयोग करने के लिए सलाह देते हैं, अगर आपने LoginActivity पूरी कर ली है तो बस काम नहीं करता है।

— कोन्सुमियर

उत्तर के लिए धन्यवाद। एक परिदृश्य ऐसा होता है जब कोई सत्र होता है (जैसे fb) यहां तक ​​कि हम लॉगिन गतिविधि को कॉल नहीं करते हैं, इसलिए स्टैक में लॉगिन गतिविधि का कोई मतलब नहीं है। फिर ऊपर वर्णित दृष्टिकोण बेकार है।

— प्रशांत देवबदवार

Answer 3

अपडेट करें

सुपर finishAffinity()विधि कोड को कम करने में मदद करेगी लेकिन समान हासिल करेगी। यह वर्तमान गतिविधि के साथ-साथ स्टैक में सभी गतिविधियों को समाप्त कर देगा, getActivity().finishAffinity()यदि आप एक टुकड़े में हैं तो उपयोग करें ।

finishAffinity(); 
startActivity(new Intent(mActivity, LoginActivity.class));

मूल ANSWER

मान लें कि LoginActivity -> HomeActivity -> ... -> SettingsActivity call signOut ():

void signOut() {
    Intent intent = new Intent(this, HomeActivity.class);
    intent.putExtra("finish", true);
    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); // To clean up all activities
    startActivity(intent);
    finish();
}

HomeActivity:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    boolean finish = getIntent().getBooleanExtra("finish", false);
    if (finish) {
        startActivity(new Intent(mContext, LoginActivity.class));
        finish();
        return;
    }
    initializeView();
}

यह मेरे लिए काम करता है, आशा है कि यह आपके लिए भी उपयोगी है। :)

Comments

मुझे लगता है कि आपका समाधान मानता है कि उपयोगकर्ता साइनऑट पर क्लिक करेगा और केवल एक गतिविधि (होमएक्टिविटी) पर वापस जाएगा। यदि आपके पास स्टैक पर 10 गतिविधियां हैं तो क्या होगा?

— इगोरगानापोलस्की

यदि आपके पास HomeActivity के शीर्ष पर 10 गतिविधियां हैं, तो FLAG_ACTIVITY_CLEAR_TOP ध्वज सभी को साफ करने में मदद करेगा।

— थानबिनहॉ

यह तभी काम कर सकता है जब होमएक्टिविटी शुरू करते समय, आप अपने ऑनक्रिएट ऑफ होमएक्टिविटी को प्राप्त करें। बस घर गतिविधि शुरू करना जरूरी नहीं है कि इसे तब तक फिर से बनाया जाए जब तक कि यह समाप्त न हो जाए या पहले से ही नष्ट न हो जाए। यदि होमएक्टिविटी को फिर से बनाने की आवश्यकता नहीं है, तो OnCreate को कॉल नहीं किया जाएगा और लॉग आउट करने के बाद आप अपने घर की गतिविधि पर बैठे होंगे।

— topwik

यह एक संभव समाधान है और जिसमें लॉगआउट जैसे सरल (उपयोगकर्ता के लिए) फ़ीचर को कम करना शामिल है।

— सबिन सेबेस्टियन 4

Intent.FLAG_ACTIVITY_CLEAR_TOP ध्वज होम एक्टिविटी सहित सभी गतिविधियों को साफ करने में मदद करता है, इस प्रकार ऑनक्रिएट () विधि तब की जाएगी जब आप इस गतिविधि को फिर से शुरू करेंगे।

— तेहबिनह84

Answer 4

यदि आप API 11 या उच्चतर का उपयोग कर रहे हैं, तो आप यह कोशिश कर सकते हैं: FLAG_ACTIVITY_CLEAR_TASK- ऐसा प्रतीत होता है कि वास्तव में आप जिस मुद्दे को ले रहे हैं, उसे संबोधित करते हैं। स्पष्ट रूप से पूर्व-एपीआई 11 भीड़ को अतिरिक्त गतिविधियों की जाँच के कुछ संयोजन का उपयोग करना होगा, जैसा कि @doreamon का सुझाव है, या कुछ अन्य चालबाजी।

(यह भी नोट करें: इसका उपयोग करने के लिए आपको पास होना होगा FLAG_ACTIVITY_NEW_TASK)

Intent intent = new Intent(this, LoginActivity.class);
intent.putExtra("finish", true); // if you are checking for this in your other Activities
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | 
                Intent.FLAG_ACTIVITY_CLEAR_TASK |
                Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
finish();

Comments

आकर्षण की तरह काम करना। आपका बहुत बहुत धन्यवाद! जैसा कि मैं मिनट एपीआई 14 पर विकसित करता हूं, यह केवल लागू करने की चीज है।

— एंडीबी

मुझे लगता है कि LoginActivity के लिए इस समाधान का उपयोग करते समय हमें FLAG_ACTIVITY_CLEAR_TOP की आवश्यकता नहीं है।

— भरत डोडेजा

मुझे लगता है कि सिर्फ finish();लॉगआउट के बाद वापस जाने से रोकने के लिए काम करेंगे। झंडे लगाने की क्या जरूरत है?

— पंकज

यह अपवाद बनाता है एक गतिविधि संदर्भ के बाहर से कॉलिंग स्टार्ट एक्टिविटी () के लिए FLAG_ACTIVITY_NEW_TASK ध्वज की आवश्यकता होती है

— अमन

Answer 5

मैंने इस पर भी कुछ घंटे बिताए ... और सहमत हूं कि FLAG_ACTIVITY_CLEAR_TOP को लगता है कि आप क्या चाहते हैं: लॉन्च किए जा रहे गतिविधि को छोड़कर, पूरे स्टैक को साफ़ करें, इसलिए बैक बटन एप्लिकेशन से बाहर निकलता है। फिर भी जैसा कि माइक रिपास ने उल्लेख किया है, FLAG_ACTIVITY_CLEAR_TOP केवल तभी काम करता है जब आप जिस गतिविधि को शुरू कर रहे हैं वह पहले से ही स्टैक में है; जब गतिविधि नहीं होती है, तो ध्वज कुछ भी नहीं करता है।

क्या करें? स्टैक में लॉन्च की जा रही गतिविधि को FLAG_ACTIVITY_NEW_TASK के साथ रखें , जो उस गतिविधि को इतिहास स्टैक पर एक नए कार्य की शुरुआत बनाता है। फिर FLAG_ACTIVITY_CLEAR_TOP ध्वज जोड़ें।

अब, जब FLAG_ACTIVITY_CLEAR_TOP स्टैक में नई गतिविधि को खोजने के लिए जाता है, तो यह वहाँ हो जाएगा और बाकी सब साफ़ होने से पहले इसे खींच लिया जाएगा।

यहाँ मेरा लॉगआउट फ़ंक्शन है; व्यू पैरामीटर वह बटन है जिससे फ़ंक्शन जुड़ा हुआ है।

public void onLogoutClick(final View view) {
    Intent i = new Intent(this, Splash.class);
    i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
    startActivity(i);
    finish();
}

Comments

एपीआई <= 10 पर काम नहीं किया जाएगा क्योंकि FLAG_ACTIVITY_CLEAR_TASKअभी तक जोड़ा नहीं गया था

— Youans

@christinac आप FLAG_ACTIVITY_CLEAR_TOP के बारे में बात कर रहे हैं और आपके कोड स्निपेट में FLAG_ACTIVITY_CLEAR_TASK है; जो तब मान्य है?

— मैरियन पाडज़िओच

Answer 6

बहुत सारे जवाब। हो सकता है कि यह भी मदद करेगा-

Intent intent = new Intent(activity, SignInActivity.class)
                .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
this.startActivity(intent);
this.finish();

कोटलिन संस्करण-

Intent(this, SignInActivity::class.java).apply {
    addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
}.also { startActivity(it) }
finish()

Answer 7

इसका उपयोग करें यह आपके लिए उपयोगी होना चाहिए। थोड़ा संशोधित xbakesx उत्तर।

Intent intent = new Intent(this, LoginActivity.class);
if(Build.VERSION.SDK_INT >= 11) {
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_CLEAR_TASK);
} else {
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
}
startActivity(intent);

Answer 8

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

protected void onResume() {
  super.onResume();
  if (isAuthRequired()) {
    checkAuthStatus();
  }
}

private void checkAuthStatus() {
  //check your shared pref value for login in this method
  if (checkIfSharedPrefLoginValueIsTrue()) {
    finish();
  }
}

boolean isAuthRequired() {
  return true;
}

Comments

सालों हो गए, लेकिन मुझे विश्वास है कि मैंने दोनों किया। प्रत्येक गतिविधि ने LogInActivity को विस्तारित किया, जिसने उपयोगकर्ता की लॉग-इन स्थिति onCreate () में जाँच की। LogInActivity ने "उपयोगकर्ता लॉग आउट" प्रसारण के लिए भी सुनी, और इस पर प्रतिक्रिया देने के लिए जो कुछ भी करने की आवश्यकता थी वह किया।

— स्काईलर

अधिक शायद आपको onResume()मेथोड में checkAuthStatus डालना चाहिए । क्योंकि जब आप बैक बटन दबाते हैं, तो गतिविधि के बजाय निर्मित होने की संभावना अधिक होती है।

— मई 06

@maysi सुझाव के लिए धन्यवाद, हाँ इस तरह से बैक बटन भी सही ढंग से काम करेगा, मैंने प्रविष्टि को अपडेट किया

— Yekmer Simsek

Answer 9

कुछ finish()समय के लिए काम नहीं कर रहा है

मैंने उस मुद्दे को हल कर लिया है

finishAffinity()

Answer 10

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

@Override
public void onBackPressed() {
    // disable going back to the MainActivity
    moveTaskToBack(true);
}

मैं यह मान रहा हूं कि उपयोगकर्ता के लॉग इन करने के बाद ही LoginActivity समाप्त हो जाती है, ताकि वह बाद में बैक बटन दबाकर उस पर वापस न जा सके। इसके बजाय, उपयोगकर्ता को ठीक से लॉग आउट करने के लिए ऐप के अंदर लॉग आउट बटन दबाया जाना चाहिए। यह लॉग आउट बटन क्या लागू करेगा एक सरल आशय इस प्रकार है:

Intent intent = new Intent(this, LoginActivity.class);
startActivity(intent);
finish();

सभी सुझावों का स्वागत है।

Answer 11

चयनित उत्तर चतुर और पेचीदा है। यहाँ मैंने यह कैसे किया:

LoginActivity कार्य की जड़ गतिविधि है, Android सेट करें : NoHistory = "true" इसे Manifest.xml में; कहो कि आप SettingsActivity से लॉगआउट करना चाहते हैं, आप इसे नीचे की तरह कर सकते हैं:

    Intent i = new Intent(SettingsActivity.this, LoginActivity.class);
    i.addFlags(IntentCompat.FLAG_ACTIVITY_CLEAR_TASK
            | Intent.FLAG_ACTIVITY_NEW_TASK);
    startActivity(i);

Answer 12

यहाँ समाधान मैं अपने अनुप्रयोग के साथ आया हूँ।

मेरी लॉगिनएक्टिविटी में, लॉगिन को सफलतापूर्वक संसाधित करने के बाद, मैं एपीआई स्तर के आधार पर अगले एक अलग शुरुआत करता हूं।

Intent i = new Intent(this, MainActivity.class);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
    startActivity(i);
    finish();
} else {
    startActivityForResult(i, REQUEST_LOGIN_GINGERBREAD);
}

फिर मेरे LoginActivity की onActivityForResult विधि में:

if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB &&
        requestCode == REQUEST_LOGIN_GINGERBREAD &&
        resultCode == Activity.RESULT_CANCELED) {
    moveTaskToBack(true);
}

अंत में, किसी अन्य गतिविधि में लॉगआउट करने के बाद:

Intent i = new Intent(this, LoginActivity.class);
i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
startActivity(i);

जब जिंजरब्रेड पर होता है, तो ऐसा करता है यदि मैं मेनऐक्टिविटी से बैक बटन दबाता हूं, तो लॉगिनएक्टिविटी तुरंत छिप जाती है। हनीकॉम्ब और बाद में, मैं सिर्फ एक लॉगिन प्रोसेस करने के बाद LoginActivity खत्म करता हूं और लॉगआउट करने के बाद इसे ठीक से रीक्रिएट किया जाता है।

Comments

यह मेरे लिए काम नहीं कर रहा है। मेरे मामले में मैंने खंडनशीलता का इस्तेमाल किया। Onactivityresult विधि को नहीं कहा जाता है।

— मोहम्मद इब्राहिम

Answer 13

यह मेरे लिए काम किया:

     // After logout redirect user to Loing Activity
    Intent i = new Intent(_context, MainActivity.class);
    // Closing all the Activities
    i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);

    // Add new Flag to start new Activity
    i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

    // Staring Login Activity
    _context.startActivity(i);

Comments

क्या आप अपने समाधान के बारे में थोड़ा और विवरण जोड़कर अपने जवाब को विस्तृत कर सकते हैं?

— अबरिसोन

Answer 14

आप StartActivityForResult के साथ गतिविधि शुरू करें और जब आप लॉगआउट करें अपना परिणाम सेट करें और परिणाम के अनुसार आप अपनी गतिविधि समाप्त करें

intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
startActivityForResult(intent, BACK_SCREEN);

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch (requestCode) {
    case BACK_SCREEN:
        if (resultCode == REFRESH) {
            setResult(REFRESH);
            finish();
        }
        break;
    }
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        AlertDialog alertDialog = builder.create();

        alertDialog
                .setTitle((String) getResources().getText(R.string.home));
        alertDialog.setMessage((String) getResources().getText(
                R.string.gotoHome));
        alertDialog.setButton(DialogInterface.BUTTON_POSITIVE, "Yes",
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                            int whichButton) {

                        setResult(REFRESH);
                        finish();
                    }

                });

        alertDialog.setButton(DialogInterface.BUTTON_NEGATIVE, "No",
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                            int whichButton) {
                    }
                });
        alertDialog.show();
        return true;
    } else
        return super.onKeyDown(keyCode, event);

}

Answer 15

समाधान @doreamon प्रदान करता है एक को छोड़कर सभी मामलों के लिए ठीक काम करता है:

यदि लॉगिन करने के बाद, लॉगिन स्क्रीन उपयोगकर्ता को सीधे मध्य स्क्रीन पर नेविगेट करता है। जैसे- A-> B-> C के प्रवाह में, जैसे: लॉगिन -> B -> C -> घर पर शॉर्टकट दबाएं। FLAG_ACTIVITY_CLEAR_TOP का उपयोग केवल C गतिविधि को साफ़ करता है, क्योंकि होम (A) स्टैक इतिहास पर नहीं है। एक स्क्रीन पर वापस दबाने से हमें बी वापस आ जाएगा।

इस समस्या से निपटने के लिए, हम एक गतिविधि स्टैक (Arraylist) रख सकते हैं और जब घर दबाया जाता है, तो हमें इस स्टैक में सभी गतिविधियों को मारना होगा।

Answer 16

यह SharedPreferences में या अनुप्रयोग गतिविधि में एक ध्वज का प्रबंधन करके संभव है।

एप्लिकेशन के शुरू होने पर (स्प्लैश स्क्रीन पर) झंडे को सेट करें = गलत; लॉगआउट पर क्लिक करें घटना बस ध्वज को सही और हर गतिविधि के OnResume () में सेट करें, जांचें कि यदि झंडा सत्य है तो कॉल समाप्त करें ()।

यह एक सम्मोहन की तरह काम करता है :)

Answer 17

लॉगआउट के क्लिक पर आप इसे कॉल कर सकते हैं

private void GoToPreviousActivity() {
    setResult(REQUEST_CODE_LOGOUT);
    this.finish();
}

पिछली गतिविधि का onActivityResult () इस कोड को फिर से कॉल करता है जब तक कि आपने सभी गतिविधियों को समाप्त नहीं कर दिया।

Comments

इसका मतलब यह है कि इसे सभी गतिविधियों के माध्यम से रैखिक रूप से पूरा करना है, बजाय एक ही बार प्रसारण () को प्रसारित करने के बजाय?

— इगोरगानापोलस्की

@ आईजी जी हां यह क्रमिक रूप से खत्म करने का एक वैकल्पिक तरीका है

— Mak

Answer 18

एक विकल्प यह है कि प्रत्येक गतिविधि का ऑन-चेक चेक लॉग-इन स्थिति हो, और लॉग-इन न होने पर समाप्त () हो। मुझे यह विकल्प पसंद नहीं है, क्योंकि बैक बटन अभी भी उपयोग के लिए उपलब्ध होगा, गतिविधियों को खुद को बंद करने के रूप में वापस नेविगेट करना।

आप क्या करना चाहते हैं लॉग ऑन () और खत्म () अपने onStop () या onPause () विधियों पर। यह एंड्रॉइड को ऑनक्रिएट () पर कॉल करने के लिए मजबूर करेगा जब गतिविधि को वापस लाया जाता है क्योंकि इसके पास इसकी गतिविधि के स्टैक में अब नहीं होगा। फिर जैसा कि आप कहते हैं, onCreate में () लॉग इन स्टेटस चेक करें और लॉग इन न होने पर स्क्रीन लॉग इन करें।

एक और चीज जो आप कर सकते हैं वह है चेक ऑन स्टेटस ऑन ओन्यूम (), और यदि लॉग इन नहीं किया गया है, तो समाप्त () और लॉगिन एक्टिविटी लॉन्च करें।

Comments

मैं प्रत्येक गतिविधि को रोकने या रोकने के लिए लॉगआउट नहीं करना चाहूंगा। इसके अलावा, आवेदन लॉगआउट या लॉगिन शुरू करता है, इसलिए मुझे लॉग-इन, वास्तव में जांचने की आवश्यकता नहीं है।

— स्काइलर

@ रिकार्डो: आपके समाधान के लिए एक ब्रॉडकास्टर की आवश्यकता नहीं है?

— इगोरगानापोलस्की