Introduction to App Lifecycle and Navigation

 

Activity and Fragment Lifecycle in Android

Understanding the lifecycle of Activities and Fragments is crucial for managing resources, ensuring a smooth user experience, and avoiding memory leaks.

Activity Lifecycle:

1. onCreate(): Called when the activity is first created. Initialize the activity, set the content view, and perform setup tasks.

   kotlin
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)
       // Initialize components
   }
   

2. onStart(): Called when the activity becomes visible to the user.

   kotlin
   override fun onStart() {
       super.onStart()
       // The activity is about to become visible
   }
   

3. onResume(): Called when the activity starts interacting with the user.

   kotlin
   override fun onResume() {
       super.onResume()
       // The activity has become visible and interactive
   }
   

4. onPause(): Called when the system is about to start resuming another activity.

   kotlin
   override fun onPause() {
       super.onPause()
       // Pause ongoing tasks, disable UI updates
   }
   

5. onStop(): Called when the activity is no longer visible to the user.

   kotlin
   override fun onStop() {
       super.onStop()
       // The activity is no longer visible
   }
   

6. onDestroy(): Called before the activity is destroyed.

   kotlin
   override fun onDestroy() {
       super.onDestroy()
       // Cleanup resources
   }
   

Fragment Lifecycle:

1. onAttach(): Called when the fragment is attached to its host activity.

   kotlin
   override fun onAttach(context: Context) {
       super.onAttach(context)
       // Perform initialization
   }
   

2. onCreateView(): Called to create the view hierarchy associated with the fragment.

   kotlin
   override fun onCreateView(
       inflater: LayoutInflater, container: ViewGroup?,
       savedInstanceState: Bundle?
   ): View? {
       return inflater.inflate(R.layout.fragment_example, container, false)
   }
   

3. onViewCreated(): Called immediately after onCreateView().

   kotlin
   override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
       super.onViewCreated(view, savedInstanceState)
       // Initialize view components
   }
   

4. onDestroyView(): Called when the view hierarchy associated with the fragment is being removed.

   kotlin
   override fun onDestroyView() {
       super.onDestroyView()
       // Cleanup view resources
   }
   

5. onDetach(): Called when the fragment is detached from its host activity.

   kotlin
   override fun onDetach() {
       super.onDetach()
       // Cleanup references
   }
   

Navigating Between Screens:

• Using Intents:

  kotlin
  val intent = Intent(this, SecondActivity::class.java)
  intent.putExtra("key", "value")
  startActivity(intent)
  

• Passing Data Between Activities:

  kotlin
  val value = intent.getStringExtra("key")
  

• Fragment Transactions:

  kotlin
  val fragment = ExampleFragment()
  supportFragmentManager.beginTransaction()
      .replace(R.id.fragment_container, fragment)
      .addToBackStack(null)
      .commit()
  

ViewController Lifecycle in iOS

ViewControllers manage the user interface and interact with the underlying data model in iOS applications.

ViewController Lifecycle:

1. viewDidLoad(): Called when the view is loaded into memory. Initialize views and data.

   swift
   override func viewDidLoad() {
       super.viewDidLoad()
       // Initialize components
   }
   

2. viewWillAppear(): Called just before the view appears on the screen.

   swift
   override func viewWillAppear(_ animated: Bool) {
       super.viewWillAppear(animated)
       // Update UI components
   }
   

3. viewDidAppear(): Called when the view has fully appeared on the screen.

   swift
   override func viewDidAppear(_ animated: Bool) {
       super.viewDidAppear(animated)
       // Start animations, tasks
   }
   

4. viewWillDisappear(): Called just before the view disappears from the screen.

   swift
   override func viewWillDisappear(_ animated: Bool) {
       super.viewWillDisappear(animated)
       // Save state, stop tasks
   }
   

5. viewDidDisappear(): Called when the view has disappeared from the screen.

   swift
   override func viewDidDisappear(_ animated: Bool) {
       super.viewDidDisappear(animated)
       // Clean up resources
   }
   

Navigating Between Screens:

• Using Segues:

  • Create segues in the storyboard and use prepare(for:sender:) to pass data.

    swift
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        if segue.identifier == "showDetail" {
            let detailVC = segue.destination as! DetailViewController
            detailVC.data = "value"
        }
    }
    

• Programmatically Navigating:

  swift
  let detailVC = storyboard?.instantiateViewController(withIdentifier: "DetailViewController") as! DetailViewController
  detailVC.data = "value"
  navigationController?.pushViewController(detailVC, animated: true)
  

Additional Tips:

• Lifecycle Awareness:

  • Be aware of the different states of activities/fragments and view controllers to manage resources effectively.
  • Use lifecycle-aware components in Android (e.g., ViewModel, LiveData) to handle data during configuration changes.

• Navigation Patterns:

  • Follow platform-specific navigation patterns for a consistent user experience.
  • Use Android Navigation Component for more complex navigation structures.
  • Use UINavigationController for hierarchical navigation in iOS.

• Passing Data:

  • Ensure data is passed securely and efficiently between different screens.
  • Use bundles or shared ViewModels in Android and properties or dependency injection in iOS.

By mastering the lifecycle of activities, fragments, and view controllers, and understanding navigation patterns, you'll be able to build robust and user-friendly mobile applications. Practice managing lifecycle events and implementing navigation to enhance your app development skills.