സേവ് ഇൻസ്‌റ്റൻസ് സ്‌റ്റേറ്റ് ഉപയോഗിച്ച് ആൻഡ്രോയിഡിൽ ആക്‌റ്റിവിറ്റി സ്‌റ്റേറ്റ് സംരക്ഷിക്കുന്നു

പ്രവർത്തനം സംസ്ഥാന സംരക്ഷണം മനസ്സിലാക്കുന്നു

Android-ൽ ഒരു ആക്റ്റിവിറ്റിയുടെ അവസ്ഥ സംരക്ഷിക്കുന്നത് അൽപ്പം ആശയക്കുഴപ്പമുണ്ടാക്കും, പ്രത്യേകിച്ച് Android SDK പ്ലാറ്റ്‌ഫോമിൽ പുതിയ ഡെവലപ്പർമാർക്ക്. ഇവിടെ നൽകിയിരിക്കുന്ന ഉദാഹരണം, ഉപയോക്താക്കൾ ആദ്യമായി ആപ്പ് തുറക്കുകയാണോ അതോ അവർ തിരികെ വരികയാണോ എന്നതിനെ ആശ്രയിച്ച് വ്യത്യസ്തമായി സ്വാഗതം ചെയ്യുന്ന ഒരു ലളിതമായ ആപ്ലിക്കേഷനെ കാണിക്കുന്നു.

എന്നിരുന്നാലും, ആപ്പിൽ നിന്നുള്ള നാവിഗേഷൻ പരിഗണിക്കാതെ, നിലവിലെ നടപ്പിലാക്കൽ എല്ലായ്‌പ്പോഴും പ്രാരംഭ ആശംസകൾ പ്രദർശിപ്പിക്കുന്നു. `onSaveInstanceState` രീതി ഉപയോഗിച്ച് ഒരു പ്രവർത്തനത്തിൻ്റെ അവസ്ഥ ശരിയായി സംരക്ഷിക്കുന്നതിനും പുനഃസ്ഥാപിക്കുന്നതിനും ആവശ്യമായ ഘട്ടങ്ങളിലൂടെ ഈ ലേഖനം നിങ്ങളെ നയിക്കും.

കമാൻഡ്	വിവരണം
onSaveInstanceState(Bundle outState)	UI ഘടകങ്ങളുടെ അവസ്ഥ സംരക്ഷിക്കുന്നതിന് ഒരു പ്രവർത്തനം നശിപ്പിക്കപ്പെടുന്നതിന് മുമ്പ് ഈ രീതി വിളിക്കുന്നു.
putString(String key, String value)	പിന്നീടുള്ള വീണ്ടെടുക്കലിനായി ഒരു നിർദ്ദിഷ്ട കീ ഉപയോഗിച്ച് ബണ്ടിലിലേക്ക് ഒരു സ്ട്രിംഗ് മൂല്യം സംരക്ഷിക്കുന്നു.
getString(String key)	നിർദ്ദിഷ്ട കീ ഉപയോഗിച്ച് ബണ്ടിൽ നിന്ന് ഒരു സ്ട്രിംഗ് മൂല്യം വീണ്ടെടുക്കുന്നു.
onRestoreInstanceState(Bundle savedInstanceState)	മുമ്പ് സംരക്ഷിച്ച ബണ്ടിൽ നിന്ന് UI നില പുനഃസ്ഥാപിക്കുന്നതിന് onStart() ന് ശേഷം ഈ രീതിയെ വിളിക്കുന്നു.
setContentView(View view)	പ്രവർത്തന ഉള്ളടക്കത്തെ ഒരു വ്യക്തമായ കാഴ്‌ചയിലേക്ക് സജ്ജീകരിക്കുന്നു, ഇത് ലേഔട്ടിൻ്റെ റൂട്ടാക്കി മാറ്റുന്നു.
TextView.setText(String text)	TextView പ്രദർശിപ്പിക്കേണ്ട വാചകം സജ്ജമാക്കുന്നു.
super.onCreate(Bundle savedInstanceState)	പ്രവർത്തനം ആരംഭിക്കുന്ന സൂപ്പർക്ലാസിൻ്റെ onCreate() രീതി വിളിക്കുന്നു.

