লাইফসাইকেল-সচেতন উপাদানগুলির সাথে লাইফসাইকেল পরিচালনা করা অ্যান্ড্রয়েড জেটপ্যাকের অংশ৷

লাইফসাইকেল-সচেতন উপাদানগুলি অন্য উপাদানের জীবনচক্রের অবস্থার পরিবর্তনের প্রতিক্রিয়া হিসাবে ক্রিয়া সম্পাদন করে, যেমন ক্রিয়াকলাপ এবং টুকরা। এই উপাদানগুলি আপনাকে আরও ভাল-সংগঠিত, এবং প্রায়শই হালকা-ওজন কোড তৈরি করতে সাহায্য করে, যা বজায় রাখা সহজ।

একটি সাধারণ প্যাটার্ন হল ক্রিয়াকলাপ এবং টুকরোগুলির জীবনচক্র পদ্ধতিতে নির্ভরশীল উপাদানগুলির ক্রিয়াগুলি বাস্তবায়ন করা। যাইহোক, এই প্যাটার্নটি কোডের একটি দুর্বল সংগঠন এবং ত্রুটির বিস্তারের দিকে নিয়ে যায়। জীবনচক্র-সচেতন উপাদানগুলি ব্যবহার করে, আপনি নির্ভরশীল উপাদানগুলির কোডকে জীবনচক্র পদ্ধতির বাইরে এবং উপাদানগুলির মধ্যে স্থানান্তর করতে পারেন।

androidx.lifecycle প্যাকেজ ক্লাস এবং ইন্টারফেস প্রদান করে যা আপনাকে জীবনচক্র-সচেতন উপাদান তৈরি করতে দেয়—যা এমন উপাদান যা একটি কার্যকলাপ বা খণ্ডের বর্তমান জীবনচক্র অবস্থার উপর ভিত্তি করে স্বয়ংক্রিয়ভাবে তাদের আচরণকে সামঞ্জস্য করতে পারে।

অ্যান্ড্রয়েড ফ্রেমওয়ার্কে সংজ্ঞায়িত বেশিরভাগ অ্যাপের উপাদানগুলির সাথে লাইফসাইকেল সংযুক্ত থাকে। আপনার প্রক্রিয়া চলাকালীন অপারেটিং সিস্টেম বা ফ্রেমওয়ার্ক কোড দ্বারা জীবনচক্র পরিচালিত হয়। এগুলি Android কীভাবে কাজ করে তার মূল বিষয় এবং আপনার অ্যাপ্লিকেশন অবশ্যই সেগুলিকে সম্মান করবে৷ এটি না করলে মেমরি লিক বা এমনকি অ্যাপ্লিকেশন ক্র্যাশ হতে পারে।

কল্পনা করুন আমাদের একটি কার্যকলাপ আছে যা স্ক্রিনে ডিভাইসের অবস্থান দেখায়। একটি সাধারণ বাস্তবায়ন নিম্নলিখিত মত হতে পারে:

internal class MyLocationListener(
        private val context: Context,
        private val callback: (Location) -> Unit
) {

    fun start() {
        // connect to system location service
    }

    fun stop() {
        // disconnect from system location service
    }
}

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        myLocationListener.start()
        // manage other components that need to respond
        // to the activity lifecycle
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

class MyLocationListener {
    public MyLocationListener(Context context, Callback callback) {
        // ...
    }

    void start() {
        // connect to system location service
    }

    void stop() {
        // disconnect from system location service
    }
}

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    @Override
    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, (location) -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        myLocationListener.start();
        // manage other components that need to respond
        // to the activity lifecycle
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

যদিও এই নমুনাটি সূক্ষ্ম দেখায়, একটি বাস্তব অ্যাপে, আপনার কাছে অনেকগুলি কল রয়েছে যা জীবনচক্রের বর্তমান অবস্থার প্রতিক্রিয়া হিসাবে UI এবং অন্যান্য উপাদানগুলি পরিচালনা করে। একাধিক উপাদান পরিচালনা করা জীবনচক্র পদ্ধতিতে যথেষ্ট পরিমাণে কোড রাখে, যেমন onStart() এবং onStop() , যা তাদের বজায় রাখা কঠিন করে তোলে।

