භ්‍රමණය වන ඇන්ඩ්‍රොයිඩ් මත ක්‍රියාකාරකම් නැවත ආරම්භ කරන්න

මගේ ඇන්ඩ්‍රොයිඩ් යෙදුමේ, මම උපාංගය කරකවන විට (යතුරුපුවරුව ලිස්සා යන්න) එවිට මගේ Activityනැවත ආරම්භ වේ ( onCreateහැඳින්වේ). දැන්, මෙය බොහෝ විට එසේ විය යුතු ය, නමුත් මම onCreateක්‍රමයේ ආරම්භක සැකසුම් ගොඩක් කරමි, එබැවින් මටද අවශ්‍ය වන්නේ:

1. සියලු ආරම්භක සැකසුම් වෙනත් ශ්‍රිතයකට දමන්න එවිට උපාංග භ්‍රමණය සියල්ලම නැති නොවේ
2. එය සාදන්න onCreateනැවත කැඳවනු නොලබන අතර පිරිසැලසුම ගැලපේ
3. යෙදුම හුදෙක් ආලේඛ්‍ය චිත්‍රයකට පමණක් සීමා කරන්න එවිට onCreateඑය කැඳවනු නොලැබේ.

යෙදුම් පන්තිය භාවිතා කිරීම

ඔබේ ආරම්භයේ දී ඔබ කරන්නේ කුමක්ද යන්න මත පදනම්ව, නව පන්තියක් නිර්මාණය කිරීම Applicationසහ ඔබේ ආරම්භක කේතය onCreateඑම පන්තිය තුළ අභිබවා යන ක්‍රමයකට ගෙනයාම පිළිබඳව සලකා බැලිය හැකිය .

public class MyApplicationClass extends Application {
  @Override
  public void onCreate() {
    super.onCreate();
    // TODO Put your application initialization code here.
  }
}

මෙම onCreateදිශානතිය හෝ යතුරු පුවරුව සැඟවීම් වෙනස්කම් මත ක්රියාකාරකම් නැවත ආරම්භ කර එය තුඩු දිය නෑ ඒ නිසා අයදුම්පත පන්තියේ පමණක්, සමස්ත අයදුම් නිර්මාණය කරන අවස්ථාවේදී ලෙස හැඳින්වේ.

මෙම පංතියේ නිදසුන සිංගල්ටන් එකක් ලෙස නිරාවරණය කිරීම සහ ඔබ ගේටර්ස් සහ සෙටර් භාවිතා කරමින් ආරම්භ කරන යෙදුම් විචල්‍යයන් නිරාවරණය කිරීම හොඳ පුරුද්දකි.

සටහන: ඔබේ නව යෙදුම් පන්තියේ නම ලියාපදිංචි කර භාවිතා කිරීම සඳහා මැනිෆෙස්ටයේ සඳහන් කළ යුතුය:

<application
    android:name="com.you.yourapp.MyApplicationClass"

වින්‍යාස වෙනස්වීම් වලට ප්‍රතික්‍රියා කිරීම [යාවත්කාලීන කිරීම: API 13 සිට මෙය ඉවත් කරනු ලැබේ; නිර්දේශිත විකල්පය බලන්න ]

තවත් විකල්පයක් ලෙස, නැවත ආරම්භ කිරීමට හේතු වන දිශානතිය සහ යතුරුපුවරු දෘශ්‍යතා වෙනස්වීම් වැනි සිදුවීම් වලට ඔබේ යෙදුම සවන් දිය හැකි අතර ඒවා ඔබගේ ක්‍රියාකාරකම් තුළ හැසිරවිය හැකිය.

android:configChangesඔබගේ ක්‍රියාකාරිත්වයේ මැනිෆෙස්ට් නෝඩයට නෝඩය එක් කිරීමෙන් ආරම්භ කරන්න

 <activity android:name=".MyActivity"
      android:configChanges="orientation|keyboardHidden"
      android:label="@string/app_name">

හෝ ඇන්ඩ්‍රොයිඩ් 3.2 සඳහා (API මට්ටම 13) සහ නවතම :

<activity android:name=".MyActivity"
      android:configChanges="keyboardHidden|orientation|screenSize"
      android:label="@string/app_name">

