Java tutorial
/* * Copyright 2013 Chris Banes * * 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.cattle.util; import android.content.Context; import android.database.ContentObserver; import android.database.Cursor; import android.database.DataSetObserver; import android.os.Handler; import android.support.v4.view.PagerAdapter; import android.support.v4.view.ViewPager; import android.view.View; import android.view.ViewGroup; public abstract class CursorPagerAdapter extends PagerAdapter { /** * This field should be made private, so it is hidden from the SDK. {@hide * * * } */ protected boolean mDataValid; /** * This field should be made private, so it is hidden from the SDK. {@hide * * * } */ protected boolean mAutoRequery; /** * This field should be made private, so it is hidden from the SDK. {@hide * * * } */ protected Cursor mCursor; /** * This field should be made private, so it is hidden from the SDK. {@hide * * * } */ protected Context mContext; /** * This field should be made private, so it is hidden from the SDK. {@hide * * * } */ protected int mRowIDColumn; /** * This field should be made private, so it is hidden from the SDK. {@hide * * * } */ protected ChangeObserver mChangeObserver; /** * This field should be made private, so it is hidden from the SDK. {@hide * * * } */ protected DataSetObserver mDataSetObserver; /** * If set the adapter will call requery() on the cursor whenever a content change notification is * delivered. Implies {@link #FLAG_REGISTER_CONTENT_OBSERVER}. * * @deprecated This option is discouraged, as it results in Cursor queries being performed on the * application's UI thread and thus can cause poor responsiveness or even Application * Not Responding errors. As an alternative, use {@link android.app.LoaderManager} with * a {@link android.content.CursorLoader}. */ @Deprecated public static final int FLAG_AUTO_REQUERY = 0x01; /** * If set the adapter will register a content observer on the cursor and will call {@link * #onContentChanged()} when a notification comes in. Be careful when using this flag: you will * need to unset the current Cursor from the adapter to avoid leaks due to its registered * observers. This flag is not needed when using a CursorAdapter with a {@link * android.content.CursorLoader}. */ public static final int FLAG_REGISTER_CONTENT_OBSERVER = 0x02; /** * Constructor that always enables auto-requery. * * @param c The cursor from which to get the data. * @param context The context * @deprecated This option is discouraged, as it results in Cursor queries being performed on the * application's UI thread and thus can cause poor responsiveness or even Application * Not Responding errors. As an alternative, use {@link android.app.LoaderManager} with * a {@link android.content.CursorLoader}. */ @Deprecated public CursorPagerAdapter(Context context, Cursor c) { init(context, c, FLAG_AUTO_REQUERY); } /** * Constructor that allows control over auto-requery. It is recommended you not use this, but * instead {@link #CursorAdapter(android.content.Context, android.database.Cursor, int)}. When using this constructor, {@link * #FLAG_REGISTER_CONTENT_OBSERVER} will always be set. * * @param c The cursor from which to get the data. * @param context The context * @param autoRequery If true the adapter will call requery() on the cursor whenever it changes so * the most recent data is always displayed. Using true here is discouraged. */ public CursorPagerAdapter(Context context, Cursor c, boolean autoRequery) { init(context, c, autoRequery ? FLAG_AUTO_REQUERY : FLAG_REGISTER_CONTENT_OBSERVER); } /** * Recommended constructor. * * @param c The cursor from which to get the data. * @param context The context * @param flags Flags used to determine the behavior of the adapter; may be any combination of * {@link #FLAG_AUTO_REQUERY} and {@link #FLAG_REGISTER_CONTENT_OBSERVER}. */ public CursorPagerAdapter(Context context, Cursor c, int flags) { init(context, c, flags); } /** * @deprecated Don't use this, use the normal constructor. This will be removed in the future. */ @Deprecated protected void init(Context context, Cursor c, boolean autoRequery) { init(context, c, autoRequery ? FLAG_AUTO_REQUERY : FLAG_REGISTER_CONTENT_OBSERVER); } void init(Context context, Cursor c, int flags) { if ((flags & FLAG_AUTO_REQUERY) == FLAG_AUTO_REQUERY) { flags |= FLAG_REGISTER_CONTENT_OBSERVER; mAutoRequery = true; } else { mAutoRequery = false; } boolean cursorPresent = c != null; mCursor = c; mDataValid = cursorPresent; mContext = context; mRowIDColumn = cursorPresent ? c.getColumnIndexOrThrow("_id") : -1; if ((flags & FLAG_REGISTER_CONTENT_OBSERVER) == FLAG_REGISTER_CONTENT_OBSERVER) { mChangeObserver = new ChangeObserver(); mDataSetObserver = new MyDataSetObserver(); } else { mChangeObserver = null; mDataSetObserver = null; } if (cursorPresent) { if (mChangeObserver != null) { c.registerContentObserver(mChangeObserver); } if (mDataSetObserver != null) { c.registerDataSetObserver(mDataSetObserver); } } } /** * Returns the cursor. * * @return the cursor. */ public Cursor getCursor() { return mCursor; } /** * @see android.widget.ListAdapter#getCount() */ public int getCount() { if (mDataValid && mCursor != null) { return mCursor.getCount(); } else { return 0; } } /** * @see android.widget.ListAdapter#getView(int, android.view.View, android.view.ViewGroup) */ @Override public Object instantiateItem(View container, int position) { if (!mDataValid) { throw new IllegalStateException("this should only be called when the cursor is valid"); } if (!mCursor.moveToPosition(position)) { throw new IllegalStateException("couldn't move cursor to position " + position); } View v = newView(mContext, mCursor, (ViewGroup) container); bindView(v, mContext, mCursor); ((ViewPager) container).addView(v); return v; } @Override public void destroyItem(View container, int position, Object object) { ((ViewPager) container).removeView((View) object); } /** * Makes a new view to hold the data pointed to by cursor. * * @param context Interface to application's global information * @param cursor The cursor from which to get the data. The cursor is already moved to the correct * position. * @param parent The parent to which the new view is attached to * @return the newly created view. */ public abstract View newView(Context context, Cursor cursor, ViewGroup parent); /** * Bind an existing view to the data pointed to by cursor * * @param view Existing view, returned earlier by newView * @param context Interface to application's global information * @param cursor The cursor from which to get the data. The cursor is already moved to the correct * position. */ public abstract void bindView(View view, Context context, Cursor cursor); /** * Change the underlying cursor to a new cursor. If there is an existing cursor it will be closed. * * @param cursor The new cursor to be used */ public void changeCursor(Cursor cursor) { Cursor old = swapCursor(cursor); if (old != null) { old.close(); } } /** * Swap in a new Cursor, returning the old Cursor. Unlike {@link #changeCursor(android.database.Cursor)}, the * returned old Cursor is <em>not</em> closed. * * @param newCursor The new cursor to be used. * @return Returns the previously set Cursor, or null if there was not one. If the given new Cursor * is the same instance is the previously set Cursor, null is also returned. */ public Cursor swapCursor(Cursor newCursor) { if (newCursor == mCursor) { return null; } Cursor oldCursor = mCursor; if (oldCursor != null) { if (mChangeObserver != null) { oldCursor.unregisterContentObserver(mChangeObserver); } if (mDataSetObserver != null) { oldCursor.unregisterDataSetObserver(mDataSetObserver); } } mCursor = newCursor; if (newCursor != null) { if (mChangeObserver != null) { newCursor.registerContentObserver(mChangeObserver); } if (mDataSetObserver != null) { newCursor.registerDataSetObserver(mDataSetObserver); } mRowIDColumn = newCursor.getColumnIndexOrThrow("_id"); mDataValid = true; // notify the observers about the new cursor notifyDataSetChanged(); } else { mRowIDColumn = -1; mDataValid = false; // notify the observers about the lack of a data set notifyDataSetChanged(); } return oldCursor; } /** * <p> Converts the cursor into a CharSequence. Subclasses should override this method to convert * their results. The default implementation returns an empty String for null values or the default * String representation of the value. </p> * * @param cursor the cursor to convert to a CharSequence * @return a CharSequence representing the value */ public CharSequence convertToString(Cursor cursor) { return cursor == null ? "" : cursor.toString(); } /** * Called when the {@link android.database.ContentObserver} on the cursor receives a change notification. The * default implementation provides the auto-requery logic, but may be overridden by sub classes. * * @see android.database.ContentObserver#onChange(boolean) */ @SuppressWarnings("deprecation") protected void onContentChanged() { if (mAutoRequery && mCursor != null && !mCursor.isClosed()) { mDataValid = mCursor.requery(); } } private class ChangeObserver extends ContentObserver { public ChangeObserver() { super(new Handler()); } @Override public boolean deliverSelfNotifications() { return true; } @Override public void onChange(boolean selfChange) { onContentChanged(); } } private class MyDataSetObserver extends DataSetObserver { @Override public void onChanged() { mDataValid = true; notifyDataSetChanged(); } @Override public void onInvalidated() { mDataValid = false; notifyDataSetChanged(); } } }