Fragment

fun Fragment.registerForAuthenticationResult(
    resultCallback: AuthenticationResultCallback
): AuthenticationResultLauncher

Returns an AuthenticationResultLauncher that can be used to initiate authentication.

A success or error result will be delivered to AuthenticationResultCallback.onAuthResult and (one or more) failures will be delivered to AuthenticationResultCallback.onAuthAttemptFailed, which is set by resultCallback. The callback will be executed on the main thread.

This must be called unconditionally, as part of initialization path, typically as a field initializer of an Fragment.

Note that if multiple calls to this method are made within a single Fragment or Activity, only the callback registered by the last invocation will be saved and receive authentication results. This can result in unexpected behavior if you intend to manage multiple independent authentication flows. It is strongly recommended to avoid multiple calls to this method in such scenarios.

import androidx.biometric.AuthenticationRequest
import androidx.biometric.AuthenticationRequest.Biometric
import androidx.biometric.AuthenticationRequest.Companion.biometricRequest
import androidx.biometric.AuthenticationResult
import androidx.biometric.PromptContentItemBulletedText
import androidx.biometric.registerForAuthenticationResult
import androidx.fragment.app.Fragment

class MyFragmentForCredentialOnlyAuth : Fragment() {
    val requestAuthentication =
        registerForAuthenticationResult { result: AuthenticationResult ->
            when (result) {
                // Handle successful authentication
                is AuthenticationResult.Success -> {
                    Log.i(TAG, "onAuthenticationSucceeded with type ${result.authType}")
                }
                // Handle authentication error, e.g. user cancellation, lockout errors, etc
                is AuthenticationResult.Error -> {
                    Log.i(
                        TAG,
                        "onAuthenticationError " +
                            "with error code: ${result.errorCode} " +
                            "and error string: ${result.errString}",
                    )
                }
                // Handle fallback option clicks
                is AuthenticationResult.CustomFallbackSelected -> {
                    Log.i(TAG, "fallback is selected, text: ${result.fallback.text}")
                }
            }
        }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val authRequest =
            biometricRequest(title = "Title", Biometric.Fallback.DeviceCredential) {
                setSubtitle("Subtitle")
                setContent(
                    AuthenticationRequest.BodyContent.VerticalList(
                        "Vertical list description",
                        listOf(
                            PromptContentItemBulletedText("test item1"),
                            PromptContentItemBulletedText("test item2"),
                        ),
                    )
                )
                setMinStrength(Biometric.Strength.Class3(/*optional: cryptoObject*/ ))
                setIsConfirmationRequired(true)
            }

        Button(context).setOnClickListener { requestAuthentication.launch(authRequest) }
    }
}

See also
`registerForAuthenticationResult`	(Executor, AuthenticationResultCallback)

Fragment.registerForAuthenticationResult

Artifact: androidx.biometric:biometric

fun Fragment.registerForAuthenticationResult(
    callbackExecutor: Executor,
    resultCallback: AuthenticationResultCallback
): AuthenticationResultLauncher

Returns an AuthenticationResultLauncher that can be used to initiate authentication.

This must be called unconditionally, as part of initialization path, typically as a field initializer of an Fragment.

import androidx.biometric.AuthenticationRequest
import androidx.biometric.AuthenticationRequest.Biometric
import androidx.biometric.AuthenticationRequest.Companion.biometricRequest
import androidx.biometric.AuthenticationResult
import androidx.biometric.PromptContentItemBulletedText
import androidx.biometric.registerForAuthenticationResult
import androidx.fragment.app.Fragment

class MyFragmentForCredentialOnlyAuth : Fragment() {
    val requestAuthentication =
        registerForAuthenticationResult { result: AuthenticationResult ->
            when (result) {
                // Handle successful authentication
                is AuthenticationResult.Success -> {
                    Log.i(TAG, "onAuthenticationSucceeded with type ${result.authType}")
                }
                // Handle authentication error, e.g. user cancellation, lockout errors, etc
                is AuthenticationResult.Error -> {
                    Log.i(
                        TAG,
                        "onAuthenticationError " +
                            "with error code: ${result.errorCode} " +
                            "and error string: ${result.errString}",
                    )
                }
                // Handle fallback option clicks
                is AuthenticationResult.CustomFallbackSelected -> {
                    Log.i(TAG, "fallback is selected, text: ${result.fallback.text}")
                }
            }
        }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val authRequest =
            biometricRequest(title = "Title", Biometric.Fallback.DeviceCredential) {
                setSubtitle("Subtitle")
                setContent(
                    AuthenticationRequest.BodyContent.VerticalList(
                        "Vertical list description",
                        listOf(
                            PromptContentItemBulletedText("test item1"),
                            PromptContentItemBulletedText("test item2"),
                        ),
                    )
                )
                setMinStrength(Biometric.Strength.Class3(/*optional: cryptoObject*/ ))
                setIsConfirmationRequired(true)
            }

