path: root/src/com/android/mail/widget/BaseWidgetProvider.java

/*
 * Copyright (C) 2012 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.mail.widget;

import android.app.PendingIntent;
import android.appwidget.AppWidgetManager;
import android.appwidget.AppWidgetProvider;
import android.content.ComponentName;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.text.TextUtils;
import android.view.View;
import android.widget.RemoteViews;

import com.android.mail.R;
import com.android.mail.preferences.MailPrefs;
import com.android.mail.providers.Account;
import com.android.mail.providers.Folder;
import com.android.mail.providers.UIProvider;
import com.android.mail.providers.UIProvider.FolderType;
import com.android.mail.ui.MailboxSelectionActivity;
import com.android.mail.utils.AccountUtils;
import com.android.mail.utils.LogTag;
import com.android.mail.utils.LogUtils;
import com.android.mail.utils.Utils;
import com.google.common.collect.Sets;
import com.google.common.primitives.Ints;

import java.util.Set;

public abstract class BaseWidgetProvider extends AppWidgetProvider {
    public static final String EXTRA_FOLDER_TYPE = "folder-type";
    public static final String EXTRA_FOLDER_CAPABILITIES = "folder-capabilities";
    public static final String EXTRA_FOLDER_URI = "folder-uri";
    public static final String EXTRA_FOLDER_CONVERSATION_LIST_URI = "folder-conversation-list-uri";
    public static final String EXTRA_FOLDER_DISPLAY_NAME = "folder-display-name";
    public static final String EXTRA_UPDATE_ALL_WIDGETS = "update-all-widgets";
    public static final String WIDGET_ACCOUNT_PREFIX = "widget-account-";

    public static final String ACCOUNT_FOLDER_PREFERENCE_SEPARATOR = " ";


    protected static final String ACTION_UPDATE_WIDGET = "com.android.mail.ACTION_UPDATE_WIDGET";
    protected static final String
            ACTION_VALIDATE_ALL_WIDGETS = "com.android.mail.ACTION_VALIDATE_ALL_WIDGETS";
    protected static final String EXTRA_WIDGET_ID = "widgetId";

    private static final String LOG_TAG = LogTag.getLogTag();

    /**
     * Remove preferences when deleting widget
     */
    @Override
    public void onDeleted(Context context, int[] appWidgetIds) {
        super.onDeleted(context, appWidgetIds);

        // TODO: (mindyp) save widget information.
        MailPrefs.get(context).clearWidgets(appWidgetIds);
    }

    public static String getProviderName(Context context) {
        return context.getString(R.string.widget_provider);
    }

    /**
     * Note: this method calls {@link BaseWidgetProvider#getProviderName} and thus returns widget
     * IDs based on the widget_provider string resource. When subclassing, be sure to either
     * override this method or provide the correct provider name in the string resource.
     *
     * @return the list ids for the currently configured widgets.
     */
    protected int[] getCurrentWidgetIds(Context context) {
        final AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(context);
        final ComponentName mailComponent = new ComponentName(context, getProviderName(context));
        return appWidgetManager.getAppWidgetIds(mailComponent);
    }

    /**
     * Get an array of account/mailbox string pairs for currently configured widgets
     * @return the account/mailbox string pairs
     */
    static public String[][] getWidgetInfo(Context context, int[] widgetIds) {
        final String[][] widgetInfo = new String[widgetIds.length][2];
        for (int i = 0; i < widgetIds.length; i++) {
            // Retrieve the persisted information for this widget from
            // preferences.
            final String accountFolder = MailPrefs.get(context).getWidgetConfiguration(
                    widgetIds[i]);
            // If the account matched, update the widget.
            if (accountFolder != null) {
                widgetInfo[i] = TextUtils.split(accountFolder, ACCOUNT_FOLDER_PREFERENCE_SEPARATOR);
            }
        }
        return widgetInfo;
    }

    /**
     * Catches ACTION_NOTIFY_DATASET_CHANGED intent and update the corresponding
     * widgets.
     */
    @Override
    public void onReceive(Context context, Intent intent) {
        // We want to migrate any legacy Email widget information to the new format
        migrateAllLegacyWidgetInformation(context);

        super.onReceive(context, intent);
        LogUtils.d(LOG_TAG, "BaseWidgetProvider.onReceive: %s", intent);

        final String action = intent.getAction();
        if (ACTION_UPDATE_WIDGET.equals(action)) {
            final int widgetId = intent.getIntExtra(EXTRA_WIDGET_ID, -1);
            final Account account = Account.newInstance(intent.getStringExtra(Utils.EXTRA_ACCOUNT));
            final int folderType = intent.getIntExtra(EXTRA_FOLDER_TYPE, FolderType.DEFAULT);
            final int folderCapabilities = intent.getIntExtra(EXTRA_FOLDER_CAPABILITIES, 0);
            final Uri folderUri = intent.getParcelableExtra(EXTRA_FOLDER_URI);
            final Uri folderConversationListUri =
                    intent.getParcelableExtra(EXTRA_FOLDER_CONVERSATION_LIST_URI);
            final String folderDisplayName = intent.getStringExtra(EXTRA_FOLDER_DISPLAY_NAME);

            if (widgetId != -1 && account != null && folderUri != null) {
                updateWidgetInternal(context, widgetId, account, folderType, folderCapabilities,
                        folderUri, folderConversationListUri, folderDisplayName);
            }
        } else if (ACTION_VALIDATE_ALL_WIDGETS.equals(action)) {
            validateAllWidgetInformation(context);
        } else if (Utils.ACTION_NOTIFY_DATASET_CHANGED.equals(action)) {
            // Receive notification for a certain account.
            final Bundle extras = intent.getExtras();
            final Uri accountUri = extras.getParcelable(Utils.EXTRA_ACCOUNT_URI);
            final Uri folderUri = extras.getParcelable(Utils.EXTRA_FOLDER_URI);
            final boolean updateAllWidgets = extras.getBoolean(EXTRA_UPDATE_ALL_WIDGETS, false);

            if (accountUri == null && Utils.isEmpty(folderUri) && !updateAllWidgets) {
                return;
            }
            final Set<Integer> widgetsToUpdate = Sets.newHashSet();
            for (int id : getCurrentWidgetIds(context)) {
                // Retrieve the persisted information for this widget from
                // preferences.
                final String accountFolder = MailPrefs.get(context).getWidgetConfiguration(id);
                // If the account matched, update the widget.
                if (accountFolder != null) {
                    final String[] parsedInfo = TextUtils.split(accountFolder,
                            ACCOUNT_FOLDER_PREFERENCE_SEPARATOR);
                    boolean updateThis = updateAllWidgets;
                    if (!updateThis) {
                        if (accountUri != null &&
                                TextUtils.equals(accountUri.toString(), parsedInfo[0])) {
                            updateThis = true;
                        } else if (folderUri != null &&
                                TextUtils.equals(folderUri.toString(), parsedInfo[1])) {
                            updateThis = true;
                        }
                    }
                    if (updateThis) {
                        widgetsToUpdate.add(id);
                    }
                }
            }
            if (widgetsToUpdate.size() > 0) {
                final int[] widgets = Ints.toArray(widgetsToUpdate);
                AppWidgetManager.getInstance(context).notifyAppWidgetViewDataChanged(widgets,
                        R.id.conversation_list);
            }
        }
    }

    /**
     * Update all widgets in the list
     */
    @Override
    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
        migrateLegacyWidgets(context, appWidgetIds);

        super.onUpdate(context, appWidgetManager, appWidgetIds);
        // Update each of the widgets with a remote adapter

        new BulkUpdateAsyncTask(context, appWidgetIds).execute((Void[]) null);
    }

    private class BulkUpdateAsyncTask extends AsyncTask<Void, Void, Void> {
        private final Context mContext;
        private final int[] mAppWidgetIds;

        public BulkUpdateAsyncTask(final Context context, final int[] appWidgetIds) {
            mContext = context;
            mAppWidgetIds = appWidgetIds;
        }

        @Override
        protected Void doInBackground(final Void... params) {
            for (int i = 0; i < mAppWidgetIds.length; ++i) {
                // Get the account for this widget from preference
                final String accountFolder = MailPrefs.get(mContext).getWidgetConfiguration(
                        mAppWidgetIds[i]);
                String accountUri = null;
                Uri folderUri = null;
                if (!TextUtils.isEmpty(accountFolder)) {
                    final String[] parsedInfo = TextUtils.split(accountFolder,
                            ACCOUNT_FOLDER_PREFERENCE_SEPARATOR);
                    if (parsedInfo.length == 2) {
                        accountUri = parsedInfo[0];
                        folderUri = Uri.parse(parsedInfo[1]);
                    } else {
                        accountUri = accountFolder;
                        folderUri =  Uri.EMPTY;
                    }
                }
                // account will be null the first time a widget is created. This is
                // OK, as isAccountValid will return false, allowing the widget to
                // be configured.

                // Lookup the account by URI.
                Account account = null;
                if (!TextUtils.isEmpty(accountUri)) {
                    account = getAccountObject(mContext, accountUri);
                }
                if (Utils.isEmpty(folderUri) && account != null) {
                    folderUri = account.settings.defaultInbox;
                }

                Folder folder = null;

                if (folderUri != null) {
                    final Cursor folderCursor =
                            mContext.getContentResolver().query(folderUri,
                                    UIProvider.FOLDERS_PROJECTION, null, null, null);

                    if (folderCursor != null) {
                        try {
                            if (folderCursor.moveToFirst()) {
                                folder = new Folder(folderCursor);
                            }
                        } finally {
                            folderCursor.close();
                        }
                    }
                }

                updateWidgetInternal(mContext, mAppWidgetIds[i], account,
                        folder == null ? FolderType.DEFAULT : folder.type,
                        folder == null ? 0 : folder.capabilities,
                        folderUri,
                        folder == null ? null : folder.conversationListUri,
                        folder == null ? null : folder.name);
            }

            return null;
        }

    }

    protected Account getAccountObject(Context context, String accountUri) {
        final ContentResolver resolver = context.getContentResolver();
        Account account = null;
        Cursor accountCursor = null;
        try {
            accountCursor = resolver.query(Uri.parse(accountUri),
                    UIProvider.ACCOUNTS_PROJECTION, null, null, null);
            if (accountCursor != null) {
                if (accountCursor.moveToFirst()) {
                    account = Account.builder().buildFrom(accountCursor);
                }
            }
        } finally {
            if (accountCursor != null) {
                accountCursor.close();
            }
        }
        return account;
    }

    /**
     * Update the widget appWidgetId with the given account and folder
     */
    public static void updateWidget(Context context, int appWidgetId, Account account,
            final int folderType, final int folderCapabilities, final Uri folderUri,
            final Uri folderConversationListUri, final String folderDisplayName) {
        if (account == null || folderUri == null) {
            LogUtils.e(LOG_TAG,
                    "Missing account or folder.  account: %s folder %s", account, folderUri);
            return;
        }
        final Intent updateWidgetIntent = new Intent(ACTION_UPDATE_WIDGET);

        updateWidgetIntent.setType(account.mimeType);
        updateWidgetIntent.putExtra(EXTRA_WIDGET_ID, appWidgetId);
        updateWidgetIntent.putExtra(Utils.EXTRA_ACCOUNT, account.serialize());
        updateWidgetIntent.putExtra(EXTRA_FOLDER_TYPE, folderType);
        updateWidgetIntent.putExtra(EXTRA_FOLDER_CAPABILITIES, folderCapabilities);
        updateWidgetIntent.putExtra(EXTRA_FOLDER_URI, folderUri);

        if (folderConversationListUri != null) {
            updateWidgetIntent.putExtra(EXTRA_FOLDER_CONVERSATION_LIST_URI,
                    folderConversationListUri);
        }
        if (folderDisplayName != null) {
            updateWidgetIntent.putExtra(EXTRA_FOLDER_DISPLAY_NAME, folderDisplayName);
        }
        updateWidgetIntent.setPackage(context.getPackageName());

        context.sendBroadcast(updateWidgetIntent,
                context.getString(R.string.permission_update_widget));
    }

    public static void validateAllWidgets(Context context, String accountMimeType) {
        final Intent migrateAllWidgetsIntent = new Intent(ACTION_VALIDATE_ALL_WIDGETS);
        migrateAllWidgetsIntent.setType(accountMimeType);
        context.sendBroadcast(migrateAllWidgetsIntent);
    }

    protected void updateWidgetInternal(Context context, int appWidgetId, Account account,
            final int folderType, final int folderCapabilities, final Uri folderUri,
            final Uri folderConversationListUri, final String folderDisplayName) {
        final RemoteViews remoteViews = new RemoteViews(context.getPackageName(), R.layout.widget);

        if (!isAccountValid(context, account) || !isFolderValid(context, folderUri)) {
            // Widget has not been configured yet
            remoteViews.setViewVisibility(R.id.widget_folder, View.GONE);
            remoteViews.setViewVisibility(R.id.widget_compose, View.GONE);
            remoteViews.setViewVisibility(R.id.conversation_list, View.GONE);
            remoteViews.setViewVisibility(R.id.empty_conversation_list, View.GONE);
            remoteViews.setViewVisibility(R.id.widget_folder_not_synced, View.GONE);
            remoteViews.setViewVisibility(R.id.widget_configuration, View.VISIBLE);

            remoteViews.setTextViewText(R.id.empty_conversation_list,
                    context.getString(R.string.loading_conversations));

            final Intent configureIntent = new Intent(context, MailboxSelectionActivity.class);
            configureIntent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
            configureIntent.setData(Uri.parse(configureIntent.toUri(Intent.URI_INTENT_SCHEME)));
            configureIntent.setFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
            PendingIntent clickIntent = PendingIntent.getActivity(context, 0, configureIntent,
                    PendingIntent.FLAG_UPDATE_CURRENT);
            remoteViews.setOnClickPendingIntent(R.id.widget_configuration, clickIntent);
        } else {
            // Set folder to a space here to avoid flicker.
            configureValidAccountWidget(context, remoteViews, appWidgetId, account, folderType,
                    folderCapabilities, folderUri, folderConversationListUri,
                    folderDisplayName == null ? " " : folderDisplayName);

        }
        AppWidgetManager.getInstance(context).updateAppWidget(appWidgetId, remoteViews);
    }

    protected boolean isAccountValid(Context context, Account account) {
        if (account != null) {
            Account[] accounts = AccountUtils.getSyncingAccounts(context);
            for (Account existing : accounts) {
                if (existing != null && account.uri.equals(existing.uri)) {
                    return true;
                }
            }
        }
        return false;
    }

    protected boolean isFolderValid(Context context, Uri folderUri) {
        if (!Utils.isEmpty(folderUri)) {
            final Cursor folderCursor =
                    context.getContentResolver().query(folderUri,
                            UIProvider.FOLDERS_PROJECTION, null, null, null);

            try {
                if (folderCursor.moveToFirst()) {
                    return true;
                }
            } finally {
                folderCursor.close();
            }
        }
        return false;
    }

    protected void configureValidAccountWidget(Context context, RemoteViews remoteViews,
            int appWidgetId, Account account, final int folderType, final int folderCapabilities,
            final Uri folderUri, final Uri folderConversationListUri, String folderDisplayName) {
        WidgetService.configureValidAccountWidget(context, remoteViews, appWidgetId, account,
                folderType, folderCapabilities, folderUri, folderConversationListUri, folderDisplayName,
                WidgetService.class);
    }

    private void migrateAllLegacyWidgetInformation(Context context) {
        final int[] currentWidgetIds = getCurrentWidgetIds(context);
        migrateLegacyWidgets(context, currentWidgetIds);
    }

    private void migrateLegacyWidgets(Context context, int[] widgetIds) {
        for (int widgetId : widgetIds) {
            // We only want to bother to attempt to upgrade a widget if we don't already
            // have information about.
            if (!MailPrefs.get(context).isWidgetConfigured(widgetId)) {
                migrateLegacyWidgetInformation(context, widgetId);
            }
        }
    }

    private void validateAllWidgetInformation(Context context) {
        final int[] widgetIds = getCurrentWidgetIds(context);
        for (int widgetId : widgetIds) {
            final String accountFolder = MailPrefs.get(context).getWidgetConfiguration(widgetId);
            String accountUri = null;
            Uri folderUri = null;
            if (!TextUtils.isEmpty(accountFolder)) {
                final String[] parsedInfo = TextUtils.split(accountFolder,
                        ACCOUNT_FOLDER_PREFERENCE_SEPARATOR);
                if (parsedInfo.length == 2) {
                    accountUri = parsedInfo[0];
                    folderUri = Uri.parse(parsedInfo[1]);
                } else {
                    accountUri = accountFolder;
                    folderUri =  Uri.EMPTY;
                }
            }

            Account account = null;
            if (!TextUtils.isEmpty(accountUri)) {
                account = getAccountObject(context, accountUri);
            }

            // unconfigure the widget if it is not valid
            if (!isAccountValid(context, account) || !isFolderValid(context, folderUri)) {
                updateWidgetInternal(context, widgetId, null, FolderType.DEFAULT, 0, null, null,
                        null);
            }
        }
    }

    /**
     * Abstract method allowing extending classes to perform widget migration
     */
    protected abstract void migrateLegacyWidgetInformation(Context context, int widgetId);
}