android-4.1.1_r1/s

/*
 * 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 com.android.email.activity;

import android.app.Activity;
import android.app.ListFragment;
import android.app.LoaderManager;
import android.app.LoaderManager.LoaderCallbacks;
import android.content.ClipData;
import android.content.ClipDescription;
import android.content.Context;
import android.content.Loader;
import android.database.Cursor;
import android.graphics.Rect;
import android.net.Uri;
import android.os.Bundle;
import android.os.Parcelable;
import android.util.Log;
import android.view.DragEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnDragListener;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ListView;

import com.android.email.Controller;
import com.android.email.Email;
import com.android.email.R;
import com.android.email.RefreshManager;
import com.android.email.provider.EmailProvider;
import com.android.emailcommon.Logging;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.Mailbox;
import com.android.emailcommon.utility.EmailAsyncTask;
import com.android.emailcommon.utility.Utility;
import com.google.common.annotations.VisibleForTesting;

import java.util.Timer;

/**
 * This fragment presents a list of mailboxes for a given account or the combined mailboxes.
 *
 * This fragment has several parameters that determine the current view.
 *
 * <pre>
 * Parameters:
 * - Account ID.
 *   - Set via {@link #newInstance}.
 *   - Can be obtained with {@link #getAccountId()}.
 *   - Will not change throughout fragment lifecycle.
 *   - Either an actual account ID, or {@link Account#ACCOUNT_ID_COMBINED_VIEW}.
 *
 * - "Highlight enabled?" flag
 *   - Set via {@link #newInstance}.
 *   - Can be obtained with {@link #getEnableHighlight()}.
 *   - Will not change throughout fragment lifecycle.
 *   - If {@code true}, we highlight the "selected" mailbox (used only on 2-pane).
 *   - Note even if it's {@code true}, there may be no highlighted mailbox.
 *     (This usually happens on 2-pane before the UI controller finds the Inbox to highlight.)
 *
 * - "Parent" mailbox ID
 *   - Stored in {@link #mParentMailboxId}
 *   - Changes as the user navigates through nested mailboxes.
 *   - Initialized using the {@code mailboxId} parameter for {@link #newInstance}
 *     in {@link #setInitialParentAndHighlight()}.
 *
 * - "Highlighted" mailbox
 *   - Only used when highlighting is enabled.  (Otherwise always {@link Mailbox#NO_MAILBOX}.)
 *     i.e. used only on two-pane.
 *   - Stored in {@link #mHighlightedMailboxId}
 *   - Initialized using the {@code mailboxId} parameter for {@link #newInstance}
 *     in {@link #setInitialParentAndHighlight()}.
 *
 *   - Can be changed any time, using {@link #setHighlightedMailbox(long)}.
 *
 *   - If set, it's considered "selected", and we highlight the list item.
 *
 *   - (It should always be the ID of the list item selected in the list view, but we store it in
 *     a member for efficiency.)
 *
 *   - Sometimes, we need to set the highlighted mailbox while we're still loading data.
 *     In this case, we can't update {@link #mHighlightedMailboxId} right away, but need to do so
 *     in when the next data set arrives, in
 *     {@link MailboxListFragment.MailboxListLoaderCallbacks#onLoadFinished}.  For this, we use
 *     we store the mailbox ID in {@link #mNextHighlightedMailboxId} and update
 *     {@link #mHighlightedMailboxId} in onLoadFinished.
 *
 *
 * The "selected" is defined using the "parent" and "highlighted" mailboxes.
 * - "Selected" mailbox  (also sometimes called "current".)
 *   - This is what the user thinks it's now selected.
 *
 *   - Can be obtained with {@link #getSelectedMailboxId()}
 *   - If the "highlighted" mailbox exists, it's the "selected."  Otherwise, the "parent"
 *     is considered "selected."
 *   - This is what is passed to {@link Callback#onMailboxSelected}.
 * </pre>
 *
 *
 * This fragment shows the content in one of the three following views, depending on the
 * parameters above.
 *
 * <pre>
 * 1. Combined view
 *   - Used if the account ID == {@link Account#ACCOUNT_ID_COMBINED_VIEW}.
 *   - Parent mailbox is always {@link Mailbox#NO_MAILBOX}.
 *   - List contains:
 *     - combined mailboxes
 *     - all accounts
 *
 * 2. Root view for an account
 *   - Used if the account ID != {@link Account#ACCOUNT_ID_COMBINED_VIEW} and
 *     Parent mailbox == {@link Mailbox#NO_MAILBOX}
 *   - List contains
 *     - all the top level mailboxes for the selected account.
 *
 * 3. Root view for a mailbox.  (nested view)
 *   - Used if the account ID != {@link Account#ACCOUNT_ID_COMBINED_VIEW} and
 *     Parent mailbox != {@link Mailbox#NO_MAILBOX}
 *   - List contains:
 *     - parent mailbox (determined by "parent" mailbox ID)
 *     - all child mailboxes of the parent mailbox.
 * </pre>
 *
 *
 * Note that when a fragment is put in the back stack, it'll lose the content view but the fragment
 * itself is not destroyed.  If you call {@link #getListView()} in this state it'll throw
 * an {@link IllegalStateException}.  So,
 * - If code is supposed to be executed only when the fragment has the content view, use
 *   {@link #getListView()} directly to make sure it doesn't accidentally get executed when there's
 *   no views.
 * - Otherwise, make sure to check if the fragment has views with {@link #isViewCreated()}
 *   before touching any views.
 */
