diff --git a/api/current.xml b/api/current.xml index 27ab9f25b6325..96ca9e9190865 100644 --- a/api/current.xml +++ b/api/current.xml @@ -16410,6 +16410,17 @@ visibility="public" > + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + CREATOR @@ -151,6 +156,7 @@ final class BackStackEntry implements FragmentTransaction, Runnable { boolean mAddToBackStack; String mName; boolean mCommitted; + int mIndex; public BackStackEntry(FragmentManager manager) { mManager = manager; @@ -289,16 +295,28 @@ final class BackStackEntry implements FragmentTransaction, Runnable { return this; } - public void commit() { + public int commit() { if (mCommitted) throw new IllegalStateException("commit already called"); if (FragmentManager.DEBUG) Log.v(TAG, "Commit: " + this); mCommitted = true; + if (mAddToBackStack) { + mIndex = mManager.allocBackStackIndex(this); + } else { + mIndex = -1; + } mManager.enqueueAction(this); + return mIndex; } public void run() { if (FragmentManager.DEBUG) Log.v(TAG, "Run: " + this); + if (mAddToBackStack) { + if (mIndex < 0) { + throw new IllegalStateException("addToBackStack() called after commit()"); + } + } + Op op = mHead; while (op != null) { switch (op.cmd) { @@ -450,6 +468,11 @@ final class BackStackEntry implements FragmentTransaction, Runnable { mManager.mActivity.invalidateOptionsMenu(); mManager.mNeedMenuInvalidate = false; } + + if (mIndex >= 0) { + mManager.freeBackStackIndex(mIndex); + mIndex = -1; + } } public String getName() { diff --git a/core/java/android/app/DialogFragment.java b/core/java/android/app/DialogFragment.java new file mode 100644 index 0000000000000..391f672823292 --- /dev/null +++ b/core/java/android/app/DialogFragment.java @@ -0,0 +1,277 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.app; + +import android.content.DialogInterface; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.view.Window; +import android.view.WindowManager; + +/** + * 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 + * {@link #onCreateView(LayoutInflater, ViewGroup, Bundle)} to supply the + * 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. + */ +public class DialogFragment extends Fragment + implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener { + + /** + * Style for {@link #DialogFragment(int, int)} constructor: a basic, + * normal dialog. + */ + public static final int STYLE_NORMAL = 0; + + /** + * Style for {@link #DialogFragment(int, int)} constructor: don't include + * a title area. + */ + public static final int STYLE_NO_TITLE = 1; + + /** + * Style for {@link #DialogFragment(int, int)} constructor: don't draw + * any frame at all; the view hierarchy returned by {@link #onCreateView} + * is entirely responsible for drawing the dialog. + */ + public static final int STYLE_NO_FRAME = 2; + + /** + * Style for {@link #DialogFragment(int, int)} constructor: like + * {@link #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. + */ + public static final int STYLE_NO_INPUT = 3; + + private static final String SAVED_DIALOG_STATE_TAG = "android:savedDialogState"; + 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_BACK_STACK_ID = "android:backStackId"; + + int mStyle = STYLE_NORMAL; + int mTheme = 0; + boolean mCancelable = true; + int mBackStackId = -1; + + Dialog mDialog; + boolean mDestroyed; + + public DialogFragment() { + } + + /** + * Constructor 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. + * + * @param style Selects a standard style: may be {@link #STYLE_NORMAL}, + * {@link #STYLE_NO_TITLE}, {@link #STYLE_NO_FRAME}, or + * {@link #STYLE_NO_INPUT}. + * @param theme Optional custom theme. If 0, an appropriate theme (based + * on the style) will be selected for you. + */ + public DialogFragment(int style, int theme) { + mStyle = style; + if (mStyle == STYLE_NO_FRAME || mStyle == STYLE_NO_INPUT) { + mTheme = android.R.style.Theme_Dialog_NoFrame; + } + if (theme != 0) { + mTheme = theme; + } + } + + /** + * Display the dialog, adding the fragment to the given activity. 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. + * @param activity The activity 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(); + 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. + * @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) { + transaction.add(this, tag); + mBackStackId = transaction.commit(); + return mBackStackId; + } + + /** + * 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. + */ + public void dismiss() { + if (mDialog != null) { + mDialog.dismiss(); + } + if (mBackStackId >= 0) { + getActivity().popBackStack(mBackStackId, Activity.POP_BACK_STACK_INCLUSIVE); + mBackStackId = -1; + } else { + FragmentTransaction ft = getActivity().openFragmentTransaction(); + ft.remove(this); + ft.commit(); + } + } + + public Dialog getDialog() { + return mDialog; + } + + public int getTheme() { + return mTheme; + } + + public void setCancelable(boolean cancelable) { + mCancelable = cancelable; + if (mDialog != null) mDialog.setCancelable(cancelable); + } + + public boolean getCancelable() { + return mCancelable; + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + 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); + } + } + + public Dialog onCreateDialog(Bundle savedInstanceState) { + return new Dialog(getActivity(), getTheme()); + } + + public void onCancel(DialogInterface dialog) { + if (mBackStackId >= 0) { + // If this fragment is part of the back stack, then cancelling + // the dialog means popping off the back stack. + getActivity().popBackStack(mBackStackId, Activity.POP_BACK_STACK_INCLUSIVE); + mBackStackId = -1; + } + } + + public void onDismiss(DialogInterface dialog) { + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + mDialog = onCreateDialog(savedInstanceState); + mDestroyed = false; + switch (mStyle) { + case STYLE_NO_INPUT: + mDialog.getWindow().addFlags( + WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | + WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE); + // fall through... + case STYLE_NO_FRAME: + case STYLE_NO_TITLE: + mDialog.requestWindowFeature(Window.FEATURE_NO_TITLE); + } + View view = getView(); + if (view != null) { + if (view.getParent() != null) { + throw new IllegalStateException("DialogFragment can not be attached to a container view"); + } + mDialog.setContentView(view); + } + mDialog.setOwnerActivity(getActivity()); + mDialog.setCancelable(mCancelable); + mDialog.setOnCancelListener(this); + mDialog.setOnDismissListener(this); + if (savedInstanceState != null) { + Bundle dialogState = savedInstanceState.getBundle(SAVED_DIALOG_STATE_TAG); + if (dialogState != null) { + mDialog.onRestoreInstanceState(dialogState); + } + } + } + + @Override + public void onStart() { + super.onStart(); + mDialog.show(); + } + + @Override + public void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + if (mDialog != null) { + Bundle dialogState = mDialog.onSaveInstanceState(); + if (dialogState != null) { + outState.putBundle(SAVED_DIALOG_STATE_TAG, dialogState); + } + } + outState.putInt(SAVED_STYLE, mStyle); + outState.putInt(SAVED_THEME, mTheme); + outState.putBoolean(SAVED_CANCELABLE, mCancelable); + outState.putInt(SAVED_BACK_STACK_ID, mBackStackId); + } + + @Override + public void onStop() { + super.onStop(); + mDialog.hide(); + } + + /** + * Detach from list view. + */ + @Override + public void onDestroyView() { + super.onDestroyView(); + mDestroyed = true; + mDialog.dismiss(); + mDialog = null; + } +} diff --git a/core/java/android/app/FragmentManager.java b/core/java/android/app/FragmentManager.java index 4f3043c40c467..c0e757d1ab0b7 100644 --- a/core/java/android/app/FragmentManager.java +++ b/core/java/android/app/FragmentManager.java @@ -86,6 +86,10 @@ public class FragmentManager { ArrayList mAvailIndices; ArrayList mBackStack; + // Must be accessed while locked. + ArrayList mBackStackIndices; + ArrayList mAvailBackStackIndices; + int mCurState = Fragment.INITIALIZING; Activity mActivity; @@ -514,6 +518,62 @@ public class FragmentManager { } } + public int allocBackStackIndex(BackStackEntry bse) { + synchronized (this) { + if (mAvailBackStackIndices == null || mAvailBackStackIndices.size() <= 0) { + if (mBackStackIndices == null) { + mBackStackIndices = new ArrayList(); + } + int index = mBackStackIndices.size(); + if (DEBUG) Log.v(TAG, "Setting back stack index " + index + " to " + bse); + mBackStackIndices.add(bse); + return index; + + } else { + int index = mAvailBackStackIndices.remove(mAvailBackStackIndices.size()-1); + if (DEBUG) Log.v(TAG, "Adding back stack index " + index + " with " + bse); + mBackStackIndices.set(index, bse); + return index; + } + } + } + + public void setBackStackIndex(int index, BackStackEntry bse) { + synchronized (this) { + if (mBackStackIndices == null) { + mBackStackIndices = new ArrayList(); + } + int N = mBackStackIndices.size(); + if (index < N) { + if (DEBUG) Log.v(TAG, "Setting back stack index " + index + " to " + bse); + mBackStackIndices.set(index, bse); + } else { + while (N < index) { + mBackStackIndices.add(null); + if (mAvailBackStackIndices == null) { + mAvailBackStackIndices = new ArrayList(); + } + if (DEBUG) Log.v(TAG, "Adding available back stack index " + N); + mAvailBackStackIndices.add(N); + N++; + } + if (DEBUG) Log.v(TAG, "Adding back stack index " + index + " with " + bse); + mBackStackIndices.add(bse); + } + } + } + + public void freeBackStackIndex(int index) { + synchronized (this) { + mBackStackIndices.set(index, null); + if (mAvailBackStackIndices == null) { + mAvailBackStackIndices = new ArrayList(); + } + if (DEBUG) Log.v(TAG, "Freeing back stack index " + index); + mAvailBackStackIndices.add(index); + } + } + /** * Only call from main thread! */ @@ -554,11 +614,22 @@ public class FragmentManager { mBackStack.add(state); } - public boolean popBackStackState(Handler handler, String name) { + public boolean popBackStackState(Handler handler, String name, int flags) { + return popBackStackState(handler, name, -1, flags); + } + + public boolean popBackStackState(Handler handler, int id, int flags) { + if (id < 0) { + return false; + } + return popBackStackState(handler, null, id, flags); + } + + boolean popBackStackState(Handler handler, String name, int id, int flags) { if (mBackStack == null) { return false; } - if (name == null) { + if (name == null && id < 0) { int last = mBackStack.size()-1; if (last < 0) { return false; @@ -576,11 +647,21 @@ public class FragmentManager { int index = mBackStack.size()-1; while (index >= 0) { BackStackEntry bss = mBackStack.get(index); - if (name.equals(bss.getName())) { + if (name != null && name.equals(bss.getName())) { break; } + if (id >= 0 && id == bss.mIndex) { + break; + } + index--; } - if (index < 0 || index == mBackStack.size()-1) { + if (index < 0) { + return false; + } + if ((flags&Activity.POP_BACK_STACK_INCLUSIVE) != 0) { + index--; + } + if (index == mBackStack.size()-1) { return false; } final ArrayList states @@ -772,6 +853,9 @@ public class FragmentManager { for (int i=0; i= 0) { + setBackStackIndex(bse.mIndex, bse); + } } } else { mBackStack = null; diff --git a/core/java/android/app/FragmentTransaction.java b/core/java/android/app/FragmentTransaction.java index 840f274f5ec6f..65cf85cff724b 100644 --- a/core/java/android/app/FragmentTransaction.java +++ b/core/java/android/app/FragmentTransaction.java @@ -147,5 +147,15 @@ public interface FragmentTransaction { public FragmentTransaction setTransitionStyle(int styleRes); public FragmentTransaction addToBackStack(String name); - public void commit(); + + /** + * Schedules a commit of this transaction. Note that the commit does + * not happen immediately; it will be scheduled as work on the main thread + * to be done the next time that thread is ready. + * + * @return Returns the identifier of this transaction's back stack entry, + * if {@link #addToBackStack(String)} had been called. Otherwise, returns + * a negative number. + */ + public int commit(); } diff --git a/core/java/android/app/ListFragment.java b/core/java/android/app/ListFragment.java index 73ef8690c6fee..6e2f4b6b54d32 100644 --- a/core/java/android/app/ListFragment.java +++ b/core/java/android/app/ListFragment.java @@ -28,10 +28,10 @@ import android.widget.ListView; import android.widget.TextView; /** - * An fragment that displays a list of items by binding to a data source such as + * A fragment that displays a list of items by binding to a data source such as * an array or Cursor, and exposes event handlers when the user selects an item. *

- * ListActivity hosts a {@link android.widget.ListView ListView} object that can + * ListFragment hosts a {@link android.widget.ListView ListView} object that can * be bound to different data sources, typically either an array or a Cursor * holding query results. Binding, screen layout, and row layout are discussed * in the following sections. @@ -39,10 +39,10 @@ import android.widget.TextView; * Screen Layout *

*

- * ListActivity has a default layout that consists of a single list view. + * ListFragment has a default layout that consists of a single list view. * However, if you desire, you can customize the fragment layout by returning * your own view hierarchy from {@link #onCreateView}. - * To do this, your view hierarchy MUST contain a ListView object with the + * To do this, your view hierarchy must contain a ListView object with the * id "@android:id/list" (or {@link android.R.id#list} if it's in code) *

* Optionally, your view hierarchy can contain another view object of any type to @@ -50,7 +50,7 @@ import android.widget.TextView; * id "android:empty". Note that when an empty view is present, the list view * will be hidden when there is no data to display. *

- * The following code demonstrates an (ugly) custom lisy layout. It has a list + * The following code demonstrates an (ugly) custom list layout. It has a list * with a green background, and an alternate red "no data" message. *

* @@ -134,6 +134,13 @@ import android.widget.TextView; * and {@link android.widget.SimpleCursorAdapter SimpleCursorAdapter} for Cursor * query results. *

+ *

+ * You must use + * {@link #setListAdapter(ListAdapter) ListFragment.setListAdapter()} to + * associate the list with an adapter. Do not directly call + * {@link ListView#setAdapter(ListAdapter) ListView.setAdapter()} or else + * important initialization will be skipped. + *

* * @see #setListAdapter * @see android.widget.ListView @@ -160,6 +167,7 @@ public class ListFragment extends Fragment { TextView mStandardEmptyView; View mProgressContainer; View mListContainer; + boolean mSetEmptyText; boolean mListShown; public ListFragment() { @@ -280,7 +288,11 @@ public class ListFragment extends Fragment { if (mStandardEmptyView == null) { throw new IllegalStateException("Can't be used with a custom content view"); } - mList.setEmptyView(mStandardEmptyView); + mStandardEmptyView.setText(text); + if (!mSetEmptyText) { + mList.setEmptyView(mStandardEmptyView); + mSetEmptyText = true; + } } /** diff --git a/core/res/res/values/public.xml b/core/res/res/values/public.xml index d0be554efeb02..34dd46c57f4dc 100644 --- a/core/res/res/values/public.xml +++ b/core/res/res/values/public.xml @@ -1314,6 +1314,7 @@ + + +