তদুপরি, কার্যকলাপ বা খণ্ডটি বন্ধ হওয়ার আগে উপাদানটি শুরু হওয়ার কোনও গ্যারান্টি নেই। এটি বিশেষত সত্য যদি আমাদের একটি দীর্ঘ-চলমান অপারেশন সঞ্চালনের প্রয়োজন হয়, যেমন কিছু কনফিগারেশন চেক ইন onStart() । এটি একটি রেস অবস্থার কারণ হতে পারে যেখানে onStop() পদ্ধতিটি onStart() আগে শেষ হয়ে যায়, উপাদানটিকে এটির প্রয়োজনের চেয়ে বেশি সময় বাঁচিয়ে রাখে।

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        Util.checkUserStatus { result ->
            // what if this callback is invoked AFTER activity is stopped?
            if (result) {
                myLocationListener.start()
            }
        }
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
    }

}

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, location -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        Util.checkUserStatus(result -> {
            // what if this callback is invoked AFTER activity is stopped?
            if (result) {
                myLocationListener.start();
            }
        });
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
    }
}

androidx.lifecycle প্যাকেজ ক্লাস এবং ইন্টারফেস সরবরাহ করে যা আপনাকে এই সমস্যাগুলিকে একটি স্থিতিস্থাপক এবং বিচ্ছিন্ন উপায়ে মোকাবেলা করতে সহায়তা করে।

জীবনচক্র

Lifecycle এমন একটি শ্রেণী যা একটি উপাদানের জীবনচক্রের অবস্থা (যেমন একটি কার্যকলাপ বা একটি খণ্ড) সম্পর্কে তথ্য রাখে এবং অন্যান্য বস্তুকে এই অবস্থা পর্যবেক্ষণ করতে দেয়।

Lifecycle তার সংশ্লিষ্ট উপাদানের জন্য জীবনচক্রের স্থিতি ট্র্যাক করতে দুটি প্রধান গণনা ব্যবহার করে:

ঘটনা

লাইফসাইকেল ইভেন্ট যা ফ্রেমওয়ার্ক এবং Lifecycle ক্লাস থেকে পাঠানো হয়। এই ইভেন্টগুলি ক্রিয়াকলাপ এবং টুকরোগুলিতে কলব্যাক ইভেন্টগুলির মানচিত্র।

রাজ্য

Lifecycle অবজেক্ট দ্বারা ট্র্যাক করা উপাদানটির বর্তমান অবস্থা।

রাজ্যগুলিকে একটি গ্রাফের নোড এবং এই নোডগুলির মধ্যে প্রান্ত হিসাবে ঘটনাগুলিকে ভাবুন৷

একটি ক্লাস DefaultLifecycleObserver প্রয়োগ করে এবং onCreate , onStart , ইত্যাদির মতো সংশ্লিষ্ট পদ্ধতিগুলিকে ওভাররাইড করে উপাদানটির জীবনচক্রের অবস্থা নিরীক্ষণ করতে পারে। তারপর আপনি Lifecycle ক্লাসের addObserver() পদ্ধতিতে কল করে এবং আপনার পর্যবেক্ষকের একটি উদাহরণ পাস করে একজন পর্যবেক্ষক যোগ করতে পারেন, যেমনটি নিম্নলিখিত উদাহরণে দেখানো হয়েছে:

class MyObserver : DefaultLifecycleObserver {
    override fun onResume(owner: LifecycleOwner) {
        connect()
    }

    override fun onPause(owner: LifecycleOwner) {
        disconnect()
    }
}

myLifecycleOwner.getLifecycle().addObserver(MyObserver())

public class MyObserver implements DefaultLifecycleObserver {
    @Override
    public void onResume(LifecycleOwner owner) {
        connect()
    }

    @Override
    public void onPause(LifecycleOwner owner) {
        disconnect()
    }
}

myLifecycleOwner.getLifecycle().addObserver(new MyObserver());

উপরের উদাহরণে, myLifecycleOwner অবজেক্টটি LifecycleOwner ইন্টারফেস প্রয়োগ করে, যা নিম্নলিখিত বিভাগে ব্যাখ্যা করা হয়েছে।

জীবনচক্রের মালিক

LifecycleOwner হল একটি একক পদ্ধতির ইন্টারফেস যা বোঝায় যে ক্লাসের একটি Lifecycle আছে। এটির একটি পদ্ধতি রয়েছে, getLifecycle() , যা অবশ্যই ক্লাস দ্বারা প্রয়োগ করা উচিত। আপনি যদি পরিবর্তে একটি সম্পূর্ণ অ্যাপ্লিকেশন প্রক্রিয়ার জীবনচক্র পরিচালনা করার চেষ্টা করছেন, ProcessLifecycleOwner দেখুন।