ක්‍රියාකාරකම තුළ onConfigurationChangedක්‍රමය ඉක්මවා ගොස් setContentViewGUI පිරිසැලසුම නව දිශානතිය තුළ නැවත සිදු කිරීමට බල කිරීමට අමතන්න .

@Override
public void onConfigurationChanged(Configuration newConfig) {
  super.onConfigurationChanged(newConfig);
  setContentView(R.layout.myLayout);
}

ඇන්ඩ්‍රොයිඩ් 3.2 සහ ඊට වැඩි යාවත්කාලීන කිරීම:

අවවාදයයි : ඇන්ඩ්‍රොයිඩ් 3.2 (API මට්ටම 13) සිට, උපාංගය ආලේඛ්‍ය හා භූ දර්ශන දිශානතිය අතර මාරු වන විට “තිර ප්‍රමාණය” ද වෙනස් වේ. මේ අනුව, API මට්ටම 13 හෝ ඊට වැඩි (minSdkVersion සහ targetSdkVersion ගුණාංග මගින් ප්‍රකාශයට පත් කර ඇති පරිදි) සංවර්ධනය කිරීමේදී දිශානතියේ වෙනසක් හේතුවෙන් ධාවන නැවත ආරම්භ වීම වැළැක්වීමට ඔබට අවශ්‍ය නම්, ඔබ "screenSize"වටිනාකමට අමතරව අගය ඇතුළත් කළ යුතුය "orientation". එනම්, ඔබ ප්‍රකාශ කළ යුතුය android:configChanges="orientation|screenSize". කෙසේ වෙතත්, ඔබගේ යෙදුම API මට්ටම 12 හෝ ඊට අඩු ඉලක්ක කරන්නේ නම්, එවිට ඔබගේ ක්‍රියාකාරකම් සෑම විටම මෙම වින්‍යාස වෙනස් කිරීමම හසුරුවයි (ඇන්ඩ්‍රොයිඩ් 3.2 හෝ ඊට වැඩි උපාංගයක් මත ධාවනය වන විට පවා මෙම වින්‍යාස වෙනස් කිරීම ඔබගේ ක්‍රියාකාරකම් නැවත ආරම්භ නොකරයි).

onCreate()වෙඩි තැබීම මුළුමනින්ම නැවැත්වීමට උත්සාහ කරනවා වෙනුවට Bundle savedInstanceState, සිදුවීම අවලංගු වී ඇත්දැයි බැලීමට උත්සාහ කරන්න .

නිදසුනක් වශයෙන්, Activityසෑම දිශානතියේ වෙනසක් මත නොව, සැබවින්ම නිර්මාණය කරන විට ක්‍රියාත්මක කළ යුතු යම් තර්කනයක් මා සතුව තිබේ නම් , මම එම තර්කනය ක්‍රියාත්මක කරන්නේ ශුන්‍ය onCreate()නම් පමණි savedInstanceState.

එසේ නොමැතිනම්, දිශානතිය සඳහා පිරිසැලසුම නිසි ලෙස නැවත ඇඳීමට මට තවමත් අවශ්‍යය.

public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_game_list);

        if(savedInstanceState == null){
            setupCloudMessaging();
        }
}

මෙය අවසාන පිළිතුර දැයි විශ්වාස නැත, නමුත් එය මට වැඩ කරයි.

මම මොනවද කළේ ...

මැනිෆෙස්ටයේ, ක්‍රියාකාරකම් අංශයට, එකතු කරන ලදි:

android:configChanges="keyboardHidden|orientation"

ක්‍රියාත්මක කිරීම සඳහා වූ කේතයේ, ක්‍රියාත්මක කර ඇත්තේ:

//used in onCreate() and onConfigurationChanged() to set up the UI elements
public void InitializeUI()
{
    //get views from ID's
    this.textViewHeaderMainMessage = (TextView) this.findViewById(R.id.TextViewHeaderMainMessage);

    //etc... hook up click listeners, whatever you need from the Views
}

//Called when the activity is first created.
@Override
public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    InitializeUI();
}

