groupPosition has changed.
+ *
+ * This is an group item change event, not a structural change event. It indicates that any
+ * reflection of the data at groupPosition is out of date and should be updated.
+ * The item at groupPosition retains the same identity.
This method does not notify for children that are contained in the specified group. + * If children have also changed, use {@link #notifyGroupAndChildrenItemsChanged(int)} instead.
+ * + * @param groupPosition Position of the group item that has changed + * + * @see #notifyGroupAndChildrenItemsChanged(int) + */ + public void notifyGroupItemChanged(int groupPosition) { + mAdapter.notifyGroupItemChanged(groupPosition); + } + + /** + * Notify any registered observers that the group and children items atgroupPosition have changed.
+ *
+ * This is an group item change event, not a structural change event. It indicates that any
+ * reflection of the data at groupPosition is out of date and should be updated.
+ * The item at groupPosition retains the same identity.
groupPosition have changed.
+ *
+ * This is an group item change event, not a structural change event. It indicates that any
+ * reflection of the data at groupPosition is out of date and should be updated.
+ * The item at groupPosition retains the same identity.
This method does not notify for the group item. + * If the group has also changed, use {@link #notifyGroupAndChildrenItemsChanged(int)} instead.
+ * + * @param groupPosition Position of the group item which contains changed children + * + * @see #notifyGroupAndChildrenItemsChanged(int) + */ + public void notifyChildrenOfGroupItemChanged(int groupPosition) { + mAdapter.notifyChildrenOfGroupItemChanged(groupPosition); + } + + /** + * Notify any registered observers that the child item at{groupPosition, childPosition} has changed.
+ *
+ * This is an item change event, not a structural change event. It indicates that any
+ * reflection of the data at {groupPosition, childPosition} is out of date and should be updated.
+ * The item at {groupPosition, childPosition} retains the same identity.
itemCount child items starting at
+ * position {groupPosition, childPosition} have changed.
+ *
+ * This is an item change event, not a structural change event. It indicates that + * any reflection of the data in the given position range is out of date and should + * be updated. The items in the given range retain the same identity.
+ * + * @param groupPosition Position of the group item which contains the changed child + * @param childPositionStart Position of the first child item in the group that has changed + * @param itemCount Number of items that have changed + * + * @see #notifyChildItemChanged(int, int) + */ + public void notifyChildItemRangeChanged(int groupPosition, int childPositionStart, int itemCount) { + mAdapter.notifyChildItemRangeChanged(groupPosition, childPositionStart, itemCount); + } + + /** + * Notify any registered observers that the group item reflected atgroupPosition
+ * has been newly inserted. The group item previously at groupPosition is now at
+ * position groupPosition + 1.
+ *
+ * This is a structural change event. Representations of other existing items in the + * data set are still considered up to date and will not be rebound, though their + * positions may be altered.
+ * + * @param groupPosition Position of the newly inserted group item in the data set + * + * @see #notifyGroupItemRangeInserted(int, int) + */ + public void notifyGroupItemInserted(int groupPosition) { + mAdapter.notifyGroupItemInserted(groupPosition); + } + + /** + * Notify any registered observers that the currently reflecteditemCount
+ * group items starting at groupPositionStart have been newly inserted. The group items
+ * previously located at groupPositionStart and beyond can now be found starting
+ * at position groupPositionStart + itemCount.
+ *
+ * This is a structural change event. Representations of other existing items in the + * data set are still considered up to date and will not be rebound, though their positions + * may be altered.
+ * + * @param groupPositionStart Position of the first group item that was inserted + * @param itemCount Number of group items inserted + * + * @see #notifyGroupItemInserted(int) + */ + public void notifyGroupItemRangeInserted(int groupPositionStart, int itemCount) { + mAdapter.notifyGroupItemRangeInserted(groupPositionStart, itemCount); + } + + + /** + * Notify any registered observers that the group item reflected atgroupPosition
+ * has been newly inserted. The group item previously at groupPosition is now at
+ * position groupPosition + 1.
+ *
+ * This is a structural change event. Representations of other existing items in the + * data set are still considered up to date and will not be rebound, though their + * positions may be altered.
+ * + * @param groupPosition Position of the group item which contains the inserted child + * @param childPosition Position of the newly inserted child item in the data set + * + * @see #notifyChildItemRangeInserted(int, int, int) + */ + public void notifyChildItemInserted(int groupPosition, int childPosition) { + mAdapter.notifyChildItemInserted(groupPosition, childPosition); + } + + /** + * Notify any registered observers that the currently reflecteditemCount
+ * child items starting at childPositionStart have been newly inserted. The child items
+ * previously located at childPositionStart and beyond can now be found starting
+ * at position childPositionStart + itemCount.
+ *
+ * This is a structural change event. Representations of other existing items in the + * data set are still considered up to date and will not be rebound, though their positions + * may be altered.
+ * + * @param groupPosition Position of the group item which contains the inserted child + * @param childPositionStart Position of the first child item that was inserted + * @param itemCount Number of child items inserted + * + * @see #notifyChildItemInserted(int, int) + */ + public void notifyChildItemRangeInserted(int groupPosition, int childPositionStart, int itemCount) { + mAdapter.notifyChildItemRangeInserted(groupPosition, childPositionStart, itemCount); + } + + /** + * Notify any registered observers that the group item previously located atgroupPosition
+ * has been removed from the data set. The group items previously located at and after
+ * groupPosition may now be found at oldGroupPosition - 1.
+ *
+ * This is a structural change event. Representations of other existing items in the + * data set are still considered up to date and will not be rebound, though their positions + * may be altered.
+ * + * @param groupPosition Position of the group item that has now been removed + * + * @see #notifyGroupItemRangeRemoved(int, int) + */ + public void notifyGroupItemRemoved(int groupPosition) { + mAdapter.notifyGroupItemRemoved(groupPosition); + } + + /** + * Notify any registered observers that theitemCount group items previously
+ * located at groupPositionStart have been removed from the data set. The group items
+ * previously located at and after groupPositionStart + itemCount may now be found
+ * at oldPosition - itemCount.
+ *
+ * This is a structural change event. Representations of other existing items in the data + * set are still considered up to date and will not be rebound, though their positions + * may be altered.
+ * + * @param groupPositionStart Previous position of the first group item that was removed + * @param itemCount Number of group items removed from the data set + */ + public void notifyGroupItemRangeRemoved(int groupPositionStart, int itemCount) { + mAdapter.notifyGroupItemRangeRemoved(groupPositionStart, itemCount); + } + + /** + * Notify any registered observers that the child item previously located atchildPosition
+ * has been removed from the data set. The child items previously located at and after
+ * childPosition may now be found at oldGroupPosition - 1.
+ *
+ * This is a structural change event. Representations of other existing items in the + * data set are still considered up to date and will not be rebound, though their positions + * may be altered.
+ * + * @param groupPosition Position of the group item which was the parent of the child item that was removed + * @param childPosition Position of the child item that has now been removed + * + * @see #notifyGroupItemRangeRemoved(int, int) + */ + public void notifyChildItemRemoved(int groupPosition, int childPosition) { + mAdapter.notifyChildItemRemoved(groupPosition, childPosition); + } + + /** + * Notify any registered observers that theitemCount child items previously
+ * located at childPositionStart have been removed from the data set. The child items
+ * previously located at and after childPositionStart + itemCount may now be found
+ * at oldPosition - itemCount.
+ *
+ * This is a structural change event. Representations of other existing items in the data + * set are still considered up to date and will not be rebound, though their positions + * may be altered.
+ * + * @param groupPosition Position of the group item which was the parent of the child item that was removed + * @param childPositionStart Previous position of the first child item that was removed + * @param itemCount Number of child items removed from the data set + */ + public void notifyChildItemRangeRemoved(int groupPosition, int childPositionStart, int itemCount) { + mAdapter.notifyChildItemRangeRemoved(groupPosition, childPositionStart, itemCount); + } + public static class SavedState implements Parcelable { final int [] adapterSavedState; diff --git a/mobile/github-advrecyclerview_lib/src/com/h6ah4i/android/widget/advrecyclerview/swipeable/ItemSlidingAnimator.java b/mobile/github-advrecyclerview_lib/src/com/h6ah4i/android/widget/advrecyclerview/swipeable/ItemSlidingAnimator.java old mode 100644 new mode 100755 index 925a006146c..7ccd5b54fdd --- a/mobile/github-advrecyclerview_lib/src/com/h6ah4i/android/widget/advrecyclerview/swipeable/ItemSlidingAnimator.java +++ b/mobile/github-advrecyclerview_lib/src/com/h6ah4i/android/widget/advrecyclerview/swipeable/ItemSlidingAnimator.java @@ -32,6 +32,7 @@ import android.view.animation.AccelerateInterpolator; import android.view.animation.Interpolator; import android.widget.FrameLayout; +import java.lang.ref.WeakReference; import java.util.ArrayList; import java.util.List; @@ -41,40 +42,62 @@ public class ItemSlidingAnimator { private Interpolator mSlideToDefaultPositionAnimationInterpolator = new AccelerateDecelerateInterpolator(); private Interpolator mSlideToOutsideOfWindowAnimationInterpolator = new AccelerateInterpolator(0.8f); private ListThis version of the pager is best for use when there are a handful of + * typically more static fragments to be paged through, such as a set of tabs. + * The fragment of each page the user visits will be kept in memory, though its + * view hierarchy may be destroyed when not visible. This can result in using + * a significant amount of memory since fragment instances can hold on to an + * arbitrary amount of state. For larger sets of pages, consider + * {@link FragmentStatePagerAdapter}. + * + *
When using FragmentPagerAdapter the host ViewPager must have a + * valid ID set.
+ * + *Subclasses only need to implement {@link #getItem(int)} + * and {@link #getCount()} to have a working adapter. + * + *
Here is an example implementation of a pager containing fragments of + * lists: + * + * {@sample development/samples/Support13Demos/src/com/example/android/supportv13/app/FragmentPagerSupport.java + * complete} + * + *
The R.layout.fragment_pager resource of the top-level fragment is:
+ *
+ * {@sample development/samples/Support13Demos/res/layout/fragment_pager.xml
+ * complete}
+ *
+ *
The R.layout.fragment_pager_list resource containing each
+ * individual fragment's layout is:
+ *
+ * {@sample development/samples/Support13Demos/res/layout/fragment_pager_list.xml
+ * complete}
+ */
+public abstract class FragmentPagerAdapter extends PagerAdapter {
+ private static final String TAG = "FragmentPagerAdapter";
+ private static final boolean DEBUG = false;
+
+ private final FragmentManager mFragmentManager;
+ private FragmentTransaction mCurTransaction = null;
+ private Fragment mCurrentPrimaryItem = null;
+
+ public FragmentPagerAdapter(FragmentManager fm) {
+ mFragmentManager = fm;
+ }
+
+ /**
+ * Return the Fragment associated with a specified position.
+ */
+ public abstract Fragment getItem(int position);
+
+ @Override
+ public void startUpdate(ViewGroup container) {
+ }
+
+ @Override
+ public Object instantiateItem(ViewGroup container, int position) {
+ if (mCurTransaction == null) {
+ mCurTransaction = mFragmentManager.beginTransaction();
+ }
+
+ final long itemId = getItemId(position);
+
+ // Do we already have this fragment?
+ String name = makeFragmentName(container.getId(), itemId);
+ Fragment fragment = mFragmentManager.findFragmentByTag(name);
+ if (fragment != null) {
+ if (DEBUG) Log.v(TAG, "Attaching item #" + itemId + ": f=" + fragment);
+ mCurTransaction.attach(fragment);
+ } else {
+ fragment = getItem(position);
+ if (DEBUG) Log.v(TAG, "Adding item #" + itemId + ": f=" + fragment);
+ mCurTransaction.add(container.getId(), fragment,
+ makeFragmentName(container.getId(), itemId));
+ }
+ if (fragment != mCurrentPrimaryItem) {
+ FragmentCompat.setMenuVisibility(fragment, false);
+ FragmentCompat.setUserVisibleHint(fragment, false);
+ }
+
+ return fragment;
+ }
+
+ @Override
+ public void destroyItem(ViewGroup container, int position, Object object) {
+ if (mCurTransaction == null) {
+ mCurTransaction = mFragmentManager.beginTransaction();
+ }
+ if (DEBUG) Log.v(TAG, "Detaching item #" + getItemId(position) + ": f=" + object
+ + " v=" + ((Fragment)object).getView());
+ mCurTransaction.detach((Fragment)object);
+ }
+
+ @Override
+ public void setPrimaryItem(ViewGroup container, int position, Object object) {
+ Fragment fragment = (Fragment)object;
+ if (fragment != mCurrentPrimaryItem) {
+ if (mCurrentPrimaryItem != null) {
+ FragmentCompat.setMenuVisibility(mCurrentPrimaryItem, false);
+ FragmentCompat.setUserVisibleHint(mCurrentPrimaryItem, false);
+ }
+ if (fragment != null) {
+ FragmentCompat.setMenuVisibility(fragment, true);
+ FragmentCompat.setUserVisibleHint(fragment, true);
+ }
+ mCurrentPrimaryItem = fragment;
+ }
+ }
+
+ @Override
+ public void finishUpdate(ViewGroup container) {
+ if (mCurTransaction != null) {
+ mCurTransaction.commitAllowingStateLoss();
+ mCurTransaction = null;
+ mFragmentManager.executePendingTransactions();
+ }
+ }
+
+ @Override
+ public boolean isViewFromObject(View view, Object object) {
+ return ((Fragment)object).getView() == view;
+ }
+
+ @Override
+ public Parcelable saveState() {
+ return null;
+ }
+
+ @Override
+ public void restoreState(Parcelable state, ClassLoader loader) {
+ }
+
+ /**
+ * Return a unique identifier for the item at the given position.
+ *
+ *
The default implementation returns the given position. + * Subclasses should override this method if the positions of items can change.
+ * + * @param position Position within this adapter + * @return Unique identifier for the item at position + */ + public long getItemId(int position) { + return position; + } + + private static String makeFragmentName(int viewId, long id) { + return "android:switcher:" + viewId + ":" + id; + } +} \ No newline at end of file diff --git a/mobile/google-android-support-v13/src/android/support/v13/app/FragmentStatePagerAdapter.java b/mobile/google-android-support-v13/src/android/support/v13/app/FragmentStatePagerAdapter.java new file mode 100644 index 00000000000..89be82e8e54 --- /dev/null +++ b/mobile/google-android-support-v13/src/android/support/v13/app/FragmentStatePagerAdapter.java @@ -0,0 +1,229 @@ +/* + * Copyright (C) 2011 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.support.v13.app; + +import android.app.Fragment; +import android.app.FragmentManager; +import android.app.FragmentTransaction; +import android.os.Bundle; +import android.os.Parcelable; +import android.support.v4.app.FragmentPagerAdapter; +import android.support.v4.view.PagerAdapter; +import android.util.Log; +import android.view.View; +import android.view.ViewGroup; + +import java.util.ArrayList; + +/** + * Implementation of {@link android.support.v4.view.PagerAdapter} that + * uses a {@link Fragment} to manage each page. This class also handles + * saving and restoring of fragment's state. + * + *This version of the pager is more useful when there are a large number + * of pages, working more like a list view. When pages are not visible to + * the user, their entire fragment may be destroyed, only keeping the saved + * state of that fragment. This allows the pager to hold on to much less + * memory associated with each visited page as compared to + * {@link FragmentPagerAdapter} at the cost of potentially more overhead when + * switching between pages. + * + *
When using FragmentPagerAdapter the host ViewPager must have a + * valid ID set.
+ * + *Subclasses only need to implement {@link #getItem(int)} + * and {@link #getCount()} to have a working adapter. + * + *
Here is an example implementation of a pager containing fragments of + * lists: + * + * {@sample development/samples/Support4Demos/src/com/example/android/supportv4/app/FragmentStatePagerSupport.java + * complete} + * + *
The R.layout.fragment_pager resource of the top-level fragment is:
+ *
+ * {@sample development/samples/Support4Demos/res/layout/fragment_pager.xml
+ * complete}
+ *
+ *
The R.layout.fragment_pager_list resource containing each
+ * individual fragment's layout is:
+ *
+ * {@sample development/samples/Support4Demos/res/layout/fragment_pager_list.xml
+ * complete}
+ */
+public abstract class FragmentStatePagerAdapter extends PagerAdapter {
+ private static final String TAG = "FragmentStatePagerAdapter";
+ private static final boolean DEBUG = false;
+
+ private final FragmentManager mFragmentManager;
+ private FragmentTransaction mCurTransaction = null;
+
+ private ArrayList