ആൻഡ്രോയിഡിൽ പ്രവർത്തന നില എങ്ങനെ സംരക്ഷിക്കാം

നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകളിൽ, ഒരു പ്രവർത്തനത്തിൻ്റെ അവസ്ഥ എങ്ങനെ സംരക്ഷിക്കാമെന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യുന്നു ആൻഡ്രോയിഡ് വികസനത്തിൽ രീതി. ആദ്യ സ്ക്രിപ്റ്റ് ഒരു ആശംസാ സന്ദേശം പ്രദർശിപ്പിക്കുന്ന ഒരു പ്രവർത്തനം പ്രകടമാക്കുന്നു, അത് ഉപയോക്താവ് ആദ്യമായി ആപ്പ് തുറക്കുന്നതാണോ അതോ അവർ നാവിഗേറ്റ് ചെയ്‌ത് മടങ്ങിയെത്തിയതാണോ എന്നതിനെ ആശ്രയിച്ച് മാറുന്നു. സ്ക്രിപ്റ്റിൻ്റെ നിർണായക ഭാഗം അതിൻ്റെ അവസ്ഥ സംരക്ഷിക്കുന്നത് ഉൾപ്പെടുന്നു ഉപയോഗിച്ച് രീതി. പ്രവർത്തനം നശിപ്പിക്കപ്പെടാൻ പോകുമ്പോൾ, UI ഘടകങ്ങളുടെ അവസ്ഥ സംരക്ഷിക്കാൻ ഈ രീതിയെ വിളിക്കുന്നു. ൽ പ്രദർശിപ്പിച്ചിരിക്കുന്ന വാചകം ഞങ്ങൾ സംഭരിക്കുന്നു TextView ഉപയോഗിച്ച് ഒരു സ്ട്രിംഗ് മൂല്യത്തെ ഒരു നിർദ്ദിഷ്ട കീയുമായി ബന്ധപ്പെടുത്തുന്ന രീതി .

പ്രവർത്തനം പുനർനിർമ്മിക്കുമ്പോൾ, സംരക്ഷിച്ച ഒരു ഇൻസ്‌റ്റൻസ് സ്റ്റേറ്റ് ഉണ്ടോ എന്ന് മെത്തേഡ് പരിശോധിക്കുന്നു. ഉണ്ടെങ്കിൽ, അത് ഉപയോഗിച്ച് മുമ്പ് സംഭരിച്ച വാചകം വീണ്ടെടുക്കുന്നു രീതി അത് തിരികെ സജ്ജമാക്കുന്നു . നാവിഗേറ്റ് ചെയ്യുന്നതിന് മുമ്പ് ഉപയോക്താവ് കണ്ട അതേ സന്ദേശം തന്നെ കാണുന്നുവെന്ന് ഇത് ഉറപ്പാക്കുന്നു. രണ്ടാമത്തെ സ്ക്രിപ്റ്റിൽ, ഞങ്ങൾ ഈ സമീപനത്തെ കൂടുതൽ പരിഷ്കരിക്കുന്നു onRestoreInstanceState(Bundle savedInstanceState) രീതി, അതിനെ വിളിക്കുന്നു മുമ്പ് സംരക്ഷിച്ചതിൽ നിന്ന് UI നില പുനഃസ്ഥാപിക്കാൻ . ഈ രീതി നേരിട്ട് സംരക്ഷിച്ച വാചകം എന്നതിലേക്ക് സജ്ജമാക്കുന്നു , പ്രവർത്തനം പുനരാരംഭിക്കുന്നതിലുടനീളം UI നില സ്ഥിരതയുള്ളതും തടസ്സമില്ലാതെ സംരക്ഷിക്കപ്പെടുന്നതും ഉറപ്പാക്കുന്നു.

package com.android.hello;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class HelloAndroid extends Activity {
    private TextView mTextView = null;
    private static final String TEXT_VIEW_KEY = "textViewKey";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mTextView = new TextView(this);

        if (savedInstanceState == null) {
            mTextView.setText("Welcome to HelloAndroid!");
        } else {
            mTextView.setText(savedInstanceState.getString(TEXT_VIEW_KEY));
        }
        setContentView(mTextView);
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putString(TEXT_VIEW_KEY, mTextView.getText().toString());
    }
}

