Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2012 Google Inc. |
| 3 | * Licensed to The Android Open Source Project. |
| 4 | * |
| 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at |
| 8 | * |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | * |
| 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
| 16 | */ |
| 17 | |
| 18 | package com.android.mail.ui; |
| 19 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 20 | |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 21 | import android.content.Context; |
Mindy Pereira | 8e91572 | 2012-02-16 14:42:56 -0800 | [diff] [blame] | 22 | import android.content.Loader; |
mindyp | ad0c30d | 2012-09-25 12:09:13 -0700 | [diff] [blame] | 23 | import android.content.res.Resources; |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 24 | import android.database.Cursor; |
Paul Westbrook | cebcc64 | 2012-08-08 10:06:04 -0700 | [diff] [blame] | 25 | import android.os.AsyncTask; |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 26 | import android.os.Bundle; |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 27 | import android.os.SystemClock; |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 28 | import android.text.TextUtils; |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 29 | import android.view.LayoutInflater; |
| 30 | import android.view.View; |
| 31 | import android.view.ViewGroup; |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 32 | import android.webkit.ConsoleMessage; |
Paul Westbrook | cebcc64 | 2012-08-08 10:06:04 -0700 | [diff] [blame] | 33 | import android.webkit.CookieManager; |
| 34 | import android.webkit.CookieSyncManager; |
Mindy Pereira | 974c966 | 2012-09-14 10:02:08 -0700 | [diff] [blame] | 35 | import android.webkit.JavascriptInterface; |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 36 | import android.webkit.WebChromeClient; |
| 37 | import android.webkit.WebSettings; |
Andy Huang | 17a9cde | 2012-03-09 18:03:16 -0800 | [diff] [blame] | 38 | import android.webkit.WebView; |
| 39 | import android.webkit.WebViewClient; |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 40 | import android.widget.TextView; |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 41 | |
Andy Huang | 59e0b18 | 2012-08-14 14:32:23 -0700 | [diff] [blame] | 42 | import com.android.mail.FormattedDateBuilder; |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 43 | import com.android.mail.R; |
Andy Huang | 5ff6374 | 2012-03-16 20:30:23 -0700 | [diff] [blame] | 44 | import com.android.mail.browse.ConversationContainer; |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 45 | import com.android.mail.browse.ConversationOverlayItem; |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 46 | import com.android.mail.browse.ConversationViewAdapter; |
Mark Wei | 56d8385 | 2012-09-19 14:28:50 -0700 | [diff] [blame] | 47 | import com.android.mail.browse.ScrollIndicatorsView; |
Andy Huang | 28b7aee | 2012-08-20 20:27:32 -0700 | [diff] [blame] | 48 | import com.android.mail.browse.ConversationViewAdapter.ConversationAccountController; |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 49 | import com.android.mail.browse.ConversationViewAdapter.MessageFooterItem; |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 50 | import com.android.mail.browse.ConversationViewAdapter.MessageHeaderItem; |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 51 | import com.android.mail.browse.ConversationViewAdapter.SuperCollapsedBlockItem; |
Andy Huang | 5ff6374 | 2012-03-16 20:30:23 -0700 | [diff] [blame] | 52 | import com.android.mail.browse.ConversationViewHeader; |
| 53 | import com.android.mail.browse.ConversationWebView; |
mindyp | dde3f9f | 2012-09-10 17:35:35 -0700 | [diff] [blame] | 54 | import com.android.mail.browse.ConversationWebView.ContentSizeChangeListener; |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 55 | import com.android.mail.browse.MessageCursor; |
Andy Huang | cd5c5ee | 2012-08-12 19:03:51 -0700 | [diff] [blame] | 56 | import com.android.mail.browse.MessageCursor.ConversationController; |
Andy Huang | 28b7aee | 2012-08-20 20:27:32 -0700 | [diff] [blame] | 57 | import com.android.mail.browse.MessageCursor.ConversationMessage; |
Andy Huang | 59e0b18 | 2012-08-14 14:32:23 -0700 | [diff] [blame] | 58 | import com.android.mail.browse.MessageHeaderView; |
Andy Huang | 3233bff | 2012-03-20 19:38:45 -0700 | [diff] [blame] | 59 | import com.android.mail.browse.MessageHeaderView.MessageHeaderViewCallbacks; |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 60 | import com.android.mail.browse.SuperCollapsedBlock; |
Andy Huang | 0b7ed6f | 2012-07-25 19:23:26 -0700 | [diff] [blame] | 61 | import com.android.mail.browse.WebViewContextMenu; |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 62 | import com.android.mail.providers.Account; |
Andy Huang | 65fe28f | 2012-04-06 18:08:53 -0700 | [diff] [blame] | 63 | import com.android.mail.providers.Address; |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 64 | import com.android.mail.providers.Conversation; |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 65 | import com.android.mail.providers.Message; |
Andy Huang | cd5c5ee | 2012-08-12 19:03:51 -0700 | [diff] [blame] | 66 | import com.android.mail.ui.ConversationViewState.ExpansionState; |
Paul Westbrook | b334c90 | 2012-06-25 11:42:46 -0700 | [diff] [blame] | 67 | import com.android.mail.utils.LogTag; |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 68 | import com.android.mail.utils.LogUtils; |
Andy Huang | 2e9acfe | 2012-03-15 22:39:36 -0700 | [diff] [blame] | 69 | import com.android.mail.utils.Utils; |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 70 | import com.google.common.collect.Lists; |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 71 | import com.google.common.collect.Sets; |
Andy Huang | 65fe28f | 2012-04-06 18:08:53 -0700 | [diff] [blame] | 72 | |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 73 | import java.util.List; |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 74 | import java.util.Set; |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 75 | |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 76 | |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 77 | /** |
| 78 | * The conversation view UI component. |
| 79 | */ |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 80 | public final class ConversationViewFragment extends AbstractConversationViewFragment implements |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 81 | MessageHeaderViewCallbacks, |
Andy Huang | cd5c5ee | 2012-08-12 19:03:51 -0700 | [diff] [blame] | 82 | SuperCollapsedBlock.OnClickListener, |
Andy Huang | 28b7aee | 2012-08-20 20:27:32 -0700 | [diff] [blame] | 83 | ConversationController, |
| 84 | ConversationAccountController { |
Mindy Pereira | 8e91572 | 2012-02-16 14:42:56 -0800 | [diff] [blame] | 85 | |
Paul Westbrook | b334c90 | 2012-06-25 11:42:46 -0700 | [diff] [blame] | 86 | private static final String LOG_TAG = LogTag.getLogTag(); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 87 | public static final String LAYOUT_TAG = "ConvLayout"; |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 88 | |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 89 | /** Do not auto load data when create this {@link ConversationView}. */ |
| 90 | public static final int NO_AUTO_LOAD = 0; |
| 91 | /** Auto load data but do not show any animation. */ |
| 92 | public static final int AUTO_LOAD_BACKGROUND = 1; |
| 93 | /** Auto load data and show animation. */ |
| 94 | public static final int AUTO_LOAD_VISIBLE = 2; |
| 95 | |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 96 | private ConversationContainer mConversationContainer; |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 97 | |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 98 | private ConversationWebView mWebView; |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 99 | |
Mark Wei | 56d8385 | 2012-09-19 14:28:50 -0700 | [diff] [blame] | 100 | private ScrollIndicatorsView mScrollIndicators; |
| 101 | |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 102 | private View mNewMessageBar; |
| 103 | |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 104 | private HtmlConversationTemplates mTemplates; |
| 105 | |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 106 | private final MailJsBridge mJsBridge = new MailJsBridge(); |
| 107 | |
Andy Huang | 17a9cde | 2012-03-09 18:03:16 -0800 | [diff] [blame] | 108 | private final WebViewClient mWebViewClient = new ConversationWebViewClient(); |
| 109 | |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 110 | private ConversationViewAdapter mAdapter; |
Andy Huang | 5106713 | 2012-03-12 20:08:19 -0700 | [diff] [blame] | 111 | |
| 112 | private boolean mViewsCreated; |
| 113 | |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 114 | /** |
| 115 | * Temporary string containing the message bodies of the messages within a super-collapsed |
| 116 | * block, for one-time use during block expansion. We cannot easily pass the body HTML |
| 117 | * into JS without problematic escaping, so hold onto it momentarily and signal JS to fetch it |
| 118 | * using {@link MailJsBridge}. |
| 119 | */ |
| 120 | private String mTempBodiesHtml; |
| 121 | |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 122 | private int mMaxAutoLoadMessages; |
| 123 | |
| 124 | private boolean mDeferredConversationLoad; |
| 125 | |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 126 | private boolean mEnableContentReadySignal; |
Andy Huang | 28b7aee | 2012-08-20 20:27:32 -0700 | [diff] [blame] | 127 | |
mindyp | dde3f9f | 2012-09-10 17:35:35 -0700 | [diff] [blame] | 128 | private ContentSizeChangeListener mWebViewSizeChangeListener; |
| 129 | |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 130 | private static final String BUNDLE_VIEW_STATE = "viewstate"; |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 131 | |
Andy Huang | bd544e3 | 2012-05-29 15:56:51 -0700 | [diff] [blame] | 132 | private static final boolean DEBUG_DUMP_CONVERSATION_HTML = false; |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 133 | private static final boolean DISABLE_OFFSCREEN_LOADING = false; |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 134 | protected static final String AUTO_LOAD_KEY = "auto-load"; |
Andy Huang | bd544e3 | 2012-05-29 15:56:51 -0700 | [diff] [blame] | 135 | |
Vikram Aggarwal | 6c51158 | 2012-02-27 10:59:47 -0800 | [diff] [blame] | 136 | /** |
| 137 | * Constructor needs to be public to handle orientation changes and activity lifecycle events. |
| 138 | */ |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 139 | public ConversationViewFragment() { |
Vikram Aggarwal | 6c51158 | 2012-02-27 10:59:47 -0800 | [diff] [blame] | 140 | super(); |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 141 | } |
| 142 | |
| 143 | /** |
| 144 | * Creates a new instance of {@link ConversationViewFragment}, initialized |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 145 | * to display a conversation with other parameters inherited/copied from an existing bundle, |
| 146 | * typically one created using {@link #makeBasicArgs}. |
| 147 | */ |
| 148 | public static ConversationViewFragment newInstance(Bundle existingArgs, |
| 149 | Conversation conversation) { |
| 150 | ConversationViewFragment f = new ConversationViewFragment(); |
| 151 | Bundle args = new Bundle(existingArgs); |
| 152 | args.putParcelable(ARG_CONVERSATION, conversation); |
| 153 | f.setArguments(args); |
| 154 | return f; |
| 155 | } |
| 156 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 157 | @Override |
| 158 | public void onAccountChanged() { |
| 159 | // settings may have been updated; refresh views that are known to |
| 160 | // depend on settings |
| 161 | mConversationContainer.getSnapHeader().onAccountChanged(); |
| 162 | mAdapter.notifyDataSetChanged(); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 163 | } |
| 164 | |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 165 | @Override |
| 166 | public void onActivityCreated(Bundle savedInstanceState) { |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 167 | LogUtils.d(LOG_TAG, "IN CVF.onActivityCreated, this=%s subj=%s", this, |
| 168 | mConversation.subject); |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 169 | super.onActivityCreated(savedInstanceState); |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 170 | Context context = getContext(); |
| 171 | mTemplates = new HtmlConversationTemplates(context); |
Andy Huang | 59e0b18 | 2012-08-14 14:32:23 -0700 | [diff] [blame] | 172 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 173 | final FormattedDateBuilder dateBuilder = new FormattedDateBuilder(context); |
Andy Huang | 59e0b18 | 2012-08-14 14:32:23 -0700 | [diff] [blame] | 174 | |
Paul Westbrook | 8081df4 | 2012-09-10 15:43:36 -0700 | [diff] [blame] | 175 | mAdapter = new ConversationViewAdapter(mActivity, this, |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 176 | getLoaderManager(), this, getContactInfoSource(), this, |
Paul Westbrook | 8081df4 | 2012-09-10 15:43:36 -0700 | [diff] [blame] | 177 | this, mAddressCache, dateBuilder); |
Andy Huang | 5106713 | 2012-03-12 20:08:19 -0700 | [diff] [blame] | 178 | mConversationContainer.setOverlayAdapter(mAdapter); |
| 179 | |
Andy Huang | 59e0b18 | 2012-08-14 14:32:23 -0700 | [diff] [blame] | 180 | // set up snap header (the adapter usually does this with the other ones) |
| 181 | final MessageHeaderView snapHeader = mConversationContainer.getSnapHeader(); |
Andy Huang | 28b7aee | 2012-08-20 20:27:32 -0700 | [diff] [blame] | 182 | snapHeader.initialize(dateBuilder, this, mAddressCache); |
Andy Huang | 59e0b18 | 2012-08-14 14:32:23 -0700 | [diff] [blame] | 183 | snapHeader.setCallbacks(this); |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 184 | snapHeader.setContactInfoSource(getContactInfoSource()); |
Andy Huang | 59e0b18 | 2012-08-14 14:32:23 -0700 | [diff] [blame] | 185 | |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 186 | mMaxAutoLoadMessages = getResources().getInteger(R.integer.max_auto_load_messages); |
| 187 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 188 | mWebView.setOnCreateContextMenuListener(new WebViewContextMenu(getActivity())); |
Andy Huang | 0b7ed6f | 2012-07-25 19:23:26 -0700 | [diff] [blame] | 189 | |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 190 | showConversation(); |
Paul Westbrook | cebcc64 | 2012-08-08 10:06:04 -0700 | [diff] [blame] | 191 | |
| 192 | if (mConversation.conversationBaseUri != null && |
| 193 | !TextUtils.isEmpty(mConversation.conversationCookie)) { |
| 194 | // Set the cookie for this base url |
| 195 | new SetCookieTask(mConversation.conversationBaseUri.toString(), |
| 196 | mConversation.conversationCookie).execute(); |
| 197 | } |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 198 | } |
| 199 | |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 200 | @Override |
| 201 | public View onCreateView(LayoutInflater inflater, |
| 202 | ViewGroup container, Bundle savedInstanceState) { |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 203 | if (savedInstanceState != null) { |
| 204 | mViewState = savedInstanceState.getParcelable(BUNDLE_VIEW_STATE); |
| 205 | } else { |
Paul Westbrook | 4d8cad5 | 2012-09-21 14:13:49 -0700 | [diff] [blame] | 206 | mViewState = getNewViewState(); |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 207 | } |
| 208 | |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 209 | View rootView = inflater.inflate(R.layout.conversation_view, container, false); |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 210 | mConversationContainer = (ConversationContainer) rootView |
| 211 | .findViewById(R.id.conversation_container); |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 212 | |
| 213 | mNewMessageBar = mConversationContainer.findViewById(R.id.new_message_notification_bar); |
| 214 | mNewMessageBar.setOnClickListener(new View.OnClickListener() { |
| 215 | @Override |
| 216 | public void onClick(View v) { |
| 217 | onNewMessageBarClick(); |
| 218 | } |
| 219 | }); |
| 220 | |
mindyp | ff282d0 | 2012-09-17 10:33:02 -0700 | [diff] [blame] | 221 | instantiateProgressIndicators(rootView); |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 222 | |
Andy Huang | 5ff6374 | 2012-03-16 20:30:23 -0700 | [diff] [blame] | 223 | mWebView = (ConversationWebView) mConversationContainer.findViewById(R.id.webview); |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 224 | |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 225 | mWebView.addJavascriptInterface(mJsBridge, "mail"); |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 226 | // On JB or newer, we use the 'webkitAnimationStart' DOM event to signal load complete |
| 227 | // Below JB, try to speed up initial render by having the webview do supplemental draws to |
| 228 | // custom a software canvas. |
mindyp | b941fdb | 2012-09-11 08:28:23 -0700 | [diff] [blame] | 229 | // TODO(mindyp): |
| 230 | //PAGE READINESS SIGNAL FOR JELLYBEAN AND NEWER |
| 231 | // Notify the app on 'webkitAnimationStart' of a simple dummy element with a simple no-op |
| 232 | // animation that immediately runs on page load. The app uses this as a signal that the |
| 233 | // content is loaded and ready to draw, since WebView delays firing this event until the |
| 234 | // layers are composited and everything is ready to draw. |
| 235 | // This signal does not seem to be reliable, so just use the old method for now. |
mindyp | 32d911f | 2012-09-24 15:14:22 -0700 | [diff] [blame] | 236 | mEnableContentReadySignal = Utils.isRunningJellybeanOrLater(); |
mindyp | afc9b36 | 2012-09-25 09:20:47 -0700 | [diff] [blame] | 237 | mWebView.setUseSoftwareLayer(!mEnableContentReadySignal); |
Andy Huang | 17a9cde | 2012-03-09 18:03:16 -0800 | [diff] [blame] | 238 | mWebView.setWebViewClient(mWebViewClient); |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 239 | mWebView.setWebChromeClient(new WebChromeClient() { |
| 240 | @Override |
| 241 | public boolean onConsoleMessage(ConsoleMessage consoleMessage) { |
| 242 | LogUtils.i(LOG_TAG, "JS: %s (%s:%d)", consoleMessage.message(), |
| 243 | consoleMessage.sourceId(), consoleMessage.lineNumber()); |
| 244 | return true; |
| 245 | } |
| 246 | }); |
| 247 | |
Andy Huang | 3233bff | 2012-03-20 19:38:45 -0700 | [diff] [blame] | 248 | final WebSettings settings = mWebView.getSettings(); |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 249 | |
Mark Wei | 56d8385 | 2012-09-19 14:28:50 -0700 | [diff] [blame] | 250 | mScrollIndicators = (ScrollIndicatorsView) rootView.findViewById(R.id.scroll_indicators); |
| 251 | mScrollIndicators.setSourceView(mWebView); |
| 252 | |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 253 | settings.setJavaScriptEnabled(true); |
| 254 | settings.setUseWideViewPort(true); |
Andy Huang | 2301470 | 2012-07-09 12:50:36 -0700 | [diff] [blame] | 255 | settings.setLoadWithOverviewMode(true); |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 256 | |
| 257 | settings.setSupportZoom(true); |
| 258 | settings.setBuiltInZoomControls(true); |
| 259 | settings.setDisplayZoomControls(false); |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 260 | |
Andy Huang | c319b55 | 2012-04-25 19:53:50 -0700 | [diff] [blame] | 261 | final float fontScale = getResources().getConfiguration().fontScale; |
Andy Huang | ba28373 | 2012-06-25 19:14:10 -0700 | [diff] [blame] | 262 | final int desiredFontSizePx = getResources() |
| 263 | .getInteger(R.integer.conversation_desired_font_size_px); |
| 264 | final int unstyledFontSizePx = getResources() |
| 265 | .getInteger(R.integer.conversation_unstyled_font_size_px); |
Andy Huang | c319b55 | 2012-04-25 19:53:50 -0700 | [diff] [blame] | 266 | |
Andy Huang | ba28373 | 2012-06-25 19:14:10 -0700 | [diff] [blame] | 267 | int textZoom = settings.getTextZoom(); |
| 268 | // apply a correction to the default body text style to get regular text to the size we want |
| 269 | textZoom = textZoom * desiredFontSizePx / unstyledFontSizePx; |
| 270 | // then apply any system font scaling |
Andy Huang | c319b55 | 2012-04-25 19:53:50 -0700 | [diff] [blame] | 271 | textZoom = (int) (textZoom * fontScale); |
| 272 | settings.setTextZoom(textZoom); |
| 273 | |
Andy Huang | 5106713 | 2012-03-12 20:08:19 -0700 | [diff] [blame] | 274 | mViewsCreated = true; |
| 275 | |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 276 | return rootView; |
| 277 | } |
| 278 | |
| 279 | @Override |
Andy Huang | a6e965e | 2012-08-21 13:44:34 -0700 | [diff] [blame] | 280 | public void onResume() { |
| 281 | super.onResume(); |
| 282 | |
| 283 | // Hacky workaround for http://b/6946182 |
| 284 | Utils.fixSubTreeLayoutIfOrphaned(getView(), "ConversationViewFragment"); |
| 285 | } |
| 286 | |
| 287 | @Override |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 288 | public void onSaveInstanceState(Bundle outState) { |
| 289 | if (mViewState != null) { |
| 290 | outState.putParcelable(BUNDLE_VIEW_STATE, mViewState); |
| 291 | } |
| 292 | } |
| 293 | |
| 294 | @Override |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 295 | public void onDestroyView() { |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 296 | super.onDestroyView(); |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 297 | mConversationContainer.setOverlayAdapter(null); |
| 298 | mAdapter = null; |
Andy Huang | 5106713 | 2012-03-12 20:08:19 -0700 | [diff] [blame] | 299 | mViewsCreated = false; |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 300 | } |
| 301 | |
Andy Huang | 5ff6374 | 2012-03-16 20:30:23 -0700 | [diff] [blame] | 302 | @Override |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 303 | protected void markUnread() { |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 304 | // Ignore unsafe calls made after a fragment is detached from an activity |
| 305 | final ControllableActivity activity = (ControllableActivity) getActivity(); |
| 306 | if (activity == null) { |
| 307 | LogUtils.w(LOG_TAG, "ignoring markUnread for conv=%s", mConversation.id); |
| 308 | return; |
| 309 | } |
| 310 | |
Andy Huang | 28e31e2 | 2012-07-26 16:33:15 -0700 | [diff] [blame] | 311 | if (mViewState == null) { |
| 312 | LogUtils.i(LOG_TAG, "ignoring markUnread for conv with no view state (%d)", |
| 313 | mConversation.id); |
| 314 | return; |
| 315 | } |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 316 | activity.getConversationUpdater().markConversationMessagesUnread(mConversation, |
Vikram Aggarwal | 4a878b6 | 2012-07-31 15:09:25 -0700 | [diff] [blame] | 317 | mViewState.getUnreadMessageUris(), mViewState.getConversationInfo()); |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 318 | } |
| 319 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 320 | @Override |
| 321 | public void onUserVisibleHintChanged() { |
| 322 | if (mUserVisible && mViewsCreated) { |
| 323 | Cursor cursor = getMessageCursor(); |
| 324 | if (cursor == null && mDeferredConversationLoad) { |
| 325 | // load |
| 326 | LogUtils.v(LOG_TAG, "Fragment is now user-visible, showing conversation: %s", |
| 327 | mConversation.uri); |
| 328 | showConversation(); |
| 329 | mDeferredConversationLoad = false; |
| 330 | } else { |
| 331 | onConversationSeen(); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 332 | } |
mindyp | 32d911f | 2012-09-24 15:14:22 -0700 | [diff] [blame] | 333 | } else if (!mUserVisible) { |
| 334 | dismissLoadingStatus(); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 335 | } |
| 336 | } |
| 337 | |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 338 | private void showConversation() { |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 339 | final boolean disableOffscreenLoading = DISABLE_OFFSCREEN_LOADING |
| 340 | || (mConversation.isRemote |
| 341 | || mConversation.getNumMessages() > mMaxAutoLoadMessages); |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 342 | if (!mUserVisible && disableOffscreenLoading) { |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 343 | LogUtils.v(LOG_TAG, "Fragment not user-visible, not showing conversation: %s", |
| 344 | mConversation.uri); |
| 345 | mDeferredConversationLoad = true; |
| 346 | return; |
| 347 | } |
| 348 | LogUtils.v(LOG_TAG, |
| 349 | "Fragment is short or user-visible, immediately rendering conversation: %s", |
| 350 | mConversation.uri); |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 351 | mWebView.setVisibility(View.VISIBLE); |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 352 | getLoaderManager().initLoader(MESSAGE_LOADER, Bundle.EMPTY, getMessageLoaderCallbacks()); |
Andy Huang | 5460ce4 | 2012-08-16 19:38:27 -0700 | [diff] [blame] | 353 | if (mUserVisible) { |
| 354 | final SubjectDisplayChanger sdc = mActivity.getSubjectDisplayChanger(); |
| 355 | if (sdc != null) { |
| 356 | sdc.setSubject(mConversation.subject); |
| 357 | } |
| 358 | } |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 359 | // TODO(mindyp): don't show loading status for a previously rendered |
| 360 | // conversation. Ielieve this is better done by making sure don't show loading status |
| 361 | // until XX ms have passed without loading completed. |
| 362 | showLoadingStatus(); |
Mindy Pereira | 8e91572 | 2012-02-16 14:42:56 -0800 | [diff] [blame] | 363 | } |
| 364 | |
Andy Huang | 5106713 | 2012-03-12 20:08:19 -0700 | [diff] [blame] | 365 | private void renderConversation(MessageCursor messageCursor) { |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 366 | final String convHtml = renderMessageBodies(messageCursor, mEnableContentReadySignal); |
Andy Huang | bd544e3 | 2012-05-29 15:56:51 -0700 | [diff] [blame] | 367 | |
| 368 | if (DEBUG_DUMP_CONVERSATION_HTML) { |
| 369 | java.io.FileWriter fw = null; |
| 370 | try { |
| 371 | fw = new java.io.FileWriter("/sdcard/conv" + mConversation.id |
| 372 | + ".html"); |
| 373 | fw.write(convHtml); |
| 374 | } catch (java.io.IOException e) { |
| 375 | e.printStackTrace(); |
| 376 | } finally { |
| 377 | if (fw != null) { |
| 378 | try { |
| 379 | fw.close(); |
| 380 | } catch (java.io.IOException e) { |
| 381 | e.printStackTrace(); |
| 382 | } |
| 383 | } |
| 384 | } |
| 385 | } |
| 386 | |
| 387 | mWebView.loadDataWithBaseURL(mBaseUri, convHtml, "text/html", "utf-8", null); |
Andy Huang | 5106713 | 2012-03-12 20:08:19 -0700 | [diff] [blame] | 388 | } |
| 389 | |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 390 | /** |
| 391 | * Populate the adapter with overlay views (message headers, super-collapsed blocks, a |
| 392 | * conversation header), and return an HTML document with spacer divs inserted for all overlays. |
| 393 | * |
| 394 | */ |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 395 | private String renderMessageBodies(MessageCursor messageCursor, |
| 396 | boolean enableContentReadySignal) { |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 397 | int pos = -1; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 398 | |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 399 | LogUtils.d(LOG_TAG, "IN renderMessageBodies, fragment=%s", this); |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 400 | boolean allowNetworkImages = false; |
| 401 | |
Andy Huang | c754357 | 2012-04-03 15:34:29 -0700 | [diff] [blame] | 402 | // TODO: re-use any existing adapter item state (expanded, details expanded, show pics) |
Andy Huang | 28b7aee | 2012-08-20 20:27:32 -0700 | [diff] [blame] | 403 | |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 404 | // Walk through the cursor and build up an overlay adapter as you go. |
| 405 | // Each overlay has an entry in the adapter for easy scroll handling in the container. |
| 406 | // Items are not necessarily 1:1 in cursor and adapter because of super-collapsed blocks. |
| 407 | // When adding adapter items, also add their heights to help the container later determine |
| 408 | // overlay dimensions. |
| 409 | |
Andy Huang | db620fe | 2012-08-24 15:45:28 -0700 | [diff] [blame] | 410 | // When re-rendering, prevent ConversationContainer from laying out overlays until after |
| 411 | // the new spacers are positioned by WebView. |
| 412 | mConversationContainer.invalidateSpacerGeometry(); |
| 413 | |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 414 | mAdapter.clear(); |
| 415 | |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 416 | // re-evaluate the message parts of the view state, since the messages may have changed |
| 417 | // since the previous render |
| 418 | final ConversationViewState prevState = mViewState; |
| 419 | mViewState = new ConversationViewState(prevState); |
| 420 | |
Andy Huang | 5ff6374 | 2012-03-16 20:30:23 -0700 | [diff] [blame] | 421 | // N.B. the units of height for spacers are actually dp and not px because WebView assumes |
Andy Huang | 2e9acfe | 2012-03-15 22:39:36 -0700 | [diff] [blame] | 422 | // a pixel is an mdpi pixel, unless you set device-dpi. |
Andy Huang | 5ff6374 | 2012-03-16 20:30:23 -0700 | [diff] [blame] | 423 | |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 424 | // add a single conversation header item |
| 425 | final int convHeaderPos = mAdapter.addConversationHeader(mConversation); |
Andy Huang | 2301470 | 2012-07-09 12:50:36 -0700 | [diff] [blame] | 426 | final int convHeaderPx = measureOverlayHeight(convHeaderPos); |
Andy Huang | 5ff6374 | 2012-03-16 20:30:23 -0700 | [diff] [blame] | 427 | |
Andy Huang | 256b35c | 2012-08-22 15:19:13 -0700 | [diff] [blame] | 428 | final int sideMarginPx = getResources().getDimensionPixelOffset( |
| 429 | R.dimen.conversation_view_margin_side) + getResources().getDimensionPixelOffset( |
| 430 | R.dimen.conversation_message_content_margin_side); |
| 431 | |
| 432 | mTemplates.startConversation(mWebView.screenPxToWebPx(sideMarginPx), |
| 433 | mWebView.screenPxToWebPx(convHeaderPx)); |
Andy Huang | 3233bff | 2012-03-20 19:38:45 -0700 | [diff] [blame] | 434 | |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 435 | int collapsedStart = -1; |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 436 | ConversationMessage prevCollapsedMsg = null; |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 437 | boolean prevSafeForImages = false; |
| 438 | |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 439 | while (messageCursor.moveToPosition(++pos)) { |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 440 | final ConversationMessage msg = messageCursor.getMessage(); |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 441 | |
Andy Huang | 3233bff | 2012-03-20 19:38:45 -0700 | [diff] [blame] | 442 | // TODO: save/restore 'show pics' state |
| 443 | final boolean safeForImages = msg.alwaysShowImages /* || savedStateSaysSafe */; |
| 444 | allowNetworkImages |= safeForImages; |
Andy Huang | 2405528 | 2012-03-27 17:37:06 -0700 | [diff] [blame] | 445 | |
Paul Westbrook | 08098ec | 2012-08-12 15:30:28 -0700 | [diff] [blame] | 446 | final Integer savedExpanded = prevState.getExpansionState(msg); |
| 447 | final int expandedState; |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 448 | if (savedExpanded != null) { |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 449 | if (ExpansionState.isSuperCollapsed(savedExpanded) && messageCursor.isLast()) { |
| 450 | // override saved state when this is now the new last message |
| 451 | // this happens to the second-to-last message when you discard a draft |
| 452 | expandedState = ExpansionState.EXPANDED; |
| 453 | } else { |
| 454 | expandedState = savedExpanded; |
| 455 | } |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 456 | } else { |
Andy Huang | cd5c5ee | 2012-08-12 19:03:51 -0700 | [diff] [blame] | 457 | // new messages that are not expanded default to being eligible for super-collapse |
Paul Westbrook | 08098ec | 2012-08-12 15:30:28 -0700 | [diff] [blame] | 458 | expandedState = (!msg.read || msg.starred || messageCursor.isLast()) ? |
Andy Huang | cd5c5ee | 2012-08-12 19:03:51 -0700 | [diff] [blame] | 459 | ExpansionState.EXPANDED : ExpansionState.SUPER_COLLAPSED; |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 460 | } |
Paul Westbrook | 08098ec | 2012-08-12 15:30:28 -0700 | [diff] [blame] | 461 | mViewState.setExpansionState(msg, expandedState); |
Andy Huang | c754357 | 2012-04-03 15:34:29 -0700 | [diff] [blame] | 462 | |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 463 | // save off "read" state from the cursor |
| 464 | // later, the view may not match the cursor (e.g. conversation marked read on open) |
Andy Huang | 423bea2 | 2012-08-21 12:00:49 -0700 | [diff] [blame] | 465 | // however, if a previous state indicated this message was unread, trust that instead |
| 466 | // so "mark unread" marks all originally unread messages |
| 467 | mViewState.setReadState(msg, msg.read && !prevState.isUnread(msg)); |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 468 | |
Andy Huang | cd5c5ee | 2012-08-12 19:03:51 -0700 | [diff] [blame] | 469 | // We only want to consider this for inclusion in the super collapsed block if |
| 470 | // 1) The we don't have previous state about this message (The first time that the |
| 471 | // user opens a conversation) |
| 472 | // 2) The previously saved state for this message indicates that this message is |
| 473 | // in the super collapsed block. |
| 474 | if (ExpansionState.isSuperCollapsed(expandedState)) { |
| 475 | // contribute to a super-collapsed block that will be emitted just before the |
| 476 | // next expanded header |
| 477 | if (collapsedStart < 0) { |
| 478 | collapsedStart = pos; |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 479 | } |
Andy Huang | cd5c5ee | 2012-08-12 19:03:51 -0700 | [diff] [blame] | 480 | prevCollapsedMsg = msg; |
| 481 | prevSafeForImages = safeForImages; |
| 482 | continue; |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 483 | } |
Andy Huang | 2405528 | 2012-03-27 17:37:06 -0700 | [diff] [blame] | 484 | |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 485 | // resolve any deferred decisions on previous collapsed items |
| 486 | if (collapsedStart >= 0) { |
| 487 | if (pos - collapsedStart == 1) { |
| 488 | // special-case for a single collapsed message: no need to super-collapse it |
| 489 | renderMessage(prevCollapsedMsg, false /* expanded */, |
| 490 | prevSafeForImages); |
| 491 | } else { |
| 492 | renderSuperCollapsedBlock(collapsedStart, pos - 1); |
| 493 | } |
| 494 | prevCollapsedMsg = null; |
| 495 | collapsedStart = -1; |
| 496 | } |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 497 | |
Paul Westbrook | 08098ec | 2012-08-12 15:30:28 -0700 | [diff] [blame] | 498 | renderMessage(msg, ExpansionState.isExpanded(expandedState), safeForImages); |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 499 | } |
Andy Huang | 3233bff | 2012-03-20 19:38:45 -0700 | [diff] [blame] | 500 | |
| 501 | mWebView.getSettings().setBlockNetworkImage(!allowNetworkImages); |
| 502 | |
Paul Westbrook | cebcc64 | 2012-08-08 10:06:04 -0700 | [diff] [blame] | 503 | // If the conversation has specified a base uri, use it here, use mBaseUri |
| 504 | final String conversationBaseUri = mConversation.conversationBaseUri != null ? |
| 505 | mConversation.conversationBaseUri.toString() : mBaseUri; |
| 506 | return mTemplates.endConversation(mBaseUri, conversationBaseUri, 320, |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 507 | mWebView.getViewportWidth(), enableContentReadySignal); |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 508 | } |
Mindy Pereira | 674afa4 | 2012-02-17 14:05:24 -0800 | [diff] [blame] | 509 | |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 510 | private void renderSuperCollapsedBlock(int start, int end) { |
| 511 | final int blockPos = mAdapter.addSuperCollapsedBlock(start, end); |
Andy Huang | 2301470 | 2012-07-09 12:50:36 -0700 | [diff] [blame] | 512 | final int blockPx = measureOverlayHeight(blockPos); |
| 513 | mTemplates.appendSuperCollapsedHtml(start, mWebView.screenPxToWebPx(blockPx)); |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 514 | } |
| 515 | |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 516 | private void renderMessage(ConversationMessage msg, boolean expanded, |
| 517 | boolean safeForImages) { |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 518 | final int headerPos = mAdapter.addMessageHeader(msg, expanded); |
| 519 | final MessageHeaderItem headerItem = (MessageHeaderItem) mAdapter.getItem(headerPos); |
| 520 | |
| 521 | final int footerPos = mAdapter.addMessageFooter(headerItem); |
| 522 | |
| 523 | // Measure item header and footer heights to allocate spacers in HTML |
| 524 | // But since the views themselves don't exist yet, render each item temporarily into |
| 525 | // a host view for measurement. |
Andy Huang | 2301470 | 2012-07-09 12:50:36 -0700 | [diff] [blame] | 526 | final int headerPx = measureOverlayHeight(headerPos); |
| 527 | final int footerPx = measureOverlayHeight(footerPos); |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 528 | |
Andy Huang | 256b35c | 2012-08-22 15:19:13 -0700 | [diff] [blame] | 529 | mTemplates.appendMessageHtml(msg, expanded, safeForImages, |
Andy Huang | 2301470 | 2012-07-09 12:50:36 -0700 | [diff] [blame] | 530 | mWebView.screenPxToWebPx(headerPx), mWebView.screenPxToWebPx(footerPx)); |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 531 | } |
| 532 | |
| 533 | private String renderCollapsedHeaders(MessageCursor cursor, |
| 534 | SuperCollapsedBlockItem blockToReplace) { |
| 535 | final List<ConversationOverlayItem> replacements = Lists.newArrayList(); |
| 536 | |
| 537 | mTemplates.reset(); |
| 538 | |
Mark Wei | 2b24e99 | 2012-09-10 16:40:07 -0700 | [diff] [blame] | 539 | // In devices with non-integral density multiplier, screen pixels translate to non-integral |
| 540 | // web pixels. Keep track of the error that occurs when we cast all heights to int |
| 541 | float error = 0f; |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 542 | for (int i = blockToReplace.getStart(), end = blockToReplace.getEnd(); i <= end; i++) { |
| 543 | cursor.moveToPosition(i); |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 544 | final ConversationMessage msg = cursor.getMessage(); |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 545 | final MessageHeaderItem header = mAdapter.newMessageHeaderItem(msg, |
| 546 | false /* expanded */); |
| 547 | final MessageFooterItem footer = mAdapter.newMessageFooterItem(header); |
| 548 | |
Andy Huang | 2301470 | 2012-07-09 12:50:36 -0700 | [diff] [blame] | 549 | final int headerPx = measureOverlayHeight(header); |
| 550 | final int footerPx = measureOverlayHeight(footer); |
Mark Wei | 2b24e99 | 2012-09-10 16:40:07 -0700 | [diff] [blame] | 551 | error += mWebView.screenPxToWebPxError(headerPx) |
| 552 | + mWebView.screenPxToWebPxError(footerPx); |
| 553 | |
| 554 | // When the error becomes greater than 1 pixel, make the next header 1 pixel taller |
| 555 | int correction = 0; |
| 556 | if (error >= 1) { |
| 557 | correction = 1; |
| 558 | error -= 1; |
| 559 | } |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 560 | |
Andy Huang | 256b35c | 2012-08-22 15:19:13 -0700 | [diff] [blame] | 561 | mTemplates.appendMessageHtml(msg, false /* expanded */, msg.alwaysShowImages, |
Mark Wei | 2b24e99 | 2012-09-10 16:40:07 -0700 | [diff] [blame] | 562 | mWebView.screenPxToWebPx(headerPx) + correction, |
| 563 | mWebView.screenPxToWebPx(footerPx)); |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 564 | replacements.add(header); |
| 565 | replacements.add(footer); |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 566 | |
Paul Westbrook | 08098ec | 2012-08-12 15:30:28 -0700 | [diff] [blame] | 567 | mViewState.setExpansionState(msg, ExpansionState.COLLAPSED); |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 568 | } |
| 569 | |
| 570 | mAdapter.replaceSuperCollapsedBlock(blockToReplace, replacements); |
| 571 | |
| 572 | return mTemplates.emit(); |
| 573 | } |
| 574 | |
| 575 | private int measureOverlayHeight(int position) { |
| 576 | return measureOverlayHeight(mAdapter.getItem(position)); |
| 577 | } |
| 578 | |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 579 | /** |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 580 | * Measure the height of an adapter view by rendering an adapter item into a temporary |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 581 | * host view, and asking the view to immediately measure itself. This method will reuse |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 582 | * a previous adapter view from {@link ConversationContainer}'s scrap views if one was generated |
| 583 | * earlier. |
| 584 | * <p> |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 585 | * After measuring the height, this method also saves the height in the |
| 586 | * {@link ConversationOverlayItem} for later use in overlay positioning. |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 587 | * |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 588 | * @param convItem adapter item with data to render and measure |
Andy Huang | 2301470 | 2012-07-09 12:50:36 -0700 | [diff] [blame] | 589 | * @return height of the rendered view in screen px |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 590 | */ |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 591 | private int measureOverlayHeight(ConversationOverlayItem convItem) { |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 592 | final int type = convItem.getType(); |
| 593 | |
| 594 | final View convertView = mConversationContainer.getScrapView(type); |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 595 | final View hostView = mAdapter.getView(convItem, convertView, mConversationContainer, |
| 596 | true /* measureOnly */); |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 597 | if (convertView == null) { |
| 598 | mConversationContainer.addScrapView(type, hostView); |
| 599 | } |
| 600 | |
Andy Huang | 9875bb4 | 2012-04-04 20:36:21 -0700 | [diff] [blame] | 601 | final int heightPx = mConversationContainer.measureOverlay(hostView); |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 602 | convItem.setHeight(heightPx); |
Andy Huang | 9875bb4 | 2012-04-04 20:36:21 -0700 | [diff] [blame] | 603 | convItem.markMeasurementValid(); |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 604 | |
Andy Huang | 2301470 | 2012-07-09 12:50:36 -0700 | [diff] [blame] | 605 | return heightPx; |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 606 | } |
| 607 | |
Andy Huang | 5ff6374 | 2012-03-16 20:30:23 -0700 | [diff] [blame] | 608 | @Override |
| 609 | public void onConversationViewHeaderHeightChange(int newHeight) { |
| 610 | // TODO: propagate the new height to the header's HTML spacer. This can happen when labels |
| 611 | // are added/removed |
| 612 | } |
| 613 | |
Andy Huang | 3233bff | 2012-03-20 19:38:45 -0700 | [diff] [blame] | 614 | // END conversation header callbacks |
| 615 | |
| 616 | // START message header callbacks |
| 617 | @Override |
Andy Huang | c754357 | 2012-04-03 15:34:29 -0700 | [diff] [blame] | 618 | public void setMessageSpacerHeight(MessageHeaderItem item, int newSpacerHeightPx) { |
| 619 | mConversationContainer.invalidateSpacerGeometry(); |
| 620 | |
| 621 | // update message HTML spacer height |
Andy Huang | 2301470 | 2012-07-09 12:50:36 -0700 | [diff] [blame] | 622 | final int h = mWebView.screenPxToWebPx(newSpacerHeightPx); |
| 623 | LogUtils.i(LAYOUT_TAG, "setting HTML spacer h=%dwebPx (%dscreenPx)", h, |
| 624 | newSpacerHeightPx); |
Vikram Aggarwal | 5349ce1 | 2012-09-24 14:12:40 -0700 | [diff] [blame] | 625 | mWebView.loadUrl(String.format("javascript:setMessageHeaderSpacerHeight('%s', %s);", |
Andy Huang | 014ea4c | 2012-09-25 14:50:54 -0700 | [diff] [blame^] | 626 | mTemplates.getMessageDomId(item.getMessage()), h)); |
Andy Huang | 3233bff | 2012-03-20 19:38:45 -0700 | [diff] [blame] | 627 | } |
| 628 | |
| 629 | @Override |
Andy Huang | c754357 | 2012-04-03 15:34:29 -0700 | [diff] [blame] | 630 | public void setMessageExpanded(MessageHeaderItem item, int newSpacerHeightPx) { |
| 631 | mConversationContainer.invalidateSpacerGeometry(); |
| 632 | |
| 633 | // show/hide the HTML message body and update the spacer height |
Andy Huang | 2301470 | 2012-07-09 12:50:36 -0700 | [diff] [blame] | 634 | final int h = mWebView.screenPxToWebPx(newSpacerHeightPx); |
| 635 | LogUtils.i(LAYOUT_TAG, "setting HTML spacer expanded=%s h=%dwebPx (%dscreenPx)", |
| 636 | item.isExpanded(), h, newSpacerHeightPx); |
Vikram Aggarwal | 5349ce1 | 2012-09-24 14:12:40 -0700 | [diff] [blame] | 637 | mWebView.loadUrl(String.format("javascript:setMessageBodyVisible('%s', %s, %s);", |
Andy Huang | 014ea4c | 2012-09-25 14:50:54 -0700 | [diff] [blame^] | 638 | mTemplates.getMessageDomId(item.getMessage()), item.isExpanded(), h)); |
Andy Huang | 839ada2 | 2012-07-20 15:48:40 -0700 | [diff] [blame] | 639 | |
Andy Huang | 014ea4c | 2012-09-25 14:50:54 -0700 | [diff] [blame^] | 640 | mViewState.setExpansionState(item.getMessage(), |
Paul Westbrook | 08098ec | 2012-08-12 15:30:28 -0700 | [diff] [blame] | 641 | item.isExpanded() ? ExpansionState.EXPANDED : ExpansionState.COLLAPSED); |
Andy Huang | 3233bff | 2012-03-20 19:38:45 -0700 | [diff] [blame] | 642 | } |
| 643 | |
| 644 | @Override |
| 645 | public void showExternalResources(Message msg) { |
| 646 | mWebView.getSettings().setBlockNetworkImage(false); |
| 647 | mWebView.loadUrl("javascript:unblockImages('" + mTemplates.getMessageDomId(msg) + "');"); |
| 648 | } |
| 649 | // END message header callbacks |
Andy Huang | 5ff6374 | 2012-03-16 20:30:23 -0700 | [diff] [blame] | 650 | |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 651 | @Override |
| 652 | public void onSuperCollapsedClick(SuperCollapsedBlockItem item) { |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 653 | MessageCursor cursor = getMessageCursor(); |
| 654 | if (cursor == null || !mViewsCreated) { |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 655 | return; |
| 656 | } |
| 657 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 658 | mTempBodiesHtml = renderCollapsedHeaders(cursor, item); |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 659 | mWebView.loadUrl("javascript:replaceSuperCollapsedBlock(" + item.getStart() + ")"); |
| 660 | } |
| 661 | |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 662 | private void showNewMessageNotification(NewMessagesInfo info) { |
| 663 | final TextView descriptionView = (TextView) mNewMessageBar.findViewById( |
| 664 | R.id.new_message_description); |
| 665 | descriptionView.setText(info.getNotificationText()); |
| 666 | mNewMessageBar.setVisibility(View.VISIBLE); |
| 667 | } |
| 668 | |
| 669 | private void onNewMessageBarClick() { |
| 670 | mNewMessageBar.setVisibility(View.GONE); |
| 671 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 672 | renderConversation(getMessageCursor()); // mCursor is already up-to-date |
| 673 | // per onLoadFinished() |
Andy Huang | 5fbda02 | 2012-02-28 18:22:03 -0800 | [diff] [blame] | 674 | } |
| 675 | |
Andy Huang | b5078b2 | 2012-03-05 19:52:29 -0800 | [diff] [blame] | 676 | private static int[] parseInts(final String[] stringArray) { |
| 677 | final int len = stringArray.length; |
| 678 | final int[] ints = new int[len]; |
| 679 | for (int i = 0; i < len; i++) { |
| 680 | ints[i] = Integer.parseInt(stringArray[i]); |
| 681 | } |
| 682 | return ints; |
| 683 | } |
| 684 | |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 685 | @Override |
| 686 | public String toString() { |
| 687 | // log extra info at DEBUG level or finer |
| 688 | final String s = super.toString(); |
| 689 | if (!LogUtils.isLoggable(LOG_TAG, LogUtils.DEBUG) || mConversation == null) { |
| 690 | return s; |
| 691 | } |
| 692 | return "(" + s + " subj=" + mConversation.subject + ")"; |
| 693 | } |
| 694 | |
Andy Huang | 1617481 | 2012-08-16 16:40:35 -0700 | [diff] [blame] | 695 | private Address getAddress(String rawFrom) { |
| 696 | Address addr = mAddressCache.get(rawFrom); |
| 697 | if (addr == null) { |
| 698 | addr = Address.getEmailAddress(rawFrom); |
| 699 | mAddressCache.put(rawFrom, addr); |
| 700 | } |
| 701 | return addr; |
| 702 | } |
| 703 | |
Andy Huang | 28b7aee | 2012-08-20 20:27:32 -0700 | [diff] [blame] | 704 | @Override |
| 705 | public Account getAccount() { |
| 706 | return mAccount; |
| 707 | } |
| 708 | |
Paul Westbrook | 542fec9 | 2012-09-18 14:47:51 -0700 | [diff] [blame] | 709 | private class ConversationWebViewClient extends AbstractConversationWebViewClient { |
Andy Huang | 17a9cde | 2012-03-09 18:03:16 -0800 | [diff] [blame] | 710 | @Override |
| 711 | public void onPageFinished(WebView view, String url) { |
Andy Huang | de56e97 | 2012-07-26 18:23:08 -0700 | [diff] [blame] | 712 | // Ignore unsafe calls made after a fragment is detached from an activity |
| 713 | final ControllableActivity activity = (ControllableActivity) getActivity(); |
| 714 | if (activity == null || !mViewsCreated) { |
| 715 | LogUtils.i(LOG_TAG, "ignoring CVF.onPageFinished, url=%s fragment=%s", url, |
Andy Huang | b95da85 | 2012-07-18 14:16:58 -0700 | [diff] [blame] | 716 | ConversationViewFragment.this); |
| 717 | return; |
| 718 | } |
| 719 | |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 720 | LogUtils.i(LOG_TAG, "IN CVF.onPageFinished, url=%s fragment=%s act=%s", url, |
| 721 | ConversationViewFragment.this, getActivity()); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 722 | |
Andy Huang | 17a9cde | 2012-03-09 18:03:16 -0800 | [diff] [blame] | 723 | super.onPageFinished(view, url); |
| 724 | |
| 725 | // TODO: save off individual message unread state (here, or in onLoadFinished?) so |
| 726 | // 'mark unread' restores the original unread state for each individual message |
| 727 | |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 728 | if (mUserVisible) { |
| 729 | onConversationSeen(); |
Andy Huang | 5106713 | 2012-03-12 20:08:19 -0700 | [diff] [blame] | 730 | } |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 731 | if (!mEnableContentReadySignal) { |
| 732 | notifyConversationLoaded(mConversation); |
| 733 | dismissLoadingStatus(); |
| 734 | } |
Paul Westbrook | 089f262 | 2012-09-09 21:51:11 -0700 | [diff] [blame] | 735 | // We are not able to use the loader manager unless this fragment is added to the |
| 736 | // activity |
| 737 | if (isAdded()) { |
| 738 | final Set<String> emailAddresses = Sets.newHashSet(); |
| 739 | for (Address addr : mAddressCache.values()) { |
| 740 | emailAddresses.add(addr.getAddress()); |
| 741 | } |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 742 | ContactLoaderCallbacks callbacks = getContactInfoSource(); |
| 743 | getContactInfoSource().setSenders(emailAddresses); |
| 744 | getLoaderManager().restartLoader(CONTACT_LOADER, Bundle.EMPTY, callbacks); |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 745 | } |
Andy Huang | 17a9cde | 2012-03-09 18:03:16 -0800 | [diff] [blame] | 746 | } |
| 747 | |
Andy Huang | af5d4e0 | 2012-03-19 19:02:12 -0700 | [diff] [blame] | 748 | @Override |
| 749 | public boolean shouldOverrideUrlLoading(WebView view, String url) { |
Paul Westbrook | 542fec9 | 2012-09-18 14:47:51 -0700 | [diff] [blame] | 750 | return mViewsCreated && super.shouldOverrideUrlLoading(view, url); |
Andy Huang | af5d4e0 | 2012-03-19 19:02:12 -0700 | [diff] [blame] | 751 | } |
Andy Huang | 17a9cde | 2012-03-09 18:03:16 -0800 | [diff] [blame] | 752 | } |
| 753 | |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 754 | /** |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 755 | * Notifies the {@link ConversationViewable.ConversationCallbacks} that the conversation has |
| 756 | * been loaded. |
| 757 | */ |
| 758 | public void notifyConversationLoaded(Conversation c) { |
mindyp | dde3f9f | 2012-09-10 17:35:35 -0700 | [diff] [blame] | 759 | if (mWebViewSizeChangeListener == null) { |
| 760 | mWebViewSizeChangeListener = new ConversationWebView.ContentSizeChangeListener() { |
| 761 | @Override |
| 762 | public void onHeightChange(int h) { |
| 763 | // When WebKit says the DOM height has changed, re-measure |
| 764 | // bodies and re-position their headers. |
| 765 | // This is separate from the typical JavaScript DOM change |
| 766 | // listeners because cases like NARROW_COLUMNS text reflow do not trigger DOM |
| 767 | // events. |
| 768 | mWebView.loadUrl("javascript:measurePositions();"); |
| 769 | } |
| 770 | }; |
| 771 | } |
| 772 | mWebView.setContentSizeChangeListener(mWebViewSizeChangeListener); |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 773 | } |
| 774 | |
| 775 | /** |
| 776 | * Notifies the {@link ConversationViewable.ConversationCallbacks} that the conversation has |
| 777 | * failed to load. |
| 778 | */ |
| 779 | protected void notifyConversationLoadError(Conversation c) { |
| 780 | mActivity.onConversationLoadError(); |
| 781 | } |
| 782 | |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 783 | /** |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 784 | * NOTE: all public methods must be listed in the proguard flags so that they can be accessed |
| 785 | * via reflection and not stripped. |
| 786 | * |
| 787 | */ |
| 788 | private class MailJsBridge { |
| 789 | |
| 790 | @SuppressWarnings("unused") |
Mindy Pereira | 974c966 | 2012-09-14 10:02:08 -0700 | [diff] [blame] | 791 | @JavascriptInterface |
Andy Huang | 7bdc375 | 2012-03-25 17:18:19 -0700 | [diff] [blame] | 792 | public void onWebContentGeometryChange(final String[] overlayBottomStrs) { |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 793 | try { |
mindyp | ff282d0 | 2012-09-17 10:33:02 -0700 | [diff] [blame] | 794 | getHandler().post(new Runnable() { |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 795 | @Override |
| 796 | public void run() { |
| 797 | if (!mViewsCreated) { |
| 798 | LogUtils.d(LOG_TAG, "ignoring webContentGeometryChange because views" + |
| 799 | " are gone, %s", ConversationViewFragment.this); |
| 800 | return; |
| 801 | } |
Andy Huang | 5106713 | 2012-03-12 20:08:19 -0700 | [diff] [blame] | 802 | |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 803 | mConversationContainer.onGeometryChange(parseInts(overlayBottomStrs)); |
| 804 | } |
| 805 | }); |
| 806 | } catch (Throwable t) { |
| 807 | LogUtils.e(LOG_TAG, t, "Error in MailJsBridge.onWebContentGeometryChange"); |
| 808 | } |
| 809 | } |
| 810 | |
| 811 | @SuppressWarnings("unused") |
Mindy Pereira | 974c966 | 2012-09-14 10:02:08 -0700 | [diff] [blame] | 812 | @JavascriptInterface |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 813 | public String getTempMessageBodies() { |
| 814 | try { |
| 815 | if (!mViewsCreated) { |
| 816 | return ""; |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 817 | } |
Andy Huang | 46dfba6 | 2012-04-19 01:47:32 -0700 | [diff] [blame] | 818 | |
| 819 | final String s = mTempBodiesHtml; |
| 820 | mTempBodiesHtml = null; |
| 821 | return s; |
| 822 | } catch (Throwable t) { |
| 823 | LogUtils.e(LOG_TAG, t, "Error in MailJsBridge.getTempMessageBodies"); |
| 824 | return ""; |
| 825 | } |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 826 | } |
| 827 | |
Andy Huang | 014ea4c | 2012-09-25 14:50:54 -0700 | [diff] [blame^] | 828 | @SuppressWarnings("unused") |
| 829 | @JavascriptInterface |
| 830 | public String getMessageBody(String domId) { |
| 831 | try { |
| 832 | final MessageCursor cursor = getMessageCursor(); |
| 833 | if (!mViewsCreated || cursor == null) { |
| 834 | return ""; |
| 835 | } |
| 836 | |
| 837 | int pos = -1; |
| 838 | while (cursor.moveToPosition(++pos)) { |
| 839 | final ConversationMessage msg = cursor.getMessage(); |
| 840 | if (TextUtils.equals(domId, mTemplates.getMessageDomId(msg))) { |
| 841 | return msg.getBodyAsHtml(); |
| 842 | } |
| 843 | } |
| 844 | |
| 845 | return ""; |
| 846 | |
| 847 | } catch (Throwable t) { |
| 848 | LogUtils.e(LOG_TAG, t, "Error in MailJsBridge.getMessageBody"); |
| 849 | return ""; |
| 850 | } |
| 851 | } |
| 852 | |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 853 | private void showConversation(Conversation conv) { |
| 854 | notifyConversationLoaded(conv); |
| 855 | dismissLoadingStatus(); |
| 856 | } |
| 857 | |
| 858 | @SuppressWarnings("unused") |
Mindy Pereira | 974c966 | 2012-09-14 10:02:08 -0700 | [diff] [blame] | 859 | @JavascriptInterface |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 860 | public void onContentReady() { |
| 861 | final Conversation conv = mConversation; |
| 862 | try { |
mindyp | ff282d0 | 2012-09-17 10:33:02 -0700 | [diff] [blame] | 863 | getHandler().post(new Runnable() { |
mindyp | 3bcf180 | 2012-09-09 11:17:00 -0700 | [diff] [blame] | 864 | @Override |
| 865 | public void run() { |
| 866 | LogUtils.d(LOG_TAG, "ANIMATION STARTED, ready to draw. t=%s", |
| 867 | SystemClock.uptimeMillis()); |
| 868 | showConversation(conv); |
| 869 | } |
| 870 | }); |
| 871 | } catch (Throwable t) { |
| 872 | LogUtils.e(LOG_TAG, t, "Error in MailJsBridge.onContentReady"); |
| 873 | // Still try to show the conversation. |
| 874 | showConversation(conv); |
| 875 | } |
| 876 | } |
Andy Huang | f70fc40 | 2012-02-17 15:37:42 -0800 | [diff] [blame] | 877 | } |
| 878 | |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 879 | private class NewMessagesInfo { |
| 880 | int count; |
| 881 | String senderAddress; |
| 882 | |
| 883 | /** |
| 884 | * Return the display text for the new message notification overlay. It will be formatted |
| 885 | * appropriately for a single new message vs. multiple new messages. |
| 886 | * |
| 887 | * @return display text |
| 888 | */ |
| 889 | public String getNotificationText() { |
mindyp | ad0c30d | 2012-09-25 12:09:13 -0700 | [diff] [blame] | 890 | Resources res = getResources(); |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 891 | if (count > 1) { |
mindyp | ad0c30d | 2012-09-25 12:09:13 -0700 | [diff] [blame] | 892 | return res.getString(R.string.new_incoming_messages_many, count); |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 893 | } else { |
Andy Huang | 1617481 | 2012-08-16 16:40:35 -0700 | [diff] [blame] | 894 | final Address addr = getAddress(senderAddress); |
mindyp | ad0c30d | 2012-09-25 12:09:13 -0700 | [diff] [blame] | 895 | return res.getString(R.string.new_incoming_messages_one, |
| 896 | TextUtils.isEmpty(addr.getName()) ? addr.getAddress() : addr.getName()); |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 897 | } |
Andy Huang | 47aa9c9 | 2012-07-31 15:37:21 -0700 | [diff] [blame] | 898 | } |
| 899 | } |
| 900 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 901 | @Override |
Andy Huang | 014ea4c | 2012-09-25 14:50:54 -0700 | [diff] [blame^] | 902 | public void onMessageCursorLoadFinished(Loader<Cursor> loader, MessageCursor newCursor, |
| 903 | MessageCursor oldCursor) { |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 904 | /* |
| 905 | * what kind of changes affect the MessageCursor? 1. new message(s) 2. |
| 906 | * read/unread state change 3. deleted message, either regular or draft |
| 907 | * 4. updated message, either from self or from others, updated in |
| 908 | * content or state or sender 5. star/unstar of message (technically |
| 909 | * similar to #1) 6. other label change Use MessageCursor.hashCode() to |
| 910 | * sort out interesting vs. no-op cursor updates. |
| 911 | */ |
Andy Huang | 014ea4c | 2012-09-25 14:50:54 -0700 | [diff] [blame^] | 912 | final boolean changed = newCursor != null && oldCursor != null |
| 913 | && newCursor.hashCode() != oldCursor.hashCode(); |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 914 | |
Andy Huang | 014ea4c | 2012-09-25 14:50:54 -0700 | [diff] [blame^] | 915 | if (oldCursor != null) { |
| 916 | final NewMessagesInfo info = getNewIncomingMessagesInfo(newCursor); |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 917 | |
Andy Huang | 014ea4c | 2012-09-25 14:50:54 -0700 | [diff] [blame^] | 918 | if (info.count > 0) { |
| 919 | // don't immediately render new incoming messages from other |
| 920 | // senders |
| 921 | // (to avoid a new message from losing the user's focus) |
| 922 | LogUtils.i(LOG_TAG, "CONV RENDER: conversation updated" |
| 923 | + ", holding cursor for new incoming message"); |
| 924 | showNewMessageNotification(info); |
| 925 | return; |
| 926 | } |
| 927 | |
| 928 | if (!changed) { |
| 929 | final boolean processedInPlace = processInPlaceUpdates(newCursor, oldCursor); |
| 930 | if (processedInPlace) { |
| 931 | LogUtils.i(LOG_TAG, "CONV RENDER: processed update(s) in place"); |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 932 | } else { |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 933 | LogUtils.i(LOG_TAG, "CONV RENDER: uninteresting update" |
| 934 | + ", ignoring this conversation update"); |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 935 | } |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 936 | return; |
| 937 | } |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 938 | } |
| 939 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 940 | // cursors are different, and not due to an incoming message. fall |
| 941 | // through and render. |
| 942 | LogUtils.i(LOG_TAG, "CONV RENDER: conversation updated" |
| 943 | + ", but not due to incoming message. rendering."); |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 944 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 945 | // TODO: if this is not user-visible, delay render until user-visible |
| 946 | // fragment is done. This is needed in addition to the |
| 947 | // showConversation() delay to speed up rotation and restoration. |
Andy Huang | 014ea4c | 2012-09-25 14:50:54 -0700 | [diff] [blame^] | 948 | renderConversation(newCursor); |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 949 | } |
| 950 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 951 | private NewMessagesInfo getNewIncomingMessagesInfo(MessageCursor newCursor) { |
| 952 | final NewMessagesInfo info = new NewMessagesInfo(); |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 953 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 954 | int pos = -1; |
| 955 | while (newCursor.moveToPosition(++pos)) { |
| 956 | final Message m = newCursor.getMessage(); |
| 957 | if (!mViewState.contains(m)) { |
| 958 | LogUtils.i(LOG_TAG, "conversation diff: found new msg: %s", m.uri); |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 959 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 960 | final Address from = getAddress(m.from); |
| 961 | // distinguish ours from theirs |
| 962 | // new messages from the account owner should not trigger a |
| 963 | // notification |
| 964 | if (mAccount.ownsFromAddress(from.getAddress())) { |
| 965 | LogUtils.i(LOG_TAG, "found message from self: %s", m.uri); |
| 966 | continue; |
| 967 | } |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 968 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 969 | info.count++; |
| 970 | info.senderAddress = m.from; |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 971 | } |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 972 | } |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 973 | return info; |
Andy Huang | b8331b4 | 2012-07-16 19:08:53 -0700 | [diff] [blame] | 974 | } |
| 975 | |
Andy Huang | 014ea4c | 2012-09-25 14:50:54 -0700 | [diff] [blame^] | 976 | private boolean processInPlaceUpdates(MessageCursor newCursor, MessageCursor oldCursor) { |
| 977 | final Set<String> idsOfChangedBodies = Sets.newHashSet(); |
| 978 | boolean changed = false; |
| 979 | |
| 980 | int pos = 0; |
| 981 | while (true) { |
| 982 | if (!newCursor.moveToPosition(pos) || !oldCursor.moveToPosition(pos)) { |
| 983 | break; |
| 984 | } |
| 985 | |
| 986 | final ConversationMessage newMsg = newCursor.getMessage(); |
| 987 | final ConversationMessage oldMsg = oldCursor.getMessage(); |
| 988 | |
| 989 | if (!TextUtils.equals(newMsg.from, oldMsg.from)) { |
| 990 | mAdapter.updateItemsForMessage(newMsg); |
| 991 | LogUtils.i(LOG_TAG, "msg #%d (%d): detected sender change", pos, newMsg.id); |
| 992 | changed = true; |
| 993 | } |
| 994 | |
| 995 | // update changed message bodies in-place |
| 996 | if (!TextUtils.equals(newMsg.bodyHtml, oldMsg.bodyHtml) || |
| 997 | !TextUtils.equals(newMsg.bodyText, oldMsg.bodyText)) { |
| 998 | // maybe just set a flag to notify JS to re-request changed bodies |
| 999 | idsOfChangedBodies.add('"' + mTemplates.getMessageDomId(newMsg) + '"'); |
| 1000 | LogUtils.i(LOG_TAG, "msg #%d (%d): detected body change", pos, newMsg.id); |
| 1001 | } |
| 1002 | |
| 1003 | pos++; |
| 1004 | } |
| 1005 | |
| 1006 | if (!idsOfChangedBodies.isEmpty()) { |
| 1007 | mWebView.loadUrl(String.format("javascript:replaceMessageBodies([%s]);", |
| 1008 | TextUtils.join(",", idsOfChangedBodies))); |
| 1009 | changed = true; |
| 1010 | } |
| 1011 | |
| 1012 | return changed; |
| 1013 | } |
| 1014 | |
Paul Westbrook | cebcc64 | 2012-08-08 10:06:04 -0700 | [diff] [blame] | 1015 | private class SetCookieTask extends AsyncTask<Void, Void, Void> { |
| 1016 | final String mUri; |
| 1017 | final String mCookie; |
| 1018 | |
| 1019 | SetCookieTask(String uri, String cookie) { |
| 1020 | mUri = uri; |
| 1021 | mCookie = cookie; |
| 1022 | } |
| 1023 | |
| 1024 | @Override |
| 1025 | public Void doInBackground(Void... args) { |
| 1026 | final CookieSyncManager csm = |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 1027 | CookieSyncManager.createInstance(getContext()); |
Paul Westbrook | cebcc64 | 2012-08-08 10:06:04 -0700 | [diff] [blame] | 1028 | CookieManager.getInstance().setCookie(mUri, mCookie); |
| 1029 | csm.sync(); |
| 1030 | return null; |
| 1031 | } |
| 1032 | } |
mindyp | 36280f3 | 2012-09-09 16:11:23 -0700 | [diff] [blame] | 1033 | |
mindyp | 26d4d2d | 2012-09-18 17:30:32 -0700 | [diff] [blame] | 1034 | @Override |
mindyp | 36280f3 | 2012-09-09 16:11:23 -0700 | [diff] [blame] | 1035 | public void onConversationUpdated(Conversation conv) { |
| 1036 | final ConversationViewHeader headerView = (ConversationViewHeader) mConversationContainer |
| 1037 | .findViewById(R.id.conversation_header); |
mindyp | b2b98ba | 2012-09-24 14:13:58 -0700 | [diff] [blame] | 1038 | mConversation = conv; |
mindyp | 9e0b236 | 2012-09-09 16:31:21 -0700 | [diff] [blame] | 1039 | if (headerView != null) { |
| 1040 | headerView.onConversationUpdated(conv); |
| 1041 | } |
mindyp | 36280f3 | 2012-09-09 16:11:23 -0700 | [diff] [blame] | 1042 | } |
Mindy Pereira | 9b87568 | 2012-02-15 18:10:54 -0800 | [diff] [blame] | 1043 | } |