Work on DialogFragment and docs. (72778205) · Commits · e / os / android_frameworks_base

api/current.xml

+40 −3

Original line number	Diff line number	Diff line
		@@ -27469,6 +27469,17 @@
		visibility="public"
		>
		</method>
		<method name="getShowsDialog"
		return="boolean"
		abstract="false"
		native="false"
		synchronized="false"
		static="false"
		final="false"
		deprecated="not deprecated"
		visibility="public"
		>
		</method>
		<method name="getTheme"
		return="int"
		abstract="false"
		@@ -27532,6 +27543,19 @@
		<parameter name="cancelable" type="boolean">
		</parameter>
		</method>
		<method name="setShowsDialog"
		return="void"
		abstract="false"
		native="false"
		synchronized="false"
		static="false"
		final="false"
		deprecated="not deprecated"
		visibility="public"
		>
		<parameter name="showsDialog" type="boolean">
		</parameter>
		</method>
		<method name="setStyle"
		return="void"
		abstract="false"
		@@ -27554,7 +27578,7 @@
		synchronized="false"
		static="false"
		final="false"
		deprecated="not deprecated"
		deprecated="deprecated"
		visibility="public"
		>
		<parameter name="activity" type="android.app.Activity">
		@@ -27563,7 +27587,7 @@
		</parameter>
		</method>
		<method name="show"
		return="int"
		return="void"
		abstract="false"
		native="false"
		synchronized="false"
		@@ -27572,8 +27596,21 @@
		deprecated="not deprecated"
		visibility="public"
		>
		<parameter name="activity" type="android.app.Activity">
		<parameter name="manager" type="android.app.FragmentManager">
		</parameter>
		<parameter name="tag" type="java.lang.String">
		</parameter>
		</method>
		<method name="show"
		return="int"
		abstract="false"
		native="false"
		synchronized="false"
		static="false"
		final="false"
		deprecated="not deprecated"
		visibility="public"
		>
		<parameter name="transaction" type="android.app.FragmentTransaction">
		</parameter>
		<parameter name="tag" type="java.lang.String">

core/java/android/app/DialogFragment.java

+183 −16