package com.android.hello;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class HelloAndroid extends Activity {
    private TextView mTextView = null;
    private static final String TEXT_VIEW_STATE = "textViewState";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mTextView = new TextView(this);

        if (savedInstanceState != null) {
            mTextView.setText(savedInstanceState.getString(TEXT_VIEW_STATE));
        } else {
            mTextView.setText("Welcome to HelloAndroid!");
        }
        setContentView(mTextView);
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putString(TEXT_VIEW_STATE, mTextView.getText().toString());
    }

    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        mTextView.setText(savedInstanceState.getString(TEXT_VIEW_STATE));
    }
}

കോൺഫിഗറേഷൻ മാറ്റങ്ങളിലുടനീളം സംസ്ഥാന സ്ഥിരത ഉറപ്പാക്കുന്നു

ആൻഡ്രോയിഡ് ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുമ്പോൾ, സ്‌ക്രീൻ റൊട്ടേഷനുകൾ പോലുള്ള കോൺഫിഗറേഷൻ മാറ്റങ്ങളിൽ പ്രവർത്തന നില നിയന്ത്രിക്കുന്നത് നിർണായകമാണ്. കോൺഫിഗറേഷൻ മാറ്റങ്ങൾ പ്രവർത്തനങ്ങൾ നശിപ്പിക്കുന്നതിനും പുനഃസൃഷ്ടിക്കുന്നതിനും കാരണമാകുന്നു, ഇത് ശരിയായി കൈകാര്യം ചെയ്തില്ലെങ്കിൽ താൽക്കാലിക യുഐ അവസ്ഥകൾ നഷ്ടപ്പെടുന്നതിലേക്ക് നയിക്കുന്നു. ഉപയോഗിച്ച് രീതി, ഡെവലപ്പർമാർക്ക് ആവശ്യമായ UI അവസ്ഥ വിവരങ്ങൾ സംരക്ഷിക്കാൻ കഴിയും. പ്രവർത്തനം നശിപ്പിക്കപ്പെടുന്നതിന് മുമ്പ് ഈ രീതി വിളിക്കപ്പെടുന്നു, ഇത് ഡവലപ്പർമാരെ കീ-മൂല്യം ജോഡികൾ സംഭരിക്കാൻ അനുവദിക്കുന്നു , പിന്നീട് പുനഃസ്ഥാപിക്കുന്നതിനായി സംസ്ഥാനത്തെ സംരക്ഷിക്കുന്നു.

കൂടാതെ, അതിൻ്റെ പങ്ക് മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ് ആൻഡ്രോയിഡിൻ്റെ ആർക്കിടെക്ചർ ഘടകങ്ങളിൽ നിന്നുള്ള ക്ലാസ്. കോൺഫിഗറേഷൻ മാറ്റങ്ങളെ അതിജീവിക്കാൻ ഡാറ്റയെ അനുവദിക്കുന്ന, ലൈഫ് സൈക്കിൾ ബോധമുള്ള രീതിയിൽ UI-മായി ബന്ധപ്പെട്ട ഡാറ്റ സംഭരിക്കാനും നിയന്ത്രിക്കാനും രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു. ഉപയോഗിച്ച് , ഡെവലപ്പർമാർക്ക് അവർ കൈകാര്യം ചെയ്യുന്ന ഡാറ്റയിൽ നിന്ന് UI കൺട്രോളറുകളെ വേർപെടുത്താൻ കഴിയും, ഇത് ആപ്ലിക്കേഷനെ കൂടുതൽ കരുത്തുറ്റതും പരിപാലിക്കാൻ എളുപ്പവുമാക്കുന്നു. സംയോജിപ്പിക്കുന്നു ViewModel കൂടെ പ്രവർത്തന നില ഫലപ്രദമായി കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു സമഗ്രമായ പരിഹാരം നൽകുന്നു.

