Java Code Examples for android.os.Bundle.putSparseParcelableArray()

public void saveActionViewStates(Bundle outStates) {
    SparseArray<Parcelable> viewStates = null;

    final int itemCount = size();
    for (int i = 0; i < itemCount; i++) {
        final MenuItem item = getItem(i);
        final View v = item.getActionView();
        if (v != null && v.getId() != View.NO_ID) {
            if (viewStates == null) {
                viewStates = new SparseArray<Parcelable>();
            }
            v.saveHierarchyState(viewStates);
            if (item.isActionViewExpanded()) {
                outStates.putInt(EXPANDED_ACTION_VIEW_ID, item.getItemId());
            }
        }
        if (item.hasSubMenu()) {
            final SubMenuBuilder subMenu = (SubMenuBuilder) item.getSubMenu();
            subMenu.saveActionViewStates(outStates);
        }
    }

    if (viewStates != null) {
        outStates.putSparseParcelableArray(getActionViewStatesKey(), viewStates);
    }
}
 

private void dispatchSaveInstanceState(Bundle outState) {
    if (mPresenters.isEmpty()) return;

    SparseArray<Parcelable> presenterStates = new SparseArray<Parcelable>();

    for (WeakReference<MenuPresenter> ref : mPresenters) {
        final MenuPresenter presenter = ref.get();
        if (presenter == null) {
            mPresenters.remove(ref);
        } else {
            final int id = presenter.getId();
            if (id > 0) {
                final Parcelable state = presenter.onSaveInstanceState();
                if (state != null) {
                    presenterStates.put(id, state);
                }
            }
        }
    }

    outState.putSparseParcelableArray(PRESENTER_KEY, presenterStates);
}
 

private void saveViewState(@NonNull View view) {
  viewState = new Bundle(getClass().getClassLoader());

  SparseArray<Parcelable> hierarchyState = new SparseArray<>();
  view.saveHierarchyState(hierarchyState);
  viewState.putSparseParcelableArray(KEY_VIEW_STATE_HIERARCHY, hierarchyState);

  Bundle stateBundle = new Bundle(getClass().getClassLoader());
  onSaveViewState(view, stateBundle);
  viewState.putBundle(KEY_VIEW_STATE_BUNDLE, stateBundle);

  if (!lifecycleListeners.isEmpty()) {
    for (LifecycleListener listener : new ArrayList<>(lifecycleListeners)) {
      listener.onSaveViewState(this, viewState);
    }
  }
}
 

private void dispatchSaveInstanceState(Bundle outState) {
    if (!this.mPresenters.isEmpty()) {
        SparseArray<Parcelable> presenterStates = new SparseArray();
        Iterator i$ = this.mPresenters.iterator();
        while (i$.hasNext()) {
            WeakReference<MenuPresenter> ref = (WeakReference) i$.next();
            MenuPresenter presenter = (MenuPresenter) ref.get();
            if (presenter == null) {
                this.mPresenters.remove(ref);
            } else {
                int id = presenter.getId();
                if (id > 0) {
                    Parcelable state = presenter.onSaveInstanceState();
                    if (state != null) {
                        presenterStates.put(id, state);
                    }
                }
            }
        }
        outState.putSparseParcelableArray(PRESENTER_KEY, presenterStates);
    }
}
 

public Bundle createInstanceState() {
    Bundle state = new Bundle();
    if (this.mCheckedItem != null) {
        state.putInt(STATE_CHECKED_ITEM, this.mCheckedItem.getItemId());
    }
    SparseArray<ParcelableSparseArray> actionViewStates = new SparseArray();
    Iterator i$ = this.mItems.iterator();
    while (i$.hasNext()) {
        NavigationMenuItem navigationMenuItem = (NavigationMenuItem) i$.next();
        if (navigationMenuItem instanceof NavigationMenuTextItem) {
            MenuItemImpl item = ((NavigationMenuTextItem) navigationMenuItem).getMenuItem();
            View actionView = item != null ? item.getActionView() : null;
            if (actionView != null) {
                ParcelableSparseArray container = new ParcelableSparseArray();
                actionView.saveHierarchyState(container);
                actionViewStates.put(item.getItemId(), container);
            }
        }
    }
    state.putSparseParcelableArray(STATE_ACTION_VIEWS, actionViewStates);
    return state;
}
 

@Override
public Parcelable saveState() {
  if (savedStateMap != null) {
    Bundle state = new Bundle();
    state.putSparseParcelableArray(KEY_SAVED_STATE_MAP, savedStateMap);
    return state;
  } else {
    return null;
  }
}
 

@Override
public Parcelable saveState()
{
	for(TabFragment fragment : tabFragments)
		savedStates.put(fragment.getTabId(), fragment.isAdded() ? fragmentManager.saveFragmentInstanceState(fragment) : null);
	Bundle state = new Bundle();
	state.putSparseParcelableArray("states", savedStates);
	return state;
}
 

public Bundler putSparseParcelableArray(@NonNull String key, SparseArray<? extends Parcelable> value) {
    Bundle safeBundle = new Bundle();
    safeBundle.putSparseParcelableArray(key, value);
    if (isValidBundleSize(safeBundle)) {
        bundle.putSparseParcelableArray(key, value);
    }
    clearBundle(safeBundle);
    return this;
}
 

@Override
public void write(Bundle bundle, Object to, StateField field) throws IllegalAccessException {
    Field propertyField = field.getField();
    propertyField.setAccessible(true);
    bundle.putSparseParcelableArray(field.getBundleKey(), (SparseArray<? extends Parcelable>) propertyField.get(to));

}
 

@Override
public void writeToParcel(final Parcel parcel, final int arg1) {
    final Bundle b = new Bundle();
    b.putString("local_name_complete", mLocalNameComplete);
    b.putString("local_name_short", mLocalNameShort);
    b.putSparseParcelableArray("records_array", mAdRecords);

    parcel.writeBundle(b);
}
 

final void save(Bundle outState) {
  saveViewState();
  if (viewState != null) {
    outState.putSparseParcelableArray(VIEW_STATE + hashCode(), viewState);
  }
  viewState = null;
}
 

public void saveHierarchyState(Bundle outState) {
    SparseArray<Parcelable> viewStates = new SparseArray();
    if (this.mMenuView != null) {
        this.mMenuView.saveHierarchyState(viewStates);
    }
    outState.putSparseParcelableArray(VIEWS_TAG, viewStates);
}
 

public Parcelable onSaveInstanceState() {
    Bundle state = new Bundle();
    if (this.mMenuView != null) {
        SparseArray<Parcelable> hierarchy = new SparseArray();
        this.mMenuView.saveHierarchyState(hierarchy);
        state.putSparseParcelableArray("android:menu:list", hierarchy);
    }
    if (this.mAdapter != null) {
        state.putBundle(STATE_ADAPTER, this.mAdapter.createInstanceState());
    }
    return state;
}
 

Parcelable onSaveInstanceState() {
    SparseArray<Parcelable> state = new SparseArray<>();
    itemView.saveHierarchyState(state);
    Bundle bundle = new Bundle();
    bundle.putSparseParcelableArray(STATE, state);
    return bundle;
}
 

@Override
public Parcelable saveState() {
    Bundle bundle = new Bundle();
    for (ViewHolder viewHolder : getAttachedViewHolders()) {
        mSavedStates.put(getItemId(viewHolder.mPosition), viewHolder.onSaveInstanceState());
    }
    bundle.putSparseParcelableArray(STATE, mSavedStates);
    return bundle;
}
 

public void putSparseParcelableArray(Bundle state, String key, SparseArray<? extends Parcelable> x) {
    state.putSparseParcelableArray(key + baseKey, x);
}
 

public void putSparseParcelableArray(Bundle state, String key, SparseArray<? extends Parcelable> x) {
    state.putSparseParcelableArray(key + mBaseKey, x);
}
 

@Override
public final void saveInstanceState(@NonNull final Bundle outState) {
    outState.putSparseParcelableArray(SAVED_INSTANCE_STATES_EXTRA, savedInstanceStates);
}
 

/**
 * The method, which is invoked by a {@link TabSwitcher} to save the current state of a tab. It
 * initializes the view holder pattern, which is provided by the decorator and then delegates
 * the method call to the decorator's custom implementation of the method
 * <code>onSaveInstanceState(...):void</code>.
 *
 * @param view
 *         The view, which is used to visualize the tab, as an instance of the class {@link
 *         View}
 * @param tab
 *         The tab, whose state should be saved, as an instance of the class {@link Tab}. The
 *         tab may not be null
 * @param index
 *         The index of the tab, whose state should be saved, as an {@link Integer} value
 * @return The bundle, which has been used to save the state, as an instance of the class {@link
 * Bundle}. The bundle may not be null
 */
@NonNull
public final Bundle saveInstanceState(@NonNull final View view, @NonNull final Tab tab,
                                      final int index) {
    setCurrentParentView(view);
    int viewType = getViewType(tab, index);
    Bundle outState = new Bundle();
    SparseArray<Parcelable> viewStates = new SparseArray<>();
    view.saveHierarchyState(viewStates);
    outState.putSparseParcelableArray(VIEW_HIERARCHY_STATE_EXTRA, viewStates);
    onSaveInstanceState(view, tab, index, viewType, outState);
    return outState;
}
 

/**
 * The method, which is invoked by a {@link TabSwitcher} to save the current state of a tab. It
 * initializes the view holder pattern, which is provided by the decorator and then delegates
 * the method call to the decorator's custom implementation of the method
 * <code>onSaveInstanceState(...):void</code>.
 *
 * @param view
 *         The view, which is used to visualize the tab, as an instance of the class {@link
 *         View}
 * @param tab
 *         The tab, whose state should be saved, as an instance of the class {@link Tab}. The
 *         tab may not be null
 * @param index
 *         The index of the tab, whose state should be saved, as an {@link Integer} value
 * @return The bundle, which has been used to save the state, as an instance of the class {@link
 * Bundle}. The bundle may not be null
 */
@NonNull
public final Bundle saveInstanceState(@NonNull final View view, @NonNull final Tab tab,
                                      final int index) {
    setCurrentParentView(view);
    int viewType = getViewType(tab, index);
    Bundle outState = new Bundle();
    SparseArray<Parcelable> viewStates = new SparseArray<>();
    view.saveHierarchyState(viewStates);
    outState.putSparseParcelableArray(VIEW_HIERARCHY_STATE_EXTRA, viewStates);
    onSaveInstanceState(view, tab, index, viewType, outState);
    return outState;
}