317 lines
14 KiB
Java
317 lines
14 KiB
Java
/*
|
|
* 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);
|
|
}
|
|
|
|
}
|