1. എന്താണ് ഉദ്ദേശം ?
2. ദി ഒരു പ്രവർത്തനത്തിൻ്റെ നിലവിലെ യുഐ നില അത് നശിപ്പിക്കപ്പെടുന്നതിന് മുമ്പ് സംരക്ഷിക്കാൻ രീതി ഉപയോഗിക്കുന്നു.
3. പ്രവർത്തന നില എങ്ങനെ പുനഃസ്ഥാപിക്കാം?
4. നിങ്ങൾക്ക് പ്രവർത്തന നില പുനഃസ്ഥാപിക്കാൻ കഴിയും savedInstanceState പരിശോധിച്ച് രീതി സംഭരിച്ച മൂല്യങ്ങൾ വീണ്ടെടുക്കുകയും ചെയ്യുന്നു.
5. എന്താണ് ഒരു ?
6. എ പ്രവർത്തനങ്ങൾക്കിടയിൽ ഡാറ്റ കൈമാറുന്നതിനും UI നില സംരക്ഷിക്കുന്നതിനും ഉപയോഗിക്കുന്ന കീ-വാല്യൂ ജോഡികളുടെ ഒരു മാപ്പ് ആണ്.
7. എന്താണ് പങ്ക് സംസ്ഥാന മാനേജ്മെൻ്റിൽ?
8. കോൺഫിഗറേഷൻ മാറ്റങ്ങളെ അതിജീവിച്ച് ലൈഫ് സൈക്കിൾ ബോധമുള്ള രീതിയിൽ UI-മായി ബന്ധപ്പെട്ട ഡാറ്റ സംഭരിക്കുന്നു.
9. എപ്പോളാണ് വിളിച്ചു?
10. എന്നാണ് വിളിക്കുന്നത് മുമ്പ് സംരക്ഷിച്ച അവസ്ഥയിൽ നിന്ന് പ്രവർത്തനം വീണ്ടും ആരംഭിക്കുമ്പോൾ.
11. രണ്ടും ഉപയോഗിക്കാമോ ഒപ്പം ഒരുമിച്ച്?
12. അതെ, സംയോജിപ്പിക്കുന്നു കൂടെ കോൺഫിഗറേഷൻ മാറ്റങ്ങളിലുടനീളം UI അവസ്ഥ നിയന്ത്രിക്കുന്നതിന് ശക്തമായ ഒരു പരിഹാരം നൽകുന്നു.
13. ആൻഡ്രോയിഡിലെ കോൺഫിഗറേഷൻ മാറ്റങ്ങൾ എന്തൊക്കെയാണ്?
14. കോൺഫിഗറേഷൻ മാറ്റങ്ങളിൽ സ്ക്രീൻ റൊട്ടേഷനുകൾ, കീബോർഡ് ലഭ്യത, പ്രവർത്തനം പുനഃസൃഷ്ടിക്കുന്നതിന് കാരണമാകുന്ന ഭാഷാ മാറ്റങ്ങൾ എന്നിവ ഉൾപ്പെടുന്നു.
15. എങ്ങിനെയാണ് എയിൽ ജോലി ചെയ്യുക ?
16. a-ൽ ഒരു സ്ട്രിംഗ് മൂല്യം സംഭരിക്കുന്നു പിന്നീടുള്ള വീണ്ടെടുക്കലിനായി ഒരു അനുബന്ധ കീ ഉപയോഗിച്ച്.

സുഗമമായ ഉപയോക്തൃ അനുഭവം നിലനിർത്തുന്നതിന്, പ്രത്യേകിച്ച് കോൺഫിഗറേഷൻ മാറ്റങ്ങളിൽ, Android പ്രവർത്തനത്തിൻ്റെ അവസ്ഥ ഫലപ്രദമായി കൈകാര്യം ചെയ്യേണ്ടത് അത്യാവശ്യമാണ്. പ്രയോജനപ്പെടുത്തുന്നതിലൂടെ ഒപ്പം രീതികൾ, ഉപയോക്തൃ ഡാറ്റയും UI അവസ്ഥകളും സംരക്ഷിക്കപ്പെടുകയും തടസ്സങ്ങളില്ലാതെ പുനഃസ്ഥാപിക്കുകയും ചെയ്യുന്നുവെന്ന് ഡവലപ്പർമാർക്ക് ഉറപ്പാക്കാൻ കഴിയും. ഈ സമീപനം ആപ്പ് സ്ഥിരത വർദ്ധിപ്പിക്കുക മാത്രമല്ല സ്ഥിരവും വിശ്വസനീയവുമായ ഇൻ്റർഫേസ് നൽകിക്കൊണ്ട് ഉപയോക്തൃ സംതൃപ്തി മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു.