[Android 기초] 7. Fragment, Fragment 생명 주기, 데이터 전달 방식

 

 

 

 

1. Fragment

 

 

프래그먼트  |  Android 개발자  |  Android Developers

• 액티비티 위에서 동작하는 모듈화된 사용자 인터페이스
• 앱 UI의 재사용 가능한 부분을 나타냄 (화면 하나를 독립적으로 작동하는 부분화면 여러개로 구현)
• 단독으로 존재할 수 없으며, 반드시 액티비티 또는 다른 프래그먼트가 필요함
• 자체 레이아웃을 정의 및 관리하고 자체 수명 주기를 보유하며 자체 입력 이벤트를 처리
• 장점1. 재사용이 가능함 (한 프래그먼트의 객체는 다수의 액티비티에서 생성 가능, UI 작업량 감소)
• 장점2. 가벼움 (4대 컴포넌트처럼 안드로이드 시스템이 직접 관리하지 않고 프래그먼트 매니저가 관리)
• 프래그먼트의 뷰 계층 구조는 호스트 뷰 계층 구조의 일부가 되거나 여기에 연결
• 탐색, BottomNavigationView, ViewPager2와 같은 일부 Android Jetpack 라이브러리는 프래그먼트와 호환

 

 

 

💡 액티비티 VS 프래그먼트

• 액티비티: 시스템의 액티비티 매니저에서 인텐트를 해석해 액티비티간 데이터를 전달
• 프래그먼트: 액티비티의 프래그먼트 매니저에서 메소드로 프래그먼트간 데이터를 전달
• 액티비티로 화면을 계속 넘기는 것보다, 프래그먼트로 일부만 바꾸는 것이 자원 이용량이 적고 속도가 빠름
• 프래그먼트 사용의 장점
  1. Fragment를 사용하면 Activity를 적게 만들 수 있음
     (Fragment 공간에 View만 집어넣으면, 여러 Activity를 만들지 않아도 여러 화면을 보여 줄 수 있음)
  2. Acitivity의 복잡도를 줄임
  3. 재사용할 수 있는 레이아웃을 분리해서 관리가 가능

 

 

 

💡 프래그먼트 정의하기

class FirstFragment : Fragment() {  
    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.fragment_first, container, false)
    }

• 액티비티를 만들 때와 비슷하게, 하나의 Kotlin 파일과 하나의 XML레이아웃으로 정의
• 프래그먼트를 생성하려면 Fragment의 서브클래스(또는 이의 기존 서브클래스)를 생성
• 프래그먼트에 대해 레이아웃을 제공하려면 반드시 onCreateView() 콜백 메서드를 구현 (아래 생명주기 참고)
• inflate()함수를 통해서 xml 파일명을 입력하여 레이아웃을 로드
• 프래그먼트도 부분 화면이므로 화면에 표시될 뷰들을 정의하는 XML 파일을 /res/layout 폴더 안에 생성
• 안드로이드 스튜디오에서 File > New > Fragment > Fragment(Blank)를 이용해서 쉽게 생성 가능하다.

 

 

 

💡 프래그먼트를 정적으로 액티비티의 레이아웃 파일에 추가하기

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/fragment_container"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />
    <fragment // 레이아웃 파일에 정적 추가
        android:name="com.skmns.fragmentbasic.FirstFragment"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/fragment" />
</LinearLayout>

• 프래그먼트를 액티비티의 레이아웃 파일 안에서 선언
• <fragment> 안의 android:name 특성은 레이아웃 안에서 인스턴스화할 Fragment 클래스를 지정
• ★ [중요] 각 프래그먼트에는 액티비티가 재시작되는 경우 프래그먼트를 복구하기 위해 시스템이 사용할 수 있는 고유한 식별자가 필요하다. 프래그먼트에 ID를 제공하는 데에는 다음과 같은 세 가지 방법이 있다.
  1. 고유한 ID와 함께 android:id 속성을 제공한다.
  2. 고유한 문자열과 함께 android:tag 속성을 제공한다.
  3. 위의 두 가지 중 어느 것도 제공하지 않으면, 시스템은 컨테이너 뷰의 ID를 사용한다.

 

 

💡 프래그먼트를 동적으로 코틀린 코드에서 추가하기

build.gradle에 아래 삽입

dependencies {
    val fragment_version = "1.6.2"
  	...
    implementation("androidx.fragment:fragment-ktx:$fragment_version")
}

supportFragmentManager.commit {
            replace(R.id.frameLayout, frag)
            setReorderingAllowed(true)
            addToBackStack("")
        }

• supportFragmentManager
  사용자 상호작용에 응답해 Fragment를 추가하거나 삭제하는 등의 작업을 할 수 있게 해주는 매니저
• replace
  어느 프레임 레이아웃에 띄울 것이냐, 어떤 프래그먼트냐 설정
• setReorderingAllowed
  애니메이션과 전환이 올바르게 작동하도록 트랜잭션과 관련된 프래그먼트의 상태 변경을 최적화
• addToBackStack
  뒤로가기 버튼 클릭시 다음 액션 (이전 fragment로 가거나 앱이 종료되거나)

 

💡 사용 예시

0. 새 프래그먼트 두 개 생성
FirstFragment, SecondFragment

 

1. fragment_first.xml 수정

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:background="#F19B9B"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="프v래그먼트 1"
        android:textAllCaps="false"
        android:textSize="40sp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintBottom_toBottomOf="parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

 

 

2. fragment_second.xml 수정

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:background="#C785D3"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="프래그먼트 2"
        android:textAllCaps="false"
        android:textSize="40sp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintBottom_toBottomOf="parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

 

3. 정적으로 추가
activity_main.xml 파일을 열고, fragment를 표시할 FrameLayout과 버튼 2개 추가

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <FrameLayout
        android:id="@+id/frameLayout"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_marginStart="10dp"
        android:layout_marginEnd="10dp"
        app:layout_constraintBottom_toTopOf="@+id/fragment1_btn"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent">
    </FrameLayout>

    <Button
        android:id="@+id/fragment1_btn"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_margin="10dp"
        android:text="Frag1"
        android:textAllCaps="false"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toStartOf="@+id/fragment2_btn"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/frameLayout" />

    <Button
        android:id="@+id/fragment2_btn"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_margin="10dp"
        android:text="Frag2"
        android:textAllCaps="false"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toEndOf="@+id/fragment1_btn"
        app:layout_constraintTop_toBottomOf="@+id/frameLayout" />

</androidx.constraintlayout.widget.ConstraintLayout>

 

4. MainActivity.kt에 Fragment 추가

MainActivity.kt 예시

class MainActivity : AppCompatActivity() {

    private val binding by lazy { ActivityMainBinding.inflate(layoutInflater) }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)

        binding.apply {
            fragment1Btn.setOnClickListener{
                setFragment(FirstFragment())
            }
            fragment2Btn.setOnClickListener {
                setFragment(SecondFragment())
            }
        }
        setFragment(FirstFragment())
    }

    private fun setFragment(frag : Fragment) {
        supportFragmentManager.commit {
            replace(R.id.frameLayout, frag)
            setReorderingAllowed(true)
            addToBackStack("")
        }
    }
}

 

 

 

---

 

 

 

2. Frament Life Cycle

 

Activity Lifecycle과의 관계

 

프래그먼트(Fragment)는 안드로이드 애플리케이션의 UI 부분을 모듈화하여 재사용할 수 있도록 해주는 구성 요소이다. 프래그먼트는 자체적인 생명주기(lifecycle)를 가지며, 액티비티의 생명주기와 밀접하게 연결되어 있다. 프래그먼트의 생명주기를 이해하는 것은 안드로이드 앱을 효율적으로 관리하고, 사용자에게 부드러운 인터페이스 경험을 제공하는 데 중요하다. 따라서 프래그먼트 생명주기를 이해하고, 메모리 릭(누수)이 발생하지 않도록 코드를 작성하자.

 

 

onAttach()

• 프래그먼트가 액티비티에 연결될 때 호출
• 이 시점에서 프래그먼트는 액티비티와 아직 완전히 연결되지는 않음

 

