---

📚 ComponentActivity Tutorial: Lifecycle Events & Usage

Focus keyword: ComponentActivity

🗂 Table of Contents

• Introduction to ComponentActivity
• Lifecycle of ComponentActivity
• Lifecycle Methods Explained
• ComponentActivity vs AppCompatActivity
• Practical Example Using ComponentActivity
• Best Practices
• Conclusion

---

🔖 Introduction to ComponentActivity

ComponentActivity is a fundamental Android class provided as part of the AndroidX libraries. It is specifically optimized for applications built with Jetpack Compose, Android’s modern UI toolkit.

✅ Key Characteristics:

• Lightweight and lifecycle-aware.
• Optimized for use with Jetpack Compose.
• Simplified lifecycle handling.
• Integration with Jetpack libraries (ViewModel, lifecycle components, etc.).

---

🔄 Lifecycle of ComponentActivity

The ComponentActivity lifecycle consists of clearly defined states:

        Activity Launched
              │
              ▼
        ┌───────────┐
        │ onCreate  │
        └───────────┘
              │
              ▼
        ┌───────────┐
        │ onStart   │
        └───────────┘
              │
              ▼
        ┌───────────┐
        │ onResume  │
        └───────────┘
              │
              ▼
          Activity Running
              │
        ┌─────────────┐
        │ onPause     │ (Partially obscured)
        └─────────────┘
              │
              ▼
        ┌─────────────┐
        │ onStop      │ (Fully obscured)
        └─────────────┘
              │
              ▼
        ┌─────────────┐
        │ onDestroy   │ (Activity destroyed)
        └─────────────┘
              │
              ▼
        Activity Shut Down

---

🚦 Lifecycle Methods Explained

1. onCreate()

• When: Called once when the activity is first created.
• Usage: Initialize the UI, set the Compose content, bind ViewModels, configure settings.

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContent {
        MyAppTheme {
            Surface(modifier = Modifier.fillMaxSize()) {
                Greeting("ComponentActivity")
            }
        }
    }
}

---

2. onStart()

• When: Activity becomes visible to the user.
• Usage: Typically used for starting operations that need to run while the activity is visible.

override fun onStart() {
    super.onStart()
    Log.d("Lifecycle", "ComponentActivity started")
}

---

3. onResume()

• When: Activity starts interacting with the user.
• Usage: Start animations, resume paused tasks, or refresh data/UI.

override fun onResume() {
    super.onResume()
    Log.d("Lifecycle", "ComponentActivity resumed")
}

---

4. onPause()

• When: Activity is partially obscured or transitioning away.
• Usage: Pause animations or persist lightweight state.

override fun onPause() {
    super.onPause()
    Log.d("Lifecycle", "ComponentActivity paused")
}

---

5. onStop()

• When: Activity is fully obscured (e.g., navigating to another activity).
• Usage: Stop resource-intensive tasks (like location or sensor updates).

override fun onStop() {
    super.onStop()
    Log.d("Lifecycle", "ComponentActivity stopped")
}

---

6. onDestroy()

• When: Activity is finishing or system destroys activity (low memory).
• Usage: Release resources, unregister listeners, finalize cleanup tasks.

override fun onDestroy() {
    super.onDestroy()
    Log.d("Lifecycle", "ComponentActivity destroyed")
}

---

📌 ComponentActivity vs AppCompatActivity

Feature	ComponentActivity	AppCompatActivity
Primary Use	Jetpack Compose UI	Traditional View/XML UI
AppCompat Support	Basic support, fewer compatibility features	Full backward-compatibility features for legacy APIs
UI Definition	Programmatic (Compose)	XML Layouts and Views
Lightweight	✅ Highly lightweight	⚠️ Slightly heavier
Modern Jetpack Support	✅ Fully integrated	⚠️ Partial integration

Recommendation:
Use ComponentActivity for modern Jetpack Compose-based apps; use AppCompatActivity if legacy UI views (XML) and compatibility across older APIs (pre-Compose) are needed.

---

📱 Practical Example Using ComponentActivity

Simple ComponentActivity Example:

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable

class MyComposeActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            WelcomeMessage("Compose World!")
        }
    }

    override fun onStart() {
        super.onStart()
        // Activity is now visible
    }

    override fun onResume() {
        super.onResume()
        // Activity has user interaction
    }

    override fun onPause() {
        super.onPause()
        // Activity partially obscured
    }

    override fun onStop() {
        super.onStop()
        // Activity completely obscured
    }

    override fun onDestroy() {
        super.onDestroy()
        // Clean up resources
    }
}

@Composable
fun WelcomeMessage(name: String) {
    Text("Hello, $name")
}

---

✅ Best Practices

• Lifecycle Awareness: Use lifecycle-aware components like ViewModel and LiveData for data consistency.
• Use Jetpack Compose: Leverage ComponentActivity as the entry point for Compose UI.
• Clean up resources: Properly release resources during onDestroy() to prevent memory leaks.
• Lifecycle Logging: Use logging in lifecycle methods to debug and optimize performance.

---

📌 Conclusion

ComponentActivity simplifies Android development by providing an optimized environment for Jetpack Compose. Understanding its lifecycle ensures efficient app behavior, smooth performance, and effective resource management.

• Understand: The lifecycle and appropriate usage.
• Apply: Best practices for efficient Android development.
• Optimize: User experience using Jetpack Compose and lifecycle-aware components.