//this is called when the screen rotates.
// (onCreate is no longer called when screen rotates due to manifest, see: android:configChanges)
@Override
public void onConfigurationChanged(Configuration newConfig)
{
    super.onConfigurationChanged(newConfig);
    setContentView(R.layout.main);

    InitializeUI();
}

ඔබ විස්තර කරන්නේ සුපුරුදු හැසිරීමයි. එකතු කිරීමෙන් මෙම සිදුවීම් ඔබම හඳුනාගෙන හැසිරවිය යුතුය:

android:configChanges

ඔබේ මැනිෆෙස්ටයට සහ පසුව ඔබට හැසිරවීමට අවශ්‍ය වෙනස්කම් වලට. එබැවින් දිශානතිය සඳහා, ඔබ භාවිතා කරන්නේ:

android:configChanges="orientation"

යතුරුපුවරුව විවෘත කිරීම හෝ වසා දැමීම සඳහා ඔබ භාවිතා කරන්නේ:

android:configChanges="keyboardHidden"

ඔබට දෙකම හැසිරවීමට අවශ්‍ය නම් ඔබට ඒවා පයිප්ප විධානයෙන් වෙන් කළ හැකිය:

android:configChanges="keyboardHidden|orientation"

මෙය ඔබ අමතන ඕනෑම ක්‍රියාකාරකමක onConfigurationChanged ක්‍රමය අවුලුවනු ඇත. ඔබ ක්‍රමවේදය ඉක්මවා ගියහොත් ඔබට නව අගයන් පසු කළ හැකිය.

මෙය උපකාරී වේ යැයි සිතමි.

මම මේ ප්‍රබන්ධය සොයාගත්තා:

දිශානතියේ වෙනසක් හරහා ක්‍රියාකාරකම සජීවීව තබා ගැනීම සහ එය හැසිරවීම සඳහා onConfigurationChanged, ඉහත සඳහන් ප්‍රලේඛනය සහ කේත නියැදිය මැනිෆෙස්ට් ගොනුවේ යෝජනා කරයි:

<activity android:name=".MyActivity"
      android:configChanges="orientation|keyboardHidden"
      android:label="@string/app_name">

එය සැමවිටම ක්‍රියාත්මක වන අමතර ප්‍රතිලාභයක් ඇත.

ප්‍රසාද දීමනාව නම්, මඟ හැරීම keyboardHiddenතාර්කික යැයි පෙනෙන්නට තිබුණත්, එය ඉමියුලේටරයේ අසමත් වීමට හේතු වේ (ඇන්ඩ්‍රොයිඩ් 2.1 සඳහා අවම වශයෙන්): පමණක් සඳහන් කිරීමෙන් පමණක් orientationඉමුලේටරය ඇමතීමට හැකි වන OnCreateඅතර onConfigurationChangedසමහර විට සහ OnCreateවෙනත් වේලාවන් පමණි .

උපකරණයක අසමත් වීම මා දැක නැත, නමුත් අනෙක් අය සඳහා ඉමියුලේටරය අසමත් වීම ගැන මම අසා ඇත්තෙමි. එබැවින් එය ලේඛනගත කිරීම වටී.

දිශානතියේ වෙනස්කම් හරහා ඇන්ඩ්‍රොයිඩ් වේදිකාවේ දත්ත දිගටම පවත්වා ගෙන යාමේ ක්‍රමය භාවිතා කිරීම ගැනද ඔබට සලකා බැලිය හැකිය: onRetainNonConfigurationInstance()සහ getLastNonConfigurationInstance().

මෙය ඔබ සේවාදායකයෙන් ලබාගෙන ඇති තොරතුරු onCreateහෝ ගණනය කර ඇති හෝ වෙනත් දෙයක් වැනි වින්‍යාස වෙනස්වීම් හරහා දත්ත දිගටම පවත්වා ගැනීමට ඉඩ සලසයි , එසේම Activityදැන් භාවිතයේ පවතින දිශානතිය සඳහා ඔබේ xml ගොනුව නැවත සැකසීමට ඇන්ඩ්‍රොයිඩ්ට ඉඩ දෙයි. .

මෙතැනින් හෝ මෙතැනින් බලන්න .