এই ইন্টারফেসটি পৃথক শ্রেণী থেকে একটি Lifecycle মালিকানাকে বিমূর্ত করে, যেমন Fragment এবং AppCompatActivity , এবং তাদের সাথে কাজ করে এমন উপাদান লেখার অনুমতি দেয়। যেকোন কাস্টম অ্যাপ্লিকেশন শ্রেণী LifecycleOwner ইন্টারফেস বাস্তবায়ন করতে পারে।

DefaultLifecycleObserver বাস্তবায়নকারী উপাদানগুলি LifecycleOwner প্রয়োগ করে এমন উপাদানগুলির সাথে নির্বিঘ্নে কাজ করে কারণ একজন মালিক একটি লাইফসাইকেল প্রদান করতে পারেন, যা একজন পর্যবেক্ষক দেখার জন্য নিবন্ধন করতে পারেন।

অবস্থান ট্র্যাকিং উদাহরণের জন্য, আমরা MyLocationListener ক্লাসটিকে DefaultLifecycleObserver প্রয়োগ করতে পারি এবং তারপর onCreate() পদ্ধতিতে কার্যকলাপের Lifecycle দিয়ে শুরু করতে পারি। এটি MyLocationListener ক্লাসকে স্বয়ংসম্পূর্ণ হতে দেয়, যার অর্থ লাইফসাইকেল স্ট্যাটাসে পরিবর্তনের প্রতিক্রিয়া করার যুক্তিটি কার্যকলাপের পরিবর্তে MyLocationListener এ ঘোষণা করা হয়। স্বতন্ত্র উপাদানগুলিকে তাদের নিজস্ব যুক্তি সংরক্ষণ করার ফলে কার্যকলাপ এবং খণ্ডিত যুক্তিগুলি পরিচালনা করা সহজ করে তোলে।

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this, lifecycle) { location ->
            // update UI
        }
        Util.checkUserStatus { result ->
            if (result) {
                myLocationListener.enable()
            }
        }
    }
}

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, getLifecycle(), location -> {
            // update UI
        });
        Util.checkUserStatus(result -> {
            if (result) {
                myLocationListener.enable();
            }
        });
  }
}

Lifecycle এই মুহূর্তে ভালো অবস্থায় না থাকলে নির্দিষ্ট কলব্যাকের আহ্বান এড়াতে একটি সাধারণ ব্যবহারের ক্ষেত্রে। উদাহরণ স্বরূপ, অ্যাক্টিভিটি স্টেট সেভ করার পর যদি কলব্যাক একটি ফ্র্যাগমেন্ট লেনদেন চালায়, তাহলে এটি একটি ক্র্যাশ ট্রিগার করবে, তাই আমরা কখনই সেই কলব্যাকটি চালু করতে চাই না।

এই ব্যবহারের ক্ষেত্রে সহজ করার জন্য, Lifecycle ক্লাস অন্যান্য অবজেক্টকে বর্তমান অবস্থা জিজ্ঞাসা করার অনুমতি দেয়।

internal class MyLocationListener(
        private val context: Context,
        private val lifecycle: Lifecycle,
        private val callback: (Location) -> Unit
): DefaultLifecycleObserver {

    private var enabled = false

    override fun onStart(owner: LifecycleOwner) {
        if (enabled) {
            // connect
        }
    }

    fun enable() {
        enabled = true
        if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
            // connect if not connected
        }
    }

    override fun onStop(owner: LifecycleOwner) {
        // disconnect if connected
    }
}

class MyLocationListener implements DefaultLifecycleObserver {
    private boolean enabled = false;
    public MyLocationListener(Context context, Lifecycle lifecycle, Callback callback) {
       ...
    }

    @Override
    public void onStart(LifecycleOwner owner) {
        if (enabled) {
           // connect
        }
    }

    public void enable() {
        enabled = true;
        if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
            // connect if not connected
        }
    }

    @Override
    public void onStop(LifecycleOwner owner) {
        // disconnect if connected
    }
}

