What is the specificity of changing application states on Android?

The specifics of changing application states on Android lie in the lifecycle of an Activity — a component that represents a single screen. Transitions between states are managed by the system and affect resource visibility and accessibility.

Key methods of the Activity lifecycle:

• onCreate(): Called when the activity is first created. UI and main components are initialized here.
• onStart(): The activity becomes visible to the user but is not yet in the foreground.
• onResume(): The activity is in the foreground and ready for user interaction.
• onPause(): The activity is partially obscured, possibly overlapped by another activity. UI is still visible but interaction is limited.
• onStop(): The activity becomes invisible.
• onDestroy(): The activity is destroyed by the system or explicitly via finish().
• onRestart(): Called after onStop(), when the activity is restarted.

Important features:

• System management: State changes are not always initiated by the developer; the system may close the activity to free resources (e.g., low memory) or during screen rotation.
• State preservation: When an activity is destroyed or partially covered, it is important to save user data or UI state using onSaveInstanceState() and restore it in onCreate() or onRestoreInstanceState().
• Fragments: Fragments have their own lifecycle, linked to the lifecycle of their containing Activity, with additional methods.
• Background processes: The app can continue working in the background (e.g., services), even if all Activities are not visible.
• Handling interruptions: Proper handling of app pause and resume during incoming calls, switching to other apps, etc.

Testing state changes involves checking app behavior during:

• Screen rotation.
• Switching to other apps and returning.
• Incoming calls and notifications.
• Pressing the "Home" and "Back" buttons.
• Changing device configuration (language, font size).
• System destruction of the app due to low memory.

Example of saving and restoring state:

// In Activity
override fun onSaveInstanceState(outState: Bundle) {
    super.onSaveInstanceState(outState)
    outState.putString("saved_text", editText.text.toString())
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    if (savedInstanceState != null) {
        val savedText = savedInstanceState.getString("saved_text")
        editText.setText(savedText)
    }
}

Understanding and correctly handling the Activity lifecycle is critical for creating robust and reliable Android applications.

// Example of logging the lifecycle public class MainActivity extends AppCompatActivity {

private static final String TAG = "Lifecycle";

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    Log.d(TAG, "onCreate");
}

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

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

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

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

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

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

}