public class MailboxListFragment extends ListFragment implements OnItemClickListener,
        OnDragListener {
    private static final String TAG = "MailboxListFragment";

    private static final String BUNDLE_KEY_PARENT_MAILBOX_ID
            = "MailboxListFragment.state.parent_mailbox_id";
    private static final String BUNDLE_KEY_HIGHLIGHTED_MAILBOX_ID
            = "MailboxListFragment.state.selected_mailbox_id";
    private static final String BUNDLE_LIST_STATE = "MailboxListFragment.state.listState";
    private static final boolean DEBUG_DRAG_DROP = false; // MUST NOT SUBMIT SET TO TRUE

    /** No drop target is available where the user is currently hovering over */
    private static final int NO_DROP_TARGET = -1;
    // Total height of the top and bottom scroll zones, in pixels
    private static final int SCROLL_ZONE_SIZE = 64;
    // The amount of time to scroll by one pixel, in ms
    private static final int SCROLL_SPEED = 4;

    /** Arbitrary number for use with the loader manager */
    private static final int MAILBOX_LOADER_ID = 1;

    /** Argument name(s) */
    private static final String ARG_ACCOUNT_ID = "accountId";
    private static final String ARG_ENABLE_HIGHLIGHT = "enablehighlight";
    private static final String ARG_INITIAL_CURRENT_MAILBOX_ID = "initialParentMailboxId";

    private final EmailAsyncTask.Tracker mTaskTracker = new EmailAsyncTask.Tracker();

    /** Rectangle used for hit testing children */
    private static final Rect sTouchFrame = new Rect();

    private RefreshManager mRefreshManager;

    // UI Support
    private Activity mActivity;
    private MailboxFragmentAdapter mListAdapter;
    private Callback mCallback = EmptyCallback.INSTANCE;

    // See the class javadoc
    private long mParentMailboxId;
    private long mHighlightedMailboxId;

    /**
     * Becomes {@code true} once we determine which mailbox to use as the parent.
     */
    private boolean mParentDetermined;

    /**
     * ID of the mailbox that should be highlighted when the next cursor is loaded.
     */
    private long mNextHighlightedMailboxId = Mailbox.NO_MAILBOX;

    // True if a drag is currently in progress
    private boolean mDragInProgress;
    /** Mailbox ID of the item being dragged. Used to determine valid drop targets. */
    private long mDragItemMailboxId = -1;
    /** A unique identifier for the drop target. May be {@link #NO_DROP_TARGET}. */
    private int mDropTargetId = NO_DROP_TARGET;
    // The mailbox list item view that the user's finger is hovering over
    private MailboxListItem mDropTargetView;
    // Lazily instantiated height of a mailbox list item (-1 is a sentinel for 'not initialized')
    private int mDragItemHeight = -1;
    /** {@code true} if we are currently scrolling under the drag item */
    private boolean mTargetScrolling;

    private Parcelable mSavedListState;

    private final MailboxFragmentAdapter.Callback mMailboxesAdapterCallback =
            new MailboxFragmentAdapter.Callback() {
        @Override
        public void onBind(MailboxListItem listItem) {
            listItem.setDropTargetBackground(mDragInProgress, mDragItemMailboxId);
        }
    };

    /**
     * Callback interface that owning activities must implement
     */
    public interface Callback {
        /**
         * Called when any mailbox (even a combined mailbox) is selected.
         *
         * @param accountId
         *          The ID of the owner account of the selected mailbox.
         *          Or {@link Account#ACCOUNT_ID_COMBINED_VIEW} if it's a combined mailbox.
         * @param mailboxId
         *          The ID of the selected mailbox. This may be real mailbox ID [e.g. a number > 0],
         *          or a combined mailbox ID [e.g. {@link Mailbox#QUERY_ALL_INBOXES}].
         * @param nestedNavigation {@code true} if the event is caused by nested mailbox navigation,
         *          that is, going up or drilling-in to a child mailbox.
         */
        public void onMailboxSelected(long accountId, long mailboxId, boolean nestedNavigation);

        /** Called when an account is selected on the combined view. */
        public void onAccountSelected(long accountId);

        /**
         * Called when the parent mailbox is changing.
         */
        public void onParentMailboxChanged();
    }

    private static class EmptyCallback implements Callback {
        public static final Callback INSTANCE = new EmptyCallback();
        @Override public void onMailboxSelected(long accountId, long mailboxId,
                boolean nestedNavigation) { }
        @Override public void onAccountSelected(long accountId) { }
        @Override
        public void onParentMailboxChanged() { }
    }

    /**
     * Returns the index of the view located at the specified coordinates in the given list.
     * If the coordinates are outside of the list, {@code NO_DROP_TARGET} is returned.
     */
    private static int pointToIndex(ListView list, int x, int y) {
        final int count = list.getChildCount();
        for (int i = count - 1; i >= 0; i--) {
            final View child = list.getChildAt(i);
            if (child.getVisibility() == View.VISIBLE) {
                child.getHitRect(sTouchFrame);
                if (sTouchFrame.contains(x, y)) {
                    return i;
                }
            }
        }
        return NO_DROP_TARGET;
    }

    /**
     * Create a new instance with initialization parameters.
     *
     * This fragment should be created only with this method.  (Arguments should always be set.)
     *
     * @param accountId The ID of the account we want to view
     * @param initialCurrentMailboxId ID of the mailbox of interest.
     *        Pass {@link Mailbox#NO_MAILBOX} to show top-level mailboxes.
     * @param enableHighlight {@code true} if highlighting is enabled on the current screen
     *        configuration.  (We don't highlight mailboxes on one-pane.)
     */
    public static MailboxListFragment newInstance(long accountId, long initialCurrentMailboxId,
            boolean enableHighlight) {
        final MailboxListFragment instance = new MailboxListFragment();
        final Bundle args = new Bundle();
        args.putLong(ARG_ACCOUNT_ID, accountId);
        args.putLong(ARG_INITIAL_CURRENT_MAILBOX_ID, initialCurrentMailboxId);
        args.putBoolean(ARG_ENABLE_HIGHLIGHT, enableHighlight);
        instance.setArguments(args);
        return instance;
    }

    /**
     * The account ID the mailbox is associated with. Do not use directly; instead, use
     * {@link #getAccountId()}.
     * <p><em>NOTE:</em> Although we cannot force these to be immutable using Java language
     * constructs, this <em>must</em> be considered immutable.
     */
    private Long mImmutableAccountId;

    /**
     * {@code initialCurrentMailboxId} passed to {@link #newInstance}.
     * Do not use directly; instead, use {@link #getInitialCurrentMailboxId()}.
     * <p><em>NOTE:</em> Although we cannot force these to be immutable using Java language
     * constructs, this <em>must</em> be considered immutable.
     */
    private long mImmutableInitialCurrentMailboxId;

    /**
     * {@code enableHighlight} passed to {@link #newInstance}.
     * Do not use directly; instead, use {@link #getEnableHighlight()}.
     * <p><em>NOTE:</em> Although we cannot force these to be immutable using Java language
     * constructs, this <em>must</em> be considered immutable.
     */
    private boolean mImmutableEnableHighlight;

    private void initializeArgCache() {
        if (mImmutableAccountId != null) return;
        mImmutableAccountId = getArguments().getLong(ARG_ACCOUNT_ID);
        mImmutableInitialCurrentMailboxId = getArguments().getLong(ARG_INITIAL_CURRENT_MAILBOX_ID);
        mImmutableEnableHighlight = getArguments().getBoolean(ARG_ENABLE_HIGHLIGHT);
    }

    /**
     * @return {@code accountId} passed to {@link #newInstance}.  Safe to call even before onCreate.
     */
    public long getAccountId() {
        initializeArgCache();
        return mImmutableAccountId;
    }

    /**
     * @return {@code initialCurrentMailboxId} passed to {@link #newInstance}.
     * Safe to call even before onCreate.
     */
    public long getInitialCurrentMailboxId() {
        initializeArgCache();
        return mImmutableInitialCurrentMailboxId;
    }

    /**
     * @return {@code enableHighlight} passed to {@link #newInstance}.
     * Safe to call even before onCreate.
     */
    public boolean getEnableHighlight() {
        initializeArgCache();
        return mImmutableEnableHighlight;
    }

    @Override
    public void onAttach(Activity activity) {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " onAttach");
        }
        super.onAttach(activity);
    }

    /**
     * Called to do initial creation of a fragment.  This is called after
     * {@link #onAttach(Activity)} and before {@link #onActivityCreated(Bundle)}.
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " onCreate");
        }
        super.onCreate(savedInstanceState);

        mActivity = getActivity();
        mRefreshManager = RefreshManager.getInstance(mActivity);
        mListAdapter = new MailboxFragmentAdapter(mActivity, mMailboxesAdapterCallback);
        setListAdapter(mListAdapter); // It's safe to do even before the list view is created.

        if (savedInstanceState == null) {
            setInitialParentAndHighlight();
        } else {
            restoreInstanceState(savedInstanceState);
        }
    }

    /**
     * Set {@link #mParentMailboxId} and {@link #mHighlightedMailboxId} from the fragment arguments.
     */
    private void setInitialParentAndHighlight() {
        final long initialMailboxId = getInitialCurrentMailboxId();
        if (getAccountId() == Account.ACCOUNT_ID_COMBINED_VIEW) {
            // For the combined view, always show the top-level, but highlight the "current".
            mParentMailboxId = Mailbox.NO_MAILBOX;
        } else {
            // Inbox needs special care.
            // Note we can't get the mailbox type on the UI thread but this method *can* be used...
            final long inboxId = Mailbox.findMailboxOfType(getActivity(), getAccountId(),
                    Mailbox.TYPE_INBOX);
            if (initialMailboxId == inboxId) {
                // If Inbox is set as the initial current, we show the top level mailboxes
                // with inbox highlighted.
                mParentMailboxId = Mailbox.NO_MAILBOX;
            } else {
                // Otherwise, try using the "current" as the "parent" (and also highlight it).
                // If it has no children, we go up in onLoadFinished().
                mParentMailboxId = initialMailboxId;
            }
        }
        // Highlight the mailbox of interest
        if (getEnableHighlight()) {
            mHighlightedMailboxId = initialMailboxId;
        }
    }

    @Override
    public View onCreateView(
            LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " onCreateView");
        }
        return inflater.inflate(R.layout.mailbox_list_fragment, container, false);
    }

    /**
     * @return true if the content view is created and not destroyed yet. (i.e. between
     * {@link #onCreateView} and {@link #onDestroyView}.
     */
    private boolean isViewCreated() {
        return getView() != null;
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " onActivityCreated");
        }
        super.onActivityCreated(savedInstanceState);

        // Note we can't do this in onCreateView.
        // getListView() is only usable after onCreateView().
        final ListView lv = getListView();
        lv.setOnItemClickListener(this);
        lv.setChoiceMode(ListView.CHOICE_MODE_SINGLE);
        lv.setOnDragListener(this);

        startLoading(mParentMailboxId, mHighlightedMailboxId);

        UiUtilities.installFragment(this);
    }

    public void setCallback(Callback callback) {
        mCallback = (callback == null) ? EmptyCallback.INSTANCE : callback;
    }

    /**
     * Called when the Fragment is visible to the user.
     */
    @Override
    public void onStart() {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " onStart");
        }
        super.onStart();
    }

    /**
     * Called when the fragment is visible to the user and actively running.
     */
    @Override
    public void onResume() {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " onResume");
        }
        super.onResume();

        // Fetch the latest mailbox list from the server here if stale so that the user always
        // sees the (reasonably) up-to-date mailbox list, without pressing "refresh".
        final long accountId = getAccountId();
        if (mRefreshManager.isMailboxListStale(accountId)) {
            mRefreshManager.refreshMailboxList(accountId);
        }
    }

    @Override
    public void onPause() {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " onPause");
        }
        mSavedListState = getListView().onSaveInstanceState();
        super.onPause();
    }

    /**
     * Called when the Fragment is no longer started.
     */
    @Override
    public void onStop() {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " onStop");
        }
        super.onStop();
    }

    @Override
    public void onDestroyView() {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " onDestroyView");
        }
        UiUtilities.uninstallFragment(this);
        super.onDestroyView();
    }

    /**
     * Called when the fragment is no longer in use.
     */
    @Override
    public void onDestroy() {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " onDestroy");
        }
        mTaskTracker.cancellAllInterrupt();
        super.onDestroy();
    }

    @Override
    public void onDetach() {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " onDetach");
        }
        super.onDetach();
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " onSaveInstanceState");
        }
        super.onSaveInstanceState(outState);
        outState.putLong(BUNDLE_KEY_PARENT_MAILBOX_ID, mParentMailboxId);
        outState.putLong(BUNDLE_KEY_HIGHLIGHTED_MAILBOX_ID, mHighlightedMailboxId);
        if (isViewCreated()) {
            outState.putParcelable(BUNDLE_LIST_STATE, getListView().onSaveInstanceState());
        }
    }

    private void restoreInstanceState(Bundle savedInstanceState) {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " restoreInstanceState");
        }
        mParentMailboxId = savedInstanceState.getLong(BUNDLE_KEY_PARENT_MAILBOX_ID);
        mNextHighlightedMailboxId = savedInstanceState.getLong(BUNDLE_KEY_HIGHLIGHTED_MAILBOX_ID);
        mSavedListState = savedInstanceState.getParcelable(BUNDLE_LIST_STATE);
    }

    /**
     * @return "Selected" mailbox ID.
     */
    public long getSelectedMailboxId() {
        return (mHighlightedMailboxId != Mailbox.NO_MAILBOX) ? mHighlightedMailboxId
                : mParentMailboxId;
    }

    /**
     * @return {@code true} if top-level mailboxes are shown.  {@code false} otherwise.
     */
    private boolean isRoot() {
        return mParentMailboxId == Mailbox.NO_MAILBOX;
    }

    /**
     * Navigate one level up in the mailbox hierarchy. Does nothing if at the root account view.
     */
    public boolean navigateUp() {
        if (isRoot()) {
            return false;
        }
        FindParentMailboxTask.ResultCallback callback = new FindParentMailboxTask.ResultCallback() {
            @Override public void onResult(long nextParentMailboxId,
                    long nextHighlightedMailboxId, long nextSelectedMailboxId) {

                startLoading(nextParentMailboxId, nextHighlightedMailboxId);
            }
        };
        new FindParentMailboxTask(
                getActivity().getApplicationContext(), mTaskTracker, getAccountId(),
                getEnableHighlight(), mParentMailboxId, mHighlightedMailboxId, callback
                ).cancelPreviousAndExecuteParallel((Void[]) null);
        return true;
    }

    /**
     * @return {@code true} if the fragment is showing nested mailboxes and we can go one level up.
     *         {@code false} otherwise, meaning we're showing the top level mailboxes *OR*
     *         we're still loading initial data and we can't determine if we're going to show
     *         top-level or not.
     */
    public boolean canNavigateUp() {
        if (!mParentDetermined) {
            return false; // We can't determine yet...
        }
        return !isRoot();
    }

    /**
     * A task to determine what parent mailbox ID/highlighted mailbox ID to use for the "UP"
     * navigation, given the current parent mailbox ID, the highlighted mailbox ID, and {@link
     * #mEnableHighlight}.
     */
    @VisibleForTesting
    static class FindParentMailboxTask extends EmailAsyncTask<Void, Void, Long[]> {
        public interface ResultCallback {
            /**
             * Callback to get the result.
             *
             * @param nextParentMailboxId ID of the mailbox to use
             * @param nextHighlightedMailboxId ID of the mailbox to highlight
             * @param nextSelectedMailboxId ID of the mailbox to notify with
             *        {@link Callback#onMailboxSelected}.
             */
            public void onResult(long nextParentMailboxId, long nextHighlightedMailboxId,
                    long nextSelectedMailboxId);
        }

        private final Context mContext;
        private final long mAccountId;
        private final boolean mEnableHighlight;
        private final long mParentMailboxId;
        private final long mHighlightedMailboxId;
        private final ResultCallback mCallback;

        public FindParentMailboxTask(Context context, EmailAsyncTask.Tracker taskTracker,
                long accountId, boolean enableHighlight, long parentMailboxId,
                long highlightedMailboxId, ResultCallback callback) {
            super(taskTracker);
            mContext = context;
            mAccountId = accountId;
            mEnableHighlight = enableHighlight;
            mParentMailboxId = parentMailboxId;
            mHighlightedMailboxId = highlightedMailboxId;
            mCallback = callback;
        }

        @Override
        protected Long[] doInBackground(Void... params) {
            Mailbox parentMailbox = Mailbox.restoreMailboxWithId(mContext, mParentMailboxId);
            final long nextParentId = (parentMailbox == null) ? Mailbox.NO_MAILBOX
                    : parentMailbox.mParentKey;
            final long nextHighlightedId;
            final long nextSelectedId;
            if (mEnableHighlight) {
                // If the "parent" is highlighted before the transition, it should still be
                // highlighted after the upper level view.
                if (mParentMailboxId == mHighlightedMailboxId) {
                    nextHighlightedId = mParentMailboxId;
                } else {
                    // Otherwise, the next parent will be highlighted, unless we're going up to
                    // the root, in which case Inbox should be highlighted.
                    if (nextParentId == Mailbox.NO_MAILBOX) {
                        nextHighlightedId = Mailbox.findMailboxOfType(mContext, mAccountId,
                                Mailbox.TYPE_INBOX);
                    } else {
                        nextHighlightedId = nextParentId;
                    }
                }

                // Highlighted one will be "selected".
                nextSelectedId = nextHighlightedId;

            } else { // !mEnableHighlight
                nextHighlightedId = Mailbox.NO_MAILBOX;

                // Parent will be selected.
                nextSelectedId = nextParentId;
            }
            return new Long[]{nextParentId, nextHighlightedId, nextSelectedId};
        }

        @Override
        protected void onSuccess(Long[] result) {
            mCallback.onResult(result[0], result[1], result[2]);
        }
    }

    /**
     * Starts the loader.
     *
     * @param parentMailboxId Mailbox ID to be used as the "parent" mailbox
     * @param highlightedMailboxId Mailbox ID that should be highlighted when the data is loaded.
     */
    private void startLoading(long parentMailboxId, long highlightedMailboxId) {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " startLoading  parent=" + parentMailboxId
                    + " highlighted=" + highlightedMailboxId);
        }
        final LoaderManager lm = getLoaderManager();
        boolean parentMailboxChanging = false;

        // Parent mailbox changing -- destroy the current loader to force reload.
        if (mParentMailboxId != parentMailboxId) {
            lm.destroyLoader(MAILBOX_LOADER_ID);
            setListShown(false);
            parentMailboxChanging = true;
        }
        mParentMailboxId = parentMailboxId;
        if (getEnableHighlight()) {
            mNextHighlightedMailboxId = highlightedMailboxId;
        }

        lm.initLoader(MAILBOX_LOADER_ID, null, new MailboxListLoaderCallbacks());

        if (parentMailboxChanging) {
            mCallback.onParentMailboxChanged();
        }
    }

    /**
     * Highlight the given mailbox.
     *
     * If data is already loaded, it just sets {@link #mHighlightedMailboxId} and highlight the
     * corresponding list item.  (And if the corresponding list item is not found,
     * {@link #mHighlightedMailboxId} is set to {@link Mailbox#NO_MAILBOX})
     *
     * If we're still loading data, it sets {@link #mNextHighlightedMailboxId} instead, and then
     * it'll be set to {@link #mHighlightedMailboxId} in
     * {@link MailboxListLoaderCallbacks#onLoadFinished}.
     *
     * @param mailboxId The ID of the mailbox to highlight.
     */
    public void setHighlightedMailbox(long mailboxId) {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, this + " setHighlightedMailbox  mailbox=" + mailboxId);
        }
        if (!getEnableHighlight()) {
            return;
        }
        if (mHighlightedMailboxId == mailboxId) {
            return; // already highlighted.
        }
        if (mListAdapter.getCursor() == null) {
            // List not loaded yet.  Just remember the ID here and let onLoadFinished() update
            // mHighlightedMailboxId.
            mNextHighlightedMailboxId = mailboxId;
            return;
        }
        mHighlightedMailboxId = mailboxId;
        updateHighlightedMailbox(true);
    }

    // TODO This class probably should be made static. There are many calls into the enclosing
    // class and we need to be cautious about what we call while in these callbacks
    private class MailboxListLoaderCallbacks implements LoaderCallbacks<Cursor> {
        private boolean mIsFirstLoad;

        @Override
        public Loader<Cursor> onCreateLoader(int id, Bundle args) {
            if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
                Log.d(Logging.LOG_TAG, MailboxListFragment.this + " onCreateLoader");
            }
            mIsFirstLoad = true;
            if (getAccountId() == Account.ACCOUNT_ID_COMBINED_VIEW) {
                return MailboxFragmentAdapter.createCombinedViewLoader(getActivity());
            } else {
                return MailboxFragmentAdapter.createMailboxesLoader(getActivity(), getAccountId(),
                        mParentMailboxId);
            }
        }

        @Override
        public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
            if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
                Log.d(Logging.LOG_TAG, MailboxListFragment.this + " onLoadFinished  count="
                        + cursor.getCount());
            }
            // Note in onLoadFinished we can assume the view is created.
            // The loader manager doesn't deliver results when a fragment is stopped.

            // If we're showing a nested mailboxes, and the current parent mailbox has no children,
            // go up.
            if (getAccountId() != Account.ACCOUNT_ID_COMBINED_VIEW) {
                MailboxFragmentAdapter.CursorWithExtras c =
                        (MailboxFragmentAdapter.CursorWithExtras) cursor;
                if ((c.mChildCount == 0) && !isRoot()) {
                    // Always swap out the cursor so we don't hold a reference to a stale one.
                    mListAdapter.swapCursor(cursor);
                    navigateUp();
                    return;
                }
            }

            // Save list view state (primarily scroll position)
            final ListView lv = getListView();
            final Parcelable listState;
            if (mSavedListState != null) {
                listState = mSavedListState;
                mSavedListState = null;
            } else {
                listState = lv.onSaveInstanceState();
            }

            if (cursor.getCount() == 0) {
                // There's no row -- call setListShown(false) to make ListFragment show progress
                // icon.
                mListAdapter.swapCursor(null);
                setListShown(false);

            } else {
                mParentDetermined = true; // Okay now we're sure which mailbox is the parent.

                mListAdapter.swapCursor(cursor);
                setListShown(true);

                // Restore the list state, so scroll position is restored - this has to happen
                // prior to setting the checked/highlighted mailbox below.
                lv.onRestoreInstanceState(listState);

                // Update the highlighted mailbox
                if (mNextHighlightedMailboxId != Mailbox.NO_MAILBOX) {
                    setHighlightedMailbox(mNextHighlightedMailboxId);
                    mNextHighlightedMailboxId = Mailbox.NO_MAILBOX;
                }

                // We want to make visible the selection only for the first load.
                // Re-load caused by content changed events shouldn't scroll the list.
                if (!updateHighlightedMailbox(mIsFirstLoad)) {
                    // This may happen if the mailbox to be selected is not actually in the list
                    // that was loaded. Let the user just pick one manually if needed.
                    return;
                }
            }

            // List has been reloaded; clear any drop target information
            mDropTargetId = NO_DROP_TARGET;
            mDropTargetView = null;

            mIsFirstLoad = false;
        }

        @Override
        public void onLoaderReset(Loader<Cursor> loader) {
            if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
                Log.d(Logging.LOG_TAG, MailboxListFragment.this + " onLoaderReset");
            }
            mListAdapter.swapCursor(null);
        }
    }

    /**
     * {@inheritDoc}
     * <p>
     * @param doNotUse <em>IMPORTANT</em>: Do not use this parameter. The ID in the list widget
     * must be a positive value. However, we rely on negative IDs for special mailboxes. Instead,
     * we use the ID returned by {@link MailboxFragmentAdapter#getId(int)}.
     */
    @Override
    public void onItemClick(AdapterView<?> parent, View view, int position, long doNotUse) {
        final long id = mListAdapter.getId(position);
        if (mListAdapter.isAccountRow(position)) {
            mCallback.onAccountSelected(id);
        } else if (mListAdapter.isMailboxRow(position)) {
            // Save account-id.  (Need to do this before startLoading() below, which will destroy
            // the current loader and make the mListAdapter lose the cursor.
            // Note, don't just use getAccountId().  A mailbox may tied to a different account ID
            // from getAccountId().  (Currently "Starred" does so.)
            long accountId = mListAdapter.getAccountId(position);
            boolean nestedNavigation = false;
            if (((MailboxListItem) view).isNavigable() && (id != mParentMailboxId)) {
                // Drill-in.  Selected one will be the next parent, and it'll also be highlighted.
                startLoading(id, id);
                nestedNavigation = true;
            }
            if (accountId == Account.ACCOUNT_ID_COMBINED_VIEW) {
                // Virtual mailboxes, such as "Starred", will have a "combined view" ID. However,
                // we really want to relay the current active account, so that
                // things like per-account starred mailboxes work as expected.
                accountId = getAccountId();
            }
            mCallback.onMailboxSelected(accountId, id, nestedNavigation);
        }
    }

    /**
     * Really highlight the mailbox for {@link #mHighlightedMailboxId} on the list view.
     *
     * Note if a list item for {@link #mHighlightedMailboxId} is not found,
     * {@link #mHighlightedMailboxId} will be set to {@link Mailbox#NO_MAILBOX}.
     *
     * @return false when the highlighted mailbox seems to be gone; i.e. if
     *         {@link #mHighlightedMailboxId} is set but not found in the list.
     */
    private boolean updateHighlightedMailbox(boolean ensureSelectionVisible) {
        if (!getEnableHighlight() || !isViewCreated()) {
            return true; // Nothing to highlight
        }
        final ListView lv = getListView();
        boolean found = false;
        if (mHighlightedMailboxId == Mailbox.NO_MAILBOX) {
            // No mailbox selected
            lv.clearChoices();
            found = true;
        } else {
            // TODO Don't mix list view & list adapter indices. This is a recipe for disaster.
            final int count = lv.getCount();
            for (int i = 0; i < count; i++) {
                if (mListAdapter.getId(i) != mHighlightedMailboxId) {
                    continue;
                }
                found = true;
                lv.setItemChecked(i, true);
                if (ensureSelectionVisible) {
                    Utility.listViewSmoothScrollToPosition(getActivity(), lv, i);
                }
                break;
            }
        }
        if (!found) {
            mHighlightedMailboxId = Mailbox.NO_MAILBOX;
        }
        return found;
    }

    // Drag & Drop handling

    /**
     * Update all of the list's child views with the proper target background (for now, orange if
     * a valid target, except red if the trash; standard background otherwise)
     */
    private void updateChildViews() {
        final ListView lv = getListView();
        int itemCount = lv.getChildCount();
        // Lazily initialize the height of our list items
        if (itemCount > 0 && mDragItemHeight < 0) {
            mDragItemHeight = lv.getChildAt(0).getHeight();
        }
        for (int i = 0; i < itemCount; i++) {
            final View child = lv.getChildAt(i);
            if (!(child instanceof MailboxListItem)) {
                continue;
            }
            MailboxListItem item = (MailboxListItem) child;
            item.setDropTargetBackground(mDragInProgress, mDragItemMailboxId);
        }
    }

    /**
     * Called when the user has dragged outside of the mailbox list area.
     */
    private void onDragExited() {
        // Reset the background of the current target
        if (mDropTargetView != null) {
            mDropTargetView.setDropTargetBackground(mDragInProgress, mDragItemMailboxId);
            mDropTargetView = null;
        }
        mDropTargetId = NO_DROP_TARGET;
        stopScrolling();
    }

    /**
     * Called while dragging;  highlight possible drop targets, and auto scroll the list.
     */
    private void onDragLocation(DragEvent event) {
        final ListView lv = getListView();
        // TODO The list may be changing while in drag-n-drop; temporarily suspend drag-n-drop
        // if the list is being updated [i.e. navigated to another mailbox]
        if (mDragItemHeight <= 0) {
            // This shouldn't be possible, but avoid NPE
            Log.w(TAG, "drag item height is not set");
            return;
        }
        // Find out which item we're in and highlight as appropriate
        final int rawTouchX = (int) event.getX();
        final int rawTouchY = (int) event.getY();
        final int viewIndex = pointToIndex(lv, rawTouchX, rawTouchY);
        int targetId = viewIndex;
        if (targetId != mDropTargetId) {
            if (DEBUG_DRAG_DROP) {
                Log.d(TAG, "=== Target changed; oldId: " + mDropTargetId + ", newId: " + targetId);
            }
            // Remove highlight the current target; if there was one
            if (mDropTargetView != null) {
                mDropTargetView.setDropTargetBackground(true, mDragItemMailboxId);
                mDropTargetView = null;
            }
            // Get the new target mailbox view
            final View childView = lv.getChildAt(viewIndex);
            final MailboxListItem newTarget;
            if (childView == null) {
                // In any event, we're no longer dragging in the list view if newTarget is null
                if (DEBUG_DRAG_DROP) {
                    Log.d(TAG, "=== Drag off the list");
                }
                newTarget = null;
                final int childCount = lv.getChildCount();
                if (viewIndex >= childCount) {
                    // Touching beyond the end of the list; may happen for small lists
                    onDragExited();
                    return;
                } else {
                    // We should never get here
                    Log.w(TAG, "null view; idx: " + viewIndex + ", cnt: " + childCount);
                }
            } else if (!(childView instanceof MailboxListItem)) {
                // We're over a header suchas "Recent folders".  We shouldn't finish DnD, but
                // drop should be disabled.
                newTarget = null;
                targetId = NO_DROP_TARGET;
            } else {
                newTarget = (MailboxListItem) childView;
                if (newTarget.mMailboxType == Mailbox.TYPE_TRASH) {
                    if (DEBUG_DRAG_DROP) {
                        Log.d(TAG, "=== Trash mailbox; id: " + newTarget.mMailboxId);
                    }
                    newTarget.setDropTrashBackground();
                } else if (newTarget.isDropTarget(mDragItemMailboxId)) {
                    if (DEBUG_DRAG_DROP) {
                        Log.d(TAG, "=== Target mailbox; id: " + newTarget.mMailboxId);
                    }
                    newTarget.setDropActiveBackground();
                } else {
                    if (DEBUG_DRAG_DROP) {
                        Log.d(TAG, "=== Non-droppable mailbox; id: " + newTarget.mMailboxId);
                    }
                    newTarget.setDropTargetBackground(true, mDragItemMailboxId);
                    targetId = NO_DROP_TARGET;
                }
            }
            // Save away our current position and view
            mDropTargetId = targetId;
            mDropTargetView = newTarget;
        }

        // This is a quick-and-dirty implementation of drag-under-scroll; something like this
        // should eventually find its way into the framework
        int scrollDiff = rawTouchY - (lv.getHeight() - SCROLL_ZONE_SIZE);
        boolean scrollDown = (scrollDiff > 0);
        boolean scrollUp = (SCROLL_ZONE_SIZE > rawTouchY);
        if (!mTargetScrolling && scrollDown) {
            int itemsToScroll = lv.getCount() - lv.getLastVisiblePosition();
            int pixelsToScroll = (itemsToScroll + 1) * mDragItemHeight;
            lv.smoothScrollBy(pixelsToScroll, pixelsToScroll * SCROLL_SPEED);
            if (DEBUG_DRAG_DROP) {
                Log.d(TAG, "=== Start scrolling list down");
            }
            mTargetScrolling = true;
        } else if (!mTargetScrolling && scrollUp) {
            int pixelsToScroll = (lv.getFirstVisiblePosition() + 1) * mDragItemHeight;
            lv.smoothScrollBy(-pixelsToScroll, pixelsToScroll * SCROLL_SPEED);
            if (DEBUG_DRAG_DROP) {
                Log.d(TAG, "=== Start scrolling list up");
            }
            mTargetScrolling = true;
        } else if (!scrollUp && !scrollDown) {
            stopScrolling();
        }
    }

    /**
     * Indicate that scrolling has stopped
     */
    private void stopScrolling() {
        final ListView lv = getListView();
        if (mTargetScrolling) {
            mTargetScrolling = false;
            if (DEBUG_DRAG_DROP) {
                Log.d(TAG, "=== Stop scrolling list");
            }
            // Stop the scrolling
            lv.smoothScrollBy(0, 0);
        }
    }

    private void onDragEnded() {
        if (mDragInProgress) {
            mDragInProgress = false;
            // Reenable updates to the view and redraw (in case it changed)
            MailboxFragmentAdapter.enableUpdates(true);
            mListAdapter.notifyDataSetChanged();
            // Stop highlighting targets
            updateChildViews();
            // Stop any scrolling that was going on
            stopScrolling();
        }
    }

    private boolean onDragStarted(DragEvent event) {
        // We handle dropping of items with our email mime type
        // If the mime type has a mailbox id appended, that is the mailbox of the item
        // being draged
        ClipDescription description = event.getClipDescription();
        int mimeTypeCount = description.getMimeTypeCount();
        for (int i = 0; i < mimeTypeCount; i++) {
            String mimeType = description.getMimeType(i);
            if (mimeType.startsWith(EmailProvider.EMAIL_MESSAGE_MIME_TYPE)) {
                if (DEBUG_DRAG_DROP) {
                    Log.d(TAG, "=== Drag started");
                }
                mDragItemMailboxId = -1;
                // See if we find a mailbox id here
                int dash = mimeType.lastIndexOf('-');
                if (dash > 0) {
                    try {
                        mDragItemMailboxId = Long.parseLong(mimeType.substring(dash + 1));
                    } catch (NumberFormatException e) {
                        // Ignore; we just won't know the mailbox
                    }
                }
                mDragInProgress = true;
                // Stop the list from updating
                MailboxFragmentAdapter.enableUpdates(false);
                // Update the backgrounds of our child views to highlight drop targets
                updateChildViews();
                return true;
            }
        }
        return false;
    }

    /**
     * Perform a "drop" action. If the user is not on top of a valid drop target, no action
     * is performed.
     * @return {@code true} if the drop action was performed. Otherwise {@code false}.
     */
    private boolean onDrop(DragEvent event) {
        stopScrolling();
        // If we're not on a target, we're done
        if (mDropTargetId == NO_DROP_TARGET) {
            return false;
        }
        final Controller controller = Controller.getInstance(mActivity);
        ClipData clipData = event.getClipData();
        int count = clipData.getItemCount();
        if (DEBUG_DRAG_DROP) {
            Log.d(TAG, "=== Dropping " + count + " items.");
        }
        // Extract the messageId's to move from the ClipData (set up in MessageListItem)
        final long[] messageIds = new long[count];
        for (int i = 0; i < count; i++) {
            Uri uri = clipData.getItemAt(i).getUri();
            String msgNum = uri.getPathSegments().get(1);
            long id = Long.parseLong(msgNum);
            messageIds[i] = id;
        }
        // Call either deleteMessage or moveMessage, depending on the target
        if (mDropTargetView.mMailboxType == Mailbox.TYPE_TRASH) {
            controller.deleteMessages(messageIds);
        } else {
            controller.moveMessages(messageIds, mDropTargetView.mMailboxId);
        }
        return true;
    }

    @Override
    public boolean onDrag(View view, DragEvent event) {
        boolean result = false;
        switch (event.getAction()) {
            case DragEvent.ACTION_DRAG_STARTED:
                result = onDragStarted(event);
                break;
            case DragEvent.ACTION_DRAG_ENTERED:
                // The drag has entered the ListView window
                if (DEBUG_DRAG_DROP) {
                    Log.d(TAG, "=== Drag entered; targetId: " + mDropTargetId);
                }
                break;
            case DragEvent.ACTION_DRAG_EXITED:
                // The drag has left the building
                if (DEBUG_DRAG_DROP) {
                    Log.d(TAG, "=== Drag exited; targetId: " + mDropTargetId);
                }
                onDragExited();
                break;
            case DragEvent.ACTION_DRAG_ENDED:
                // The drag is over
                if (DEBUG_DRAG_DROP) {
                    Log.d(TAG, "=== Drag ended");
                }
                onDragEnded();
                break;
            case DragEvent.ACTION_DRAG_LOCATION:
                // We're moving around within our window; handle scroll, if necessary
                onDragLocation(event);
                break;
            case DragEvent.ACTION_DROP:
                // The drag item was dropped
                if (DEBUG_DRAG_DROP) {
                    Log.d(TAG, "=== Drop");
                }
                result = onDrop(event);
                break;
            default:
                break;
        }
        return result;
    }
}