One of the most important concepts in Android app development is the Activity<\/strong> and its lifecycle. An Activity is a component that makes up the user interface (UI) and represents a screen that users interact with. In this course, we will explore the Activity lifecycle in Android app development using Java and explain the tasks that can be performed at each stage.<\/p>\n An Activity is a component that represents the user interface of an Android application and corresponds to a single screen within the app. Everything that the user interacts with in the app happens within an Activity. Activities include various UI elements to display information to the user and handle user interactions.<\/p>\n The Activity lifecycle refers to the flow of states and transitions from the creation to the destruction of an Activity. The Android system manages the Activity lifecycle, with the following key methods:<\/p>\n The The The The The The The Now, let’s create an example that incorporates the Activity lifecycle explained earlier. In this example, we will log the Activity’s state through button clicks.<\/p>\n Managing the Activity lifecycle has a significant impact on the performance of the app and the user experience. Data that is necessary during the creation and destruction process should be saved in When an Activity is restarted after being stopped, it may be necessary to save its state. You can use the Saved state can be restored in The Android Activity lifecycle is one of the fundamental components of an app, and understanding it and managing it effectively is important. Performing tasks correctly according to each stage of the lifecycle can provide a better user experience. I hope this course provides you with a basic understanding of the Activity lifecycle.<\/p>\n In conclusion, I have explained the Activity lifecycle in Android app development using Java. Deepen your understanding through practical exercises, and make good use of the lifecycle in various situations!<\/p>\n <\/body><\/p>\n","protected":false},"excerpt":{"rendered":"What is an Activity?<\/h2>\n
Activity Lifecycle<\/h2>\n
\n
onCreate()<\/code><\/li>\nonStart()<\/code><\/li>\nonResume()<\/code><\/li>\nonPause()<\/code><\/li>\nonStop()<\/code><\/li>\nonDestroy()<\/code><\/li>\nonRestart()<\/code><\/li>\n<\/ul>\n1. onCreate()<\/h3>\n
onCreate()<\/code> method is called when the Activity is first created. It primarily performs UI setup and basic initialization tasks. In this method, the layout is set and initial variables are defined.<\/p>\npublic class MainActivity extends AppCompatActivity {\n @Override\n protected void onCreate(Bundle savedInstanceState) {\n super.onCreate(savedInstanceState);\n setContentView(R.layout.activity_main);\n }\n}\n<\/code><\/pre>\n2. onStart()<\/h3>\n
onStart()<\/code> method is called just before the Activity becomes visible to the user. In this method, the UI can be initialized, signaling that the Activity is ready for user interaction.<\/p>\n@Override\nprotected void onStart() {\n super.onStart();\n \/\/ Handle just before the Activity is shown to the user\n}\n<\/code><\/pre>\n3. onResume()<\/h3>\n
onResume()<\/code> method is called when the Activity is about to become the foreground activity. Common tasks performed here include updating the UI or starting animations.<\/p>\n@Override\nprotected void onResume() {\n super.onResume();\n \/\/ Update UI or start animations\n}\n<\/code><\/pre>\n4. onPause()<\/h3>\n
onPause()<\/code> method is called when another Activity is starting or this Activity is being paused. In this method, data should be saved, or animations should be stopped. It indicates that the user is no longer actively using this Activity.<\/p>\n@Override\nprotected void onPause() {\n super.onPause();\n \/\/ Save data and stop animations\n}\n<\/code><\/pre>\n5. onStop()<\/h3>\n
onStop()<\/code> method is called when the Activity is no longer visible to the user. At this stage, resources should be released, and tasks that need to be handled when the Activity is not visible should be performed.<\/p>\n@Override\nprotected void onStop() {\n super.onStop();\n \/\/ Release resources and perform cleanup\n}\n<\/code><\/pre>\n6. onDestroy()<\/h3>\n
onDestroy()<\/code> method is called when the Activity is finishing. In this method, memory can be released and final cleanup tasks can be carried out. However, this method may not be called, so it is advisable to save important data in onPause()<\/code> or onStop()<\/code>.<\/p>\n@Override\nprotected void onDestroy() {\n super.onDestroy();\n \/\/ Final cleanup tasks\n}\n<\/code><\/pre>\n7. onRestart()<\/h3>\n
onRestart()<\/code> method is called when the Activity is being restarted after stopping. This method is called after onStop()<\/code>. Here, tasks to restore the previous state are performed.<\/p>\n@Override\nprotected void onRestart() {\n super.onRestart();\n \/\/ Tasks when restarting the Activity\n}\n<\/code><\/pre>\nLifecycle Example<\/h2>\n
import android.os.Bundle;\nimport android.util.Log;\nimport android.view.View;\nimport android.widget.Button;\nimport androidx.appcompat.app.AppCompatActivity;\n\npublic class MainActivity extends AppCompatActivity {\n private static final String TAG = \"MainActivity\";\n\n @Override\n protected void onCreate(Bundle savedInstanceState) {\n super.onCreate(savedInstanceState);\n setContentView(R.layout.activity_main);\n\n Button button = findViewById(R.id.button);\n button.setOnClickListener(new View.OnClickListener() {\n @Override\n public void onClick(View v) {\n Log.d(TAG, \"Button clicked!\");\n }\n });\n }\n\n @Override\n protected void onStart() {\n super.onStart();\n Log.d(TAG, \"onStart called\");\n }\n\n @Override\n protected void onResume() {\n super.onResume();\n Log.d(TAG, \"onResume called\");\n }\n\n @Override\n protected void onPause() {\n super.onPause();\n Log.d(TAG, \"onPause called\");\n }\n\n @Override\n protected void onStop() {\n super.onStop();\n Log.d(TAG, \"onStop called\");\n }\n\n @Override\n protected void onDestroy() {\n super.onDestroy();\n Log.d(TAG, \"onDestroy called\");\n }\n}\n<\/code><\/pre>\nManaging the Lifecycle<\/h2>\n
onPause()<\/code> or onStop()<\/code>, and the UI should be updated in onResume()<\/code> when changes occur.<\/p>\nSaving State<\/h3>\n
onSaveInstanceState()<\/code> method for this purpose. Below is an example of how to save state.<\/p>\n@Override\nprotected void onSaveInstanceState(Bundle outState) {\n super.onSaveInstanceState(outState);\n outState.putString(\"key\", \"value\");\n}\n<\/code><\/pre>\nonCreate()<\/code> or onRestoreInstanceState()<\/code>.<\/p>\n@Override\nprotected void onCreate(Bundle savedInstanceState) {\n super.onCreate(savedInstanceState);\n setContentView(R.layout.activity_main);\n \n if (savedInstanceState != null) {\n String value = savedInstanceState.getString(\"key\");\n }\n}\n<\/code><\/pre>\nConclusion<\/h2>\n