onCreate()

• Fragment가 생성(CREATED) 된 상황
• 이 시점에는 아직 Fragment View 가 생성되지 않았기 때문에 Fragment 의 View 와 관련된 작업을 두면 안 됨
• onCreate() 콜백 시점에는 Bundle 타입으로 savedInstanceState 파라미터가 함께 제공되는데, 이는 onSaveInstanceState() 콜백 함수에 의해 저장된 Bundle 값
• savedInstanceState 파라미터는 프래그먼트가 처음 생성 됐을 때만 null 로 넘어오며, onSaveInstanceState() 함수를 재정의하지 않았더라도 그 이후 재생성부터는 non-null 값으로 넘어 옴
• 초기화 작업, 리소스 바인딩 등을 수행

 

onCreateView(), onViewCreated()

• 프래그먼트의 레이아웃을 인플레이트하는 곳
• onCreateView()의 반환값으로 정상적인 Fragment View 객체를 제공했을 때만 Fragment View 의 Lifecycle 생성
• onCreateView()를 재정의 하여 Fragment View를 직접 생성하고 inflate 할 수 있지만, LayoutId를 받는 Fragment의 생성자를 사용하여 해당 리소스 아이디 값을 통해 onCreateView() 재정의 없이도 Fragment View 를 생성할 수 있음
• onCreateView() 를 통해 반환된 View 객체는 onViewCreated() 의 파라미터로 전달
• 해당 시점에선 Fragment View의 Lifecycle 이 INITIALIZED 상태로 업데이트
• 뷰를 생성하고 레이아웃을 설정
  onViewCreated()에선 View 초기값 설정, LiveData 옵저빙, RecyclerView/ViewPager2 에 사용될 Adapter 세팅 등

 

onViewStateRestored()

• 저장해둔 모든 state 값이 Fragment의 View 계층구조에 복원 됐을 때 호출
• 여기서부터는 체크박스 위젯이 현재 체크 되어있는지 등 각 뷰의 상태값을 체크할 수 있음
• View lifecycle owner 는 이때 INITIALIZED 상태에서 CREATED 상태로 변경

 

onStart()

• Fragment가 사용자에게 보여질 준비가 되었을 때 호출
• 주로 Fragment가 attach되어있는 Activity의 onStart() 시점과 유사
• 이 시점부터는 Fragment의 child FragmentManager를 통해 FragmentTransaction을 안전하게 수행
• Fragment View 의 Lifecycle 또한 STARTED로 변경
• 필요한 리소스를 할당하거나, 애니메이션을 시작

 

onResume()

• 모든 Animator와 Transition효과가 종료되고, 프래그먼트가 사용자와 상호작용할 수 있는 상태가 되었을 때 호출
• 주로 Fragment가 attach되어있는 Activity의 onResume() 시점과 유사
• 사용자가 프래그먼트와 상호작용 하기에 적절한 상태
• 반대로 onResume() 이 호출되지 않은 시점에서는 입력을 시도하거나 포커스를 설정하는 등의 작업 안 됨
• 프래그먼트가 포그라운드에 있을 때 실행되는 작업을 여기서 처리

 

onPause()

• 프래그먼트가 일시정지될 때 호출
• 사용자가 Fragment 를 떠나기 시작했지만 Fragment는 여전히 visible 일 때 호출
• Fragment와 View 의 Lifecycle이 PAUSED 가 아닌 STARTED가 됨
  (엄밀히 따지면 Lifecycle 에 PAUSE 와 STOP 에 해당하는 상태가 없음)

 

onStop()

• Fragment가 더이상 화면에 보여지지 않게 될 때 호출
• 부모 액티비티나 프래그먼트가 중단됐을 때 뿐만 아니라, 부모 액티비티나 프래그먼트의 상태가 저장될 때도 호출
• Fragment 와 View 의 Lifecycle 은 CREATED 상태가 됨
• API 28 버전을 기점으로 함수 호출 순서
  ON_STOP Event -> onStop() -> (상태 저장) -> onSaveInstanceState()

 

 onDestroyView()

• 프래그먼트의 뷰와 관련된 리소스를 정리할 때 호출
• 모든 exit animation 과 transition 이 완료되고, Fragment가 화면으로부터 벗어났을 경우 호출
• Fragment View 의 Lifecycle 은 DESTROYED 상태가 됨
• 이 시점부터는 getViewLifecycleOwnerLiveData() 의 리턴값으로 null 이 반환
• 이 시점부터는 가비지 컬렉터에 의해 수거될 수 있도록 Fragment View에 대한 모든 참조가 제거되어야 함
  (아직 프래그먼트 자체는 메모리에 남아있으므로, 프래그먼트 뷰에 대한 모든 참조를 제거해야 메모리 누수 방지)

 

onDestroy()

• Fragment 가 제거되거나 FragmentManager 가 destroy 됐을 경우 호출
• 프래그먼트의 Lifecycle 은 DESTROYED 상태로 변경
• 프래그먼트의 상태를 정리하고, 모든 리소스를 해제

 

onDetach()

• 프래그먼트가 액티비티로부터 분리될 때 호출
• 프래그먼트가 액티비티와의 모든 연결을 해제

 

 

---

 

3. Fragment 데이터 전달 방식

 

• 프래그먼트 간의 데이터 전달은 안드로이드 애플리케이션의 유연성과 모듈성을 향상시키는 중요한 기능

 

 

1. Activity → Fragment

• 액티비티에서 프래그먼트로 데이터를 전달할 때
• 프래그먼트의 인스턴스를 생성하고 newInstance 메소드를 통해 데이터를 전달
• Bundle 객체를 사용하여 데이터를 프래그먼트의 인자(arguments)로 설정하고, 이 인자를 프래그먼트가 받아 사용

 

MainActivity.kt (보내는 코드)

binding.run {
            fragment1Btn.setOnClickListener{
                val dataToSend = "Hello First Fragment! \n From Activity"
                val fragment = FirstFragment.newInstance(dataToSend)
                setFragment(fragment)
            }

            fragment2Btn.setOnClickListener {
                val dataToSend = "Hello Second Fragment!\n From Activity"
                val fragment = SecondFragment.newInstance(dataToSend)
                setFragment(fragment)
            }

• Fragment1Btn 클릭 리스너 안에서 FirstFragment의 인스턴스를 생성하고,
  newInstance 메소드에 데이터를 전달하여 프래그먼트를 설정(set)
• Fragment2Btn에 대해서도 동일한 방법으로 SecondFragment에 데이터를 전달

 

FirstFragment.kt (받는 코드):

private var param1: String? = null

companion object {
        @JvmStatic
        fun newInstance(param1: String) =
            // [1] Activity -> FirstFragment
            FirstFragment().apply {
                arguments = Bundle().apply {
                    putString(ARG_PARAM1, param1)
                }
            }
}

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        // [1] Activity -> FirstFragment
        binding.tvFrag1Text.text = param1     
}

• newInstance 메소드에서 전달받은 데이터를 Bundle에 담고, 프래그먼트의 인자로 설정
• onViewCreated에서는 인자로 받은 데이터를 텍스트 뷰에 설정

 

 

2. Fragment → Fragment

• 한 프래그먼트에서 다른 프래그먼트로 데이터를 전달할 때
• 첫 번째 프래그먼트에서 두 번째 프래그먼트의 newInstance 메소드를 사용하여 인스턴스를 생성, 데이터 전달

 

FirstFragment.kt (보내는 코드)

        binding.btnGofrag2.setOnClickListener{
            val dataToSend = "Hello Fragment2! \n From Fragment1"
            val fragment2 = SecondFragment.newInstance(dataToSend)
            requireActivity().supportFragmentManager.beginTransaction()
                .replace(R.id.frameLayout, fragment2)
                .addToBackStack(null)
                .commit()
        }

• 버튼 클릭 시 SecondFragment의 새 인스턴스를 생성
• newInstance 메소드를 사용하여 데이터를 전달한 후 프래그먼트 트랜잭션을 통해 두 번째 프래그먼트를 시작

 

