Exercise state and fragment lifecycle in Android apps with Kotlin

In fashionable Android improvement, the exercise state and fragment lifecycle play an important position, influencing implementation selections in addition to the ultimate output that’s seen and skilled by finish customers. On this article, we’ll evaluation what these ideas are, how they work, and what steps to observe to implement them in an Android software.

To observe together with this tutorial, you’ll want fundamental data of the Kotlin programming language in addition to Android Studio or IntelliJ IDE put in. Let’s get began!

What’s exercise state?

An exercise refers to a single motion {that a} person can carry out. In Android improvement, an exercise is a Java class that has some pre-defined features that may be triggered in several app states to carry out any form of job you need. The exercise can also be liable for the creation, destruction, and management of the different states of the app’s lifecycle.

An exercise class handles most of the computation particulars, like making a window for you.

In Android, there could be a number of actions, however there is just one MainActivity, which is the doorway of the appliance, identical to the essential() methodology begins the execution of a program in Java. Once we name the MainActivity class, the execution begins with the onCreate() methodology.

The subclass of all actions implement two strategies:

• onPause: Permits the person to pause lively interplay with the exercise
• onCreate: Initializes your actions. You’ll should name the setContentView() programmatically

We will specific this within the code snippet beneath. We use the onCreate methodology to create or begin an exercise, the tremendous key phrase to name the tremendous class constructor, and eventually, setContentView to set the XML:

bundle com.instance.myfirstandroidapplication

import android.os.Bundle
import com.google.android.materials.snackbar.Snackbar
import androidx.appcompat.app.AppCompatActivity
import androidx.core.view.WindowCompat
import androidx.navigation.findNavController
import androidx.navigation.ui.AppBarConfiguration
import androidx.navigation.ui.navigateUp
import androidx.navigation.ui.setupActionBarWithNavController
import android.view.Menu
import android.view.MenuItem
import com.instance.myfirstandroidapplication.databinding.ActivityMainBinding

class MainActivity : AppCompatActivity() {

    non-public lateinit var appBarConfiguration: AppBarConfiguration
    non-public lateinit var binding: ActivityMainBinding

    override enjoyable onCreate(savedInstanceState: Bundle?) {
        WindowCompat.setDecorFitsSystemWindows(window, false)
        tremendous.onCreate(savedInstanceState)

        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        setSupportActionBar(binding.toolbar)

        val navController = findNavController(R.id.nav_host_fragment_content_main)
        appBarConfiguration = AppBarConfiguration(navController.graph)
        setupActionBarWithNavController(navController, appBarConfiguration)

        binding.fab.setOnClickListener { view ->
            Snackbar.make(view, "Change with your individual motion", Snackbar.LENGTH_LONG)
                .setAnchorView(R.id.fab)
                .setAction("Motion", null).present()
        }
    }

    override enjoyable onCreateOptionsMenu(menu: Menu): Boolean {
        // Inflate the menu; this provides objects to the motion bar whether it is current.
        menuInflater.inflate(R.menu.menu_main, menu)
        return true
    }

An exercise state refers to occasions which might be triggered by both the system or by customers, ensuing within the transition of an exercise from one state to a different.

For instance, when a person is lively in an app, they often transition between clicking the app’s icon on their homepage, to launching the app, then in the end exiting from the app, leading to state modifications. These modifications from one state to a different are what is called an exercise state change.

What’s the exercise lifecycle?

The exercise modifications that happen in a system are managed in exercise stacks. The most recent exercise is often positioned on prime of the present stack, and it turns into the working exercise whereas the earlier exercise stays beneath it within the stack.

The exercise lifecycle refers back to the whole exercise {that a} person performs, from launching the app to shutting down all operations. A number of exercise strategies outline the whole lifecycle of an exercise. For one, onCreate() is the preliminary state of the app after being launched by the person. The code snippet beneath exhibits the syntax for the onCreate() methodology:

protected void onCreate()

onPause() is a paused state when the person is about to resolve the subsequent line of motion, whether or not to exit or proceed utilizing the app:

protected void onPause()

The onStart() state is named when the exercise resumes from the paused state and is made seen to the person:

protected void onStart()

onDestroy() is a state that outcomes when all actions are closed down, leading to shutting down all operations:

protected void onDestroy()

onStop() is the state that outcomes from the person clicking on the house button, which often minimizes the app. This shouldn’t be mistaken for when the app is closed:

protected void onStop()

onResume() is a callback that’s invoked when an exercise restarts after being stopped. The syntax for this methodology is proven within the code snippet beneath:

protected void onResume()

The strategies listed above work together with the saveInstanceState() methodology to protect the configuration of the exercise UI state:

public class Exercise extends ApplicationContext {
      protected void onCreate(Bundle savedInstanceState);

