IT. Expert System.

Android Reference

DialogFragment


android.app

Class DialogFragment

  • All Implemented Interfaces:
    ComponentCallbacks, ComponentCallbacks2, DialogInterface.OnCancelListener, DialogInterface.OnDismissListener, View.OnCreateContextMenuListener

    public class DialogFragment
extends Fragment
implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener
    A fragment that displays a dialog window, floating on top of its activity's window. This fragment contains a Dialog object, which it displays as appropriate based on the fragment's state. Control of the dialog (deciding when to show, hide, dismiss it) should be done through the API here, not with direct calls on the dialog.

    Implementations should override this class and implement Fragment.onCreateView(LayoutInflater, ViewGroup, Bundle) to supply the content of the dialog. Alternatively, they can override onCreateDialog(Bundle) to create an entirely custom dialog, such as an AlertDialog, with its own content.

    Topics covered here:

    1. Lifecycle
    2. Basic Dialog
    3. Alert Dialog
    4. Selecting Between Dialog or Embedding

    Lifecycle

    DialogFragment does various things to keep the fragment's lifecycle driving it, instead of the Dialog. Note that dialogs are generally autonomous entities -- they are their own window, receiving their own input events, and often deciding on their own when to disappear (by receiving a back key event or the user clicking on a button).

    DialogFragment needs to ensure that what is happening with the Fragment and Dialog states remains consistent. To do this, it watches for dismiss events from the dialog and takes care of removing its own state when they happen. This means you should use show(FragmentManager, String) or show(FragmentTransaction, String) to add an instance of DialogFragment to your UI, as these keep track of how DialogFragment should remove itself when the dialog is dismissed.

    Basic Dialog

    The simplest use of DialogFragment is as a floating container for the fragment's view hierarchy. A simple implementation may look like this:

    An example showDialog() method on the Activity could be:

    This removes any currently shown dialog, creates a new DialogFragment with an argument, and shows it as a new state on the back stack. When the transaction is popped, the current DialogFragment and its Dialog will be destroyed, and the previous one (if any) re-shown. Note that in this case DialogFragment will take care of popping the transaction of the Dialog is dismissed separately from it.

    Alert Dialog

    Instead of (or in addition to) implementing Fragment.onCreateView(android.view.LayoutInflater, android.view.ViewGroup, android.os.Bundle) to generate the view hierarchy inside of a dialog, you may implement onCreateDialog(Bundle) to create your own custom Dialog object.

    This is most useful for creating an AlertDialog, allowing you to display standard alerts to the user that are managed by a fragment. A simple example implementation of this is:

    The activity creating this fragment may have the following methods to show the dialog and receive results from it:

    Note that in this case the fragment is not placed on the back stack, it is just added as an indefinitely running fragment. Because dialogs normally are modal, this will still operate as a back stack, since the dialog will capture user input until it is dismissed. When it is dismissed, DialogFragment will take care of removing itself from its fragment manager.

    Selecting Between Dialog or Embedding

    A DialogFragment can still optionally be used as a normal fragment, if desired. This is useful if you have a fragment that in some cases should be shown as a dialog and others embedded in a larger UI. This behavior will normally be automatically selected for you based on how you are using the fragment, but can be customized with setShowsDialog(boolean).

    For example, here is a simple dialog fragment:

    An instance of this fragment can be created and shown as a dialog:

    It can also be added as content in a view hierarchy:

    • Constructor Detail

      • DialogFragment

        public DialogFragment()

    • Method Detail

      • 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 - Selects a standard style: may be STYLE_NORMAL, STYLE_NO_TITLE, STYLE_NO_FRAME, or STYLE_NO_INPUT.
        theme - 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 back stack. When the fragment is dismissed, a new transaction will be executed to remove it from the activity.
        Parameters:
        manager - The FragmentManager this fragment will be added to.
        tag - 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 - An existing transaction in which to add the fragment.
        tag - The tag for this fragment, as per FragmentTransaction.add.
        Returns:
        Returns the identifier of the committed transaction, as per FragmentTransaction.commit().

      • 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.

      • getDialog

        public Dialog getDialog()

      • getTheme

        public int getTheme()

      • 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 - 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 in onActivityCreated(Bundle), 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.

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

      • onStart

        public void onStart()
        Description copied from class: Fragment
        Called when the Fragment is visible to the user. This is generally tied to Activity.onStart of the containing Activity's lifecycle.
        Overrides:
        onStart in class Fragment

      • onStop

        public void onStop()
        Description copied from class: Fragment
        Called when the Fragment is no longer started. This is generally tied to Activity.onStop of the containing Activity's lifecycle.
        Overrides:
        onStop in class Fragment

      • dump

        public void dump(String prefix,
        FileDescriptor fd,
        PrintWriter writer,
        String[] args)
        Description copied from class: Fragment
        Print the Fragments's state into the given stream.
        Overrides:
        dump in class Fragment
        Parameters:
        prefix - Text to print at the front of each line.
        fd - The raw file descriptor that the dump is being sent to.
        writer - The PrintWriter to which you should dump your state. This will be closed for you after you return.
        args - additional arguments to the dump request.


Content

Android Reference

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)

SQL

HTML

PHP

CSS

Java Script

MYSQL

JQUERY

VBS

REGEX

C

C++

C#

Design patterns

RFC (standard status)

RFC (proposed standard status)

RFC (draft standard status)

RFC (informational status)

RFC (experimental status)

RFC (best current practice status)

RFC (historic status)

RFC (unknown status)

IT dictionary

License.
All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
Copyright 2016 © ELTASK.COM. All rights reserved.
Site is optimized for mobile devices.
Downloads: 1641 / 96490140. Delta: 0.06440 с