SecondFragment.kt (받는 코드)

private const val ARG_PARAM1 = "param1"

class SecondFragment : Fragment() {

    private var param1: String? = null

    private var _binding: FragmentSecondBinding? = null
    private val binding get() = _binding!!


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        arguments?.let {
            param1 = it.getString(ARG_PARAM1)
        }
    }

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        _binding = FragmentSecondBinding.inflate(inflater, container, false)
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.tvFrag2Text.text = param1
    }


    companion object {
        @JvmStatic
        fun newInstance(param1: String) =
            // [1] Activity -> FirstFragment
            SecondFragment().apply {
                arguments = Bundle().apply {
                    putString(ARG_PARAM1, param1)
                }
            }
    }

    override fun onDestroyView() {
        super.onDestroyView()
        // Binding 객체 해제
        _binding = null
    }
}

• newInstance 메소드로 전달받은 데이터를 Bundle에 담고, onCreate 또는 onViewCreated에서 Bundle로부터 데이터를 추출하여 사용

 

 

 

3. Fragment → Activity

• 프래그먼트에서 액티비티로 데이터를 전달할 때
• 콜백 인터페이스를 정의하고, 해당 인터페이스를 액티비티가 구현하도록 함
• 프래그먼트는 이 인터페이스를 사용하여 액티비티에 데이터를 전달

 

SecondFragment.kt (보내는 코드):

private const val ARG_PARAM1 = "param1"

interface FragmentDataListener {
    fun onDataReceived(data: String)
}

class SecondFragment : Fragment() {

    private var listener: FragmentDataListener? = null

    private var param1: String? = null

    private var _binding: FragmentSecondBinding? = null
    private val binding get() = _binding!!


    override fun onAttach(context: Context) {
        super.onAttach(context)

        if (context is FragmentDataListener) {
            listener = context
        } else {
            throw RuntimeException("$context must implement FragmentDataListener")
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        arguments?.let {
            param1 = it.getString(ARG_PARAM1)
        }
    }

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        _binding = FragmentSecondBinding.inflate(inflater, container, false)
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.tvFrag2Text.text = param1

        binding.btnSendActivity.setOnClickListener{
            val dataToSend = "Hello from SecondFragment!"
            listener?.onDataReceived(dataToSend)
        }
    }


    companion object {
        @JvmStatic
        fun newInstance(param1: String) =
            // [1] Activity -> FirstFragment
            SecondFragment().apply {
                arguments = Bundle().apply {
                    putString(ARG_PARAM1, param1)
                }
            }
    }

    override fun onDestroyView() {
        super.onDestroyView()
        // Binding 객체 해제
        _binding = null
        listener = null
    }
}

• FragmentDataListener 인터페이스를 정의하고, 프래그먼트가 액티비티에 붙을 때 (onAttach)
  액티비티가 이 인터페이스를 구현했는지 확인
• 버튼 클릭 리스너에서 onDataReceived 메소드를 호출하여 데이터를 액티비티에 전달

 

MainActivity.kt (받는 코드):

class MainActivity : AppCompatActivity(), FragmentDataListener {

    private val binding by lazy { ActivityMainBinding.inflate(layoutInflater) }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)

        binding.run {
            fragment1Btn.setOnClickListener{
                // [1] Activity -> FirstFragment
                val dataToSend = "Hello First Fragment! \n From Activity"
                val fragment = FirstFragment.newInstance(dataToSend)
                setFragment(fragment)
            }

            fragment2Btn.setOnClickListener {
                // [1] Activity -> SecondFragment
                val dataToSend = "Hello Second Fragment!\n From Activity"
                val fragment = SecondFragment.newInstance(dataToSend)
                setFragment(fragment)
            }
        }

        setFragment(FirstFragment())
    }

    private fun setFragment(frag : Fragment) {
        supportFragmentManager.commit {
            replace(R.id.frameLayout, frag)
            setReorderingAllowed(true)
            addToBackStack("")
        }
    }

    // [3] SecondFragment -> Activity
    override fun onDataReceived(data: String) {
        // Fragment에서 받은 데이터를 처리
        Toast.makeText(this, data, Toast.LENGTH_SHORT).show()
    }
}