මෙම ක්‍රම දැන් අතහැර දමා ඇති බව සැලකිල්ලට ගත යුතුය (ඉහත විසඳුම් බොහොමයක් යෝජනා කරන පරිදි දිශානතිය හැසිරවීමට වඩා නම්‍යශීලී වුවද) ඔබ රඳවා තබා ගැනීමට අවශ්‍ය සෑම කෙනෙකුටම මාරුවිය යුතු Fragmentsඅතර ඒ වෙනුවට භාවිතා setRetainInstance(true)කළ Fragmentයුතුය.

ප්රවේශය ප්රයෝජනවත් නමුත් කොටස් භාවිතා කිරීමේදී අසම්පූර්ණයි.

කොටස් සාමාන්‍යයෙන් වින්‍යාස වෙනස් කිරීම මත ප්‍රතිනිර්මාණය වේ. මෙය සිදුවීමට ඔබ අකමැති නම්, භාවිතා කරන්න

setRetainInstance(true); කැබැල්ලේ ඉදිකිරීම්කරු (ය) තුළ

මෙය වින්‍යාස වෙනස් කිරීමේදී කොටස් රඳවා තබා ගැනීමට හේතු වේ.

http://developer.android.com/reference/android/app/Fragment.html#setRetainInstance(boolean)

මම සරලවම එකතු කළා

     android:configChanges="keyboard|keyboardHidden|orientation"

මැනිෆෙස්ට් ගොනුවේ ඇති අතර මගේ ක්‍රියාකාරකමේ කිසිදු ක්‍රමයක් එකතු කර නැත onConfigurationChanged.

එබැවින් යතුරුපුවරුව ලිස්සා යන සෑම අවස්ථාවකම කිසිවක් සිදු නොවේ .

onCreateඔබ orientationඇන්ඩ්‍රොයිඩ් වෙනස් කළ විට පවා මෙම ක්‍රමය හැඳින්වේ . එබැවින් සියලු බර ක්‍රියාකාරිත්වය මෙම ක්‍රමයට ගෙනයාම ඔබට උපකාරී නොවේ

ඔබගේ <activity>ටැගය තුළ පහත කේතය තබන්න Manifest.xml:

android:configChanges="screenLayout|screenSize|orientation"

 onConfigurationChanged is called when the screen rotates. 
 (onCreate is no longer called when screen rotates due to manifest, see:  
 android:configChanges)

මැනිෆෙස්ටයේ කුමන කොටස එය "අමතන්න එපා onCreate()" යැයි පවසයි?

එසේම, ගූගල්ගේ ලියකියවිලි භාවිතා කිරීමෙන් වළකින්නැයි කියනු ලැබේ android:configChanges(අවසාන පියවරක් හැර) .... නමුත් පසුව ඔවුන් යෝජනා කරන විකල්ප ක්‍රම සියල්ලම DO භාවිතා කිරීමට යෝජනා කරයි android:configChanges.

ඉමියුලේටරය සෑම විටම onCreate()භ්‍රමණය ඉල්ලා සිටින බව මගේ අත්දැකීමයි .
නමුත් මම එකම කේතය ක්‍රියාත්මක කරන උපාංග 1-2 ... එසේ නොකරන්න. (කිසියම් වෙනසක් සිදුවන්නේ මන්දැයි විශ්වාස නැත.)

පහත දැක්වෙන පියවරයන් අනුගමනය කිරීම ඉතා සරල ය:

<activity
    android:name=".Test"
    android:configChanges="orientation|screenSize"
    android:screenOrientation="landscape" >
</activity>

මෙය මට වැඩ කරයි:

සටහන: දිශානතිය ඔබේ ඉල්ලීම මත රඳා පවතී

ඇන්ඩ්‍රොයිඩ් මැනිෆෙස්ටයේ කළ යුතු වෙනස්කම්:

android:configChanges="keyboardHidden|orientation" 

ක්‍රියාකාරකම් ඇතුළත කළ යුතු එකතු කිරීම්:

public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);

    // Checks the orientation of the screen
    if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
        Toast.makeText(this, "landscape", Toast.LENGTH_SHORT).show();
    } else if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT) {
        Toast.makeText(this, "portrait", Toast.LENGTH_SHORT).show();
    }
}

ඔබේ මැනිෆෙස්ටයට මෙම රේඛාව එක් කරන්න: -