এই বাস্তবায়নের মাধ্যমে, আমাদের LocationListener ক্লাস সম্পূর্ণরূপে জীবনচক্র-সচেতন। আমাদের যদি অন্য কোনো কার্যকলাপ বা খণ্ড থেকে আমাদের LocationListener ব্যবহার করতে হয়, তাহলে আমাদের শুধু এটি আরম্ভ করতে হবে। সমস্ত সেটআপ এবং টিয়ারডাউন অপারেশন ক্লাস নিজেই পরিচালনা করে।

যদি কোনো লাইব্রেরি এমন ক্লাস সরবরাহ করে যেগুলিকে অ্যান্ড্রয়েড লাইফসাইকেলের সাথে কাজ করতে হবে, আমরা আপনাকে লাইফসাইকেল-সচেতন উপাদানগুলি ব্যবহার করার পরামর্শ দিই। আপনার লাইব্রেরি ক্লায়েন্টরা ক্লায়েন্ট সাইডে ম্যানুয়াল লাইফসাইকেল ম্যানেজমেন্ট ছাড়াই সেই উপাদানগুলিকে সহজেই একীভূত করতে পারে।

একটি কাস্টম লাইফসাইকেল মালিক বাস্তবায়ন করা

সাপোর্ট লাইব্রেরি 26.1.0 এবং পরবর্তীতে ইতিমধ্যেই LifecycleOwner ইন্টারফেস প্রয়োগ করা হয়েছে।

আপনার যদি একটি কাস্টম ক্লাস থাকে যা আপনি একটি LifecycleOwner বানাতে চান, আপনি LifecycleRegistry ক্লাস ব্যবহার করতে পারেন, তবে আপনাকে সেই ক্লাসে ইভেন্টগুলি ফরোয়ার্ড করতে হবে, যেমনটি নিম্নলিখিত কোড উদাহরণে দেখানো হয়েছে:

class MyActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }

    public override fun onStart() {
        super.onStart()
        lifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

public class MyActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry lifecycleRegistry;

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

        lifecycleRegistry = new LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    public void onStart() {
        super.onStart();
        lifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return lifecycleRegistry;
    }
}

জীবনচক্র-সচেতন উপাদানগুলির জন্য সর্বোত্তম অনুশীলন

• আপনার UI নিয়ন্ত্রক (ক্রিয়াকলাপ এবং টুকরা) যতটা সম্ভব চর্বিহীন রাখুন। তাদের নিজেদের ডেটা অর্জনের চেষ্টা করা উচিত নয়; পরিবর্তে, এটি করার জন্য একটি ViewModel ব্যবহার করুন এবং দৃশ্যগুলিতে ফিরে পরিবর্তনগুলি প্রতিফলিত করতে একটি LiveData অবজেক্ট পর্যবেক্ষণ করুন।
• ডেটা-চালিত UI লেখার চেষ্টা করুন যেখানে আপনার UI নিয়ন্ত্রকের দায়িত্ব হল ভিউগুলি ডেটা পরিবর্তন হিসাবে আপডেট করা, অথবা ব্যবহারকারীর ক্রিয়াগুলিকে ViewModel এ ফেরত জানানো।
• আপনার ViewModel ক্লাসে আপনার ডেটা লজিক রাখুন। ViewModel আপনার UI কন্ট্রোলার এবং আপনার বাকি অ্যাপের মধ্যে সংযোগকারী হিসেবে কাজ করবে। যদিও সতর্ক থাকুন, ডেটা আনার দায়িত্ব ViewModel এর নয় (উদাহরণস্বরূপ, একটি নেটওয়ার্ক থেকে)। পরিবর্তে, ViewModel উচিত ডেটা আনার জন্য উপযুক্ত কম্পোনেন্টকে কল করা, তারপর ফলাফলটি UI কন্ট্রোলারে ফিরিয়ে দেওয়া।
• আপনার ভিউ এবং UI কন্ট্রোলারের মধ্যে একটি পরিষ্কার ইন্টারফেস বজায় রাখতে ডেটা বাইন্ডিং ব্যবহার করুন। এটি আপনাকে আপনার মতামতগুলিকে আরও ঘোষণামূলক করতে এবং আপনার কার্যকলাপ এবং টুকরোগুলিতে লিখতে প্রয়োজনীয় আপডেট কোডটি ছোট করতে দেয়৷ আপনি যদি জাভা প্রোগ্রামিং ভাষায় এটি করতে পছন্দ করেন তবে বয়লারপ্লেট কোড এড়াতে বাটার নাইফের মতো একটি লাইব্রেরি ব্যবহার করুন এবং আরও ভাল বিমূর্ততা পান।
• আপনার UI জটিল হলে, UI পরিবর্তনগুলি পরিচালনা করার জন্য একটি উপস্থাপক শ্রেণী তৈরি করার কথা বিবেচনা করুন৷ এটি একটি শ্রমসাধ্য কাজ হতে পারে, তবে এটি আপনার UI উপাদানগুলি পরীক্ষা করা সহজ করে তুলতে পারে।
• আপনার ViewModel এ একটি View বা Activity প্রসঙ্গ উল্লেখ করা এড়িয়ে চলুন। যদি ViewModel ক্রিয়াকলাপের বাইরে থাকে (কনফিগারেশন পরিবর্তনের ক্ষেত্রে), আপনার কার্যকলাপ লিক হয়ে যায় এবং আবর্জনা সংগ্রহকারীর দ্বারা সঠিকভাবে নিষ্পত্তি করা হয় না।
• দীর্ঘমেয়াদী কাজ এবং অ্যাসিঙ্ক্রোনাসভাবে চলতে পারে এমন অন্যান্য ক্রিয়াকলাপ পরিচালনা করতে Kotlin coroutines ব্যবহার করুন।

