java - करन - मेरा ऑनस्यूम दो बार क्यों बुलाया जा रहा है?




प्यार करने वालों को सताया जा रहा है मोहब्बत का नक्शा मिटाया जा रहा (9)

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

    boolean resumeblock = false;

    @Override
    protected void onResume() {
        super.onResume();
        sceneView.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
            @Override
            public boolean onPreDraw() {
                sceneView.getViewTreeObserver().removeOnPreDrawListener(this);
                if (resumeblock) return false;
                resumeblock = true;

                //Some code.

                return false;
            }
        });
    }

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

असल में, मैं यही कर रहा हूं

1) ब्रॉडकास्ट रिसीवर (बीसीआर) निष्पादित करने के लिए अलार्ममेनगर सेट करें

Intent intent = new Intent(m_Context, BCR.class);  
intent.putExtras(extras);  
PendingIntent pendingIntent = PendingIntent.getBroadcast(m_Context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);  
AlarmManager am = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
am.set(AlarmManager.RTC_WAKEUP, StartTime, pendingIntent)  

2) बीसीआर से MyActivity शुरू करें

@Override  
public void onReceive(Context context, Intent intent) {  
    Intent newIntent = new Intent(context, MyActivity.class);
    newIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);  
    context.startActivity(newIntent);  
}

3) अगर यह चालू नहीं है तो माईएक्टिविटी स्क्रीन पर चालू हो

@Override  
public void onCreate(Bundle savedInstanceState) {  
    super.onCreate(savedInstanceState); 
    getWindow().addFlags(LayoutParams.FLAG_DISMISS_KEYGUARD);
    getWindow().addFlags(LayoutParams.FLAG_SHOW_WHEN_LOCKED);
    getWindow().addFlags(LayoutParams.FLAG_TURN_SCREEN_ON);
    setContentView(R.layout.myactivity);  
} 

@Overide  
protected void onNewIntent(Intent intent) {  
    super.onNewIntent(intent);  
}  

किसी कारण से, मुझे लगता है कि जब सही मायनेक्टिविटी खोला जाता है, तो इसका प्रवाह इस तरह होता है:

ऑनक्रेट / ऑन न्यूइन्टेंट -> ऑनर्यूम -> ऑन पॉज़ -> ऑन रेज़्यूम

मुझे यकीन नहीं है कि यह तुरंत क्यों चल रहा है। मुझे लगता है कि यह तब होता है जब झंडे द्वारा स्क्रीन चालू किया जाता है। क्या किसी को पता है यह क्यों होता है? क्या इस व्यवहार को रोका जा सकता है?


ऐसा लगता है कि समर्थन लाइब्रेरी से Activity का उपयोग सहेजता है और उदाहरण को स्वचालित रूप से पुनर्स्थापित करता है। इसलिए, savedInstanceState अगर आपका काम केवल तभी किया जाए तो savedInstanceState null


मुझे इस मुद्दे का भी सामना करना पड़ा क्योंकि यह टुकड़ों की वजह से है .. आपके पास गतिविधि में मौजूद टुकड़ों की संख्या onResume() उस संख्या को कॉल करेगी। साझा करने के लिए मैंने SharedPrefrences में ध्वज चर का उपयोग किया


मुझे एक ही समस्या है। मेरी स्थिति अगले थी CurrentActivity मुख्य सक्रियता CurrentFragment बढ़ाता है मुख्यफ्रेगमेंट बढ़ाता है

मैं आमतौर पर इरादे के साथ CurrentActivity खोल रहा था। ऑनक्रेट करंटएसिटीविटी में मैं CurrentFragment को बदल रहा था।

लाइफ साइकल था: 1. ऑनर्यूम मेनएक्टिविटी 2. ऑनर्यूज चालूएक्टिविटी 3. ऑनर्यूम मेनफ्रैगमेंट 4. ऑनस्यूज वर्तमान फ्रैगमेंट

स्वचालित रूप से रोकें, और उसके बाद फिर से

  1. onResume मुख्य गतिविधि
  2. onResume CurrentActivity
  3. ऑनर्यूम मेनफ्रेगमेंट
  4. onResume CurrentFragment

मैं सबकुछ पुनः स्थापित करने का फैसला करता हूं और कोशिश करने और खेलने में कुछ घंटों के बाद मुझे रूट मुद्दा मिला। मेनफ्रैगमेंट ऑनस्टार्ट में मैं हर समय स्टार्ट एक्टिविटीफॉर रिसेट को कॉल कर रहा था (मेरे मामले में वाईफाई चालू करने के लिए एंड्रॉइड पॉपअप में) जिसे मेनफ्रैगमेंट पर रोक दिया गया था। और हम सभी जानते हैं कि आगे के बाद अगले पर है।

तो यह एंड्रॉइड बग नहीं है, यह केवल मेरा है :-)

हैप्पी लाइफसाइकिल डीबगिंग!



मेरे पास एक समान समस्या थी, और मेरी समस्या यह थी कि ऑनक्रेट () विधि पर, मैं कर रहा था:

@Override
protected void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    super.setContentView(R.layout.friends);  <-- problem
}

"सुपर" के लिए मेरा फोन दो बार रेज़्यूम () को ट्रिगर कर रहा था। यह इरादे के रूप में काम करने के बाद मैंने इसे बदल दिया:

@Override
protected void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    setContentView(R.layout.friends);  <-- 'super.' removed
}

आशा करता हूँ की ये काम करेगा।


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