        Button(context).setOnClickListener { requestAuthentication.launch(authRequest) }
    }
}

Fragment.clearFragmentResult

fun Fragment.clearFragmentResult(requestKey: String): Unit

Clears the stored result for the given requestKey.

This clears a result that was previously set a call to setFragmentResult.

If this is called with a requestKey that is not associated with any result, this method does nothing.

Parameters
`requestKey: String`	key used to identify the result

Fragment.clearFragmentResultListener

fun Fragment.clearFragmentResultListener(requestKey: String): Unit

Clears the stored FragmentResultListener for the given requestKey.

This clears a FragmentResultListener that was previously set a call to setFragmentResultListener.

If this is called with a requestKey that is not associated with any FragmentResultListener, this method does nothing.

Parameters
`requestKey: String`	key used to identify the result

Fragment.content

Artifact: androidx.fragment:fragment-compose

fun Fragment.content(content: @Composable () -> Unit): ComposeView

Wrapper function that handles the setup for creating a custom Fragment that hosts Compose content. It automatically sets the ViewCompositionStrategy to ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed.

It should be used as part of the implementation of Fragment.onCreateView and requires a context meaning the fragment must be attached to a FragmentManager.

class ExampleFragment : Fragment() {
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ) = content {
        val viewModel: ExampleViewModel = viewModel()
        // put your @Composable content here
    }
}

Fragment.findNavController

fun Fragment.findNavController(): NavController

Find a NavController given a Fragment

Calling this on a Fragment that is not a NavHostFragment or within a NavHostFragment will result in an IllegalStateException

Fragment.setFragmentResult

fun Fragment.setFragmentResult(requestKey: String, result: Bundle): Unit

Sets the given result for the requestKey. This result will be delivered to a FragmentResultListener that is called given to setFragmentResultListener with the same requestKey. If no FragmentResultListener with the same key is set or the Lifecycle associated with the listener is not at least androidx.lifecycle.Lifecycle.State.STARTED, the result is stored until one becomes available, or clearFragmentResult is called with the same requestKey.

Parameters
`requestKey: String`	key used to identify the result
`result: Bundle`	the result to be passed to another fragment.

Fragment.setFragmentResultListener

fun Fragment.setFragmentResultListener(
    requestKey: String,
    listener: (requestKey: String, bundle: Bundle) -> Unit
): Unit

Sets the FragmentResultListener for a given requestKey. Once this Fragment is at least in the androidx.lifecycle.Lifecycle.State.STARTED state, any results set by setFragmentResult using the same requestKey will be delivered to the FragmentResultListener.onFragmentResult callback. The callback will remain active until this Fragment reaches the androidx.lifecycle.Lifecycle.State.DESTROYED state or clearFragmentResultListener is called with the same requestKey.

Parameters
`requestKey: String`	requestKey used to store the result
`listener: (requestKey: String, bundle: Bundle) -> Unit`	listener for result changes.

Fragment.navArgs

@MainThread
inline fun <Args : NavArgs> Fragment.navArgs(): NavArgsLazy<Args>

Returns a Lazy delegate to access the Fragment's arguments as an Args instance.

It is strongly recommended that this method only be used when the Fragment is created by androidx.navigation.NavController.navigate with the corresponding androidx.navigation.NavDirections object, which ensures that the required arguments are present.

class MyFragment : Fragment() {
    val args: MyFragmentArgs by navArgs()
}

This property can be accessed only after the Fragment's constructor.

Fragment.activityViewModels

@MainThread
inline fun <VM : ViewModel> Fragment.activityViewModels(
    noinline extrasProducer: (() -> CreationExtras)? = null,
    noinline factoryProducer: (() -> ViewModelProvider.Factory)? = null
): Lazy<VM>

Returns a property delegate to access parent activity's ViewModel, if factoryProducer is specified then ViewModelProvider.Factory returned by it will be used to create ViewModel first time. Otherwise, the activity's default factory will be used.

class MyFragment : Fragment() {
    val viewmodel: MyViewModel by activityViewModels()
}

This property can be accessed only after this Fragment is attached i.e., after Fragment.onAttach(), and access prior to that will result in IllegalArgumentException.

Fragment.createViewModelLazy

@MainThread
fun <VM : ViewModel> Fragment.createViewModelLazy(
    viewModelClass: KClass<VM>,
    storeProducer: () -> ViewModelStore,
    extrasProducer: () -> CreationExtras = { defaultViewModelCreationExtras },
    factoryProducer: (() -> ViewModelProvider.Factory)? = null
): Lazy<VM>

