Java tutorial
/* * Copyright 2015. Appsi Mobile * * 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 com.appsimobile.appsii; import android.content.Context; import android.os.Bundle; import android.support.annotation.StringRes; import android.support.v4.util.CircularArray; import android.support.v4.util.SimpleArrayMap; import android.support.v4.view.PagerAdapter; import android.util.SparseArray; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import com.appsimobile.appsii.annotation.VisibleForTesting; import com.appsimobile.appsii.module.home.provider.HomeContract; /** * A pager adapter that holds client state. This is modeled after * fragments and the FragmentStatePagerAdapter * Created by nick on 10/08/14. */ public abstract class AbstractSidebarPagerAdapter extends PagerAdapter { /** * A controller frag that indicates that the background and * other decorations should not be shown */ public static final int FLAG_NO_DECORATIONS = 1; static final int CLOSE_ACTION_AUTO_CLOSE = PageController.CLOSE_ACTION_AUTO_CLOSE; static final int CLOSE_ACTION_KEEP_OPEN = PageController.CLOSE_ACTION_KEEP_OPEN; static final int CLOSE_ACTION_ASK = PageController.CLOSE_ACTION_ASK; static final int CLOSE_ACTION_DONT_KNOW = PageController.CLOSE_ACTION_DONT_KNOW; @VisibleForTesting final SimpleArrayMap<HotspotPageEntry, PageController> mCachedControllers = new SimpleArrayMap<>(); @VisibleForTesting final SparseArray<HotspotPageEntry> mActivePageKeys = new SparseArray<>(8); @VisibleForTesting final SparseArray<PageController> mActivePageControllers = new SparseArray<>(8); @VisibleForTesting final SparseArray<PageController> mPrevPageControllers = new SparseArray<>(8); final boolean mDontCachePages = true; private final SimpleArrayMap<HotspotPageEntry, Bundle> mSavedControllerStates = new SimpleArrayMap<>(); private final Context mContext; FlagListener mFlagListener; boolean mAttachedToWindow; @VisibleForTesting PageController mActivePageController; boolean mSidebarOpening; public AbstractSidebarPagerAdapter(Context context) { mContext = context; } protected String getString(@StringRes int stringResId) { return mContext.getString(stringResId); } public void setFlagListener(FlagListener flagListener) { mFlagListener = flagListener; } public void setPages(CircularArray<HotspotPageEntry> pages) { // FIXME: this is a bug if (mActivePageKeys.equals(pages)) return; // temporary keep the old items in a separate list so we can // figure out the exact change in getItemPosition mPrevPageControllers.clear(); int count = mActivePageControllers.size(); for (int i = 0; i < count; i++) { int key = mActivePageControllers.keyAt(i); PageController controller = mActivePageControllers.valueAt(i); mPrevPageControllers.put(key, controller); } mActivePageKeys.clear(); mActivePageControllers.clear(); for (int i = 0, position = 0; i < pages.size(); i++) { HotspotPageEntry page = pages.get(i); if (!page.mEnabled) continue; if (page.mPageType == HomeContract.Pages.PAGE_SETTINGS) continue; if (page.mPageType == HomeContract.Pages.PAGE_SMS) continue; PageController controller = mCachedControllers.get(page); if (controller == null) { controller = instantiateAndCacheControllerForPage(page); } mActivePageKeys.put(position, page); mActivePageControllers.put(position, controller); position++; } notifyDataSetChanged(); } private PageController instantiateAndCacheControllerForPage(HotspotPageEntry page) { Bundle state = mSavedControllerStates.get(page); PageController controller = createPageController(page, state); controller.setDeferLoads(mSidebarOpening); controller.setUserVisible(false); mCachedControllers.put(page, controller); return controller; } public final PageController createPageController(HotspotPageEntry page, Bundle state) { return onCreatePageController(mContext, page); } protected abstract PageController onCreatePageController(Context context, HotspotPageEntry page); HotspotPageEntry getPageKey(int position) { return mActivePageKeys.get(position); } @Override public int getCount() { return mActivePageKeys.size(); } @Override public final Object instantiateItem(ViewGroup container, int position) { LayoutInflater inflater = LayoutInflater.from(mContext); PageController controller = mActivePageControllers.get(position); if (controller == null) { HotspotPageEntry page = mActivePageKeys.get(position); controller = instantiateAndCacheControllerForPage(page); } HotspotPageEntry page = mActivePageKeys.get(position); controller.setPage(page); Bundle state = mSavedControllerStates.get(page); controller.performCreate(state); View result = controller.performCreateView(inflater, container); controller.performViewCreated(result); if (mAttachedToWindow) { controller.onSidebarAttached(); } else { controller.onSidebarDetached(); } container.addView(controller.getView()); controller.performOnAttach(); controller.performStart(); controller.performRestoreInstanceState(); controller.performResume(); return controller; } @Override public void destroyItem(ViewGroup container, int position, Object object) { PageController controller = (PageController) object; HotspotPageEntry page = controller.getPage(); Bundle savedControllerState = mSavedControllerStates.get(page); if (savedControllerState == null) { savedControllerState = new Bundle(); mSavedControllerStates.put(page, savedControllerState); } else { savedControllerState.clear(); } controller.performPause(); controller.performSaveInstanceState(savedControllerState); controller.performStop(); controller.performOnDetach(); container.removeView(controller.getView()); controller.performDestroy(); if (mDontCachePages) { mActivePageControllers.remove(position); HotspotPageEntry e = controller.getPage(); mCachedControllers.remove(e); } } @Override public void setPrimaryItem(ViewGroup container, int position, Object object) { super.setPrimaryItem(container, position, object); if (mActivePageController != object) { if (mActivePageController != null) { mActivePageController.setUserVisible(false); mActivePageController.onUserInvisible(); } mActivePageController = (PageController) object; // TODO: probably happens when the user disabled all pages (?) if (mActivePageController != null) { mActivePageController.setUserVisible(true); mActivePageController.onUserVisible(); updatePageFlags(mActivePageController.getFlags()); } else { updatePageFlags(0); } } } protected void updatePageFlags(int i) { if (mFlagListener != null) { mFlagListener.onFlagsChanged(i); } } @Override public boolean isViewFromObject(View view, Object object) { PageController controller = (PageController) object; return view == controller.getView(); } @Override public int getItemPosition(Object object) { int oldPos = keyOf(mPrevPageControllers, (PageController) object); int newIdx = keyOf(mActivePageControllers, (PageController) object); if (oldPos != -1) { mPrevPageControllers.remove(oldPos); } if (newIdx == -1) { return POSITION_NONE; } else if (newIdx == oldPos) { return POSITION_UNCHANGED; } else { return newIdx; } } static <T> int keyOf(SparseArray<T> array, T object) { int length = array.size(); for (int i = 0; i < length; i++) { T value = array.valueAt(i); if (value == object) return array.keyAt(i); } return -1; } public void onTrimMemory(int level) { int length = mActivePageControllers.size(); for (int i = 0; i < length; i++) { PageController controller = mActivePageControllers.get(i); if (controller != null) { controller.onTrimMemory(level); } } } public void setSidebarClosed() { if (mActivePageController != null) { mActivePageController.onUserInvisible(); } } public void setSidebarOpening(boolean sidebarOpening) { mSidebarOpening = sidebarOpening; int length = mActivePageControllers.size(); for (int i = 0; i < length; i++) { PageController controller = mActivePageControllers.get(i); if (controller != null) { controller.setDeferLoads(sidebarOpening); } } if (mActivePageController != null) { if (sidebarOpening) { mActivePageController.onUserInvisible(); } else { mActivePageController.onUserVisible(); } // TODO: how come this is not properly called when after using try; loading home? // seems like the new active page has not yet been added to the list of // ActivePageControllers mActivePageController.setDeferLoads(sidebarOpening); } } public void onAttachedToWindow() { mAttachedToWindow = true; int length = mActivePageControllers.size(); for (int i = 0; i < length; i++) { PageController controller = mActivePageControllers.get(i); if (controller != null) { controller.onSidebarAttached(); } } } public void onDetachedFromWindow() { mAttachedToWindow = false; int length = mActivePageControllers.size(); for (int i = 0; i < length; i++) { PageController controller = mActivePageControllers.get(i); if (controller != null) { controller.onSidebarDetached(); } } } public int shouldClose(Bundle state) { if (mActivePageController != null) { return mActivePageController.shouldClose(state); } return PageController.CLOSE_ACTION_DONT_KNOW; } public void rememberCloseAction(Bundle state, int action) { if (mActivePageController != null) { mActivePageController.rememberCloseAction(state, action); } } interface FlagListener { void onFlagsChanged(int flags); } }