জীবনচক্র-সচেতন উপাদানগুলির জন্য কেস ব্যবহার করুন

জীবনচক্র-সচেতন উপাদানগুলি বিভিন্ন ক্ষেত্রে জীবনচক্র পরিচালনা করা আপনার পক্ষে আরও সহজ করে তুলতে পারে। কয়েকটি উদাহরণ হল:

• মোটা এবং সূক্ষ্ম-দানাযুক্ত অবস্থান আপডেটের মধ্যে স্যুইচ করা। আপনার লোকেশন অ্যাপটি দৃশ্যমান থাকাকালীন সূক্ষ্ম-দানাযুক্ত অবস্থান আপডেটগুলি সক্ষম করতে জীবনচক্র-সচেতন উপাদানগুলি ব্যবহার করুন এবং অ্যাপটি ব্যাকগ্রাউন্ডে থাকা অবস্থায় মোটা দানাদার আপডেটগুলিতে স্যুইচ করুন। LiveData , একটি জীবনচক্র-সচেতন উপাদান, যখন আপনার ব্যবহারকারী অবস্থান পরিবর্তন করে তখন আপনার অ্যাপকে স্বয়ংক্রিয়ভাবে UI আপডেট করতে দেয়।
• ভিডিও বাফারিং বন্ধ করা এবং শুরু করা হচ্ছে। যত তাড়াতাড়ি সম্ভব ভিডিও বাফারিং শুরু করতে জীবনচক্র-সচেতন উপাদানগুলি ব্যবহার করুন, তবে অ্যাপটি সম্পূর্ণরূপে শুরু না হওয়া পর্যন্ত প্লেব্যাক স্থগিত করুন। আপনার অ্যাপটি ধ্বংস হয়ে গেলে আপনি বাফারিং বন্ধ করতে জীবনচক্র-সচেতন উপাদানগুলিও ব্যবহার করতে পারেন।
• নেটওয়ার্ক সংযোগ শুরু এবং বন্ধ করা। একটি অ্যাপ ফোরগ্রাউন্ডে থাকাকালীন নেটওয়ার্ক ডেটার লাইভ আপডেট (স্ট্রিমিং) সক্ষম করতে এবং অ্যাপটি ব্যাকগ্রাউন্ডে গেলে স্বয়ংক্রিয়ভাবে বিরাম দিতে জীবনচক্র-সচেতন উপাদানগুলি ব্যবহার করুন।
• অ্যানিমেটেড অঙ্কনযোগ্যগুলি বিরাম দেওয়া এবং পুনরায় শুরু করা হচ্ছে৷ অ্যাপটি ব্যাকগ্রাউন্ডে থাকাকালীন অ্যানিমেটেড ড্রয়েবলগুলিকে থামানোর জন্য লাইফসাইকেল-সচেতন উপাদানগুলি ব্যবহার করুন এবং অ্যাপটি ফোরগ্রাউন্ডে থাকার পরে অঙ্কনযোগ্যগুলি পুনরায় শুরু করুন।

স্টপ ইভেন্টে হ্যান্ডলিং