android:configChanges="orientation|keyboard|keyboardHidden|screenSize|screenLayout|uiMode"

සහ ක්‍රියාකාරකම් සඳහා මෙම ස්නිපටය: -

@Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
    }

මෙය කිරීමට ක්‍රම කිහිපයක් තිබේ:

ක්‍රියාකාරකම් තත්වය සුරකින්න

ඔබට ක්‍රියාකාරී තත්වය සුරැකිය හැක onSaveInstanceState.

@Override
public void onSaveInstanceState(Bundle outState) {
    /*Save your data to be restored here
    Example : outState.putLong("time_state", time); , time is a long variable*/
    super.onSaveInstanceState(outState);
}

ඉන්පසු bundleතත්වය යථා තත්වයට පත් කිරීමට භාවිතා කරන්න .

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

    if(savedInstanceState!= null){
       /*When rotation occurs
        Example : time = savedInstanceState.getLong("time_state", 0); */
    } else {
      //When onCreate is called for the first time
    }
}

දිශානතියේ වෙනස්කම් ඔබ විසින්ම හසුරුවන්න

තවත් විකල්පයක් වන්නේ දිශානතියේ වෙනස්කම් ඔබ විසින්ම හසුරුවා ගැනීමයි. නමුත් මෙය හොඳ පුරුද්දක් ලෙස නොසැලකේ.

මෙය ඔබේ මැනිෆෙස්ට් ගොනුවට එක් කරන්න.

android:configChanges="keyboardHidden|orientation"

Android 3.2 සහ ඊට පසුව:

android:configChanges="keyboardHidden|orientation|screenSize"

@Override
public void onConfigurationChanged(Configuration config) {
    super.onConfigurationChanged(config);

if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT) {
        //Handle rotation from landscape to portarit mode here
    } else if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE){
        //Handle rotation from portrait to landscape mode here
    }
}

භ්‍රමණය සීමා කරන්න

භ්‍රමණය වීම වළක්වා ගැනීම සඳහා ඔබේ ක්‍රියාකාරකම් ආලේඛ්‍ය හෝ භූ දර්ශන මාදිලියට සීමා කළ හැකිය.

ඔබගේ මැනිෆෙස්ට් ගොනුවේ ක්‍රියාකාරකම් ටැගයට මෙය එක් කරන්න:

        android:screenOrientation="portrait"

නැතහොත් මෙය ඔබගේ ක්‍රියාකාරකම තුළ ක්‍රමලේඛිකව ක්‍රියාත්මක කරන්න:

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}

මෙය කිරීමට මා සොයාගෙන ඇති ක්‍රමය වන්නේ යම් දෙයක් සුරැකීමට onRestoreInstanceStateසහ onSaveInstanceStateසිදුවීම් භාවිතා කිරීමයි Bundle(ඔබට කිසිදු විචල්‍යයක් සුරැකීමට අවශ්‍ය නොවුවද, යමක් එහි තබන්න, එවිට Bundleඑය හිස් නොවේ). ඉන්පසුව, onCreateක්‍රමවේදය මත , Bundleඑය හිස් දැයි බැලීමට පරීක්ෂා කරන්න , එය එසේ නම්, ආරම්භක කිරීම කරන්න, එසේ නොවේ නම් එය කරන්න.

එය "ඇන්ඩ්‍රොයිඩ් ක්‍රමය" නොවුනත්, දිශානතියේ වෙනස්කම් හසුරුවමින් සහ වෙනස් කළ දිශානතිය සැලකිල්ලට ගැනීම සඳහා විජට් නැවත ස්ථානගත කිරීමෙන් මම ඉතා හොඳ ප්‍රති results ල ලබා ඇත්තෙමි. මෙය වෙනත් ඕනෑම ප්‍රවේශයකට වඩා වේගවත් ය, මන්ද ඔබේ අදහස් සුරැකීමට සහ ප්‍රතිෂ් .ාපනය කිරීමට අවශ්‍ය නොවන බැවිනි. එය පරිශීලකයාට වඩාත් අසීමිත අත්දැකීමක් ලබා දෙයි, මන්දයත් ප්‍රතිස්ථාපිත විජට් හරියටම එකම විජට් වන අතර, දැන් ගෙන ගොස් / හෝ ප්‍රමාණය වෙනස් කර ඇත. ආදර්ශ රාජ්ය පමණක් නොව, රාජ්යය ද මේ ආකාරයෙන් සංරක්ෂණය කළ හැකිය.

