Summary: Constants | Ctors | Methods | Inherited Methods

DialogFragment

Kotlin |Java

public class DialogFragment
extends Fragment implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener

java.lang.Object
↳	androidx.fragment.app.Fragment
	↳	androidx.fragment.app.DialogFragment

Known direct subclasses

AppCompatDialogFragment, MediaRouteChooserDialogFragment, MediaRouteControllerDialogFragment, PreferenceDialogFragmentCompat

AppCompatDialogFragment	A special version of `DialogFragment` which uses an `AppCompatDialog` in place of a platform-styled dialog.
MediaRouteChooserDialogFragment	Media route chooser dialog fragment.
MediaRouteControllerDialogFragment	Media route controller dialog fragment.
PreferenceDialogFragmentCompat	Abstract base class which presents a dialog associated with a `DialogPreference`.

Known indirect subclasses

EditTextPreferenceDialogFragmentCompat, ListPreferenceDialogFragmentCompat, MultiSelectListPreferenceDialogFragmentCompat

EditTextPreferenceDialogFragmentCompat
ListPreferenceDialogFragmentCompat
MultiSelectListPreferenceDialogFragmentCompat

Static library support version of the framework's DialogFragment. Used to write apps that run on platforms prior to Android 3.0. When running on Android 3.0 or above, this implementation is still used; it does not try to switch to the framework's implementation. See the framework SDK documentation for a class overview.

Summary

Constants
`int`	`STYLE_NORMAL` Style for `setStyle(int, int)`: a basic, normal dialog.
`int`	`STYLE_NO_FRAME` Style for `setStyle(int, int)`: don't draw any frame at all; the view hierarchy returned by `Fragment.onCreateView(LayoutInflater, ViewGroup, Bundle)` is entirely responsible for drawing the dialog.
`int`	`STYLE_NO_INPUT` Style for `setStyle(int, int)`: like `STYLE_NO_FRAME`, but also disables all input to the dialog.
`int`	`STYLE_NO_TITLE` Style for `setStyle(int, int)`: don't include a title area.

Public constructors
`DialogFragment()` Constructor used by the default `FragmentFactory`.
`DialogFragment(int contentLayoutId)` Alternate constructor that can be called from your default, no argument constructor to provide a default layout that will be inflated by `Fragment.onCreateView(LayoutInflater, ViewGroup, Bundle)`.

Public methods
`void`	`dismiss()` Dismiss the fragment and its dialog.
`void`	`dismissAllowingStateLoss()` Version of `dismiss()` that uses `FragmentTransaction.commitAllowingStateLoss()`.
`Dialog`	`getDialog()` Return the `Dialog` this fragment is currently controlling.
`boolean`	`getShowsDialog()` Return the current value of `setShowsDialog(boolean)`.
`int`	`getTheme()`
`boolean`	`isCancelable()` Return the current value of `setCancelable(boolean)`.
`void`	`onAttach(Context context)` Called when a fragment is first attached to its context.
`void`	`onCancel(DialogInterface dialog)`
`void`	`onCreate(Bundle savedInstanceState)` Called to do initial creation of a fragment.
`Dialog`	`onCreateDialog(Bundle savedInstanceState)` Override to build your own custom Dialog container.
`void`	`onDestroyView()` Remove dialog.
`void`	`onDetach()` Called when the fragment is no longer attached to its activity.
`void`	`onDismiss(DialogInterface dialog)`
`LayoutInflater`	`onGetLayoutInflater(Bundle savedInstanceState)` Returns the LayoutInflater used to inflate Views of this Fragment. If this is called from within `onCreateDialog(Bundle)`, the layout inflater from `Fragment.onGetLayoutInflater(Bundle)`, without the dialog theme, will be returned.
`void`	`onSaveInstanceState(Bundle outState)` Called to ask the fragment to save its current dynamic state, so it can later be reconstructed in a new instance if its process is restarted.
`void`	`onStart()` Called when the Fragment is visible to the user.
`void`	`onStop()` Called when the Fragment is no longer started.
`void`	`onViewStateRestored(Bundle savedInstanceState)` Called when all saved state has been restored into the view hierarchy of the fragment.
`final Dialog`	`requireDialog()` Return the `Dialog` this fragment is currently controlling.
`void`	`setCancelable(boolean cancelable)` Control whether the shown Dialog is cancelable.
`void`	`setShowsDialog(boolean showsDialog)` Controls whether this fragment should be shown in a dialog.
`void`	`setStyle(int style, int theme)` Call to customize the basic appearance and behavior of the fragment's dialog.
`void`	`show(FragmentManager manager, String tag)` Display the dialog, adding the fragment to the given FragmentManager.
`int`	`show(FragmentTransaction transaction, String tag)` Display the dialog, adding the fragment using an existing transaction and then `committing` the transaction.
`void`	`showNow(FragmentManager manager, String tag)` Display the dialog, immediately adding the fragment to the given FragmentManager.

