email/activity/MoveMessageToDialog.java

/*
 * 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.AlertDialog;
import android.app.Dialog;
import android.app.DialogFragment;
import android.app.Fragment;
import android.app.LoaderManager;
import android.content.AsyncTaskLoader;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Loader;
import android.database.Cursor;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;

import com.android.email.Email;
import com.android.email.R;
import com.android.emailcommon.Logging;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.EmailContent.Message;
import com.android.emailcommon.provider.Mailbox;
import com.android.emailcommon.utility.Utility;

/**
 * "Move (messages) to" dialog. This is a modal dialog and the design is such so that only one is
 * active. If a new instance is created while an existing one is active, the existing one is
 * dismissed.
 *
 * TODO The check logic in MessageCheckerCallback is not efficient.  It shouldn't restore full
 * Message objects.
 */
public class MoveMessageToDialog extends DialogFragment implements DialogInterface.OnClickListener {
    private static final String BUNDLE_MESSAGE_IDS = "message_ids";

    private static final int LOADER_ID_MOVE_TO_DIALOG_MAILBOX_LOADER = 1;
    private static final int LOADER_ID_MOVE_TO_DIALOG_MESSAGE_CHECKER = 2;

    /** Message IDs passed to {@link #newInstance} */
    private long[] mMessageIds;
    private MailboxMoveToAdapter mAdapter;

    /** ID of the account that contains all of the messages to move */
    private long mAccountId;
    /** ID of the mailbox that contains all of the messages to move */
    private long mMailboxId;

    private boolean mDestroyed;

    /**
     * Callback that target fragments, or the owner activity should implement.
     */
    public interface Callback {
        public void onMoveToMailboxSelected(long newMailboxId, long[] messageIds);
    }