onPause-onResume-onPause-onResume हर बार होता है, जब ऐप इंस्टॉलेशन के बाद पहली बार शुरू होता है। आप कोड में किसी भी बदलाव करके और अपने आईडीई से ऐप को फिर से चलाने (जिसमें पुन: सम्मिलित करना शामिल है) करके इस व्यवहार को आसानी से बुला सकते हैं।

कोई फर्क नहीं पड़ता कि आप AppCompat libs का उपयोग करते हैं या नहीं। मैंने दोनों मामलों और व्यवहार का परीक्षण किया है।

नोट: एंड्रॉइड मार्शमलो पर परीक्षण किया गया।

मैंने इस धागे से कोड को खंड और गतिविधि जीवन चक्र के बारे में उधार लिया है और यहां यह है (केवल कॉपी, पेस्ट करें, मैनिफेस्ट में गतिविधि घोषित करें और वन रन चलाएं):

import android.app.Activity;
import android.app.Fragment;
import android.app.FragmentTransaction;
import android.content.Context;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

public class TestActivity extends Activity {

    private static final String TAG = "ACTIVITY";

    public TestActivity() {
        super();
        Log.d(TAG, this + ": this()");
    }

    protected void finalize() throws Throwable {
        super.finalize();
        Log.d(TAG, this + ": finalize()");
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, this + ": onCreate()");


        TextView tv = new TextView(this);
        tv.setText("Hello world");
        setContentView(tv);

        if (getFragmentManager().findFragmentByTag("test_fragment") == null) {
            Log.d(TAG, this + ": Existing fragment not found.");
            FragmentTransaction ft = getFragmentManager().beginTransaction();
            ft.add(new TestFragment(), "test_fragment").commit();
        } else {
            Log.d(TAG, this + ": Existing fragment found.");
        }
    }

    @Override
    public void onStart() {
        super.onStart();
        Log.d(TAG, this + ": onStart()");
    }

    @Override
    public void onResume() {
        super.onResume();
        Log.d(TAG, this + ": onResume()");
    }

    @Override
    public void onPause() {
        super.onPause();
        Log.d(TAG, this + ": onPause()");
    }

    @Override
    public void onStop() {
        super.onStop();
        Log.d(TAG, this + ": onStop()");
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, this + ": onDestroy()");
    }


    public static class TestFragment extends Fragment {

        private static final String TAG = "FRAGMENT";

        public TestFragment() {
            super();
            Log.d(TAG, this + ": this() " + this);
        }

        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            Log.d(TAG, this + ": onCreate()");
        }


        @Override
        public void onAttach(final Context context) {
            super.onAttach(context);
            Log.d(TAG, this + ": onAttach(" + context + ")");
        }

        @Override
        public void onActivityCreated(Bundle savedInstanceState) {
            super.onActivityCreated(savedInstanceState);
            Log.d(TAG, this + ": onActivityCreated()");
        }

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
            Log.d(TAG, this + ": onCreateView()");
            return null;
        }

        @Override
        public void onViewCreated(View view, Bundle savedInstanceState) {
            super.onViewCreated(view, savedInstanceState);
            Log.d(TAG, this + ": onViewCreated()");
        }

        @Override
        public void onDestroyView() {
            super.onDestroyView();
            Log.d(TAG, this + ": onDestroyView()");
        }

        @Override
        public void onDetach() {
            super.onDetach();
            Log.d(TAG, this + ": onDetach()");
        }

        @Override
        public void onStart() {
            super.onStart();
            Log.d(TAG, this + ": onStart()");
        }

        @Override
        public void onResume() {
            super.onResume();
            Log.d(TAG, this + ": onResume()");
        }

        @Override
        public void onPause() {
            super.onPause();
            Log.d(TAG, this + ": onPause()");
        }

        @Override
        public void onStop() {
            super.onStop();
            Log.d(TAG, this + ": onStop()");
        }

        @Override
        public void onDestroy() {
            super.onDestroy();
            Log.d(TAG, this + ": onDestroy()");
        }
    }

}

मैं बस इसमें भाग गया, और ऐसा लगता है कि getWindow().addFlags() और सामान्य रूप से Window गुणों को getWindow().addFlags() करना एक अपराधी हो सकता है।

जब मेरा कोड इस तरह है

@Override
protected void onCreate(Bundle savedInstanceState) {
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_generic_fragment_host);
    // performing fragment transaction when instance state is null...

onResume() दो बार ट्रिगर किया जाता है, लेकिन जब मैं requestWindowFeature() हटा देता requestWindowFeature() , तो इसे केवल एक बार बुलाया जाता है।


यदि आपके पास ईएस फाइल एक्सप्लोरर है, तो इसे रोकें। किसी भी तरह, वे आपके ऐप के जीवन चक्र को बाधित करते हैं।

रेस्यूम के साथ मेरा मुद्दा दो बार हुआ क्योंकि कारण किसी भी तरह से गतिविधि के निर्माण के बाद बुलाया जा रहा था, कुछ मेरे ऐप को बाधित कर रहा था।

और यह केवल स्थापना के बाद पहली बार या स्टूडियो से निर्मित होने के बाद होता है।

मुझे एक और पोस्ट से CLUE मिला और पता चला कि यह ईएस फाइल एक्सप्लोरर के कारण था। ऑनस्यूम () को दो बार क्यों कहा जाता है?

जैसे ही मैं ईएस फाइल एक्सप्लोरर को रोकता हूं, यह हिचकी व्यवहार अब नहीं होता है ... कई अन्य प्रस्तावित समाधानों को आजमाने के बाद जानना बहुत निराशाजनक है।







android-lifecycle