•  MainActivity는 FragmentDataListener 인터페이스를 구현하고,
  onDataReceived 메소드를 오버라이드하여 프래그먼트로부터 데이터를 받음
• 데이터를 받으면 Toast 메시지로 표시

 

---

 

4. Fragment 데이터 전달 방식 (심화)

 

1. FragmentManager에 Bundle로 Date를 담아 전달
2. Fragment Result API를 사용하여 Data 전달
3. Fragment간 공통의 ViewModel(ex. HostActivity의 ViewModel)로 전달
4. Jetpack의 Navigation에서 제공하는 safe-args로 전달

각각의 방법에 장단점이 있으며 상황에 따라 적합한 방법 사용

 

 

FragmentManager에 Bundle로 Data를 담아 전달

• FragmentManager는 Android에서 Fragment를 관리하는 시스템 서비스
• 이 방법은 Fragment 간에 데이터를 전달하는 가장 직접적이고 기본적인 방법 중 하나
• 데이터를 전달할 Fragment에 Bundle을 생성하고, 그 안에 전달하려는 데이터를 담음
• 그 후에 setArguments() 메서드를 사용하여 Bundle을 전달하려는 Fragment에 설정
• 전달받는 Fragment에서는 getArguments() 메서드를 사용하여 Bundle을 받고, 그 안에 담긴 데이터를 추출하여 사용
• 간단하고 직관적인 방법이지만, 데이터의 유효성 검사나 복잡한 데이터 전달에는 적합하지 않음

 

Fragment Result API를 사용하여 Data 전달

• Fragment Result API는 Jetpack 라이브러리에 포함된 기능으로, Fragment 간에 데이터를 주고받는 데 사용
• 이 방법은 Fragment 간에 요청과 결과를 주고받는 메커니즘을 제공
• 데이터를 요청하는 Fragment에서는 startActivityForResult() 메서드를 사용하여 결과를 받을 Fragment를 호출
• 결과를 받는 Fragment에서는 setResult() 메서드로 결과를 설정, onActivityResult() 메서드로 결과를 처리
• requestKey는 사용하는 Fragment에서 어떤 listener에게 데이터를 전달할 지 결정하기 위한 식별자로 사용
• Fragment 간의 비동기적인 데이터 교환을 효율적으로 처리할 수 있는 방법

 

Fragment간 공통의 ViewModel(ex. HostActivity의 ViewModel)로 전달

• ViewModel은 안드로이드 아키텍처 컴포넌트 중 하나로, 데이터를 관리하고 UI와 관련된 비즈니스 로직을 처리
• Fragment들이 공유하는 ViewModel을 생성하여 그 안에 데이터를 저장하고 사용하는 방법
• Fragment들은 해당 ViewModel을 참조하여 데이터를 읽거나 쓸 수 있음
  (ViewModel은 Activity의 lifecycle보다 오래 살아있는 것이 보장되기 때문에,
  안전하게 공통의 Activity의 ViewModel을 사용하여 데이터 전달이 가능)
• 여러 Fragment 간에 데이터를 공유하고 유지하기 용이하며, 데이터의 일관성을 유지하는 데 도움이 되는 방법

 

Jetpack의 Navigation에서 제공하는 safe-args로 전달

• Jetpack의 Navigation은 Android 앱에서 화면 간의 이동을 관리하는 데 사용
• safe-args는 Navigation 그래프에서 목적지 간에 안전하게 인자를 전달하기 위한 메커니즘을 제공
• Navigation 그래프에서 각 목적지에 필요한 매개변수를 정의, safe-args 플러그인은 이를 기반으로 코드 자동 생성
• 컴파일 타임에 안전성을 보장하고,명시적으로 정의된 인자를 통해 목적지 간의 데이터 전달을 간단하고 안전하게 처리할 수 있는 방법
• Jetpack의 Navigation을 사용하는 프로젝트에서 적용하는 것을 추천

 

 

 

참고 블로그1 (링크)
참고 블로그2 (링크)