    /**
     * Create and return a new instance.
     *
     * @param messageIds IDs of the messages to be moved.
     * @param callbackFragment Fragment that gets a callback.  The fragment must implement
     *     {@link Callback}.
     */
    public static <T extends Fragment & Callback> MoveMessageToDialog newInstance(long[] messageIds,
            T callbackFragment) {
        if (messageIds.length == 0) {
            throw new IllegalArgumentException();
        }
        if (callbackFragment == null) {
            throw new IllegalArgumentException(); // fail fast
        }
        MoveMessageToDialog dialog = new MoveMessageToDialog();
        Bundle args = new Bundle();
        args.putLongArray(BUNDLE_MESSAGE_IDS, messageIds);
        dialog.setArguments(args);
        dialog.setTargetFragment(callbackFragment, 0);
        return dialog;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) {
            Log.d(Logging.LOG_TAG, "" + this + " onCreate  target=" + getTargetFragment());
        }
        super.onCreate(savedInstanceState);
        mMessageIds = getArguments().getLongArray(BUNDLE_MESSAGE_IDS);
        setStyle(STYLE_NORMAL, android.R.style.Theme_Holo_Light);
    }

    @Override
    public void onDestroy() {
        mDestroyed = true;
        super.onDestroy();
    }

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        final Activity activity = getActivity();

        // Build adapter & dialog
        // Make sure to pass Builder's context to the adapter, so that it'll get the correct theme.
        AlertDialog.Builder builder = new AlertDialog.Builder(activity)
                .setTitle(activity.getResources().getString(R.string.move_to_folder_dialog_title));

        mAdapter = new MailboxMoveToAdapter(builder.getContext());
        builder.setSingleChoiceItems(mAdapter, -1, this);

        getLoaderManager().initLoader(
                LOADER_ID_MOVE_TO_DIALOG_MESSAGE_CHECKER,
                null, new MessageCheckerCallback());

        return builder.create();
    }

    @Override
    public void onStart() {
        super.onStart();

        if (mAdapter.getCursor() == null) {
            // Data isn't ready - don't show yet.
            getDialog().hide();
        }
    }

    /**
     * The active move message dialog. This dialog is fairly modal so it only makes sense to have
     * one instance active, and for debounce purposes, we dismiss any existing ones.
     *
     * Only touched on the UI thread so doesn't require synchronization.
     */
    static MoveMessageToDialog sActiveDialog;

    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        if (sActiveDialog != null) {
            // Something is already attached. Dismiss it!
            sActiveDialog.dismissAsync();
        }

        sActiveDialog = this;
    }

    @Override
    public void onDetach() {
        super.onDetach();

        if (sActiveDialog == this) {
            sActiveDialog = null;
        }
    }

    @Override
    public void onClick(DialogInterface dialog, int position) {
        final long mailboxId = mAdapter.getItemId(position);

        ((Callback) getTargetFragment()).onMoveToMailboxSelected(mailboxId, mMessageIds);
        dismiss();
    }

    /**
     * Delay-call {@link #dismissAllowingStateLoss()} using a {@link Handler}.  Calling
     * {@link #dismissAllowingStateLoss()} from {@link LoaderManager.LoaderCallbacks#onLoadFinished}
     * is not allowed, so we use it instead.
     */
    private void dismissAsync() {
        Utility.getMainThreadHandler().post(new Runnable() {
            @Override
            public void run() {
                if (!mDestroyed) {
                    dismissAllowingStateLoss();
                }
            }
        });
    }

    /**
     * Loader callback for {@link MessageChecker}
     */
    private class MessageCheckerCallback implements LoaderManager.LoaderCallbacks<IdContainer> {
        @Override
        public Loader<IdContainer> onCreateLoader(int id, Bundle args) {
            return new MessageChecker(getActivity(), mMessageIds);
        }

        @Override
        public void onLoadFinished(Loader<IdContainer> loader, IdContainer idSet) {
            if (mDestroyed) {
                return;
            }
            // accountId shouldn't be null, but I'm paranoia.
            if (idSet == null || idSet.mAccountId == Account.NO_ACCOUNT
                    || idSet.mMailboxId == Mailbox.NO_MAILBOX) {
                // Some of the messages can't be moved.  Close the dialog.
                dismissAsync();
                return;
            }
            mAccountId = idSet.mAccountId;
            mMailboxId = idSet.mMailboxId;
            getLoaderManager().initLoader(
                    LOADER_ID_MOVE_TO_DIALOG_MAILBOX_LOADER,
                    null, new MailboxesLoaderCallbacks());
        }

        @Override
        public void onLoaderReset(Loader<IdContainer> loader) {
        }
    }

    /**
     * Loader callback for destination mailbox list.
     */
    private class MailboxesLoaderCallbacks implements LoaderManager.LoaderCallbacks<Cursor> {
        @Override
        public Loader<Cursor> onCreateLoader(int id, Bundle args) {
            return MailboxMoveToAdapter.createLoader(getActivity().getApplicationContext(),
                    mAccountId, mMailboxId);
        }

        @Override
        public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
            if (mDestroyed) {
                return;
            }
            boolean needsShowing = (mAdapter.getCursor() == null);
            mAdapter.swapCursor(data);

            // The first time data is loaded, we need to show the dialog.
            if (needsShowing && isAdded()) {
                getDialog().show();
            }
        }

        @Override
        public void onLoaderReset(Loader<Cursor> loader) {
            mAdapter.swapCursor(null);
        }
    }

    /**
     * A loader that checks if the messages can be moved. If messages can be moved, it returns
     * the account and mailbox IDs where the messages are currently located. If any the messages
     * cannot be moved (such as the messages belong to different accounts), the IDs returned
     * will be {@link Account#NO_ACCOUNT} and {@link Mailbox#NO_MAILBOX}.
     */
    private static class MessageChecker extends AsyncTaskLoader<IdContainer> {
        private final Activity mActivity;
        private final long[] mMessageIds;

        public MessageChecker(Activity activity, long[] messageIds) {
            super(activity);
            mActivity = activity;
            mMessageIds = messageIds;
        }

        @Override
        public IdContainer loadInBackground() {
            final Context c = getContext();

            long accountId = Account.NO_ACCOUNT;
            long mailboxId = Mailbox.NO_MAILBOX;

            for (long messageId : mMessageIds) {
                // TODO This shouln't restore a full Message object.
                final Message message = Message.restoreMessageWithId(c, messageId);
                if (message == null) {
                    continue; // Skip removed messages.
                }

                // First, check account.
                if (accountId == Account.NO_ACCOUNT) {
                    // First, check if the account supports move
                    accountId = message.mAccountKey;
                    if (!Account.restoreAccountWithId(c, accountId).supportsMoveMessages(c)) {
                        Utility.showToast(
                                mActivity, R.string.cannot_move_protocol_not_supported_toast);
                        accountId = Account.NO_ACCOUNT;
                        break;
                    }
                    mailboxId = message.mMailboxKey;
                    // Second, check if the mailbox supports move
                    if (!Mailbox.restoreMailboxWithId(c, mailboxId).canHaveMessagesMoved()) {
                        Utility.showToast(mActivity, R.string.cannot_move_special_mailboxes_toast);
                        accountId = Account.NO_ACCOUNT;
                        mailboxId = Mailbox.NO_MAILBOX;
                        break;
                    }
                } else {
                    // Subsequent messages; all messages must to belong to the same mailbox
                    if (message.mAccountKey != accountId || message.mMailboxKey != mailboxId) {
                        Utility.showToast(mActivity, R.string.cannot_move_multiple_accounts_toast);
                        accountId = Account.NO_ACCOUNT;
                        mailboxId = Mailbox.NO_MAILBOX;
                        break;
                    }
                }
            }
            return new IdContainer(accountId, mailboxId);
        }

        @Override
        protected void onStartLoading() {
            cancelLoad();
            forceLoad();
        }

        @Override
        protected void onStopLoading() {
            cancelLoad();
        }

        @Override
        protected void onReset() {
            stopLoading();
        }
    }

    /** Container for multiple types of IDs */
    private static class IdContainer {
        private final long mAccountId;
        private final long mMailboxId;

        private IdContainer(long accountId, long mailboxId) {
            mAccountId = accountId;
            mMailboxId = mailboxId;
        }
    }
}