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




हूं वीडियो (12)

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

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);  
}  

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

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

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


Answers

बस अगर कोई और इसमें चलता है, तो मुझे लगता है कि जब मैं एक्सएमएल लेआउट के माध्यम से किसी गतिविधि के अंदर टुकड़े को बढ़ाता हूं तो मुझे यह व्यवहार दिखाई देता है। मुझे नहीं पता कि यह व्यवहार Fragments के संगतता लाइब्रेरी संस्करण के साथ भी होता है (मैं android.app.Fragment का उपयोग कर रहा हूं)

ऐसा लगता है कि गतिविधि Fragment#onResume को किसी भी अतिरिक्त Fragment#onResume पर कॉल करने से पहले एक बार Activity#onResume Fragment#onResume को कॉल करेगी, और उसके बाद Activity#onResume फिर से कॉल करेगी।

  1. गतिविधि: onCreate
  2. टुकड़ा: onAttach
  3. गतिविधि: onAttachFragments
  4. टुकड़ा: onCreate
  5. गतिविधि: ऑनस्टार्ट
  6. गतिविधि: ऑनर्यूम
  7. टुकड़ा: onResume
  8. गतिविधि: ऑनर्यूम

यदि आप हर बार अनुरोध अनुमतियों का प्रयास कर रहे हैं तो यह ऐसी समस्याओं का कारण बन सकता है, बस जांचें कि क्या आपने उन्हें पहले ही दिया है या नहीं

requestPermissions इसका कारण बन सकती हैं:

onCreate
onStart
onResume
onPause
onResume

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

    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;
            }
        });
    }

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


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

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

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

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

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

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

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

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


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

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

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

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

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



मैं बस इसमें भाग गया, और ऐसा लगता है कि 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() , तो इसे केवल एक बार बुलाया जाता है।


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


मैं इस ऑन्रेस्यूम-ऑनपोज़-ऑन्रेस्यूम अनुक्रम में भी चला गया (4.1.2 और ऊपर, लेकिन मुझे 2.3 पर इसका अनुभव नहीं हुआ)। मेरी समस्या वाकेलॉक हैंडलिंग से संबंधित थी: मैं गलती से एक वाकलॉक जारी करने के लिए भूल गया था और इसे पुनः प्राप्त करने के कारण यह संदेश के साथ एक त्रुटि हुई "वेक लॉक अभी भी आयोजित होने पर अंतिम रूप दिया गया"। इस समस्या के परिणामस्वरूप रेज्यूम के तुरंत बाद कॉल किया जा रहा था और इसके परिणामस्वरूप दोषपूर्ण व्यवहार हुआ।

मेरा सुझाव है: लॉग में त्रुटियों की जांच करें, वे इस मुद्दे से संबंधित हो सकते हैं।

एक और संकेत: खिड़की के झंडे का उपयोग करने से स्क्रीन पर मोड़ना थोड़ा और मुश्किल हो सकता है। आप यहां यह उत्तर देखना चाहेंगे - यह सुझाव देता है कि आप एक रिसीवर सेट अप करें ताकि यह जांच सके कि स्क्रीन पहले ही चालू हो चुकी है या वांछित गतिविधि को लॉन्च करने के बाद: https://.com/a/16346369/875442


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


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

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()");
        }
    }

}

अपने एंटीवायरस को अक्षम करने का प्रयास करें। शायद यह एमुलेटर थोड़ा तेज कर देगा।







java android android-activity android-lifecycle