যখন একটি Lifecycle একটি AppCompatActivity বা Fragment অন্তর্গত হয়, তখন Lifecycle অবস্থা CREATED এ পরিবর্তিত হয় এবং যখন AppCompatActivity বা Fragment onSaveInstanceState() কল করা হয় তখন ON_STOP ইভেন্টটি প্রেরণ করা হয়।

onSaveInstanceState() এর মাধ্যমে যখন একটি Fragment বা AppCompatActivity এর অবস্থা সংরক্ষিত হয়, তখন ON_START কল না করা পর্যন্ত এর UI অপরিবর্তনীয় বলে বিবেচিত হয়৷ স্টেট সেভ করার পর UI পরিবর্তন করার চেষ্টা করলে আপনার অ্যাপ্লিকেশানের নেভিগেশন স্টেটে অসঙ্গতি দেখা দিতে পারে যার কারণে FragmentManager যদি স্টেট সেভ করার পরে একটি FragmentTransaction চালায় তাহলে একটি ব্যতিক্রম থ্রো করে। বিস্তারিত জানার জন্য commit() দেখুন।

যদি পর্যবেক্ষকের সংশ্লিষ্ট Lifecycle অন্তত STARTED না হয় তাহলে LiveData তার পর্যবেক্ষককে কল করা থেকে বিরত থাকার মাধ্যমে এই প্রান্তের কেসটিকে বাক্সের বাইরে আটকায়৷ পর্দার আড়ালে, এটি তার পর্যবেক্ষককে আহ্বান করার সিদ্ধান্ত নেওয়ার আগে isAtLeast() কল করে।

দুর্ভাগ্যবশত, AppCompatActivity এর onStop() পদ্ধতিটিকে onSaveInstanceState() পরে বলা হয়, যা একটি ফাঁক রেখে যায় যেখানে UI অবস্থার পরিবর্তন অনুমোদিত নয় কিন্তু Lifecycle এখনও CREATED অবস্থায় সরানো হয়নি।

এই সমস্যাটি প্রতিরোধ করার জন্য, Lifecycle ক্লাস beta2 সংস্করণে এবং ইভেন্টটি প্রেরণ না করেই স্টেটটিকে CREATED হিসাবে চিহ্নিত করুন যাতে সিস্টেম দ্বারা onStop() কল না করা পর্যন্ত ইভেন্টটি প্রেরণ না করা হলেও বর্তমান অবস্থা পরীক্ষা করে এমন যেকোন কোডটি আসল মান পায়।

দুর্ভাগ্যক্রমে, এই সমাধানটির দুটি প্রধান সমস্যা রয়েছে:

• এপিআই লেভেল 23 এবং তার নিচে, অ্যান্ড্রয়েড সিস্টেম প্রকৃতপক্ষে একটি কার্যকলাপের অবস্থা সংরক্ষণ করে এমনকি যদি এটি আংশিকভাবে অন্য কার্যকলাপ দ্বারা আচ্ছাদিত হয়। অন্য কথায়, অ্যান্ড্রয়েড সিস্টেমটি onSaveInstanceState() কল করে তবে এটি অগত্যা onStop() কল করে না। এটি একটি সম্ভাব্য দীর্ঘ ব্যবধান তৈরি করে যেখানে পর্যবেক্ষক এখনও মনে করেন যে জীবনচক্র সক্রিয় যদিও এর UI অবস্থা পরিবর্তন করা যায় না।
• LiveData ক্লাসে অনুরূপ আচরণ প্রকাশ করতে চায় এমন যেকোন শ্রেণীকে Lifecycle সংস্করণ beta 2 এবং তার নিচের দ্বারা প্রদত্ত কর্মক্ষেত্র বাস্তবায়ন করতে হবে।

অতিরিক্ত সম্পদ

লাইফসাইকেল-সচেতন উপাদানগুলির সাথে জীবনচক্র পরিচালনা সম্পর্কে আরও জানতে, নিম্নলিখিত অতিরিক্ত সংস্থানগুলি দেখুন৷

নমুনা

• সানফ্লাওয়ার , একটি ডেমো অ্যাপ যা আর্কিটেকচার উপাদানগুলির সাথে সেরা অনুশীলনগুলি প্রদর্শন করে৷

কোডল্যাব

• অ্যান্ড্রয়েড লাইফসাইকেল-সচেতন উপাদান

ব্লগ

• Android Sunflower উপস্থাপন করা হচ্ছে