Original line number	Diff line number	Diff line
		@@ -36,6 +36,102 @@ import android.view.WindowManager;
		* content of the dialog. Alternatively, they can override
		* {@link #onCreateDialog(Bundle)} to create an entirely custom dialog, such
		* as an AlertDialog, with its own content.
		*
		* <p>Topics covered here:
		* <ol>
		* <li><a href="#Lifecycle">Lifecycle</a>
		* <li><a href="#BasicDialog">Basic Dialog</a>
		* <li><a href="#AlertDialog">Alert Dialog</a>
		* <li><a href="#DialogOrEmbed">Selecting Between Dialog or Embedding</a>
		* </ol>
		*
		* <a name="Lifecycle"></a>
		* <h3>Lifecycle</h3>
		*
		* <p>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).
		*
		* <p>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 are of removing its own state when they
		* happen. This means you should use {@link #show(FragmentManager, String)}
		* or {@link #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.
		*
		* <a name="BasicDialog"></a>
		* <h3>Basic Dialog</h3>
		*
		* <p>The simplest use of DialogFragment is as a floating container for the
		* fragment's view hierarchy. A simple implementation may look like this:
		*
		* {@sample development/samples/ApiDemos/src/com/example/android/apis/app/FragmentDialog.java
		* dialog}
		*
		* <p>An example showDialog() method on the Activity could be:
		*
		* {@sample development/samples/ApiDemos/src/com/example/android/apis/app/FragmentDialog.java
		* add_dialog}
		*
		* <p>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.
		*
		* <a name="AlertDialog"></a>
		* <h3>Alert Dialog</h3>
		*
		* <p>Instead of (or in addition to) implementing {@link #onCreateView} to
		* generate the view hierarchy inside of a dialog, you may implement
		* {@link #onCreateDialog(Bundle)} to create your own custom Dialog object.
		*
		* <p>This is most useful for creating an {@link AlertDialog}, allowing you
		* to display standard alerts to the user that are managed by a fragment.
		* A simple example implementation of this is:
		*
		* {@sample development/samples/ApiDemos/src/com/example/android/apis/app/FragmentAlertDialog.java
		* dialog}
		*
		* <p>The activity creating this fragment may have the following methods to
		* show the dialog and receive results from it:
		*
		* {@sample development/samples/ApiDemos/src/com/example/android/apis/app/FragmentAlertDialog.java
		* activity}
		*
		* <p>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.
		*
		* <a name="DialogOrEmbed"></a>
		* <h3>Selecting Between Dialog or Embedding</h3>
		*
		* <p>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 {@link #setShowsDialog(boolean)}.
		*
		* <p>For example, here is a simple dialog fragment:
		*
		* {@sample development/samples/ApiDemos/src/com/example/android/apis/app/FragmentDialogOrActivity.java
		* dialog}
		*
		* <p>An instance of this fragment can be created and shown as a dialog:
		*
		* {@sample development/samples/ApiDemos/src/com/example/android/apis/app/FragmentDialogOrActivity.java
		* show_dialog}
		*
		* <p>It can also be added as content in a view hierarchy:
		*
		* {@sample development/samples/ApiDemos/src/com/example/android/apis/app/FragmentDialogOrActivity.java
		* embed}
		*/
		public class DialogFragment extends Fragment
		implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener {
		@@ -70,11 +166,13 @@ public class DialogFragment extends Fragment
		private static final String SAVED_STYLE = "android:style";
		private static final String SAVED_THEME = "android:theme";
		private static final String SAVED_CANCELABLE = "android:cancelable";
		private static final String SAVED_SHOWS_DIALOG = "android:showsDialog";
		private static final String SAVED_BACK_STACK_ID = "android:backStackId";

		int mStyle = STYLE_NORMAL;
		int mTheme = 0;
		boolean mCancelable = true;
		boolean mShowsDialog = true;
		int mBackStackId = -1;

		Dialog mDialog;
		@@ -109,33 +207,42 @@ public class DialogFragment extends Fragment
		}

		/**
		* Display the dialog, adding the fragment to the given activity. This
		* @deprecated Please use {@link #show(FragmentManager, String)}.
		*/
		@Deprecated
		public void show(Activity activity, String tag) {
		FragmentTransaction ft = activity.openFragmentTransaction();
		ft.add(this, tag);
		ft.commit();
		}

		/**
		* 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
		* <em>not</em> add the transaction to the back stack. When the fragment
		* is dismissed, a new transaction will be executed to remove it from
		* the activity.
		* @param activity The activity this fragment will be added to.
		* @param manager The FragmentManager this fragment will be added to.
		* @param tag The tag for this fragment, as per
		* {@link FragmentTransaction#add(Fragment, String) FragmentTransaction.add}.
		*/
		public void show(Activity activity, String tag) {
		FragmentTransaction ft = activity.openFragmentTransaction();
		public void show(FragmentManager manager, String tag) {
		FragmentTransaction ft = manager.openTransaction();
		ft.add(this, tag);
		ft.commit();
		}

		/**
		* Display the dialog, adding the fragment to the given activity using
		* an existing transaction and then committing the transaction.
		* @param activity The activity this fragment will be added to.
		* Display the dialog, adding the fragment using an existing transaction
		* and then committing the transaction.
		* @param transaction An existing transaction in which to add the fragment.
		* @param tag The tag for this fragment, as per
		* {@link FragmentTransaction#add(Fragment, String) FragmentTransaction.add}.
		* @return Returns the identifier of the committed transaction, as per
		* {@link FragmentTransaction#commit() FragmentTransaction.commit()}.
		*/
		public int show(Activity activity, FragmentTransaction transaction, String tag) {
		public int show(FragmentTransaction transaction, String tag) {
		transaction.add(this, tag);
		mRemoved = false;
		mBackStackId = transaction.commit();
		@@ -173,23 +280,67 @@ public class DialogFragment extends Fragment
		return mTheme;
		}

		/**
		* Control whether the shown Dialog is cancelable. Use this instead of
		* directly calling {@link Dialog#setCancelable(boolean)
		* Dialog.setCancelable(boolean)}, because DialogFragment needs to change
		* its behavior based on this.
		*
		* @param cancelable If true, the dialog is cancelable. The default
		* is true.
		*/
		public void setCancelable(boolean cancelable) {
		mCancelable = cancelable;
		if (mDialog != null) mDialog.setCancelable(cancelable);
		}

		/**
		* Return the current value of {@link #setCancelable(boolean)}.
		*/
		public boolean getCancelable() {
		return mCancelable;
		}

		/**
		* Controls whether this fragment should be shown in a dialog. If not
		* set, no Dialog will be created in {@link #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).
		*
		* <p>This is normally set for you based on whether the fragment is
		* associated with a container view ID passed to
		* {@link FragmentTransaction#add(int, Fragment) FragmentTransaction.add(int, Fragment)}.
		* If the fragment was added with a container, setShowsDialog will be
		* initialized to false; otherwise, it will be true.
		*
		* @param 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.
		*/
		public void setShowsDialog(boolean showsDialog) {
		mShowsDialog = showsDialog;
		}

		/**
		* Return the current value of {@link #setShowsDialog(boolean)}.
		*/
		public boolean getShowsDialog() {
		return mShowsDialog;
		}

		@Override
		public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);

		mShowsDialog = mContainerId == 0;

		if (savedInstanceState != null) {
		mStyle = savedInstanceState.getInt(SAVED_STYLE, mStyle);
		mTheme = savedInstanceState.getInt(SAVED_THEME, mTheme);
		mCancelable = savedInstanceState.getBoolean(SAVED_CANCELABLE, mCancelable);
		mBackStackId = savedInstanceState.getInt(SAVED_BACK_STACK_ID, mBackStackId);
		mStyle = savedInstanceState.getInt(SAVED_STYLE, STYLE_NORMAL);
		mTheme = savedInstanceState.getInt(SAVED_THEME, 0);
		mCancelable = savedInstanceState.getBoolean(SAVED_CANCELABLE, true);
		mShowsDialog = savedInstanceState.getBoolean(SAVED_SHOWS_DIALOG, mShowsDialog);
		mBackStackId = savedInstanceState.getInt(SAVED_BACK_STACK_ID, -1);
		}
		}

		@@ -209,6 +360,11 @@ public class DialogFragment extends Fragment
		@Override
		public void onActivityCreated(Bundle savedInstanceState) {
		super.onActivityCreated(savedInstanceState);

		if (!mShowsDialog) {
		return;
		}

		mDialog = onCreateDialog(savedInstanceState);
		mDestroyed = false;
		switch (mStyle) {
		@@ -258,11 +414,22 @@ public class DialogFragment extends Fragment
		outState.putBundle(SAVED_DIALOG_STATE_TAG, dialogState);
		}
		}
		if (mStyle != STYLE_NORMAL) {
		outState.putInt(SAVED_STYLE, mStyle);
		}
		if (mTheme != 0) {
		outState.putInt(SAVED_THEME, mTheme);
		}
		if (!mCancelable) {
		outState.putBoolean(SAVED_CANCELABLE, mCancelable);
		}
		if (!mShowsDialog) {
		outState.putBoolean(SAVED_SHOWS_DIALOG, mShowsDialog);
		}
		if (mBackStackId != -1) {
		outState.putInt(SAVED_BACK_STACK_ID, mBackStackId);
		}
		}

		@Override
		public void onStop() {

core/java/android/app/Fragment.java

+19 −0

Original line number	Diff line number	Diff line
		@@ -849,6 +849,25 @@ public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener
		mCalled = true;
		}

		/**
		* Called to ask the fragment to save its current dynamic state, so it
		* can later be reconstructed in a new instance of 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 {@link #onCreate(Bundle)},
		* {@link #onCreateView(LayoutInflater, ViewGroup, Bundle)}, and
		* {@link #onActivityCreated(Bundle)}.
		*
		* <p>This corresponds to {@link Activity#onSaveInstanceState(Bundle)
		* Activity.onnSaveInstanceState(Bundle)} and most of the discussion there
		* applies here as well. Note however: <em>this method may be called
		* at any time before {@link #onDestroy()}</em>. 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.
		*
		* @param outState Bundle in which to place your saved state.
		*/
		public void onSaveInstanceState(Bundle outState) {
		}

core/java/com/android/internal/util/HierarchicalStateMachine.java

+14 −14

Original line number	Diff line number	Diff line
		@@ -137,7 +137,7 @@ class HelloWorld extends HierarchicalStateMachine {
		}

		class State1 extends HierarchicalState {
		@Override public boolean processMessage(Message message) {
		\@Override public boolean processMessage(Message message) {
		Log.d(TAG, "Hello World");
		return HANDLED;
		}
		@@ -257,10 +257,10 @@ class Hsm1 extends HierarchicalStateMachine {
		}

		class P1 extends HierarchicalState {
		@Override public void enter() {
		\@Override public void enter() {
		Log.d(TAG, "mP1.enter");
		}
		@Override public boolean processMessage(Message message) {
		\@Override public boolean processMessage(Message message) {
		boolean retVal;
		Log.d(TAG, "mP1.processMessage what=" + message.what);
		switch(message.what) {
		@@ -278,16 +278,16 @@ class Hsm1 extends HierarchicalStateMachine {
		}
		return retVal;
		}
		@Override public void exit() {
		\@Override public void exit() {
		Log.d(TAG, "mP1.exit");
		}
		}

		class S1 extends HierarchicalState {
		@Override public void enter() {
		\@Override public void enter() {
		Log.d(TAG, "mS1.enter");
		}
		@Override public boolean processMessage(Message message) {
		\@Override public boolean processMessage(Message message) {
		Log.d(TAG, "S1.processMessage what=" + message.what);
		if (message.what == CMD_1) {
		// Transition to ourself to show that enter/exit is called
		@@ -298,16 +298,16 @@ class Hsm1 extends HierarchicalStateMachine {
		return NOT_HANDLED;
		}
		}
		@Override public void exit() {
		\@Override public void exit() {
		Log.d(TAG, "mS1.exit");
		}
		}

		class S2 extends HierarchicalState {
		@Override public void enter() {
		\@Override public void enter() {
		Log.d(TAG, "mS2.enter");
		}
		@Override public boolean processMessage(Message message) {
		\@Override public boolean processMessage(Message message) {
		boolean retVal;
		Log.d(TAG, "mS2.processMessage what=" + message.what);
		switch(message.what) {
		@@ -326,17 +326,17 @@ class Hsm1 extends HierarchicalStateMachine {
		}
		return retVal;
		}
		@Override public void exit() {
		\@Override public void exit() {
		Log.d(TAG, "mS2.exit");
		}
		}

		class P2 extends HierarchicalState {
		@Override public void enter() {
		\@Override public void enter() {
		Log.d(TAG, "mP2.enter");
		sendMessage(obtainMessage(CMD_5));
		}
		@Override public boolean processMessage(Message message) {
		\@Override public boolean processMessage(Message message) {
		Log.d(TAG, "P2.processMessage what=" + message.what);
		switch(message.what) {
		case(CMD_3):
		@@ -349,12 +349,12 @@ class Hsm1 extends HierarchicalStateMachine {
		}
		return HANDLED;
		}
		@Override public void exit() {
		\@Override public void exit() {
		Log.d(TAG, "mP2.exit");
		}
		}

		@Override
		\@Override
		void halting() {
		Log.d(TAG, "halting");
		synchronized (this) {