Helper method for creation of ViewModelLazy, that resolves null passed as factoryProducer to the default factory.

This method also takes a CreationExtras producer that provides default extras to the created ViewModel.

Fragment.viewModels

@MainThread
inline fun <VM : ViewModel> Fragment.viewModels(
    noinline ownerProducer: () -> ViewModelStoreOwner = { this },
    noinline extrasProducer: (() -> CreationExtras)? = null,
    noinline factoryProducer: (() -> ViewModelProvider.Factory)? = null
): Lazy<VM>

Returns a property delegate to access ViewModel by default scoped to this Fragment:

class MyFragment : Fragment() {
    val viewmodel: MyViewModel by viewModels()
}

Custom ViewModelProvider.Factory can be defined via factoryProducer parameter, factory returned by it will be used to create ViewModel:

class MyFragment : Fragment() {
    val viewmodel: MyViewModel by viewModels { myFactory }
}

Default scope may be overridden with parameter ownerProducer:

class MyFragment : Fragment() {
    val viewmodel: MyViewModel by viewModels ({requireParentFragment()})
}

This property can be accessed only after this Fragment is attached i.e., after Fragment.onAttach(), and access prior to that will result in IllegalArgumentException.

Fragment.hiltNavGraphViewModels

Artifact: androidx.hilt:hilt-navigation-fragment

@MainThread
inline fun <VM : ViewModel> Fragment.hiltNavGraphViewModels(navGraphId: @IdRes Int): Lazy<VM>

Returns a property delegate to access a HiltViewModel -annotated ViewModel scoped to a navigation graph present on the androidx.navigation.NavController back stack:

class MyFragment : Fragment() {
    val viewmodel: MainViewModel by hiltNavGraphViewModels(R.navigation.main)
}

This property can be accessed only after this NavGraph is on the NavController back stack, and an attempt access prior to that will result in an IllegalArgumentException.

Parameters
`navGraphId: @IdRes Int`	ID of a NavGraph that exists on the `androidx.navigation.NavController` back stack

Fragment.hiltNavGraphViewModels

Artifact: androidx.hilt:hilt-navigation-fragment

@MainThread
inline fun <VM : ViewModel, VMF : Any> Fragment.hiltNavGraphViewModels(
    navGraphId: @IdRes Int,
    noinline creationCallback: (VMF) -> VM
): Lazy<VM>

Returns a property delegate to access a HiltViewModel -annotated ViewModel with an @AssistedInject-annotated constructor that is scoped to a navigation graph present on the androidx.navigation.NavController back stack:

class MyFragment : Fragment() {
    val viewmodel: MainViewModel by hiltNavGraphViewModels(R.navigation.main) { factory: MainViewModelFactory ->
        factory.create(...)
    }
}

This property can be accessed only after this NavGraph is on the NavController back stack, and an attempt access prior to that will result in an IllegalArgumentException.

Parameters
`navGraphId: @IdRes Int`	ID of a NavGraph that exists on the `androidx.navigation.NavController` back stack
`noinline creationCallback: (VMF) -> VM`	callback that takes an @AssistedFactory-annotated factory and creates a HiltViewModel using @AssistedInject-annotated constructor.

Fragment.navGraphViewModels

@MainThread
inline fun <VM : ViewModel> Fragment.navGraphViewModels(
    navGraphId: @IdRes Int,
    noinline extrasProducer: (() -> CreationExtras)? = null,
    noinline factoryProducer: (() -> ViewModelProvider.Factory)? = null
): Lazy<VM>

Returns a property delegate to access a ViewModel scoped to a navigation graph present on the NavController back stack:

class MyFragment : Fragment() {
    val viewmodel: MainViewModel by navGraphViewModels(R.id.main)
}

Custom ViewModelProvider.Factory can be defined via factoryProducer parameter, factory returned by it will be used to create ViewModel:

class MyFragment : Fragment() {
    val viewmodel: MainViewModel by navGraphViewModels(R.id.main) { myFactory }
}

This property can be accessed only after this NavGraph is on the NavController back stack, and an attempt access prior to that will result in an IllegalArgumentException.

Parameters
`navGraphId: @IdRes Int`	ID of a NavGraph that exists on the `NavController` back stack
`noinline extrasProducer: (() -> CreationExtras)? = null`	lambda that will be called during initialization to return `CreationExtras`. If none is provided, this will use the extras from the `NavBackStackEntry` referenced by the `navGraphId`.
`noinline factoryProducer: (() -> ViewModelProvider.Factory)? = null`	lambda that will be called during initialization to return `ViewModelProvider.Factory`. If none is provided, this will use the factory from the `NavBackStackEntry` referenced by the `navGraphId`.

Fragment.navGraphViewModels