Android Activities


What is Activity?

Activity is the fundamental concept in Android development. It is an entry point which provides a surface to let users interact with the application. Every activity is independent of each other though they work together to form a cohesive user experience.

Activity creates a window on which you can place your UI which the user can interact to. These are just glue classes that provide an interface for letting apps communicate with the system and vice-versa. So the result is that the OS can destroy these components anytime based on different reasons. Activity are called as UI-based class.

Things Activity provides:
  • To let the system know to keep the process running which is hosting the activity (app in a whole).
  • Keeps track of previous processes which the user can return to.
  • Helps in handling process kill scenarios, so that previous state can be restored.
  • Helps apps to implement user flow between each other, and systems to coordinate this flow.

Things to consider while designing an Activity?

All the code required to keep the app functional should not be part of the single component and different components should be created to share those responsibilities. Activity can then delegate those responsibilities to these different components. i.e We should focus on achieving the principle of “Separation of Concern.

Activity should ONLY handle UI and OS interactions.

What should activity look like?
  • As lean as possible
  • With minimal dependency on other components
  • Loosely bound with other activities
  • How to create and declare an Activity?

Important points to note:
  • Create new activity and extend it using AppCompactActivity
  • Register your activity by declaring it in AndroidManifest file
  • Add intent-filters to the activity declared in AndroidManifest file (required if it is the launcher activity)




How does Activity System work together to create an Activity?
  • Android system uses the concept of Looper, Handler and MessageQueues to govern the different callbacks required to connect to the app process.
  • ActivityThread#main is the starting point
  • APPLICATION_INFO_CHANGED message is scheduled (via scheduleApplicationInfoChanged method)
  • Eventually, this message is handled (in handleMessage method), calls handleApplicationInfoChanged
  • RELAUNCH_ACTIVITY message is scheduled (via handleApplicationInfoChanged method)
  • Eventually, this message is handled (in handleMessage method), called handleRelaunchActivityLocally which initializes some configuration and executes ActivityRelaunchItem transaction.
  • handleRelaunchActivity is called, which will subsequently call handleLaunchActivity which prepares ground for new activity launch and finally calls performLaunchActivity
  • performLaunchActivity is the core implementation of activity launch. This sets all the required properties of activity like context, intent, theme, and the state (ON_CREATE). Then calls callActivityOnCreate.
  • callActivityOnCreate calls performCreate method on activity object which finally provides onCreate callback which we receive in our Activity class.
  • This is the point where Activity is CREATED :)
Resources
  • https://developer.android.com/guide/components/activities/intro-activities
  • https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread.java
  • https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/Activity.java
Location: India

Comments

Post a Comment

Popular posts from this blog

Fragment Lifecycle

Image
Just like Activities, Fragments also manages its own lifecycle. Though these lifecycle callbacks are a bit different than activity’s callbacks they exist for the similar reason as that of activity’s callback. Fragment manages two different lifecycles. One for the fragment instance and other for the view shown in the fragment. Having different lifecycle for fragment’s view is useful in the situations where the work should be performed only when view exists. Points to note: Fragment lifecycle call-backs are similar to Activity’s lifecycle. More important they are dependent on Activity’ state. Fragment manages 2 different lifecycles - Instance and View. Fragment callbacks are: onAttach, onCreate, onCreateView, onViewCreated, onViewStateRestored, onStart, onResume, onPause, onStop, onDestroyView, onDestroy, onDetach Fragment state is saved before onStop for API level less than 28 while in API level 28 and above its saved after onStop method. i.e In API level 28 or above devices its safe to...
Read more

AndroidManifest

Image
One of the most important components of your project. Stays in the root directory of the project source. This is used to describe essential information about the app to Android Build Tools, Android OS and Google Play. Most important things for which AndroidManifest is used: To declare app’s package name: Used by Android build tools to map code entities and to map it with applicationId defined in build.gradle To declare different app components: Include all activities, services, broadcast receivers, and content providers To declare app permissions: Helps in accessing specific restricted by System or other apps. To declare hardware and software features: Used to decide which device can app be installed into Package name and application ID Example <?xml version="1.0" encoding="utf-8"?>        <manifest            xmlns:android="http://schemas.android.com/apk/res/android"           package="co...
Read more

Activity Lifecycle

Image
To let Android System interact with Application different methods are defined by the system which communicate different states of the activity to the application. Those methods/states are called as Lifecycle Callbacks. Activity can go into different combination of these states. In the code each callback is used to understand the state in which the activity is in and accordingly perform different operations. Let’s discuss different activity callbacks and what each of them represent in real life scenarios. You will find each section explained with the 3 labels. Let us see what each label represents: Called: It will tell you when is this method called. Implement: What should be implemented in this method. State: What is the state of activity from user's perspective.                         onCreate() Called: This is the first callback received in Activity which is called as soon as the system creates the Activity. Implement: Used ...
Read more