Introduction

Handling screen orientation changes in Android can be challenging, especially when dealing with background operations and progress dialogs. This operation involves maintaining a consistent user experience without interrupting ongoing tasks or losing user data. This article will explore strategies to manage screen orientation changes effectively while a background thread is active, and a progress dialog is being shown.

Understanding the Problem

When the screen orientation changes, Android typically destroys and recreates the activity. This means any long-running tasks, UI elements, or dialogs may be lost unless explicitly handled. We need a strategy to manage these changes without disrupting the user experience.

Strategies for Handling Screen Orientation Changes

1. Preserve State with ViewModel

The ViewModel class is part of Android Architecture Components and provides a way to manage UI-related data in a lifecycle-conscious manner. By utilizing ViewModel, you can store data related to the background operations that persist through configuration changes.

Implementation

1. Create a ViewModel:

1   class MyViewModel : ViewModel() {
2       val progressLiveData = MutableLiveData<Int>()
3       val isLoading = MutableLiveData<Boolean>()
4   }

1. Use ViewModel in Activity:

1   class MyActivity : AppCompatActivity() {
2       private lateinit var viewModel: MyViewModel
3
4       override fun onCreate(savedInstanceState: Bundle?) {
5           super.onCreate(savedInstanceState)
6           viewModel = ViewModelProvider(this).get(MyViewModel::class.java)
7
8           viewModel.isLoading.observe(this, Observer { isLoading ->
9               if (isLoading) showProgressDialog() else dismissProgressDialog()
10           })
11
12           viewModel.progressLiveData.observe(this, Observer { progress ->
13               updateProgressDialog(progress)
14           })
15       }
16   }

2. Use Retain Instance in Fragments

For dialog-related tasks, a Fragment that retains its instance may be useful. By setting a fragment to retain its instance, you ensure that it will not be destroyed and recreated during configuration changes.

Implementation

• Create a Retainable Fragment:

1  class ProgressDialogFragment : DialogFragment() {
2
3      override fun onCreate(savedInstanceState: Bundle?) {
4          super.onCreate(savedInstanceState)
5          retainInstance = true
6      }
7  }

3. Utilize onSaveInstanceState

Store essential information in the Bundle within onSaveInstanceState method. Although this will not keep threads running in the background, it will ensure essential data is not lost.

Implementation

1override fun onSaveInstanceState(outState: Bundle) {
2    super.onSaveInstanceState(outState)
3    outState.putInt("progress_level", currentProgress)
4    // Store other essential data
5}
6
7override fun onRestoreInstanceState(savedInstanceState: Bundle) {
8    super.onRestoreInstanceState(savedInstanceState)
9    // Restore data from the bundle
10    val restoredProgress = savedInstanceState.getInt("progress_level")
11    updateProgressDialog(restoredProgress)
12}

4. Use Service or WorkManager for Long-Running Tasks

For tasks that must persist beyond the activity lifecycle, a Service or WorkManager is advisable. A Service runs in the background without a UI, and a WorkManager is a flexible API for executing deferrable, guaranteed background work.

Example with WorkManager:

1class MyWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
2    override fun doWork(): Result {
3        // Perform the work here
4        return Result.success()
5    }
6}

5. Leverage Configuration Change Callbacks

Override onConfigurationChanged in your activity to directly manage specific attributes during orientation changes while avoiding a complete activity restart.

Implementation

1override fun onConfigurationChanged(newConfig: Configuration) {
2    super.onConfigurationChanged(newConfig)
3    // Code to execute when orientation changes
4}

Summary Table

Conclusion

Handling screen orientation changes while maintaining an active background thread and progress dialog requires a multifaceted approach combining architectural components like ViewModel, retained fragments, and background services. By choosing the appropriate strategy based on your app's needs, you can create a seamless user experience that gracefully handles these changes.