      protected void onStart();

      protected void onRestart();

      protected void onResume();

      protected void onPause();

      protected void onStop();

      protected void onDestroy();
  }

What’s fragment lifecycle?

A fraction refers back to the portion of an exercise’s UI that enables us to create a number of screens in our Android software. Fragments have been launched in Android v3.0 to help a extra versatile UI design on giant screens like tablets. The most recent model of Android on the time of writing, v12.x, consists of additional options like a extra expressive and dynamic system UI.

One method we will observe to create a number of screens in an software is swapping one fragment with one other.

Relationship between exercise state and fragment lifecycle

Actions are typically thought to be the working system’s entry level to the appliance. In an Android software, the exercise can comprise a couple of fragment and features. These function a body that accommodates the UI fragment, offering UI components that encompass the fragment.

Whereas an exercise can exist with out a fragment, you can not use a fraction with out an exercise. The UI fragments function like a view throughout the exercise’s structure. To realize this, it’s a must to create a sub-class, like within the code beneath:

class InfoFragment: Fragment{
@override enjoyable onCreateView(...): View? {
     return inflater.inflate (
      R.structure.fragment_info,...)
  }
}

The code snippet above exhibits a reusable UI element containing UI logic that inflates the structure of the fragment. Whereas most UI components are carried out within the fragment, the OS can solely open actions.

Word that throughout the exercise, you may inform Android which structure to make use of by calling setContentView in onCreate. Whereas within the fragment, you’ll should manually inflate and return the inflated structure throughout the onCreateView methodology, which is unbiased of the onCreate methodology.

The code snippets beneath additional emphasize that time:

// Exercise 
override enjoyable onCreate(savedInstanceState : Bundle?) {
  tremendous.onCreate(savedInstanceState)
  val binding = DataBindingUtil
  .setContentView<ActivityMainBinding> (
  this, R.structure.activity_main)
  ...
}

// Fragment
override enjoyable onCreateView (...): View? {
  return inflater.inflate (
  R.structure.fragment_message,...)
}

Whereas actions inherit from the context class, fragments don’t. You’ll want to make use of the context property inside a fraction to have entry to app information that’s accessible to the context, like strings or photos.

// Exercise 
public class ActivityCompat extends ContextCompat

//Fragment
open class Fragment: componentCallbacks

context!!.getString(R.string.app_name)

context!!.getDrawable(R.drawable.ic_launcher_background

In Android, you may navigate to and from between totally different actions. They’re organized in a stack with the most recent exercise on prime of the stack hint, known as the again stack.

Fragments have the same again stack, however the whole stack is contained throughout the exercise. That is managed by a category generally known as FragmentManager, which we’ll evaluation subsequent.

FragmentManager and fragment lifecycle state

In Android software improvement, the FragmentManager and fragment lifecycle are liable for the state transition that the appliance undergoes.

A fraction all the time begins by being instantiated in an INITIALIZED state. For this fragment to transition all through the totally different states in its lifecycle, it have to be added to FragmentManager. The FragmentManager determines what state its fragment ought to be in and determines the fragment’s most state.

Identical to an exercise, fragments even have their very own lifecycle. Every time a person interacts with an Android software, the fragment transitions by totally different states in its lifecycle, together with the next:

• INITIALIZED
• CREATED
• STARTED
• RESUMED
• DESTROYED

Nonetheless, the easiest way to study fragments is by implementing them.

Creating and including fragments to the Android software

To create a fraction, we’ll observe the steps beneath:

1. Choose File and click on on New
2. Click on on Fragment and Fragment (Clean) from the dropdown menu
3. Use TitleFragment for the fragment’s identify
4. Uncheck the create structure XML
5. Uncheck embrace fragment manufacturing unit strategies
6. Uncheck embrace interface callbacks
7. Choose end

After creating a fraction, you’ll have so as to add the fragment to your software. So as to add a fraction, first click on on the linear structure and create a fraction tag from the activity_main.xml structure. Give this fragment a fragment id and an android:identify to the complete path of the fragment class. Lastly, set the structure width and top to match_parent, and also you’re good to go!

Conclusion

On this tutorial, we coated some fundamental and superior ideas on exercise state and fragment lifecycle in an Android software utilizing the Kotlin programming language.

Fragments help modularity and code reuse, permitting us to make use of the identical listing view in lots of actions. They’re additionally useful for constructing multi-pane interfaces for Android pill units. Alternatively, the exercise state lifecycle gives data on how the Android software would behave all through its seven states. Lastly, we created some fragment lifecycle examples, evaluating their similarities and variations between exercise state.

As an Android developer, it’s necessary to all the time keep updated with newest expertise launch and observe greatest practices throughout Android software developments. I hope you loved this text, and depart a remark in case you have any questions. Blissful coding!