Inherited methods

From class


        
          androidx.fragment.app.Fragment

`void`	`dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args)` Print the Fragments's state into the given stream.
`final boolean`	`equals(Object o)` Subclasses can not override equals().
`final FragmentActivity`	`getActivity()` Return the `FragmentActivity` this fragment is currently associated with.
`boolean`	`getAllowEnterTransitionOverlap()` Returns whether the the exit transition and enter transition overlap or not.
`boolean`	`getAllowReturnTransitionOverlap()` Returns whether the the return transition and reenter transition overlap or not.
`final Bundle`	`getArguments()` Return the arguments supplied when the fragment was instantiated, if any.
`final FragmentManager`	`getChildFragmentManager()` Return a private FragmentManager for placing and managing Fragments inside of this Fragment.
`Context`	`getContext()` Return the `Context` this fragment is currently associated with.
`ViewModelProvider.Factory`	`getDefaultViewModelProviderFactory()` Returns the default `ViewModelProvider.Factory` that should be used when no custom `Factory` is provided to the `ViewModelProvider` constructors. The `Fragment's arguments` when this is first called will be used as the defaults to any `SavedStateHandle` passed to a view model created using this factory.
`Object`	`getEnterTransition()` Returns the Transition that will be used to move Views into the initial scene.
`Object`	`getExitTransition()` Returns the Transition that will be used to move Views out of the scene when the fragment is removed, hidden, or detached when not popping the back stack.
`final FragmentManager`	`getFragmentManager()` This method is deprecated. This has been removed in favor of `getParentFragmentManager()` which throws an `IllegalStateException` if the FragmentManager is null. Check if `isAdded()` returns `false` to determine if the FragmentManager is `null`.
`final Object`	`getHost()` Return the host object of this fragment.
`final int`	`getId()` Return the identifier this fragment is known by.
`final LayoutInflater`	`getLayoutInflater()` Returns the cached LayoutInflater used to inflate Views of this Fragment.
`Lifecycle`	`getLifecycle()` Returns the Lifecycle of the provider. Overriding this method is no longer supported and this method will be made `final` in a future version of Fragment.
`LoaderManager`	`getLoaderManager()` This method is deprecated. Use `LoaderManager.getInstance(this)`.
`final Fragment`	`getParentFragment()` Returns the parent Fragment containing this Fragment.
`final FragmentManager`	`getParentFragmentManager()` Return the FragmentManager for interacting with fragments associated with this fragment's activity.
`Object`	`getReenterTransition()` Returns the Transition that will be used to move Views in to the scene when returning due to popping a back stack.
`final Resources`	`getResources()` Return `requireActivity().getResources()`.
`final boolean`	`getRetainInstance()` This method is deprecated. Instead of retaining the Fragment itself, use a non-retained Fragment and keep retained state in a ViewModel attached to that Fragment. The ViewModel's constructor and its onCleared() callback provide the signal for initial creation and final destruction of the retained state.
`Object`	`getReturnTransition()` Returns the Transition that will be used to move Views out of the scene when the Fragment is preparing to be removed, hidden, or detached because of popping the back stack.
`final SavedStateRegistry`	`getSavedStateRegistry()` Returns owned `SavedStateRegistry`
`Object`	`getSharedElementEnterTransition()` Returns the Transition that will be used for shared elements transferred into the content Scene.
`Object`	`getSharedElementReturnTransition()` Return the Transition that will be used for shared elements transferred back during a pop of the back stack.
`final String`	`getString(int resId, Object... formatArgs)` Return a localized formatted string from the application's package's default string table, substituting the format arguments as defined in `Formatter` and `String.format(String, Object...)`.
`final String`	`getString(int resId)` Return a localized string from the application's package's default string table.
`final String`	`getTag()` Get the tag name of the fragment, if specified.
`final Fragment`	`getTargetFragment()` This method is deprecated. Instead of using a target fragment to pass results, use `FragmentManager.setFragmentResult(String, Bundle)` to deliver results to `FragmentResultListener` instances registered by other fragments via `FragmentManager.setFragmentResultListener(String, LifecycleOwner, FragmentResultListener)`.
`final int`	`getTargetRequestCode()` This method is deprecated. When using the target fragment replacement of `FragmentManager.setFragmentResultListener(String, LifecycleOwner, FragmentResultListener)` and `FragmentManager.setFragmentResult(String, Bundle)`, consider using `setArguments(Bundle)` to pass a `requestKey` if you need to support dynamic request keys.
`final CharSequence`	`getText(int resId)` Return a localized, styled CharSequence from the application's package's default string table.
`boolean`	`getUserVisibleHint()` This method is deprecated. Use `FragmentTransaction.setMaxLifecycle(Fragment, Lifecycle.State)` instead.
`View`	`getView()` Get the root view for the fragment's layout (the one returned by `onCreateView(LayoutInflater, ViewGroup, Bundle)`), if provided.
`LifecycleOwner`	`getViewLifecycleOwner()` Get a `LifecycleOwner` that represents the `Fragment's View` lifecycle.
`LiveData<LifecycleOwner>`	`getViewLifecycleOwnerLiveData()` Retrieve a `LiveData` which allows you to observe the `lifecycle of the Fragment's View`.
`ViewModelStore`	`getViewModelStore()` Returns the `ViewModelStore` associated with this Fragment Overriding this method is no longer supported and this method will be made `final` in a future version of Fragment.
`final int`	`hashCode()` Subclasses can not override hashCode().
`static Fragment`	`instantiate(Context context, String fname)` This method is deprecated. Use `FragmentManager.getFragmentFactory()` and `FragmentFactory.instantiate(ClassLoader, String)`
`static Fragment`	`instantiate(Context context, String fname, Bundle args)` This method is deprecated. Use `FragmentManager.getFragmentFactory()` and `FragmentFactory.instantiate(ClassLoader, String)`, manually calling `setArguments(Bundle)` on the returned Fragment.
`final boolean`	`isAdded()` Return true if the fragment is currently added to its activity.
`final boolean`	`isDetached()` Return true if the fragment has been explicitly detached from the UI.
`final boolean`	`isHidden()` Return true if the fragment has been hidden.
`final boolean`	`isInLayout()` Return true if the layout is included as part of an activity view hierarchy via the <fragment> tag.
`final boolean`	`isRemoving()` Return true if this fragment is currently being removed from its activity.
`final boolean`	`isResumed()` Return true if the fragment is in the resumed state.
`final boolean`	`isStateSaved()` Returns true if this fragment is added and its state has already been saved by its host.
`final boolean`	`isVisible()` Return true if the fragment is currently visible to the user.
`void`	`onActivityCreated(Bundle savedInstanceState)` This method is deprecated. use `onViewCreated(View, Bundle)` for code touching the Fragment's view and `onCreate(Bundle)` for other initialization. To get a callback specifically when a Fragment activity's `Activity.onCreate(Bundle)` is called, register a `LifecycleObserver` on the Activity's `Lifecycle` in `onAttach(Context)`, removing it when it receives the `Lifecycle.State.CREATED` callback.
`void`	`onActivityResult(int requestCode, int resultCode, Intent data)` This method is deprecated. use `registerForActivityResult(ActivityResultContract, ActivityResultCallback)` with the appropriate `ActivityResultContract` and handling the result in the `callback`.
`void`	`onAttach(Activity activity)` This method is deprecated. See `onAttach(Context)`.
`void`	`onAttach(Context context)` Called when a fragment is first attached to its context.
`void`	`onAttachFragment(Fragment childFragment)` This method is deprecated. The responsibility for listening for fragments being attached has been moved to FragmentManager. You can add a listener to `getChildFragmentManager()` the child FragmentManager} by calling `FragmentManager.addFragmentOnAttachListener(FragmentOnAttachListener)` in `onAttach(Context)` to get callbacks when a child fragment is attached.
`void`	`onConfigurationChanged(Configuration newConfig)`
`boolean`	`onContextItemSelected(MenuItem item)` This hook is called whenever an item in a context menu is selected.
`void`	`onCreate(Bundle savedInstanceState)` Called to do initial creation of a fragment.
`Animation`	`onCreateAnimation(int transit, boolean enter, int nextAnim)` Called when a fragment loads an animation.
`Animator`	`onCreateAnimator(int transit, boolean enter, int nextAnim)` Called when a fragment loads an animator.
`void`	`onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo)` Called when a context menu for the `view` is about to be shown.
`void`	`onCreateOptionsMenu(Menu menu, MenuInflater inflater)` Initialize the contents of the Fragment host's standard options menu.
`View`	`onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)` Called to have the fragment instantiate its user interface view.
`void`	`onDestroy()` Called when the fragment is no longer in use.
`void`	`onDestroyOptionsMenu()` Called when this fragment's option menu items are no longer being included in the overall options menu.
`void`	`onDestroyView()` Called when the view previously created by `onCreateView(LayoutInflater, ViewGroup, Bundle)` has been detached from the fragment.
`void`	`onDetach()` Called when the fragment is no longer attached to its activity.
`LayoutInflater`	`onGetLayoutInflater(Bundle savedInstanceState)` Returns the LayoutInflater used to inflate Views of this Fragment.
`void`	`onHiddenChanged(boolean hidden)` Called when the hidden state (as returned by `isHidden()` of the fragment has changed.
`void`	`onInflate(Activity activity, AttributeSet attrs, Bundle savedInstanceState)` This method is deprecated. See `onInflate(Context, AttributeSet, Bundle)`.
`void`	`onInflate(Context context, AttributeSet attrs, Bundle savedInstanceState)` Called when a fragment is being created as part of a view layout inflation, typically from setting the content view of an activity.
`void`	`onLowMemory()`
`void`	`onMultiWindowModeChanged(boolean isInMultiWindowMode)` Called when the Fragment's activity changes from fullscreen mode to multi-window mode and visa-versa.
`boolean`	`onOptionsItemSelected(MenuItem item)` This hook is called whenever an item in your options menu is selected.
`void`	`onOptionsMenuClosed(Menu menu)` This hook is called whenever the options menu is being closed (either by the user canceling the menu with the back/menu button, or when an item is selected).
`void`	`onPause()` Called when the Fragment is no longer resumed.
`void`	`onPictureInPictureModeChanged(boolean isInPictureInPictureMode)` Called by the system when the activity changes to and from picture-in-picture mode.
`void`	`onPrepareOptionsMenu(Menu menu)` Prepare the Fragment host's standard options menu to be displayed.
`void`	`onPrimaryNavigationFragmentChanged(boolean isPrimaryNavigationFragment)` Callback for when the primary navigation state of this Fragment has changed.
`void`	`onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults)` This method is deprecated. use `registerForActivityResult(ActivityResultContract, ActivityResultCallback)` passing in a `ActivityResultContracts.RequestMultiplePermissions` object for the `ActivityResultContract` and handling the result in the `callback`.
`void`	`onResume()` Called when the fragment is visible to the user and actively running.
`void`	`onSaveInstanceState(Bundle outState)` Called to ask the fragment to save its current dynamic state, so it can later be reconstructed in a new instance if its process is restarted.
`void`	`onStart()` Called when the Fragment is visible to the user.
`void`	`onStop()` Called when the Fragment is no longer started.
`void`	`onViewCreated(View view, Bundle savedInstanceState)` Called immediately after `onCreateView(LayoutInflater, ViewGroup, Bundle)` has returned, but before any saved state has been restored in to the view.
`void`	`onViewStateRestored(Bundle savedInstanceState)` Called when all saved state has been restored into the view hierarchy of the fragment.
`void`	`postponeEnterTransition()` Postpone the entering Fragment transition until `startPostponedEnterTransition()` or `FragmentManager.executePendingTransactions()` has been called.
`final void`	`postponeEnterTransition(long duration, TimeUnit timeUnit)` Postpone the entering Fragment transition for a given amount of time and then call `startPostponedEnterTransition()`.
`final <I, O> ActivityResultLauncher<I>`	`registerForActivityResult(ActivityResultContract<I, O> contract, ActivityResultCallback<O> callback)` Register a request to `start an activity for result`, designated by the given `contract`. If the host of this fragment is an `ActivityResultRegistryOwner` the `ActivityResultRegistry` of the host will be used.
`final <I, O> ActivityResultLauncher<I>`	`registerForActivityResult(ActivityResultContract<I, O> contract, ActivityResultRegistry registry, ActivityResultCallback<O> callback)` Register a request to `start an activity for result`, designated by the given `contract`.
`void`	`registerForContextMenu(View view)` Registers a context menu to be shown for the given view (multiple views can show the context menu).
`final void`	`requestPermissions(String[] permissions, int requestCode)` This method is deprecated. use `registerForActivityResult(ActivityResultContract, ActivityResultCallback)` passing in a `ActivityResultContracts.RequestMultiplePermissions` object for the `ActivityResultContract` and handling the result in the `callback`.
`final FragmentActivity`	`requireActivity()` Return the `FragmentActivity` this fragment is currently associated with.
`final Bundle`	`requireArguments()` Return the arguments supplied when the fragment was instantiated.
`final Context`	`requireContext()` Return the `Context` this fragment is currently associated with.
`final FragmentManager`	`requireFragmentManager()` This method is deprecated. This has been renamed to `getParentFragmentManager()` to make it clear that you are accessing the FragmentManager that contains this Fragment and not the FragmentManager associated with child Fragments.
`final Object`	`requireHost()` Return the host object of this fragment.
`final Fragment`	`requireParentFragment()` Returns the parent Fragment containing this Fragment.
`final View`	`requireView()` Get the root view for the fragment's layout (the one returned by `onCreateView(LayoutInflater, ViewGroup, Bundle)`).
`void`	`setAllowEnterTransitionOverlap(boolean allow)` Sets whether the the exit transition and enter transition overlap or not.
`void`	`setAllowReturnTransitionOverlap(boolean allow)` Sets whether the the return transition and reenter transition overlap or not.
`void`	`setArguments(Bundle args)` Supply the construction arguments for this fragment.
`void`	`setEnterSharedElementCallback(SharedElementCallback callback)` When custom transitions are used with Fragments, the enter transition callback is called when this Fragment is attached or detached when not popping the back stack.
`void`	`setEnterTransition(Object transition)` Sets the Transition that will be used to move Views into the initial scene.
`void`	`setExitSharedElementCallback(SharedElementCallback callback)` When custom transitions are used with Fragments, the exit transition callback is called when this Fragment is attached or detached when popping the back stack.
`void`	`setExitTransition(Object transition)` Sets the Transition that will be used to move Views out of the scene when the fragment is removed, hidden, or detached when not popping the back stack.
`void`	`setHasOptionsMenu(boolean hasMenu)` Report that this fragment would like to participate in populating the options menu by receiving a call to `onCreateOptionsMenu(Menu, MenuInflater)` and related methods.
`void`	`setInitialSavedState(Fragment.SavedState state)` Set the initial saved state that this Fragment should restore itself from when first being constructed, as returned by `FragmentManager.saveFragmentInstanceState`.
`void`	`setMenuVisibility(boolean menuVisible)` Set a hint for whether this fragment's menu should be visible.
`void`	`setReenterTransition(Object transition)` Sets the Transition that will be used to move Views in to the scene when returning due to popping a back stack.
`void`	`setRetainInstance(boolean retain)` This method is deprecated. Instead of retaining the Fragment itself, use a non-retained Fragment and keep retained state in a ViewModel attached to that Fragment. The ViewModel's constructor and its onCleared() callback provide the signal for initial creation and final destruction of the retained state.
`void`	`setReturnTransition(Object transition)` Sets the Transition that will be used to move Views out of the scene when the Fragment is preparing to be removed, hidden, or detached because of popping the back stack.
`void`	`setSharedElementEnterTransition(Object transition)` Sets the Transition that will be used for shared elements transferred into the content Scene.
`void`	`setSharedElementReturnTransition(Object transition)` Sets the Transition that will be used for shared elements transferred back during a pop of the back stack.
`void`	`setTargetFragment(Fragment fragment, int requestCode)` This method is deprecated. Instead of using a target fragment to pass results, the fragment requesting a result should use `FragmentManager.setFragmentResultListener(String, LifecycleOwner, FragmentResultListener)` to register a `FragmentResultListener` with a `requestKey` using its `parent fragment manager`. The fragment delivering a result should then call `FragmentManager.setFragmentResult(String, Bundle)` using the same `requestKey`. Consider using `setArguments(Bundle)` to pass the `requestKey` if you need to support dynamic request keys.
`void`	`setUserVisibleHint(boolean isVisibleToUser)` This method is deprecated. If you are manually calling this method, use `FragmentTransaction.setMaxLifecycle(Fragment, Lifecycle.State)` instead. If overriding this method, behavior implemented when passing in `true` should be moved to `onResume()`, and behavior implemented when passing in `false` should be moved to `onPause()`.
`boolean`	`shouldShowRequestPermissionRationale(String permission)` Gets whether you should show UI with rationale before requesting a permission.
`void`	`startActivity(Intent intent)` Call `Activity.startActivity(Intent)` from the fragment's containing Activity.
`void`	`startActivity(Intent intent, Bundle options)` Call `Activity.startActivity(Intent, Bundle)` from the fragment's containing Activity.
`void`	`startActivityForResult(Intent intent, int requestCode)` This method is deprecated. use `registerForActivityResult(ActivityResultContract, ActivityResultCallback)` passing in a `ActivityResultContracts.StartActivityForResult` object for the `ActivityResultContract`.
`void`	`startActivityForResult(Intent intent, int requestCode, Bundle options)` This method is deprecated. use `registerForActivityResult(ActivityResultContract, ActivityResultCallback)` passing in a `ActivityResultContracts.StartActivityForResult` object for the `ActivityResultContract`.
`void`	`startIntentSenderForResult(IntentSender intent, int requestCode, Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options)` This method is deprecated. use `registerForActivityResult(ActivityResultContract, ActivityResultCallback)` passing in a `ActivityResultContracts.StartIntentSenderForResult` object for the `ActivityResultContract`.
`void`	`startPostponedEnterTransition()` Begin postponed transitions after `postponeEnterTransition()` was called.
`String`	`toString()`
`void`	`unregisterForContextMenu(View view)` Prevents a context menu to be shown for the given view.

From class


        
          java.lang.Object

`Object`	`clone()`
`boolean`	`equals(Object arg0)`
`void`	`finalize()`
`final Class<?>`	`getClass()`
`int`	`hashCode()`
`final void`	`notify()`
`final void`	`notifyAll()`
`String`	`toString()`
`final void`	`wait(long arg0, int arg1)`
`final void`	`wait(long arg0)`
`final void`	`wait()`

From interface


        
          android.content.ComponentCallbacks

`abstract void`	`onConfigurationChanged(Configuration arg0)`
`abstract void`	`onLowMemory()`

From interface


        
          android.view.View.OnCreateContextMenuListener

abstract void onCreateContextMenu(ContextMenu arg0, View arg1, ContextMenu.ContextMenuInfo arg2)

From interface


        
          androidx.lifecycle.LifecycleOwner


        abstract
        
        
        
        
        Lifecycle


      getLifecycle()

Returns the Lifecycle of the provider.

From interface


        
          androidx.lifecycle.ViewModelStoreOwner


        abstract
        
        
        
        
        ViewModelStore


      getViewModelStore()

Returns owned ViewModelStore

From interface


        
          androidx.lifecycle.HasDefaultViewModelProviderFactory


        abstract
        
        
        
        
        ViewModelProvider.Factory


      getDefaultViewModelProviderFactory()

Returns the default ViewModelProvider.Factory that should be used when no custom Factory is provided to the ViewModelProvider constructors.

From interface


        
          androidx.savedstate.SavedStateRegistryOwner


        abstract
        
        
        
        
        SavedStateRegistry


      getSavedStateRegistry()

Returns owned SavedStateRegistry

From interface


        
          androidx.activity.result.ActivityResultCaller

`abstract <I, O> ActivityResultLauncher<I>`	`registerForActivityResult(ActivityResultContract<I, O> contract, ActivityResultCallback<O> callback)` Register a request to `start an activity for result`, designated by the given `contract`.
`abstract <I, O> ActivityResultLauncher<I>`	`registerForActivityResult(ActivityResultContract<I, O> contract, ActivityResultRegistry registry, ActivityResultCallback<O> callback)` Register a request to `start an activity for result`, designated by the given `contract`.

From interface


        
          android.content.DialogInterface.OnCancelListener

abstract void onCancel(DialogInterface arg0)

From interface


        
          android.content.DialogInterface.OnDismissListener

abstract void onDismiss(DialogInterface arg0)

Constants

STYLE_NORMAL

public static final int STYLE_NORMAL

Style for setStyle(int, int): a basic, normal dialog.

Constant Value: 0 (0x00000000)

STYLE_NO_FRAME

public static final int STYLE_NO_FRAME

Style for setStyle(int, int): don't draw any frame at all; the view hierarchy returned by Fragment.onCreateView(LayoutInflater, ViewGroup, Bundle) is entirely responsible for drawing the dialog.

Constant Value: 2 (0x00000002)

STYLE_NO_INPUT

public static final int STYLE_NO_INPUT

Style for setStyle(int, int): like STYLE_NO_FRAME, but also disables all input to the dialog. The user can not touch it, and its window will not receive input focus.

Constant Value: 3 (0x00000003)

STYLE_NO_TITLE

public static final int STYLE_NO_TITLE

Style for setStyle(int, int): don't include a title area.

Constant Value: 1 (0x00000001)

Public constructors

DialogFragment

public DialogFragment ()

Constructor used by the default FragmentFactory. You must set a custom FragmentFactory if you want to use a non-default constructor to ensure that your constructor is called when the fragment is re-instantiated.

It is strongly recommended to supply arguments with Fragment.setArguments(Bundle) and later retrieved by the Fragment with Fragment.getArguments(). These arguments are automatically saved and restored alongside the Fragment.

Applications should generally not implement a constructor. Prefer onAttach(Context) instead. It is the first place application code can run where the fragment is ready to be used - the point where the fragment is actually associated with its context.

DialogFragment

public DialogFragment (int contentLayoutId)

Alternate constructor that can be called from your default, no argument constructor to provide a default layout that will be inflated by Fragment.onCreateView(LayoutInflater, ViewGroup, Bundle).

 class MyDialogFragment extends DialogFragment {
   public MyDialogFragment() {
     super(R.layout.dialog_fragment_main);
   }
 }

You must set a custom FragmentFactory if you want to use a non-default constructor to ensure that your constructor is called when the fragment is re-instantiated.

Parameters
`contentLayoutId`	`int`

See also:

Public methods

dismiss

public void dismiss ()

Dismiss the fragment and its dialog. If the fragment was added to the back stack, all back stack state up to and including this entry will be popped. Otherwise, a new transaction will be committed to remove the fragment.

dismissAllowingStateLoss

public void dismissAllowingStateLoss ()

Version of dismiss() that uses FragmentTransaction.commitAllowingStateLoss(). See linked documentation for further details.

getDialog

public Dialog getDialog ()

Return the Dialog this fragment is currently controlling.

Returns
`Dialog`

See also:

requireDialog()

getShowsDialog

public boolean getShowsDialog ()

Return the current value of setShowsDialog(boolean).

Returns
`boolean`

getTheme

public int getTheme ()

Returns
`int`

isCancelable

public boolean isCancelable ()

Return the current value of setCancelable(boolean).

Returns
`boolean`

onAttach

public void onAttach (Context context)

Called when a fragment is first attached to its context. onCreate(Bundle) will be called after this.

Parameters
`context`	`Context`

onCancel

public void onCancel (DialogInterface dialog)

Parameters
`dialog`	`DialogInterface`

onCreate

public void onCreate (Bundle savedInstanceState)

Called to do initial creation of a fragment. This is called after onAttach(Activity) and before onCreateView(LayoutInflater, ViewGroup, Bundle).

Note that this can be called while the fragment's activity is still in the process of being created. As such, you can not rely on things like the activity's content view hierarchy being initialized at this point. If you want to do work once the activity itself is created, add a LifecycleObserver on the activity's Lifecycle, removing it when it receives the Lifecycle.State.CREATED callback.

Any restored child fragments will be created before the base Fragment.onCreate method returns.

Parameters
`savedInstanceState`	`Bundle`: If the fragment is being re-created from a previous saved state, this is the state.

onCreateDialog

public Dialog onCreateDialog (Bundle savedInstanceState)

Override to build your own custom Dialog container. This is typically used to show an AlertDialog instead of a generic Dialog; when doing so, Fragment.onCreateView(LayoutInflater, ViewGroup, Bundle) does not need to be implemented since the AlertDialog takes care of its own content.

This method will be called after onCreate(Bundle) and immediately before Fragment.onCreateView(LayoutInflater, ViewGroup, Bundle). The default implementation simply instantiates and returns a Dialog class.

Note: DialogFragment own the Dialog.setOnCancelListener and Dialog.setOnDismissListener callbacks. You must not set them yourself. To find out about these events, override onCancel(DialogInterface) and onDismiss(DialogInterface).

Parameters
`savedInstanceState`	`Bundle`: The last saved instance state of the Fragment, or null if this is a freshly created Fragment.

Returns
`Dialog`	Return a new Dialog instance to be displayed by the Fragment.

onDestroyView

public void onDestroyView ()

Remove dialog.

onDetach

public void onDetach ()

Called when the fragment is no longer attached to its activity. This is called after onDestroy().

onDismiss

public void onDismiss (DialogInterface dialog)

Parameters
`dialog`	`DialogInterface`

onGetLayoutInflater

public LayoutInflater onGetLayoutInflater (Bundle savedInstanceState)

Returns the LayoutInflater used to inflate Views of this Fragment. The default implementation will throw an exception if the Fragment is not attached.

If this is called from within onCreateDialog(Bundle), the layout inflater from Fragment.onGetLayoutInflater(Bundle), without the dialog theme, will be returned.

Parameters
`savedInstanceState`	`Bundle`: If the fragment is being re-created from a previous saved state, this is the state.

Returns
`LayoutInflater`	The LayoutInflater used to inflate Views of this Fragment.

onSaveInstanceState

public void onSaveInstanceState (Bundle outState)

Called to ask the fragment to save its current dynamic state, so it can later be reconstructed in a new instance if its process is restarted. If a new instance of the fragment later needs to be created, the data you place in the Bundle here will be available in the Bundle given to onCreate(Bundle), onCreateView(LayoutInflater, ViewGroup, Bundle), and onViewCreated(View, Bundle).

This corresponds to Activity.onSaveInstanceState(Bundle) and most of the discussion there applies here as well. Note however: this method may be called at any time before onDestroy(). There are many situations where a fragment may be mostly torn down (such as when placed on the back stack with no UI showing), but its state will not be saved until its owning activity actually needs to save its state.

Parameters
`outState`	`Bundle`: Bundle in which to place your saved state.

onStart

public void onStart ()

Called when the Fragment is visible to the user. This is generally tied to Activity.onStart of the containing Activity's lifecycle.

onStop

public void onStop ()

Called when the Fragment is no longer started. This is generally tied to Activity.onStop of the containing Activity's lifecycle.

onViewStateRestored

public void onViewStateRestored (Bundle savedInstanceState)

Called when all saved state has been restored into the view hierarchy of the fragment. This can be used to do initialization based on saved state that you are letting the view hierarchy track itself, such as whether check box widgets are currently checked. This is called after onViewCreated(View, Bundle) and before onStart().

Parameters
`savedInstanceState`	`Bundle`: If the fragment is being re-created from a previous saved state, this is the state.

requireDialog

public final Dialog requireDialog ()

Return the Dialog this fragment is currently controlling.

Returns
`Dialog`

Throws
`IllegalStateException`	if the Dialog has not yet been created (before `onCreateDialog(Bundle)`) or has been destroyed (after `onDestroyView()`.

See also:

getDialog()

setCancelable

public void setCancelable (boolean cancelable)

Control whether the shown Dialog is cancelable. Use this instead of directly calling Dialog.setCancelable(boolean), because DialogFragment needs to change its behavior based on this.

Parameters
`cancelable`	`boolean`: If true, the dialog is cancelable. The default is true.

setShowsDialog

public void setShowsDialog (boolean showsDialog)

Controls whether this fragment should be shown in a dialog. If not set, no Dialog will be created and the fragment's view hierarchy will thus not be added to it. This allows you to instead use it as a normal fragment (embedded inside of its activity).

This is normally set for you based on whether the fragment is associated with a container view ID passed to FragmentTransaction.add(int, Fragment). If the fragment was added with a container, setShowsDialog will be initialized to false; otherwise, it will be true.

If calling this manually, it should be called in onCreate(Bundle) as calling it any later will have no effect.

Parameters
`showsDialog`	`boolean`: If true, the fragment will be displayed in a Dialog. If false, no Dialog will be created and the fragment's view hierarchy left undisturbed.

setStyle

public void setStyle (int style, 
                int theme)

Call to customize the basic appearance and behavior of the fragment's dialog. This can be used for some common dialog behaviors, taking care of selecting flags, theme, and other options for you. The same effect can be achieve by manually setting Dialog and Window attributes yourself. Calling this after the fragment's Dialog is created will have no effect.

Parameters
`style`	`int`: Selects a standard style: may be `STYLE_NORMAL`, `STYLE_NO_TITLE`, `STYLE_NO_FRAME`, or `STYLE_NO_INPUT`.
`theme`	`int`: Optional custom theme. If 0, an appropriate theme (based on the style) will be selected for you.

show

public void show (FragmentManager manager, 
                String tag)

Display the dialog, adding the fragment to the given FragmentManager. This is a convenience for explicitly creating a transaction, adding the fragment to it with the given tag, and committing it. This does not add the transaction to the fragment back stack. When the fragment is dismissed, a new transaction will be executed to remove it from the activity.

Parameters
`manager`	`FragmentManager`: The FragmentManager this fragment will be added to.
`tag`	`String`: The tag for this fragment, as per `FragmentTransaction.add`.

show

public int show (FragmentTransaction transaction, 
                String tag)

Display the dialog, adding the fragment using an existing transaction and then committing the transaction.

Parameters
`transaction`	`FragmentTransaction`: An existing transaction in which to add the fragment.
`tag`	`String`: The tag for this fragment, as per `FragmentTransaction.add`.

Returns
`int`	Returns the identifier of the committed transaction, as per `FragmentTransaction.commit()`.

showNow

public void showNow (FragmentManager manager, 
                String tag)

Display the dialog, immediately adding the fragment to the given FragmentManager. This is a convenience for explicitly creating a transaction, adding the fragment to it with the given tag, and calling FragmentTransaction.commitNow(). This does not add the transaction to the fragment back stack. When the fragment is dismissed, a new transaction will be executed to remove it from the activity.

Parameters
`manager`	`FragmentManager`: The FragmentManager this fragment will be added to.
`tag`	`String`: The tag for this fragment, as per `FragmentTransaction.add`.