RelativeLayoutවරින් වර නැවත වෙනස් කළ යුතු දර්ශනයක් සඳහා සමහර විට හොඳ තේරීමක් විය හැකිය. සෑම ළමා විජට් එකක් සඳහාම ඔබ එකිනෙකට වෙනස් සාපේක්ෂ ස්ථානගත කිරීමේ රීති සහිත පෝට්රේට් පිරිසැලසුම් පරාමිතීන් සහ භූ දර්ශන පිරිසැලසුම් පරාමිති කට්ටලයක් ලබා දෙයි. ඉන්පසු, ඔබේ onConfigurationChanged()ක්‍රමයේදී, ඔබ setLayoutParams()සෑම දරුවෙකුටම ඇමතුමකට සුදුසු එකක් ලබා දේ . ඕනෑම ළමා පාලනයක් අභ්‍යන්තරව ප්‍රතිනිර්මාණය කිරීමට අවශ්‍ය නම්, ඔබ එම දරුවාට නැවත සකස් කිරීම සඳහා ක්‍රමවේදයක් අමතන්න. එම දරුවා හා සමාන ඕනෑම මත ක්රම ඉල්ලා එහි සහ එසේ මත, අභ්යන්තර නව මගකට යොමු අවශ්ය බව ළමා පාලනය.

තිරය ​​භ්‍රමණය වන සෑම අවස්ථාවකම, විවෘත කළ ක්‍රියාකාරකම් අවසන් වී onCreate () නැවත කැඳවනු ලැබේ.

1. තිරය ​​භ්‍රමණය වන විට ක්‍රියාකාරීත්වයේ තත්වය සුරැකීමට ඔබට එක් දෙයක් කළ හැකි අතර, එමඟින් ක්‍රියාකාරීත්වයේ onCreate () නැවත කැඳවූ විට ඔබට සියලු පැරණි දේවල් නැවත ලබා ගත හැකිය. මෙම සබැඳිය බලන්න

2. ක්‍රියාකාරකම නැවත ආරම්භ කිරීම වලක්වා ගැනීමට ඔබට අවශ්‍ය නම් පහත දැක්වෙන රේඛා ඔබේ මැනිෆෙස්ට්.

  <activity android:name=".Youractivity"
  android:configChanges="orientation|screenSize"/>

එහි පරාමිතියෙහි සියලු අගයන් ගබඩා කිරීම සඳහා ඔබ onSavedInstanceState ක්‍රමය භාවිතා කළ යුතුය.

@Override
    public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {
        super.onSaveInstanceState(outState, outPersistentState);
        outPersistentState.putBoolean("key",value);
    }

සහ භාවිතා කරන්න

@Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        savedInstanceState.getBoolean("key");
    } 

නැවත ලබා ගැනීමට සහ වස්තු බැලීමට අගය සැකසීමට එය තිර භ්‍රමණයන් හසුරුවනු ඇත

සටහන: අනාගතයේ යමෙකු මා හා සමාන ගැටලුවකට මුහුණ දෙන්නේ නම් මම මෙම පිළිතුර පළ කරමි. මට නම් පහත දැක්වෙන පේළිය ප්‍රමාණවත් නොවේ:

android:configChanges="orientation"

