Initial checkin of AOSP Messaging app.

b/23110861 Change-Id: I11db999bd10656801e618f78ab2b2ef74136fff1
2015-08-12 12:47:26 -07:00
parent ef8c7abbcf
commit d3b009ae55
1645 changed files with 186271 additions and 0 deletions
@@ -0,0 +1,316 @@
+/*
+ * Copyright (C) 2015 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.messaging.widget;
+
+import android.app.PendingIntent;
+import android.appwidget.AppWidgetManager;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Looper;
+import android.text.TextUtils;
+import android.view.View;
+import android.widget.RemoteViews;
+
+import com.android.messaging.R;
+import com.android.messaging.datamodel.MessagingContentProvider;
+import com.android.messaging.datamodel.data.ConversationListItemData;
+import com.android.messaging.ui.UIIntents;
+import com.android.messaging.ui.WidgetPickConversationActivity;
+import com.android.messaging.util.LogUtil;
+import com.android.messaging.util.OsUtil;
+import com.android.messaging.util.SafeAsyncTask;
+import com.android.messaging.util.UiUtils;
+
+public class WidgetConversationProvider extends BaseWidgetProvider {
+    public static final String ACTION_NOTIFY_MESSAGES_CHANGED =
+            "com.android.Bugle.intent.action.ACTION_NOTIFY_MESSAGES_CHANGED";
+
+    public static final int WIDGET_CONVERSATION_TEMPLATE_REQUEST_CODE = 1985;
+    public static final int WIDGET_CONVERSATION_REPLY_CODE = 1987;
+
+    // Intent extras
+    public static final String UI_INTENT_EXTRA_RECIPIENT = "recipient";
+    public static final String UI_INTENT_EXTRA_ICON = "icon";
+
+    /**
+     * Update the widget appWidgetId
+     */
+    @Override
+    protected void updateWidget(final Context context, final int appWidgetId) {
+        if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+            LogUtil.v(TAG, "updateWidget appWidgetId: " + appWidgetId);
+        }
+        if (OsUtil.hasRequiredPermissions()) {
+            rebuildWidget(context, appWidgetId);
+        } else {
+            AppWidgetManager.getInstance(context).updateAppWidget(appWidgetId,
+                    UiUtils.getWidgetMissingPermissionView(context));
+        }
+    }
+
+    @Override
+    protected String getAction() {
+        return ACTION_NOTIFY_MESSAGES_CHANGED;
+    }
+
+    @Override
+    protected int getListId() {
+        return R.id.message_list;
+    }
+
+    public static void rebuildWidget(final Context context, final int appWidgetId) {
+        if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+            LogUtil.v(TAG, "WidgetConversationProvider.rebuildWidget appWidgetId: " + appWidgetId);
+        }
+        final RemoteViews remoteViews = new RemoteViews(context.getPackageName(),
+                R.layout.widget_conversation);
+        PendingIntent clickIntent;
+        final UIIntents uiIntents = UIIntents.get();
+        if (!isWidgetConfigured(appWidgetId)) {
+            // Widget has not been configured yet. Hide the normal UI elements and show the
+            // configuration view instead.
+            remoteViews.setViewVisibility(R.id.widget_label, View.GONE);
+            remoteViews.setViewVisibility(R.id.message_list, View.GONE);
+            remoteViews.setViewVisibility(R.id.launcher_icon, View.VISIBLE);
+            remoteViews.setViewVisibility(R.id.widget_configuration, View.VISIBLE);
+
+            remoteViews.setOnClickPendingIntent(R.id.widget_configuration,
+                    uiIntents.getWidgetPendingIntentForConfigurationActivity(context, appWidgetId));
+
+            // On click intent for Goto Conversation List
+            clickIntent = uiIntents.getWidgetPendingIntentForConversationListActivity(context);
+            remoteViews.setOnClickPendingIntent(R.id.widget_header, clickIntent);
+
+            if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+                LogUtil.v(TAG, "WidgetConversationProvider.rebuildWidget appWidgetId: " +
+                        appWidgetId + " going into configure state");
+            }
+        } else {
+            remoteViews.setViewVisibility(R.id.widget_label, View.VISIBLE);
+            remoteViews.setViewVisibility(R.id.message_list, View.VISIBLE);
+            remoteViews.setViewVisibility(R.id.launcher_icon, View.GONE);
+            remoteViews.setViewVisibility(R.id.widget_configuration, View.GONE);
+
+            final String conversationId =
+                    WidgetPickConversationActivity.getConversationIdPref(appWidgetId);
+            final boolean isMainThread =  Looper.myLooper() == Looper.getMainLooper();
+            // If we're running on the UI thread, we can't do the DB access needed to get the
+            // conversation data. We'll do excute this again off of the UI thread.
+            final ConversationListItemData convData = isMainThread ?
+                    null : getConversationData(context, conversationId);
+
+            // Launch an intent to avoid ANRs
+            final Intent intent = new Intent(context, WidgetConversationService.class);
+            intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
+            intent.putExtra(UIIntents.UI_INTENT_EXTRA_CONVERSATION_ID, conversationId);
+            intent.setData(Uri.parse(intent.toUri(Intent.URI_INTENT_SCHEME)));
+            remoteViews.setRemoteAdapter(appWidgetId, R.id.message_list, intent);
+
+            remoteViews.setTextViewText(R.id.widget_label, convData != null ?
+                    convData.getName() : context.getString(R.string.app_name));
+
+            // On click intent for Goto Conversation List
+            clickIntent = uiIntents.getWidgetPendingIntentForConversationListActivity(context);
+            remoteViews.setOnClickPendingIntent(R.id.widget_goto_conversation_list, clickIntent);
+
+            // Open the conversation when click on header
+            clickIntent = uiIntents.getWidgetPendingIntentForConversationActivity(context,
+                    conversationId, WIDGET_CONVERSATION_REQUEST_CODE);
+            remoteViews.setOnClickPendingIntent(R.id.widget_header, clickIntent);
+
+            // On click intent for Conversation
+            // Note: the template intent has to be a "naked" intent without any extras. It turns out
+            // that if the template intent does have extras, those particular extras won't get
+            // replaced by the fill-in intent on each list item.
+            clickIntent = uiIntents.getWidgetPendingIntentForConversationActivity(context,
+                    conversationId, WIDGET_CONVERSATION_TEMPLATE_REQUEST_CODE);
+            remoteViews.setPendingIntentTemplate(R.id.message_list, clickIntent);
+
+            if (isMainThread) {
+                // We're running on the UI thread and we couldn't update all the parts of the
+                // widget dependent on ConversationListItemData. However, we have to update
+                // the widget regardless, even with those missing pieces. Here we update the
+                // widget again in the background.
+                SafeAsyncTask.executeOnThreadPool(new Runnable() {
+                    @Override
+                    public void run() {
+                        rebuildWidget(context, appWidgetId);
+                    }
+                });
+            }
+        }
+
+        AppWidgetManager.getInstance(context).updateAppWidget(appWidgetId, remoteViews);
+
+    }
+
+    /*
+     * notifyMessagesChanged called when the conversation changes so the widget will
+     * update and reflect the changes
+     */
+    public static void notifyMessagesChanged(final Context context, final String conversationId) {
+        if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+            LogUtil.v(TAG, "notifyMessagesChanged");
+        }
+        final Intent intent = new Intent(ACTION_NOTIFY_MESSAGES_CHANGED);
+        intent.putExtra(UIIntents.UI_INTENT_EXTRA_CONVERSATION_ID, conversationId);
+        context.sendBroadcast(intent);
+    }
+
+    /*
+     * notifyConversationDeleted is called when a conversation is deleted. Look through all the
+     * widgets and if they're displaying that conversation, force the widget into its
+     * configuration state.
+     */
+    public static void notifyConversationDeleted(final Context context,
+            final String conversationId) {
+        if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+            LogUtil.v(TAG, "notifyConversationDeleted convId: " + conversationId);
+        }
+
+        final AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(context);
+        for (final int appWidgetId : appWidgetManager.getAppWidgetIds(new ComponentName(context,
+                WidgetConversationProvider.class))) {
+            // Retrieve the persisted information for this widget from preferences.
+            final String widgetConvId =
+                    WidgetPickConversationActivity.getConversationIdPref(appWidgetId);
+
+            if (widgetConvId == null || widgetConvId.equals(conversationId)) {
+                if (widgetConvId != null) {
+                    WidgetPickConversationActivity.deleteConversationIdPref(appWidgetId);
+                }
+                rebuildWidget(context, appWidgetId);
+            }
+        }
+    }
+
+    /*
+     * notifyConversationRenamed is called when a conversation is renamed. Look through all the
+     * widgets and if they're displaying that conversation, force the widget to rebuild itself
+     */
+    public static void notifyConversationRenamed(final Context context,
+            final String conversationId) {
+        if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+            LogUtil.v(TAG, "notifyConversationRenamed convId: " + conversationId);
+        }
+
+        final AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(context);
+        for (final int appWidgetId : appWidgetManager.getAppWidgetIds(new ComponentName(context,
+                WidgetConversationProvider.class))) {
+            // Retrieve the persisted information for this widget from preferences.
+            final String widgetConvId =
+                    WidgetPickConversationActivity.getConversationIdPref(appWidgetId);
+
+            if (widgetConvId != null && widgetConvId.equals(conversationId)) {
+                rebuildWidget(context, appWidgetId);
+            }
+        }
+    }
+
+    @Override
+    public void onReceive(final Context context, final Intent intent) {
+        if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+            LogUtil.v(TAG, "WidgetConversationProvider onReceive intent: " + intent);
+        }
+        final String action = intent.getAction();
+
+        // The base class AppWidgetProvider's onReceive handles the normal widget intents. Here
+        // we're looking for an intent sent by our app when it knows a message has
+        // been sent or received (or a conversation has been read) and is telling the widget it
+        // needs to update.
+        if (getAction().equals(action)) {
+            final AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(context);
+            final int[] appWidgetIds = appWidgetManager.getAppWidgetIds(new ComponentName(context,
+                    this.getClass()));
+
+            if (appWidgetIds.length == 0) {
+                if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+                    LogUtil.v(TAG, "WidgetConversationProvider onReceive no widget ids");
+                }
+                return;
+            }
+            // Normally the conversation id points to a specific conversation and we only update
+            // widgets looking at that conversation. When the conversation id is null, that means
+            // there's been a massive change (such as the initial import) and we need to update
+            // every conversation widget.
+            final String conversationId = intent.getExtras()
+                    .getString(UIIntents.UI_INTENT_EXTRA_CONVERSATION_ID);
+
+            // Only update the widgets that match the conversation id that changed.
+            for (final int widgetId : appWidgetIds) {
+                // Retrieve the persisted information for this widget from preferences.
+                final String widgetConvId =
+                        WidgetPickConversationActivity.getConversationIdPref(widgetId);
+                if (conversationId == null || TextUtils.equals(conversationId, widgetConvId)) {
+                    // Update the list portion (i.e. the message list) of the widget
+                    appWidgetManager.notifyAppWidgetViewDataChanged(widgetId, getListId());
+                }
+            }
+        } else {
+            super.onReceive(context, intent);
+        }
+    }
+
+    private static ConversationListItemData getConversationData(final Context context,
+            final String conversationId) {
+        if (TextUtils.isEmpty(conversationId)) {
+            return null;
+        }
+        final Uri uri = MessagingContentProvider.buildConversationMetadataUri(conversationId);
+        Cursor cursor = null;
+        try {
+            cursor = context.getContentResolver().query(uri,
+                    ConversationListItemData.PROJECTION,
+                    null,       // selection
+                    null,       // selection args
+                    null);      // sort order
+            if (cursor != null && cursor.getCount() > 0) {
+                final ConversationListItemData conv = new ConversationListItemData();
+                cursor.moveToFirst();
+                conv.bind(cursor);
+                return conv;
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected void deletePreferences(final int widgetId) {
+        WidgetPickConversationActivity.deleteConversationIdPref(widgetId);
+    }
+
+    /**
+     * When this widget is created, it's created for a particular conversation and that
+     * ConversationId is stored in shared prefs. If the associated conversation is deleted,
+     * the widget doesn't get deleted. Instead, it goes into a "tap to configure" state. This
+     * function determines whether the widget has been configured and has an associated
+     * ConversationId.
+     */
+    public static boolean isWidgetConfigured(final int appWidgetId) {
+        final String conversationId =
+                WidgetPickConversationActivity.getConversationIdPref(appWidgetId);
+        return !TextUtils.isEmpty(conversationId);
+    }
+
+}