මම තිරය භ්‍රමණය කරන විට, `onConfigurationChanged (Configuration newConfig) ක්‍රමය ඇමතුවේ නැත.

විසඳුම: දිශානතිය සමඟ ගැටළුව සම්බන්ධ වුවද මට "තිර ප්‍රමාණය" එකතු කිරීමට සිදුවිය. එබැවින් AndroidManifest.xml - ගොනුවේ මෙය එකතු කරන්න:

android:configChanges="keyboardHidden|orientation|screenSize"

ඉන්පසු ක්රමය ක්රියාත්මක කරන්න onConfigurationChanged(Configuration newConfig)

හි ක්‍රියාකාරකම් කොටසේ manifest, එකතු කරන්න:

android:configChanges="keyboardHidden|orientation"

මැනිෆෙස්ට් හි මෙම පේළිය එක් කරන්න: android:configChanges="orientation|screenSize"

මිනිස්සු කියන්නේ ඔබ භාවිතා කළ යුතු බවයි

android:configChanges="keyboardHidden|orientation"

නමුත් ඇන්ඩ්‍රොයිඩ් හි භ්‍රමණය හැසිරවිය හැකි හොඳම හා වඩාත්ම වෘත්තීය ක්‍රමය වන්නේ ලෝඩර් පන්තිය භාවිතා කිරීමයි. එය ප්‍රසිද්ධ පංතියක් නොවේ (ඇයිදැයි මම නොදනිමි), නමුත් එය අසින්ක් කාර්යයට වඩා හොඳය. වැඩි විස්තර සඳහා, ඔබට Udacity හි Android පා .මාලා වල ඇති Android නිබන්ධන කියවිය හැකිය.

ඇත්ත වශයෙන්ම, වෙනත් ක්‍රමයක් ලෙස, ඔබට සාරධර්ම හෝ අදහස් onSaveInstanceState සමඟ ගබඩා කර onRestoreInstanceState සමඟ කියවිය හැකිය. එය ඇත්තෙන්ම ඔබට භාරයි.

අත්හදා බැලීම් සහ දෝෂයන්ගෙන් ටික කලකට පසු, බොහෝ අවස්ථාවලදී මගේ අවශ්‍යතාවන්ට ගැලපෙන විසඳුමක් මට හමු විය. මෙන්න කේතය:

ප්‍රතිපත්ති වින්‍යාසය:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.pepperonas.myapplication">

    <application
        android:name=".App"
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity
            android:name=".MainActivity"
            android:configChanges="orientation|keyboardHidden|screenSize">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>

                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
    </application>

</manifest>

ප්‍රධාන ක්‍රියාකාරිත්වය:

import android.content.res.Configuration;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private static final String TAG = "MainActivity";

    private Fragment mFragment;

    private int mSelected = -1;


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

        // null check not realy needed - but just in case...
        if (savedInstanceState == null) {

            initUi();

            // get an instance of FragmentTransaction from your Activity
            FragmentManager fragmentManager = getSupportFragmentManager();
            FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

            /*IMPORTANT: Do the INITIAL(!) transaction only once!
            * If we call this everytime the layout changes orientation,
            * we will end with a messy, half-working UI.
            * */
            mFragment = FragmentOne.newInstance(mSelected = 0);
            fragmentTransaction.add(R.id.frame, mFragment);
            fragmentTransaction.commit();
        }
    }


    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        Log.d(TAG, "onConfigurationChanged  " +
                   (newConfig.orientation
                    == Configuration.ORIENTATION_LANDSCAPE
                    ? "landscape" : "portrait"));

        initUi();

        Log.i(TAG, "onConfigurationChanged - last selected: " + mSelected);
        makeFragmentTransaction(mSelected);
    }


    /**
     * Called from {@link #onCreate} and {@link #onConfigurationChanged}
     */
    private void initUi() {
        setContentView(R.layout.activity_main);
        Log.d(TAG, "onCreate  instanceState == null / reinitializing..." + "");
        Button btnFragmentOne = (Button) findViewById(R.id.btn_fragment_one);
        Button btnFragmentTwo = (Button) findViewById(R.id.btn_fragment_two);
        btnFragmentOne.setOnClickListener(this);
        btnFragmentTwo.setOnClickListener(this);
    }


    /**
     * Not invoked (just for testing)...
     */
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        Log.d(TAG, "onSaveInstanceState  " + "YOU WON'T SEE ME!!!");
    }


    /**
     * Not invoked (just for testing)...
     */
    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        Log.d(TAG, "onSaveInstanceState  " + "YOU WON'T SEE ME, AS WELL!!!");
    }


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


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


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


    @Override
    public void onClick(View v) {

        switch (v.getId()) {
            case R.id.btn_fragment_one:
                Log.d(TAG, "onClick btn_fragment_one " + "");
                makeFragmentTransaction(0);
                break;

            case R.id.btn_fragment_two:
                Log.d(TAG, "onClick btn_fragment_two " + "");
                makeFragmentTransaction(1);
                break;

            default:
                Log.d(TAG, "onClick  null - wtf?!" + "");
        }
    }


    /**
     * We replace the current Fragment with the selected one.
     * Note: It's called from {@link #onConfigurationChanged} as well.
     */
    private void makeFragmentTransaction(int selection) {

        switch (selection) {
            case 0:
                mFragment = FragmentOne.newInstance(mSelected = 0);
                break;
            case 1:
                mFragment = FragmentTwo.newInstance(mSelected = 1);
                break;
        }

        // Create new transaction
        FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();

        // Replace whatever is in the fragment_container view with this fragment,
        // and add the transaction to the back stack
        transaction.replace(R.id.frame, mFragment);

        /*This would add the Fragment to the backstack...
        * But right now we comment it out.*/
        //        transaction.addToBackStack(null);

        // Commit the transaction
        transaction.commit();
    }

}

සහ නියැදි කොටස්:

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

/**
 * @author Martin Pfeffer (pepperonas)
 */
public class FragmentOne extends Fragment {

    private static final String TAG = "FragmentOne";


    public static Fragment newInstance(int i) {
        Fragment fragment = new FragmentOne();
        Bundle args = new Bundle();
        args.putInt("the_id", i);
        fragment.setArguments(args);
        return fragment;
    }


    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        Log.d(TAG, "onCreateView  " + "");
        return inflater.inflate(R.layout.fragment_one, container, false);
    }

}

ගිතූබ් හි සොයාගත හැකිය .

orientationවිවිධ දිශානතිය මත විවිධ කාර්යයන් ඉටු කිරීමට සවන්දෙන්නන් භාවිතා කරන්න .

@Override
public void onConfigurationChanged(Configuration myConfig) 
{
    super.onConfigurationChanged(myConfig);
    int orient = getResources().getConfiguration().orientation; 
    switch(orient) 
    {
       case Configuration.ORIENTATION_LANDSCAPE:
          setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
                    break;
       case Configuration.ORIENTATION_PORTRAIT:
          setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
                    break;
       default:
          setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
    }
}

ඔබේ කේතය පහත මෙම දාන්න Activityදී Android Manifest.

android:configChanges="orientation"

ඔබ දිශානතිය වෙනස් කරන විට මෙය ඔබගේ ක්‍රියාකාරකම් නැවත ආරම්භ නොවේ.

තිරයේ දිශානතිය (භූ දර්ශනය හෝ ආලේඛ්‍ය චිත්‍රය) සවි කරන්න AndroidManifest.xml

android:screenOrientation="portrait" හෝ android:screenOrientation="landscape"

මේ සඳහා ඔබේ onResume()ක්‍රමය කැඳවනු නොලැබේ.

ගූගල් විසින් හඳුන්වා දෙන ලද ඇන්ඩ්‍රොයිඩ් ගෘහ නිර්මාණ ශිල්පයේ හොඳම අංගයක් වන්නේ ඔබේ සියලු අවශ්‍යතාවයන් වන ViewModel සපුරාලීමයි.

එය නිර්මාණය කර ඇත්තේ UI ආශ්‍රිත දත්ත ජීවන චක්‍රයේ ගබඩා කිරීම සහ කළමනාකරණය කිරීම සඳහා වන අතර එමඟින් තිරය භ්‍රමණය වන විට දත්ත නොනැසී පවතිනු ඇත

class MyViewModel : ViewModel() {

කරුණාකර මෙය යොමු කරන්න: https://developer.android.com/topic/libraries/architecture/viewmodel

ඔබගේ ක්‍රියාකාරකම තුළ ඔබට ViewModel වස්තුව භාවිතා කළ හැකිය.

වින්‍යාස වෙනස්වීම් වලදී ViewModel වස්තූන් ස්වයංක්‍රීයව රඳවා තබා ගන්නා අතර එමඟින් ඔවුන් සතුව ඇති දත්ත ඊළඟ ක්‍රියාකාරකමට හෝ කොටස් නිදසුනක් සඳහා වහාම ලබා ගත හැකිය. වැඩිදුර කියවන්න:

https://developer.android.com/topic/libraries/architecture/viewmodel