| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.email.activity; |
| |
| import android.app.Activity; |
| import android.app.DownloadManager; |
| import android.app.Fragment; |
| import android.app.LoaderManager.LoaderCallbacks; |
| import android.content.ActivityNotFoundException; |
| import android.content.ContentResolver; |
| import android.content.ContentUris; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.Loader; |
| import android.content.pm.PackageManager; |
| import android.content.res.Resources; |
| import android.database.ContentObserver; |
| import android.graphics.Bitmap; |
| import android.graphics.BitmapFactory; |
| import android.media.MediaScannerConnection; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Environment; |
| import android.os.Handler; |
| import android.provider.ContactsContract; |
| import android.provider.ContactsContract.QuickContact; |
| import android.text.SpannableStringBuilder; |
| import android.text.TextUtils; |
| import android.text.format.DateUtils; |
| import android.util.Log; |
| import android.util.Patterns; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.webkit.WebSettings; |
| import android.webkit.WebView; |
| import android.webkit.WebViewClient; |
| import android.widget.Button; |
| import android.widget.ImageView; |
| import android.widget.LinearLayout; |
| import android.widget.ProgressBar; |
| import android.widget.TextView; |
| |
| import com.android.email.AttachmentInfo; |
| import com.android.email.Controller; |
| import com.android.email.ControllerResultUiThreadWrapper; |
| import com.android.email.Email; |
| import com.android.email.Preferences; |
| import com.android.email.R; |
| import com.android.email.Throttle; |
| import com.android.email.mail.internet.EmailHtmlUtil; |
| import com.android.email.service.AttachmentDownloadService; |
| import com.android.emailcommon.Logging; |
| import com.android.emailcommon.mail.Address; |
| import com.android.emailcommon.mail.MessagingException; |
| import com.android.emailcommon.provider.Account; |
| import com.android.emailcommon.provider.EmailContent.Attachment; |
| import com.android.emailcommon.provider.EmailContent.Body; |
| import com.android.emailcommon.provider.EmailContent.Message; |
| import com.android.emailcommon.provider.Mailbox; |
| import com.android.emailcommon.utility.AttachmentUtilities; |
| import com.android.emailcommon.utility.EmailAsyncTask; |
| import com.android.emailcommon.utility.Utility; |
| import com.google.common.collect.Maps; |
| |
| import org.apache.commons.io.IOUtils; |
| |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.util.Formatter; |
| import java.util.Map; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| // TODO Better handling of config changes. |
| // - Retain the content; don't kick 3 async tasks every time |
| |
| /** |
| * Base class for {@link MessageViewFragment} and {@link MessageFileViewFragment}. |
| */ |
| public abstract class MessageViewFragmentBase extends Fragment implements View.OnClickListener { |
| private static final String BUNDLE_KEY_CURRENT_TAB = "MessageViewFragmentBase.currentTab"; |
| private static final String BUNDLE_KEY_PICTURE_LOADED = "MessageViewFragmentBase.pictureLoaded"; |
| private static final int PHOTO_LOADER_ID = 1; |
| protected Context mContext; |
| |
| // Regex that matches start of img tag. '<(?i)img\s+'. |
| private static final Pattern IMG_TAG_START_REGEX = Pattern.compile("<(?i)img\\s+"); |
| // Regex that matches Web URL protocol part as case insensitive. |
| private static final Pattern WEB_URL_PROTOCOL = Pattern.compile("(?i)http|https://"); |
| |
| private static int PREVIEW_ICON_WIDTH = 62; |
| private static int PREVIEW_ICON_HEIGHT = 62; |
| |
| // The different levels of zoom: read from the Preferences. |
| private static String[] sZoomSizes = null; |
| |
| private TextView mSubjectView; |
| private TextView mFromNameView; |
| private TextView mFromAddressView; |
| private TextView mDateTimeView; |
| private TextView mAddressesView; |
| private WebView mMessageContentView; |
| private LinearLayout mAttachments; |
| private View mTabSection; |
| private ImageView mFromBadge; |
| private ImageView mSenderPresenceView; |
| private View mMainView; |
| private View mLoadingProgress; |
| private View mDetailsCollapsed; |
| private View mDetailsExpanded; |
| private boolean mDetailsFilled; |
| |
| private TextView mMessageTab; |
| private TextView mAttachmentTab; |
| private TextView mInviteTab; |
| // It is not really a tab, but looks like one of them. |
| private TextView mShowPicturesTab; |
| private View mAlwaysShowPicturesButton; |
| |
| private View mAttachmentsScroll; |
| private View mInviteScroll; |
| |
| private long mAccountId = Account.NO_ACCOUNT; |
| private long mMessageId = Message.NO_MESSAGE; |
| private Message mMessage; |
| |
| private Controller mController; |
| private ControllerResultUiThreadWrapper<ControllerResults> mControllerCallback; |
| |
| // contains the HTML body. Is used by LoadAttachmentTask to display inline images. |
| // is null most of the time, is used transiently to pass info to LoadAttachementTask |
| private String mHtmlTextRaw; |
| |
| // contains the HTML content as set in WebView. |
| private String mHtmlTextWebView; |
| |
| private boolean mIsMessageLoadedForTest; |
| |
| private MessageObserver mMessageObserver; |
| |
| private static final int CONTACT_STATUS_STATE_UNLOADED = 0; |
| private static final int CONTACT_STATUS_STATE_UNLOADED_TRIGGERED = 1; |
| private static final int CONTACT_STATUS_STATE_LOADED = 2; |
| |
| private int mContactStatusState; |
| private Uri mQuickContactLookupUri; |
| |
| /** Flag for {@link #mTabFlags}: Message has attachment(s) */ |
| protected static final int TAB_FLAGS_HAS_ATTACHMENT = 1; |
| |
| /** |
| * Flag for {@link #mTabFlags}: Message contains invite. This flag is only set by |
| * {@link MessageViewFragment}. |
| */ |
| protected static final int TAB_FLAGS_HAS_INVITE = 2; |
| |
| /** Flag for {@link #mTabFlags}: Message contains pictures */ |
| protected static final int TAB_FLAGS_HAS_PICTURES = 4; |
| |
| /** Flag for {@link #mTabFlags}: "Show pictures" has already been pressed */ |
| protected static final int TAB_FLAGS_PICTURE_LOADED = 8; |
| |
| /** |
| * Flags to control the tabs. |
| * @see #updateTabs(int) |
| */ |
| private int mTabFlags; |
| |
| /** # of attachments in the current message */ |
| private int mAttachmentCount; |
| |
| // Use (random) large values, to avoid confusion with TAB_FLAGS_* |
| protected static final int TAB_MESSAGE = 101; |
| protected static final int TAB_INVITE = 102; |
| protected static final int TAB_ATTACHMENT = 103; |
| private static final int TAB_NONE = 0; |
| |
| /** Current tab */ |
| private int mCurrentTab = TAB_NONE; |
| /** |
| * Tab that was selected in the previous activity instance. |
| * Used to restore the current tab after screen rotation. |
| */ |
| private int mRestoredTab = TAB_NONE; |
| |
| private boolean mRestoredPictureLoaded; |
| |
| private final EmailAsyncTask.Tracker mTaskTracker = new EmailAsyncTask.Tracker(); |
| |
| public interface Callback { |
| /** |
| * Called when a link in a message is clicked. |
| * |
| * @param url link url that's clicked. |
| * @return true if handled, false otherwise. |
| */ |
| public boolean onUrlInMessageClicked(String url); |
| |
| /** |
| * Called when the message specified doesn't exist, or is deleted/moved. |
| */ |
| public void onMessageNotExists(); |
| |
| /** Called when it starts loading a message. */ |
| public void onLoadMessageStarted(); |
| |
| /** Called when it successfully finishes loading a message. */ |
| public void onLoadMessageFinished(); |
| |
| /** Called when an error occurred during loading a message. */ |
| public void onLoadMessageError(String errorMessage); |
| } |
| |
| public static class EmptyCallback implements Callback { |
| public static final Callback INSTANCE = new EmptyCallback(); |
| @Override public void onLoadMessageError(String errorMessage) {} |
| @Override public void onLoadMessageFinished() {} |
| @Override public void onLoadMessageStarted() {} |
| @Override public void onMessageNotExists() {} |
| @Override |
| public boolean onUrlInMessageClicked(String url) { |
| return false; |
| } |
| } |
| |
| private Callback mCallback = EmptyCallback.INSTANCE; |
| |
| @Override |
| public void onAttach(Activity activity) { |
| if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) { |
| Log.d(Logging.LOG_TAG, this + " onAttach"); |
| } |
| super.onAttach(activity); |
| } |
| |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) { |
| Log.d(Logging.LOG_TAG, this + " onCreate"); |
| } |
| super.onCreate(savedInstanceState); |
| |
| mContext = getActivity().getApplicationContext(); |
| |
| // Initialize components, but don't "start" them. Registering the controller callbacks |
| // and starting MessageObserver, should be done in onActivityCreated or later and be stopped |
| // in onDestroyView to prevent from getting callbacks when the fragment is in the back |
| // stack, but they'll start again when it's back from the back stack. |
| mController = Controller.getInstance(mContext); |
| mControllerCallback = new ControllerResultUiThreadWrapper<ControllerResults>( |
| new Handler(), new ControllerResults()); |
| mMessageObserver = new MessageObserver(new Handler(), mContext); |
| |
| if (savedInstanceState != null) { |
| restoreInstanceState(savedInstanceState); |
| } |
| } |
| |
| @Override |
| public View onCreateView( |
| LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { |
| if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) { |
| Log.d(Logging.LOG_TAG, this + " onCreateView"); |
| } |
| final View view = inflater.inflate(R.layout.message_view_fragment, container, false); |
| |
| cleanupDetachedViews(); |
| |
| mSubjectView = (TextView) UiUtilities.getView(view, R.id.subject); |
| mFromNameView = (TextView) UiUtilities.getView(view, R.id.from_name); |
| mFromAddressView = (TextView) UiUtilities.getView(view, R.id.from_address); |
| mAddressesView = (TextView) UiUtilities.getView(view, R.id.addresses); |
| mDateTimeView = (TextView) UiUtilities.getView(view, R.id.datetime); |
| mMessageContentView = (WebView) UiUtilities.getView(view, R.id.message_content); |
| mAttachments = (LinearLayout) UiUtilities.getView(view, R.id.attachments); |
| mTabSection = UiUtilities.getView(view, R.id.message_tabs_section); |
| mFromBadge = (ImageView) UiUtilities.getView(view, R.id.badge); |
| mSenderPresenceView = (ImageView) UiUtilities.getView(view, R.id.presence); |
| mMainView = UiUtilities.getView(view, R.id.main_panel); |
| mLoadingProgress = UiUtilities.getView(view, R.id.loading_progress); |
| mDetailsCollapsed = UiUtilities.getView(view, R.id.sub_header_contents_collapsed); |
| mDetailsExpanded = UiUtilities.getView(view, R.id.sub_header_contents_expanded); |
| |
| mFromNameView.setOnClickListener(this); |
| mFromAddressView.setOnClickListener(this); |
| mFromBadge.setOnClickListener(this); |
| mSenderPresenceView.setOnClickListener(this); |
| |
| mMessageTab = UiUtilities.getView(view, R.id.show_message); |
| mAttachmentTab = UiUtilities.getView(view, R.id.show_attachments); |
| mShowPicturesTab = UiUtilities.getView(view, R.id.show_pictures); |
| mAlwaysShowPicturesButton = UiUtilities.getView(view, R.id.always_show_pictures_button); |
| // Invite is only used in MessageViewFragment, but visibility is controlled here. |
| mInviteTab = UiUtilities.getView(view, R.id.show_invite); |
| |
| mMessageTab.setOnClickListener(this); |
| mAttachmentTab.setOnClickListener(this); |
| mShowPicturesTab.setOnClickListener(this); |
| mAlwaysShowPicturesButton.setOnClickListener(this); |
| mInviteTab.setOnClickListener(this); |
| mDetailsCollapsed.setOnClickListener(this); |
| mDetailsExpanded.setOnClickListener(this); |
| |
| mAttachmentsScroll = UiUtilities.getView(view, R.id.attachments_scroll); |
| mInviteScroll = UiUtilities.getView(view, R.id.invite_scroll); |
| |
| WebSettings webSettings = mMessageContentView.getSettings(); |
| boolean supportMultiTouch = mContext.getPackageManager() |
| .hasSystemFeature(PackageManager.FEATURE_TOUCHSCREEN_MULTITOUCH); |
| webSettings.setDisplayZoomControls(!supportMultiTouch); |
| webSettings.setSupportZoom(true); |
| webSettings.setBuiltInZoomControls(true); |
| mMessageContentView.setWebViewClient(new CustomWebViewClient()); |
| return view; |
| } |
| |
| @Override |
| public void onActivityCreated(Bundle savedInstanceState) { |
| if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) { |
| Log.d(Logging.LOG_TAG, this + " onActivityCreated"); |
| } |
| super.onActivityCreated(savedInstanceState); |
| mController.addResultCallback(mControllerCallback); |
| |
| resetView(); |
| new LoadMessageTask(true).executeParallel(); |
| |
| UiUtilities.installFragment(this); |
| } |
| |
| @Override |
| public void onStart() { |
| if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) { |
| Log.d(Logging.LOG_TAG, this + " onStart"); |
| } |
| super.onStart(); |
| } |
| |
| @Override |
| public void onResume() { |
| if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) { |
| Log.d(Logging.LOG_TAG, this + " onResume"); |
| } |
| super.onResume(); |
| |
| // We might have comes back from other full-screen activities. If so, we need to update |
| // the attachment tab as system settings may have been updated that affect which |
| // options are available to the user. |
| updateAttachmentTab(); |
| } |
| |
| @Override |
| public void onPause() { |
| if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) { |
| Log.d(Logging.LOG_TAG, this + " onPause"); |
| } |
| super.onPause(); |
| } |
| |
| @Override |
| public void onStop() { |
| if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) { |
| Log.d(Logging.LOG_TAG, this + " onStop"); |
| } |
| super.onStop(); |
| } |
| |
| @Override |
| public void onDestroyView() { |
| if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) { |
| Log.d(Logging.LOG_TAG, this + " onDestroyView"); |
| } |
| UiUtilities.uninstallFragment(this); |
| mController.removeResultCallback(mControllerCallback); |
| cancelAllTasks(); |
| |
| // We should clean up the Webview here, but it can't release resources until it is |
| // actually removed from the view tree. |
| |
| super.onDestroyView(); |
| } |
| |
| private void cleanupDetachedViews() { |
| // WebView cleanup must be done after it leaves the rendering tree, according to |
| // its contract |
| if (mMessageContentView != null) { |
| mMessageContentView.destroy(); |
| mMessageContentView = null; |
| } |
| } |
| |
| @Override |
| public void onDestroy() { |
| if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) { |
| Log.d(Logging.LOG_TAG, this + " onDestroy"); |
| } |
| |
| cleanupDetachedViews(); |
| super.onDestroy(); |
| } |
| |
| @Override |
| public void onDetach() { |
| if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) { |
| Log.d(Logging.LOG_TAG, this + " onDetach"); |
| } |
| super.onDetach(); |
| } |
| |
| @Override |
| public void onSaveInstanceState(Bundle outState) { |
| if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) { |
| Log.d(Logging.LOG_TAG, this + " onSaveInstanceState"); |
| } |
| super.onSaveInstanceState(outState); |
| outState.putInt(BUNDLE_KEY_CURRENT_TAB, mCurrentTab); |
| outState.putBoolean(BUNDLE_KEY_PICTURE_LOADED, (mTabFlags & TAB_FLAGS_PICTURE_LOADED) != 0); |
| } |
| |
| private void restoreInstanceState(Bundle state) { |
| if (Logging.DEBUG_LIFECYCLE && Email.DEBUG) { |
| Log.d(Logging.LOG_TAG, this + " restoreInstanceState"); |
| } |
| // At this point (in onCreate) no tabs are visible (because we don't know if the message has |
| // an attachment or invite before loading it). We just remember the tab here. |
| // We'll make it current when the tab first becomes visible in updateTabs(). |
| mRestoredTab = state.getInt(BUNDLE_KEY_CURRENT_TAB); |
| mRestoredPictureLoaded = state.getBoolean(BUNDLE_KEY_PICTURE_LOADED); |
| } |
| |
| public void setCallback(Callback callback) { |
| mCallback = (callback == null) ? EmptyCallback.INSTANCE : callback; |
| } |
| |
| private void cancelAllTasks() { |
| mMessageObserver.unregister(); |
| mTaskTracker.cancellAllInterrupt(); |
| } |
| |
| protected final Controller getController() { |
| return mController; |
| } |
| |
| protected final Callback getCallback() { |
| return mCallback; |
| } |
| |
| public final Message getMessage() { |
| return mMessage; |
| } |
| |
| protected final boolean isMessageOpen() { |
| return mMessage != null; |
| } |
| |
| /** |
| * Returns the account id of the current message, or -1 if unknown (message not open yet, or |
| * viewing an EML message). |
| */ |
| public long getAccountId() { |
| return mAccountId; |
| } |
| |
| /** |
| * Show/hide the content. We hide all the content (except for the bottom buttons) when loading, |
| * to avoid flicker. |
| */ |
| private void showContent(boolean showContent, boolean showProgressWhenHidden) { |
| makeVisible(mMainView, showContent); |
| makeVisible(mLoadingProgress, !showContent && showProgressWhenHidden); |
| } |
| |
| // TODO: clean this up - most of this is not needed since the WebView and Fragment is not |
| // reused for multiple messages. |
| protected void resetView() { |
| showContent(false, false); |
| updateTabs(0); |
| setCurrentTab(TAB_MESSAGE); |
| if (mMessageContentView != null) { |
| blockNetworkLoads(true); |
| mMessageContentView.scrollTo(0, 0); |
| |
| // Dynamic configuration of WebView |
| final WebSettings settings = mMessageContentView.getSettings(); |
| settings.setLayoutAlgorithm(WebSettings.LayoutAlgorithm.NORMAL); |
| mMessageContentView.setInitialScale(getWebViewZoom()); |
| } |
| mAttachmentsScroll.scrollTo(0, 0); |
| mInviteScroll.scrollTo(0, 0); |
| mAttachments.removeAllViews(); |
| mAttachments.setVisibility(View.GONE); |
| initContactStatusViews(); |
| } |
| |
| /** |
| * Returns the zoom scale (in percent) which is a combination of the user setting |
| * (tiny, small, normal, large, huge) and the device density. The intention |
| * is for the text to be physically equal in size over different density |
| * screens. |
| */ |
| private int getWebViewZoom() { |
| float density = mContext.getResources().getDisplayMetrics().density; |
| int zoom = Preferences.getPreferences(mContext).getTextZoom(); |
| if (sZoomSizes == null) { |
| sZoomSizes = mContext.getResources() |
| .getStringArray(R.array.general_preference_text_zoom_size); |
| } |
| return (int)(Float.valueOf(sZoomSizes[zoom]) * density * 100); |
| } |
| |
| private void initContactStatusViews() { |
| mContactStatusState = CONTACT_STATUS_STATE_UNLOADED; |
| mQuickContactLookupUri = null; |
| showDefaultQuickContactBadgeImage(); |
| } |
| |
| private void showDefaultQuickContactBadgeImage() { |
| mFromBadge.setImageResource(R.drawable.ic_contact_picture); |
| } |
| |
| protected final void addTabFlags(int tabFlags) { |
| updateTabs(mTabFlags | tabFlags); |
| } |
| |
| private final void clearTabFlags(int tabFlags) { |
| updateTabs(mTabFlags & ~tabFlags); |
| } |
| |
| private void setAttachmentCount(int count) { |
| mAttachmentCount = count; |
| if (mAttachmentCount > 0) { |
| addTabFlags(TAB_FLAGS_HAS_ATTACHMENT); |
| } else { |
| clearTabFlags(TAB_FLAGS_HAS_ATTACHMENT); |
| } |
| } |
| |
| private static void makeVisible(View v, boolean visible) { |
| final int visibility = visible ? View.VISIBLE : View.GONE; |
| if ((v != null) && (v.getVisibility() != visibility)) { |
| v.setVisibility(visibility); |
| } |
| } |
| |
| private static boolean isVisible(View v) { |
| return (v != null) && (v.getVisibility() == View.VISIBLE); |
| } |
| |
| /** |
| * Update the visual of the tabs. (visibility, text, etc) |
| */ |
| private void updateTabs(int tabFlags) { |
| mTabFlags = tabFlags; |
| |
| if (getView() == null) { |
| return; |
| } |
| |
| boolean messageTabVisible = (tabFlags & (TAB_FLAGS_HAS_INVITE | TAB_FLAGS_HAS_ATTACHMENT)) |
| != 0; |
| makeVisible(mMessageTab, messageTabVisible); |
| makeVisible(mInviteTab, (tabFlags & TAB_FLAGS_HAS_INVITE) != 0); |
| makeVisible(mAttachmentTab, (tabFlags & TAB_FLAGS_HAS_ATTACHMENT) != 0); |
| |
| final boolean hasPictures = (tabFlags & TAB_FLAGS_HAS_PICTURES) != 0; |
| final boolean pictureLoaded = (tabFlags & TAB_FLAGS_PICTURE_LOADED) != 0; |
| makeVisible(mShowPicturesTab, hasPictures && !pictureLoaded); |
| |
| mAttachmentTab.setText(mContext.getResources().getQuantityString( |
| R.plurals.message_view_show_attachments_action, |
| mAttachmentCount, mAttachmentCount)); |
| |
| // Hide the entire section if no tabs are visible. |
| makeVisible(mTabSection, isVisible(mMessageTab) || isVisible(mInviteTab) |
| || isVisible(mAttachmentTab) || isVisible(mShowPicturesTab) |
| || isVisible(mAlwaysShowPicturesButton)); |
| |
| // Restore previously selected tab after rotation |
| if (mRestoredTab != TAB_NONE && isVisible(getTabViewForFlag(mRestoredTab))) { |
| setCurrentTab(mRestoredTab); |
| mRestoredTab = TAB_NONE; |
| } |
| } |
| |
| /** |
| * Set the current tab. |
| * |
| * @param tab any of {@link #TAB_MESSAGE}, {@link #TAB_ATTACHMENT} or {@link #TAB_INVITE}. |
| */ |
| private void setCurrentTab(int tab) { |
| mCurrentTab = tab; |
| |
| // Hide & unselect all tabs |
| makeVisible(getTabContentViewForFlag(TAB_MESSAGE), false); |
| makeVisible(getTabContentViewForFlag(TAB_ATTACHMENT), false); |
| makeVisible(getTabContentViewForFlag(TAB_INVITE), false); |
| getTabViewForFlag(TAB_MESSAGE).setSelected(false); |
| getTabViewForFlag(TAB_ATTACHMENT).setSelected(false); |
| getTabViewForFlag(TAB_INVITE).setSelected(false); |
| |
| makeVisible(getTabContentViewForFlag(mCurrentTab), true); |
| getTabViewForFlag(mCurrentTab).setSelected(true); |
| } |
| |
| private View getTabViewForFlag(int tabFlag) { |
| switch (tabFlag) { |
| case TAB_MESSAGE: |
| return mMessageTab; |
| case TAB_ATTACHMENT: |
| return mAttachmentTab; |
| case TAB_INVITE: |
| return mInviteTab; |
| } |
| throw new IllegalArgumentException(); |
| } |
| |
| private View getTabContentViewForFlag(int tabFlag) { |
| switch (tabFlag) { |
| case TAB_MESSAGE: |
| return mMessageContentView; |
| case TAB_ATTACHMENT: |
| return mAttachmentsScroll; |
| case TAB_INVITE: |
| return mInviteScroll; |
| } |
| throw new IllegalArgumentException(); |
| } |
| |
| private void blockNetworkLoads(boolean block) { |
| if (mMessageContentView != null) { |
| mMessageContentView.getSettings().setBlockNetworkLoads(block); |
| } |
| } |
| |
| private void setMessageHtml(String html) { |
| if (html == null) { |
| html = ""; |
| } |
| if (mMessageContentView != null) { |
| mMessageContentView.loadDataWithBaseURL("email://", html, "text/html", "utf-8", null); |
| } |
| } |
| |
| /** |
| * Handle clicks on sender, which shows {@link QuickContact} or prompts to add |
| * the sender as a contact. |
| */ |
| private void onClickSender() { |
| if (!isMessageOpen()) return; |
| final Address senderEmail = Address.unpackFirst(mMessage.mFrom); |
| if (senderEmail == null) return; |
| |
| if (mContactStatusState == CONTACT_STATUS_STATE_UNLOADED) { |
| // Status not loaded yet. |
| mContactStatusState = CONTACT_STATUS_STATE_UNLOADED_TRIGGERED; |
| return; |
| } |
| if (mContactStatusState == CONTACT_STATUS_STATE_UNLOADED_TRIGGERED) { |
| return; // Already clicked, and waiting for the data. |
| } |
| |
| if (mQuickContactLookupUri != null) { |
| QuickContact.showQuickContact(mContext, mFromBadge, mQuickContactLookupUri, |
| QuickContact.MODE_MEDIUM, null); |
| } else { |
| // No matching contact, ask user to create one |
| final Uri mailUri = Uri.fromParts("mailto", senderEmail.getAddress(), null); |
| final Intent intent = new Intent(ContactsContract.Intents.SHOW_OR_CREATE_CONTACT, |
| mailUri); |
| |
| // Only provide personal name hint if we have one |
| final String senderPersonal = senderEmail.getPersonal(); |
| if (!TextUtils.isEmpty(senderPersonal)) { |
| intent.putExtra(ContactsContract.Intents.Insert.NAME, senderPersonal); |
| } |
| intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET); |
| |
| startActivity(intent); |
| } |
| } |
| |
| private static class ContactStatusLoaderCallbacks |
| implements LoaderCallbacks<ContactStatusLoader.Result> { |
| private static final String BUNDLE_EMAIL_ADDRESS = "email"; |
| private final MessageViewFragmentBase mFragment; |
| |
| public ContactStatusLoaderCallbacks(MessageViewFragmentBase fragment) { |
| mFragment = fragment; |
| } |
| |
| public static Bundle createArguments(String emailAddress) { |
| Bundle b = new Bundle(); |
| b.putString(BUNDLE_EMAIL_ADDRESS, emailAddress); |
| return b; |
| } |
| |
| @Override |
| public Loader<ContactStatusLoader.Result> onCreateLoader(int id, Bundle args) { |
| return new ContactStatusLoader(mFragment.mContext, |
| args.getString(BUNDLE_EMAIL_ADDRESS)); |
| } |
| |
| @Override |
| public void onLoadFinished(Loader<ContactStatusLoader.Result> loader, |
| ContactStatusLoader.Result result) { |
| boolean triggered = |
| (mFragment.mContactStatusState == CONTACT_STATUS_STATE_UNLOADED_TRIGGERED); |
| mFragment.mContactStatusState = CONTACT_STATUS_STATE_LOADED; |
| mFragment.mQuickContactLookupUri = result.mLookupUri; |
| |
| if (result.isUnknown()) { |
| mFragment.mSenderPresenceView.setVisibility(View.GONE); |
| } else { |
| mFragment.mSenderPresenceView.setVisibility(View.VISIBLE); |
| mFragment.mSenderPresenceView.setImageResource(result.mPresenceResId); |
| } |
| if (result.mPhoto != null) { // photo will be null if unknown. |
| mFragment.mFromBadge.setImageBitmap(result.mPhoto); |
| } |
| if (triggered) { |
| mFragment.onClickSender(); |
| } |
| } |
| |
| @Override |
| public void onLoaderReset(Loader<ContactStatusLoader.Result> loader) { |
| } |
| } |
| |
| private void onSaveAttachment(MessageViewAttachmentInfo info) { |
| if (!Utility.isExternalStorageMounted()) { |
| /* |
| * Abort early if there's no place to save the attachment. We don't want to spend |
| * the time downloading it and then abort. |
| */ |
| Utility.showToast(getActivity(), R.string.message_view_status_attachment_not_saved); |
| return; |
| } |
| |
| if (info.isFileSaved()) { |
| // Nothing to do - we have the file saved. |
| return; |
| } |
| |
| File savedFile = performAttachmentSave(info); |
| if (savedFile != null) { |
| Utility.showToast(getActivity(), String.format( |
| mContext.getString(R.string.message_view_status_attachment_saved), |
| savedFile.getName())); |
| } else { |
| Utility.showToast(getActivity(), R.string.message_view_status_attachment_not_saved); |
| } |
| } |
| |
| private File performAttachmentSave(MessageViewAttachmentInfo info) { |
| Attachment attachment = Attachment.restoreAttachmentWithId(mContext, info.mId); |
| Uri attachmentUri = AttachmentUtilities.getAttachmentUri(mAccountId, attachment.mId); |
| |
| try { |
| File downloads = Environment.getExternalStoragePublicDirectory( |
| Environment.DIRECTORY_DOWNLOADS); |
| downloads.mkdirs(); |
| File file = Utility.createUniqueFile(downloads, attachment.mFileName); |
| Uri contentUri = AttachmentUtilities.resolveAttachmentIdToContentUri( |
| mContext.getContentResolver(), attachmentUri); |
| InputStream in = mContext.getContentResolver().openInputStream(contentUri); |
| OutputStream out = new FileOutputStream(file); |
| IOUtils.copy(in, out); |
| out.flush(); |
| out.close(); |
| in.close(); |
| |
| String absolutePath = file.getAbsolutePath(); |
| |
| // Although the download manager can scan media files, scanning only happens after the |
| // user clicks on the item in the Downloads app. So, we run the attachment through |
| // the media scanner ourselves so it gets added to gallery / music immediately. |
| MediaScannerConnection.scanFile(mContext, new String[] {absolutePath}, |
| null, null); |
| |
| DownloadManager dm = |
| (DownloadManager) getActivity().getSystemService(Context.DOWNLOAD_SERVICE); |
| dm.addCompletedDownload(info.mName, info.mName, |
| false /* do not use media scanner */, |
| info.mContentType, absolutePath, info.mSize, |
| true /* show notification */); |
| |
| // Cache the stored file information. |
| info.setSavedPath(absolutePath); |
| |
| // Update our buttons. |
| updateAttachmentButtons(info); |
| |
| return file; |
| |
| } catch (IOException ioe) { |
| // Ignore. Callers will handle it from the return code. |
| } |
| |
| return null; |
| } |
| |
| private void onOpenAttachment(MessageViewAttachmentInfo info) { |
| if (info.mAllowInstall) { |
| // The package installer is unable to install files from a content URI; it must be |
| // given a file path. Therefore, we need to save it first in order to proceed |
| if (!info.mAllowSave || !Utility.isExternalStorageMounted()) { |
| Utility.showToast(getActivity(), R.string.message_view_status_attachment_not_saved); |
| return; |
| } |
| |
| if (!info.isFileSaved()) { |
| if (performAttachmentSave(info) == null) { |
| // Saving failed for some reason - bail. |
| Utility.showToast( |
| getActivity(), R.string.message_view_status_attachment_not_saved); |
| return; |
| } |
| } |
| } |
| try { |
| Intent intent = info.getAttachmentIntent(mContext, mAccountId); |
| startActivity(intent); |
| } catch (ActivityNotFoundException e) { |
| Utility.showToast(getActivity(), R.string.message_view_display_attachment_toast); |
| } |
| } |
| |
| private void onInfoAttachment(final MessageViewAttachmentInfo attachment) { |
| AttachmentInfoDialog dialog = |
| AttachmentInfoDialog.newInstance(getActivity(), attachment.mDenyFlags); |
| dialog.show(getActivity().getFragmentManager(), null); |
| } |
| |
| private void onLoadAttachment(final MessageViewAttachmentInfo attachment) { |
| attachment.loadButton.setVisibility(View.GONE); |
| // If there's nothing in the download queue, we'll probably start right away so wait a |
| // second before showing the cancel button |
| if (AttachmentDownloadService.getQueueSize() == 0) { |
| // Set to invisible; if the button is still in this state one second from now, we'll |
| // assume the download won't start right away, and we make the cancel button visible |
| attachment.cancelButton.setVisibility(View.GONE); |
| // Create the timed task that will change the button state |
| new EmailAsyncTask<Void, Void, Void>(mTaskTracker) { |
| @Override |
| protected Void doInBackground(Void... params) { |
| try { |
| Thread.sleep(1000L); |
| } catch (InterruptedException e) { } |
| return null; |
| } |
| @Override |
| protected void onSuccess(Void result) { |
| // If the timeout completes and the attachment has not loaded, show cancel |
| if (!attachment.loaded) { |
| attachment.cancelButton.setVisibility(View.VISIBLE); |
| } |
| } |
| }.executeParallel(); |
| } else { |
| attachment.cancelButton.setVisibility(View.VISIBLE); |
| } |
| attachment.showProgressIndeterminate(); |
| mController.loadAttachment(attachment.mId, mMessageId, mAccountId); |
| } |
| |
| private void onCancelAttachment(MessageViewAttachmentInfo attachment) { |
| // Don't change button states if we couldn't cancel the download |
| if (AttachmentDownloadService.cancelQueuedAttachment(attachment.mId)) { |
| attachment.loadButton.setVisibility(View.VISIBLE); |
| attachment.cancelButton.setVisibility(View.GONE); |
| attachment.hideProgress(); |
| } |
| } |
| |
| /** |
| * Called by ControllerResults. Show the "View" and "Save" buttons; hide "Load" and "Stop" |
| * |
| * @param attachmentId the attachment that was just downloaded |
| */ |
| private void doFinishLoadAttachment(long attachmentId) { |
| MessageViewAttachmentInfo info = findAttachmentInfo(attachmentId); |
| if (info != null) { |
| info.loaded = true; |
| updateAttachmentButtons(info); |
| } |
| } |
| |
| private void showPicturesInHtml() { |
| boolean picturesAlreadyLoaded = (mTabFlags & TAB_FLAGS_PICTURE_LOADED) != 0; |
| if ((mMessageContentView != null) && !picturesAlreadyLoaded) { |
| blockNetworkLoads(false); |
| // TODO: why is this calling setMessageHtml just because the images can load now? |
| setMessageHtml(mHtmlTextWebView); |
| |
| // Prompt the user to always show images from this sender. |
| makeVisible(UiUtilities.getView(getView(), R.id.always_show_pictures_button), true); |
| |
| addTabFlags(TAB_FLAGS_PICTURE_LOADED); |
| } |
| } |
| |
| private void showDetails() { |
| if (!isMessageOpen()) { |
| return; |
| } |
| |
| if (!mDetailsFilled) { |
| String date = formatDate(mMessage.mTimeStamp, true); |
| final String SEPARATOR = "\n"; |
| String to = Address.toString(Address.unpack(mMessage.mTo), SEPARATOR); |
| String cc = Address.toString(Address.unpack(mMessage.mCc), SEPARATOR); |
| String bcc = Address.toString(Address.unpack(mMessage.mBcc), SEPARATOR); |
| setDetailsRow(mDetailsExpanded, date, R.id.date, R.id.date_row); |
| setDetailsRow(mDetailsExpanded, to, R.id.to, R.id.to_row); |
| setDetailsRow(mDetailsExpanded, cc, R.id.cc, R.id.cc_row); |
| setDetailsRow(mDetailsExpanded, bcc, R.id.bcc, R.id.bcc_row); |
| mDetailsFilled = true; |
| } |
| |
| mDetailsCollapsed.setVisibility(View.GONE); |
| mDetailsExpanded.setVisibility(View.VISIBLE); |
| } |
| |
| private void hideDetails() { |
| mDetailsCollapsed.setVisibility(View.VISIBLE); |
| mDetailsExpanded.setVisibility(View.GONE); |
| } |
| |
| private static void setDetailsRow(View root, String text, int textViewId, int rowViewId) { |
| if (TextUtils.isEmpty(text)) { |
| root.findViewById(rowViewId).setVisibility(View.GONE); |
| return; |
| } |
| ((TextView) UiUtilities.getView(root, textViewId)).setText(text); |
| } |
| |
| |
| @Override |
| public void onClick(View view) { |
| if (!isMessageOpen()) { |
| return; // Ignore. |
| } |
| switch (view.getId()) { |
| case R.id.badge: |
| onClickSender(); |
| break; |
| case R.id.load: |
| onLoadAttachment((MessageViewAttachmentInfo) view.getTag()); |
| break; |
| case R.id.info: |
| onInfoAttachment((MessageViewAttachmentInfo) view.getTag()); |
| break; |
| case R.id.save: |
| onSaveAttachment((MessageViewAttachmentInfo) view.getTag()); |
| break; |
| case R.id.open: |
| onOpenAttachment((MessageViewAttachmentInfo) view.getTag()); |
| break; |
| case R.id.cancel: |
| onCancelAttachment((MessageViewAttachmentInfo) view.getTag()); |
| break; |
| case R.id.show_message: |
| setCurrentTab(TAB_MESSAGE); |
| break; |
| case R.id.show_invite: |
| setCurrentTab(TAB_INVITE); |
| break; |
| case R.id.show_attachments: |
| setCurrentTab(TAB_ATTACHMENT); |
| break; |
| case R.id.show_pictures: |
| showPicturesInHtml(); |
| break; |
| case R.id.always_show_pictures_button: |
| setShowImagesForSender(); |
| break; |
| case R.id.sub_header_contents_collapsed: |
| showDetails(); |
| break; |
| case R.id.sub_header_contents_expanded: |
| hideDetails(); |
| break; |
| } |
| } |
| |
| /** |
| * Start loading contact photo and presence. |
| */ |
| private void queryContactStatus() { |
| if (!isMessageOpen()) return; |
| initContactStatusViews(); // Initialize the state, just in case. |
| |
| // Find the sender email address, and start presence check. |
| Address sender = Address.unpackFirst(mMessage.mFrom); |
| if (sender != null) { |
| String email = sender.getAddress(); |
| if (email != null) { |
| getLoaderManager().restartLoader(PHOTO_LOADER_ID, |
| ContactStatusLoaderCallbacks.createArguments(email), |
| new ContactStatusLoaderCallbacks(this)); |
| } |
| } |
| } |
| |
| /** |
| * Called by {@link LoadMessageTask} and {@link ReloadMessageTask} to load a message in a |
| * subclass specific way. |
| * |
| * NOTE This method is called on a worker thread! Implementations must properly synchronize |
| * when accessing members. |
| * |
| * @param activity the parent activity. Subclass use it as a context, and to show a toast. |
| */ |
| protected abstract Message openMessageSync(Activity activity); |
| |
| /** |
| * Called in a background thread to reload a new copy of the Message in case something has |
| * changed. |
| */ |
| protected Message reloadMessageSync(Activity activity) { |
| return openMessageSync(activity); |
| } |
| |
| /** |
| * Async task for loading a single message outside of the UI thread |
| */ |
| private class LoadMessageTask extends EmailAsyncTask<Void, Void, Message> { |
| |
| private final boolean mOkToFetch; |
| private Mailbox mMailbox; |
| |
| /** |
| * Special constructor to cache some local info |
| */ |
| public LoadMessageTask(boolean okToFetch) { |
| super(mTaskTracker); |
| mOkToFetch = okToFetch; |
| } |
| |
| @Override |
| protected Message doInBackground(Void... params) { |
| Activity activity = getActivity(); |
| Message message = null; |
| if (activity != null) { |
| message = openMessageSync(activity); |
| } |
| if (message != null) { |
| mMailbox = Mailbox.restoreMailboxWithId(mContext, message.mMailboxKey); |
| if (mMailbox == null) { |
| message = null; // mailbox removed?? |
| } |
| } |
| return message; |
| } |
| |
| @Override |
| protected void onSuccess(Message message) { |
| if (message == null) { |
| resetView(); |
| mCallback.onMessageNotExists(); |
| return; |
| } |
| mMessageId = message.mId; |
| |
| reloadUiFromMessage(message, mOkToFetch); |
| queryContactStatus(); |
| onMessageShown(mMessageId, mMailbox); |
| RecentMailboxManager.getInstance(mContext).touch(mAccountId, message.mMailboxKey); |
| } |
| } |
| |
| /** |
| * Kicked by {@link MessageObserver}. Reload the message and update the views. |
| */ |
| private class ReloadMessageTask extends EmailAsyncTask<Void, Void, Message> { |
| public ReloadMessageTask() { |
| super(mTaskTracker); |
| } |
| |
| @Override |
| protected Message doInBackground(Void... params) { |
| Activity activity = getActivity(); |
| if (activity == null) { |
| return null; |
| } else { |
| return reloadMessageSync(activity); |
| } |
| } |
| |
| @Override |
| protected void onSuccess(Message message) { |
| if (message == null || message.mMailboxKey != mMessage.mMailboxKey) { |
| // Message deleted or moved. |
| mCallback.onMessageNotExists(); |
| return; |
| } |
| mMessage = message; |
| updateHeaderView(mMessage); |
| } |
| } |
| |
| /** |
| * Called when a message is shown to the user. |
| */ |
| protected void onMessageShown(long messageId, Mailbox mailbox) { |
| } |
| |
| /** |
| * Called when the message body is loaded. |
| */ |
| protected void onPostLoadBody() { |
| } |
| |
| /** |
| * Async task for loading a single message body outside of the UI thread |
| */ |
| private class LoadBodyTask extends EmailAsyncTask<Void, Void, String[]> { |
| |
| private final long mId; |
| private boolean mErrorLoadingMessageBody; |
| private final boolean mAutoShowPictures; |
| |
| /** |
| * Special constructor to cache some local info |
| */ |
| public LoadBodyTask(long messageId, boolean autoShowPictures) { |
| super(mTaskTracker); |
| mId = messageId; |
| mAutoShowPictures = autoShowPictures; |
| } |
| |
| @Override |
| protected String[] doInBackground(Void... params) { |
| try { |
| String text = null; |
| String html = Body.restoreBodyHtmlWithMessageId(mContext, mId); |
| if (html == null) { |
| text = Body.restoreBodyTextWithMessageId(mContext, mId); |
| } |
| return new String[] { text, html }; |
| } catch (RuntimeException re) { |
| // This catches SQLiteException as well as other RTE's we've seen from the |
| // database calls, such as IllegalStateException |
| Log.d(Logging.LOG_TAG, "Exception while loading message body", re); |
| mErrorLoadingMessageBody = true; |
| return null; |
| } |
| } |
| |
| @Override |
| protected void onSuccess(String[] results) { |
| if (results == null) { |
| if (mErrorLoadingMessageBody) { |
| Utility.showToast(getActivity(), R.string.error_loading_message_body); |
| } |
| resetView(); |
| return; |
| } |
| reloadUiFromBody(results[0], results[1], mAutoShowPictures); // text, html |
| onPostLoadBody(); |
| } |
| } |
| |
| /** |
| * Async task for loading attachments |
| * |
| * Note: This really should only be called when the message load is complete - or, we should |
| * leave open a listener so the attachments can fill in as they are discovered. In either case, |
| * this implementation is incomplete, as it will fail to refresh properly if the message is |
| * partially loaded at this time. |
| */ |
| private class LoadAttachmentsTask extends EmailAsyncTask<Long, Void, Attachment[]> { |
| public LoadAttachmentsTask() { |
| super(mTaskTracker); |
| } |
| |
| @Override |
| protected Attachment[] doInBackground(Long... messageIds) { |
| return Attachment.restoreAttachmentsWithMessageId(mContext, messageIds[0]); |
| } |
| |
| @Override |
| protected void onSuccess(Attachment[] attachments) { |
| try { |
| if (attachments == null) { |
| return; |
| } |
| boolean htmlChanged = false; |
| int numDisplayedAttachments = 0; |
| for (Attachment attachment : attachments) { |
| if (mHtmlTextRaw != null && attachment.mContentId != null |
| && attachment.mContentUri != null) { |
| // for html body, replace CID for inline images |
| // Regexp which matches ' src="cid:contentId"'. |
| String contentIdRe = |
| "\\s+(?i)src=\"cid(?-i):\\Q" + attachment.mContentId + "\\E\""; |
| String srcContentUri = " src=\"" + attachment.mContentUri + "\""; |
| mHtmlTextRaw = mHtmlTextRaw.replaceAll(contentIdRe, srcContentUri); |
| htmlChanged = true; |
| } else { |
| addAttachment(attachment); |
| numDisplayedAttachments++; |
| } |
| } |
| setAttachmentCount(numDisplayedAttachments); |
| mHtmlTextWebView = mHtmlTextRaw; |
| mHtmlTextRaw = null; |
| if (htmlChanged) { |
| setMessageHtml(mHtmlTextWebView); |
| } |
| } finally { |
| showContent(true, false); |
| } |
| } |
| } |
| |
| private static Bitmap getPreviewIcon(Context context, AttachmentInfo attachment) { |
| try { |
| return BitmapFactory.decodeStream( |
| context.getContentResolver().openInputStream( |
| AttachmentUtilities.getAttachmentThumbnailUri( |
| attachment.mAccountKey, attachment.mId, |
| PREVIEW_ICON_WIDTH, |
| PREVIEW_ICON_HEIGHT))); |
| } catch (Exception e) { |
| Log.d(Logging.LOG_TAG, "Attachment preview failed with exception " + e.getMessage()); |
| return null; |
| } |
| } |
| |
| /** |
| * Subclass of AttachmentInfo which includes our views and buttons related to attachment |
| * handling, as well as our determination of suitability for viewing (based on availability of |
| * a viewer app) and saving (based upon the presence of external storage) |
| */ |
| private static class MessageViewAttachmentInfo extends AttachmentInfo { |
| private Button openButton; |
| private Button saveButton; |
| private Button loadButton; |
| private Button infoButton; |
| private Button cancelButton; |
| private ImageView iconView; |
| |
| private static final Map<AttachmentInfo, String> sSavedFileInfos = Maps.newHashMap(); |
| |
| // Don't touch it directly from the outer class. |
| private final ProgressBar mProgressView; |
| private boolean loaded; |
| |
| private MessageViewAttachmentInfo(Context context, Attachment attachment, |
| ProgressBar progressView) { |
| super(context, attachment); |
| mProgressView = progressView; |
| } |
| |
| /** |
| * Create a new attachment info based upon an existing attachment info. Display |
| * related fields (such as views and buttons) are copied from old to new. |
| */ |
| private MessageViewAttachmentInfo(Context context, MessageViewAttachmentInfo oldInfo) { |
| super(context, oldInfo); |
| openButton = oldInfo.openButton; |
| saveButton = oldInfo.saveButton; |
| loadButton = oldInfo.loadButton; |
| infoButton = oldInfo.infoButton; |
| cancelButton = oldInfo.cancelButton; |
| iconView = oldInfo.iconView; |
| mProgressView = oldInfo.mProgressView; |
| loaded = oldInfo.loaded; |
| } |
| |
| public void hideProgress() { |
| // Don't use GONE, which'll break the layout. |
| if (mProgressView.getVisibility() != View.INVISIBLE) { |
| mProgressView.setVisibility(View.INVISIBLE); |
| } |
| } |
| |
| public void showProgress(int progress) { |
| if (mProgressView.getVisibility() != View.VISIBLE) { |
| mProgressView.setVisibility(View.VISIBLE); |
| } |
| if (mProgressView.isIndeterminate()) { |
| mProgressView.setIndeterminate(false); |
| } |
| mProgressView.setProgress(progress); |
| |
| // Hide on completion. |
| if (progress == 100) { |
| hideProgress(); |
| } |
| } |
| |
| public void showProgressIndeterminate() { |
| if (mProgressView.getVisibility() != View.VISIBLE) { |
| mProgressView.setVisibility(View.VISIBLE); |
| } |
| if (!mProgressView.isIndeterminate()) { |
| mProgressView.setIndeterminate(true); |
| } |
| } |
| |
| /** |
| * Determines whether or not this attachment has a saved file in the external storage. That |
| * is, the user has at some point clicked "save" for this attachment. |
| * |
| * Note: this is an approximation and uses an in-memory cache that can get wiped when the |
| * process dies, and so is somewhat conservative. Additionally, the user can modify the file |
| * after saving, and so the file may not be the same (though this is unlikely). |
| */ |
| public boolean isFileSaved() { |
| String path = getSavedPath(); |
| if (path == null) { |
| return false; |
| } |
| boolean savedFileExists = new File(path).exists(); |
| if (!savedFileExists) { |
| // Purge the cache entry. |
| setSavedPath(null); |
| } |
| return savedFileExists; |
| } |
| |
| private void setSavedPath(String path) { |
| if (path == null) { |
| sSavedFileInfos.remove(this); |
| } else { |
| sSavedFileInfos.put(this, path); |
| } |
| } |
| |
| /** |
| * Returns an absolute file path for the given attachment if it has been saved. If one is |
| * not found, {@code null} is returned. |
| * |
| * Clients are expected to validate that the file at the given path is still valid. |
| */ |
| private String getSavedPath() { |
| return sSavedFileInfos.get(this); |
| } |
| |
| @Override |
| protected Uri getUriForIntent(Context context, long accountId) { |
| // Prefer to act on the saved file for intents. |
| String path = getSavedPath(); |
| return (path != null) |
| ? Uri.parse("file://" + getSavedPath()) |
| : super.getUriForIntent(context, accountId); |
| } |
| } |
| |
| /** |
| * Updates all current attachments on the attachment tab. |
| */ |
| private void updateAttachmentTab() { |
| for (int i = 0, count = mAttachments.getChildCount(); i < count; i++) { |
| View view = mAttachments.getChildAt(i); |
| MessageViewAttachmentInfo oldInfo = (MessageViewAttachmentInfo)view.getTag(); |
| MessageViewAttachmentInfo newInfo = |
| new MessageViewAttachmentInfo(getActivity(), oldInfo); |
| updateAttachmentButtons(newInfo); |
| view.setTag(newInfo); |
| } |
| } |
| |
| /** |
| * Updates the attachment buttons. Adjusts the visibility of the buttons as well |
| * as updating any tag information associated with the buttons. |
| */ |
| private void updateAttachmentButtons(MessageViewAttachmentInfo attachmentInfo) { |
| ImageView attachmentIcon = attachmentInfo.iconView; |
| Button openButton = attachmentInfo.openButton; |
| Button saveButton = attachmentInfo.saveButton; |
| Button loadButton = attachmentInfo.loadButton; |
| Button infoButton = attachmentInfo.infoButton; |
| Button cancelButton = attachmentInfo.cancelButton; |
| |
| if (!attachmentInfo.mAllowView) { |
| openButton.setVisibility(View.GONE); |
| } |
| if (!attachmentInfo.mAllowSave) { |
| saveButton.setVisibility(View.GONE); |
| } |
| |
| if (!attachmentInfo.mAllowView && !attachmentInfo.mAllowSave) { |
| // This attachment may never be viewed or saved, so block everything |
| attachmentInfo.hideProgress(); |
| openButton.setVisibility(View.GONE); |
| saveButton.setVisibility(View.GONE); |
| loadButton.setVisibility(View.GONE); |
| cancelButton.setVisibility(View.GONE); |
| infoButton.setVisibility(View.VISIBLE); |
| } else if (attachmentInfo.loaded) { |
| // If the attachment is loaded, show 100% progress |
| // Note that for POP3 messages, the user will only see "Open" and "Save", |
| // because the entire message is loaded before being shown. |
| // Hide "Load" and "Info", show "View" and "Save" |
| attachmentInfo.showProgress(100); |
| if (attachmentInfo.mAllowSave) { |
| saveButton.setVisibility(View.VISIBLE); |
| |
| boolean isFileSaved = attachmentInfo.isFileSaved(); |
| saveButton.setEnabled(!isFileSaved); |
| if (!isFileSaved) { |
| saveButton.setText(R.string.message_view_attachment_save_action); |
| } else { |
| saveButton.setText(R.string.message_view_attachment_saved); |
| } |
| } |
| if (attachmentInfo.mAllowView) { |
| // Set the attachment action button text accordingly |
| if (attachmentInfo.mContentType.startsWith("audio/") || |
| attachmentInfo.mContentType.startsWith("video/")) { |
| openButton.setText(R.string.message_view_attachment_play_action); |
| } else if (attachmentInfo.mAllowInstall) { |
| openButton.setText(R.string.message_view_attachment_install_action); |
| } else { |
| openButton.setText(R.string.message_view_attachment_view_action); |
| } |
| openButton.setVisibility(View.VISIBLE); |
| } |
| if (attachmentInfo.mDenyFlags == AttachmentInfo.ALLOW) { |
| infoButton.setVisibility(View.GONE); |
| } else { |
| infoButton.setVisibility(View.VISIBLE); |
| } |
| loadButton.setVisibility(View.GONE); |
| cancelButton.setVisibility(View.GONE); |
| |
| updatePreviewIcon(attachmentInfo); |
| } else { |
| // The attachment is not loaded, so present UI to start downloading it |
| |
| // Show "Load"; hide "View", "Save" and "Info" |
| saveButton.setVisibility(View.GONE); |
| openButton.setVisibility(View.GONE); |
| infoButton.setVisibility(View.GONE); |
| |
| // If the attachment is queued, show the indeterminate progress bar. From this point,. |
| // any progress changes will cause this to be replaced by the normal progress bar |
| if (AttachmentDownloadService.isAttachmentQueued(attachmentInfo.mId)) { |
| attachmentInfo.showProgressIndeterminate(); |
| loadButton.setVisibility(View.GONE); |
| cancelButton.setVisibility(View.VISIBLE); |
| } else { |
| loadButton.setVisibility(View.VISIBLE); |
| cancelButton.setVisibility(View.GONE); |
| } |
| } |
| openButton.setTag(attachmentInfo); |
| saveButton.setTag(attachmentInfo); |
| loadButton.setTag(attachmentInfo); |
| infoButton.setTag(attachmentInfo); |
| cancelButton.setTag(attachmentInfo); |
| } |
| |
| /** |
| * Copy data from a cursor-refreshed attachment into the UI. Called from UI thread. |
| * |
| * @param attachment A single attachment loaded from the provider |
| */ |
| private void addAttachment(Attachment attachment) { |
| LayoutInflater inflater = getActivity().getLayoutInflater(); |
| View view = inflater.inflate(R.layout.message_view_attachment, null); |
| |
| TextView attachmentName = (TextView) UiUtilities.getView(view, R.id.attachment_name); |
| TextView attachmentInfoView = (TextView) UiUtilities.getView(view, R.id.attachment_info); |
| ImageView attachmentIcon = (ImageView) UiUtilities.getView(view, R.id.attachment_icon); |
| Button openButton = (Button) UiUtilities.getView(view, R.id.open); |
| Button saveButton = (Button) UiUtilities.getView(view, R.id.save); |
| Button loadButton = (Button) UiUtilities.getView(view, R.id.load); |
| Button infoButton = (Button) UiUtilities.getView(view, R.id.info); |
| Button cancelButton = (Button) UiUtilities.getView(view, R.id.cancel); |
| ProgressBar attachmentProgress = (ProgressBar) UiUtilities.getView(view, R.id.progress); |
| |
| MessageViewAttachmentInfo attachmentInfo = new MessageViewAttachmentInfo( |
| mContext, attachment, attachmentProgress); |
| |
| // Check whether the attachment already exists |
| if (Utility.attachmentExists(mContext, attachment)) { |
| attachmentInfo.loaded = true; |
| } |
| |
| attachmentInfo.openButton = openButton; |
| attachmentInfo.saveButton = saveButton; |
| attachmentInfo.loadButton = loadButton; |
| attachmentInfo.infoButton = infoButton; |
| attachmentInfo.cancelButton = cancelButton; |
| attachmentInfo.iconView = attachmentIcon; |
| |
| updateAttachmentButtons(attachmentInfo); |
| |
| view.setTag(attachmentInfo); |
| openButton.setOnClickListener(this); |
| saveButton.setOnClickListener(this); |
| loadButton.setOnClickListener(this); |
| infoButton.setOnClickListener(this); |
| cancelButton.setOnClickListener(this); |
| |
| attachmentName.setText(attachmentInfo.mName); |
| attachmentInfoView.setText(UiUtilities.formatSize(mContext, attachmentInfo.mSize)); |
| |
| mAttachments.addView(view); |
| mAttachments.setVisibility(View.VISIBLE); |
| } |
| |
| private MessageViewAttachmentInfo findAttachmentInfoFromView(long attachmentId) { |
| for (int i = 0, count = mAttachments.getChildCount(); i < count; i++) { |
| MessageViewAttachmentInfo attachmentInfo = |
| (MessageViewAttachmentInfo) mAttachments.getChildAt(i).getTag(); |
| if (attachmentInfo.mId == attachmentId) { |
| return attachmentInfo; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Reload the UI from a provider cursor. {@link LoadMessageTask#onSuccess} calls it. |
| * |
| * Update the header views, and start loading the body. |
| * |
| * @param message A copy of the message loaded from the database |
| * @param okToFetch If true, and message is not fully loaded, it's OK to fetch from |
| * the network. Use false to prevent looping here. |
| */ |
| protected void reloadUiFromMessage(Message message, boolean okToFetch) { |
| mMessage = message; |
| mAccountId = message.mAccountKey; |
| |
| mMessageObserver.register(ContentUris.withAppendedId(Message.CONTENT_URI, mMessage.mId)); |
| |
| updateHeaderView(mMessage); |
| |
| // Handle partially-loaded email, as follows: |
| // 1. Check value of message.mFlagLoaded |
| // 2. If != LOADED, ask controller to load it |
| // 3. Controller callback (after loaded) should trigger LoadBodyTask & LoadAttachmentsTask |
| // 4. Else start the loader tasks right away (message already loaded) |
| if (okToFetch && message.mFlagLoaded != Message.FLAG_LOADED_COMPLETE) { |
| mControllerCallback.getWrappee().setWaitForLoadMessageId(message.mId); |
| mController.loadMessageForView(message.mId); |
| } else { |
| Address[] fromList = Address.unpack(mMessage.mFrom); |
| boolean autoShowImages = false; |
| for (Address sender : fromList) { |
| String email = sender.getAddress(); |
| if (shouldShowImagesFor(email)) { |
| autoShowImages = true; |
| break; |
| } |
| } |
| mControllerCallback.getWrappee().setWaitForLoadMessageId(Message.NO_MESSAGE); |
| // Ask for body |
| new LoadBodyTask(message.mId, autoShowImages).executeParallel(); |
| } |
| } |
| |
| protected void updateHeaderView(Message message) { |
| mSubjectView.setText(message.mSubject); |
| final Address from = Address.unpackFirst(message.mFrom); |
| |
| // Set sender address/display name |
| // Note we set " " for empty field, so TextView's won't get squashed. |
| // Otherwise their height will be 0, which breaks the layout. |
| if (from != null) { |
| final String fromFriendly = from.toFriendly(); |
| final String fromAddress = from.getAddress(); |
| mFromNameView.setText(fromFriendly); |
| mFromAddressView.setText(fromFriendly.equals(fromAddress) ? " " : fromAddress); |
| } else { |
| mFromNameView.setText(" "); |
| mFromAddressView.setText(" "); |
| } |
| mDateTimeView.setText(DateUtils.getRelativeTimeSpanString(mContext, message.mTimeStamp) |
| .toString()); |
| |
| // To/Cc/Bcc |
| final Resources res = mContext.getResources(); |
| final SpannableStringBuilder ssb = new SpannableStringBuilder(); |
| final String friendlyTo = Address.toFriendly(Address.unpack(message.mTo)); |
| final String friendlyCc = Address.toFriendly(Address.unpack(message.mCc)); |
| final String friendlyBcc = Address.toFriendly(Address.unpack(message.mBcc)); |
| |
| if (!TextUtils.isEmpty(friendlyTo)) { |
| Utility.appendBold(ssb, res.getString(R.string.message_view_to_label)); |
| ssb.append(" "); |
| ssb.append(friendlyTo); |
| } |
| if (!TextUtils.isEmpty(friendlyCc)) { |
| ssb.append(" "); |
| Utility.appendBold(ssb, res.getString(R.string.message_view_cc_label)); |
| ssb.append(" "); |
| ssb.append(friendlyCc); |
| } |
| if (!TextUtils.isEmpty(friendlyBcc)) { |
| ssb.append(" "); |
| Utility.appendBold(ssb, res.getString(R.string.message_view_bcc_label)); |
| ssb.append(" "); |
| ssb.append(friendlyBcc); |
| } |
| mAddressesView.setText(ssb); |
| } |
| |
| /** |
| * @return the given date/time in a human readable form. The returned string always have |
| * month and day (and year if {@code withYear} is set), so is usually long. |
| * Use {@link DateUtils#getRelativeTimeSpanString} instead to save the screen real estate. |
| */ |
| private String formatDate(long millis, boolean withYear) { |
| StringBuilder sb = new StringBuilder(); |
| Formatter formatter = new Formatter(sb); |
| DateUtils.formatDateRange(mContext, formatter, millis, millis, |
| DateUtils.FORMAT_SHOW_DATE |
| | DateUtils.FORMAT_ABBREV_ALL |
| | DateUtils.FORMAT_SHOW_TIME |
| | (withYear ? DateUtils.FORMAT_SHOW_YEAR : DateUtils.FORMAT_NO_YEAR)); |
| return sb.toString(); |
| } |
| |
| /** |
| * Reload the body from the provider cursor. This must only be called from the UI thread. |
| * |
| * @param bodyText text part |
| * @param bodyHtml html part |
| * |
| * TODO deal with html vs text and many other issues <- WHAT DOES IT MEAN?? |
| */ |
| private void reloadUiFromBody(String bodyText, String bodyHtml, boolean autoShowPictures) { |
| String text = null; |
| mHtmlTextRaw = null; |
| boolean hasImages = false; |
| |
| if (bodyHtml == null) { |
| text = bodyText; |
| /* |
| * Convert the plain text to HTML |
| */ |
| StringBuffer sb = new StringBuffer("<html><body>"); |
| if (text != null) { |
| // Escape any inadvertent HTML in the text message |
| text = EmailHtmlUtil.escapeCharacterToDisplay(text); |
| // Find any embedded URL's and linkify |
| Matcher m = Patterns.WEB_URL.matcher(text); |
| while (m.find()) { |
| int start = m.start(); |
| /* |
| * WEB_URL_PATTERN may match domain part of email address. To detect |
| * this false match, the character just before the matched string |
| * should not be '@'. |
| */ |
| if (start == 0 || text.charAt(start - 1) != '@') { |
| String url = m.group(); |
| Matcher proto = WEB_URL_PROTOCOL.matcher(url); |
| String link; |
| if (proto.find()) { |
| // This is work around to force URL protocol part be lower case, |
| // because WebView could follow only lower case protocol link. |
| link = proto.group().toLowerCase() + url.substring(proto.end()); |
| } else { |
| // Patterns.WEB_URL matches URL without protocol part, |
| // so added default protocol to link. |
| link = "http://" + url; |
| } |
| String href = String.format("<a href=\"%s\">%s</a>", link, url); |
| m.appendReplacement(sb, href); |
| } |
| else { |
| m.appendReplacement(sb, "$0"); |
| } |
| } |
| m.appendTail(sb); |
| } |
| sb.append("</body></html>"); |
| text = sb.toString(); |
| } else { |
| text = bodyHtml; |
| mHtmlTextRaw = bodyHtml; |
| hasImages = IMG_TAG_START_REGEX.matcher(text).find(); |
| } |
| |
| // TODO this is not really accurate. |
| // - Images aren't the only network resources. (e.g. CSS) |
| // - If images are attached to the email and small enough, we download them at once, |
| // and won't need network access when they're shown. |
| if (hasImages) { |
| if (mRestoredPictureLoaded || autoShowPictures) { |
| blockNetworkLoads(false); |
| addTabFlags(TAB_FLAGS_PICTURE_LOADED); // Set for next onSaveInstanceState |
| |
| // Make sure to reset the flag -- otherwise this will keep taking effect even after |
| // moving to another message. |
| mRestoredPictureLoaded = false; |
| } else { |
| addTabFlags(TAB_FLAGS_HAS_PICTURES); |
| } |
| } |
| setMessageHtml(text); |
| |
| // Ask for attachments after body |
| new LoadAttachmentsTask().executeParallel(mMessage.mId); |
| |
| mIsMessageLoadedForTest = true; |
| } |
| |
| /** |
| * Overrides for WebView behaviors. |
| */ |
| private class CustomWebViewClient extends WebViewClient { |
| @Override |
| public boolean shouldOverrideUrlLoading(WebView view, String url) { |
| return mCallback.onUrlInMessageClicked(url); |
| } |
| } |
| |
| private View findAttachmentView(long attachmentId) { |
| for (int i = 0, count = mAttachments.getChildCount(); i < count; i++) { |
| View view = mAttachments.getChildAt(i); |
| MessageViewAttachmentInfo attachment = (MessageViewAttachmentInfo) view.getTag(); |
| if (attachment.mId == attachmentId) { |
| return view; |
| } |
| } |
| return null; |
| } |
| |
| private MessageViewAttachmentInfo findAttachmentInfo(long attachmentId) { |
| View view = findAttachmentView(attachmentId); |
| if (view != null) { |
| return (MessageViewAttachmentInfo)view.getTag(); |
| } |
| return null; |
| } |
| |
| /** |
| * Controller results listener. We wrap it with {@link ControllerResultUiThreadWrapper}, |
| * so all methods are called on the UI thread. |
| */ |
| private class ControllerResults extends Controller.Result { |
| private long mWaitForLoadMessageId; |
| |
| public void setWaitForLoadMessageId(long messageId) { |
| mWaitForLoadMessageId = messageId; |
| } |
| |
| @Override |
| public void loadMessageForViewCallback(MessagingException result, long accountId, |
| long messageId, int progress) { |
| if (messageId != mWaitForLoadMessageId) { |
| // We are not waiting for this message to load, so exit quickly |
| return; |
| } |
| if (result == null) { |
| switch (progress) { |
| case 0: |
| mCallback.onLoadMessageStarted(); |
| // Loading from network -- show the progress icon. |
| showContent(false, true); |
| break; |
| case 100: |
| mWaitForLoadMessageId = -1; |
| mCallback.onLoadMessageFinished(); |
| // reload UI and reload everything else too |
| // pass false to LoadMessageTask to prevent looping here |
| cancelAllTasks(); |
| new LoadMessageTask(false).executeParallel(); |
| break; |
| default: |
| // do nothing - we don't have a progress bar at this time |
| break; |
| } |
| } else { |
| mWaitForLoadMessageId = Message.NO_MESSAGE; |
| String error = mContext.getString(R.string.status_network_error); |
| mCallback.onLoadMessageError(error); |
| resetView(); |
| } |
| } |
| |
| @Override |
| public void loadAttachmentCallback(MessagingException result, long accountId, |
| long messageId, long attachmentId, int progress) { |
| if (messageId == mMessageId) { |
| if (result == null) { |
| showAttachmentProgress(attachmentId, progress); |
| switch (progress) { |
| case 100: |
| final MessageViewAttachmentInfo attachmentInfo = |
| findAttachmentInfoFromView(attachmentId); |
| if (attachmentInfo != null) { |
| updatePreviewIcon(attachmentInfo); |
| } |
| doFinishLoadAttachment(attachmentId); |
| break; |
| default: |
| // do nothing - we don't have a progress bar at this time |
| break; |
| } |
| } else { |
| MessageViewAttachmentInfo attachment = findAttachmentInfo(attachmentId); |
| if (attachment == null) { |
| // Called before LoadAttachmentsTask finishes. |
| // (Possible if you quickly close & re-open a message) |
| return; |
| } |
| attachment.cancelButton.setVisibility(View.GONE); |
| attachment.loadButton.setVisibility(View.VISIBLE); |
| attachment.hideProgress(); |
| |
| final String error; |
| if (result.getCause() instanceof IOException) { |
| error = mContext.getString(R.string.status_network_error); |
| } else { |
| error = mContext.getString( |
| R.string.message_view_load_attachment_failed_toast, |
| attachment.mName); |
| } |
| mCallback.onLoadMessageError(error); |
| } |
| } |
| } |
| |
| private void showAttachmentProgress(long attachmentId, int progress) { |
| MessageViewAttachmentInfo attachment = findAttachmentInfo(attachmentId); |
| if (attachment != null) { |
| if (progress == 0) { |
| attachment.cancelButton.setVisibility(View.GONE); |
| } |
| attachment.showProgress(progress); |
| } |
| } |
| } |
| |
| /** |
| * Class to detect update on the current message (e.g. toggle star). When it gets content |
| * change notifications, it kicks {@link ReloadMessageTask}. |
| */ |
| private class MessageObserver extends ContentObserver implements Runnable { |
| private final Throttle mThrottle; |
| private final ContentResolver mContentResolver; |
| |
| private boolean mRegistered; |
| |
| public MessageObserver(Handler handler, Context context) { |
| super(handler); |
| mContentResolver = context.getContentResolver(); |
| mThrottle = new Throttle("MessageObserver", this, handler); |
| } |
| |
| public void unregister() { |
| if (!mRegistered) { |
| return; |
| } |
| mThrottle.cancelScheduledCallback(); |
| mContentResolver.unregisterContentObserver(this); |
| mRegistered = false; |
| } |
| |
| public void register(Uri notifyUri) { |
| unregister(); |
| mContentResolver.registerContentObserver(notifyUri, true, this); |
| mRegistered = true; |
| } |
| |
| @Override |
| public boolean deliverSelfNotifications() { |
| return true; |
| } |
| |
| @Override |
| public void onChange(boolean selfChange) { |
| if (mRegistered) { |
| mThrottle.onEvent(); |
| } |
| } |
| |
| /** This method is delay-called by {@link Throttle} on the UI thread. */ |
| @Override |
| public void run() { |
| // This method is delay-called, so need to make sure if it's still registered. |
| if (mRegistered) { |
| new ReloadMessageTask().cancelPreviousAndExecuteParallel(); |
| } |
| } |
| } |
| |
| private void updatePreviewIcon(MessageViewAttachmentInfo attachmentInfo) { |
| new UpdatePreviewIconTask(attachmentInfo).executeParallel(); |
| } |
| |
| private class UpdatePreviewIconTask extends EmailAsyncTask<Void, Void, Bitmap> { |
| @SuppressWarnings("hiding") |
| private final Context mContext; |
| private final MessageViewAttachmentInfo mAttachmentInfo; |
| |
| public UpdatePreviewIconTask(MessageViewAttachmentInfo attachmentInfo) { |
| super(mTaskTracker); |
| mContext = getActivity(); |
| mAttachmentInfo = attachmentInfo; |
| } |
| |
| @Override |
| protected Bitmap doInBackground(Void... params) { |
| return getPreviewIcon(mContext, mAttachmentInfo); |
| } |
| |
| @Override |
| protected void onSuccess(Bitmap result) { |
| if (result == null) { |
| return; |
| } |
| mAttachmentInfo.iconView.setImageBitmap(result); |
| } |
| } |
| |
| private boolean shouldShowImagesFor(String senderEmail) { |
| return Preferences.getPreferences(getActivity()).shouldShowImagesFor(senderEmail); |
| } |
| |
| private void setShowImagesForSender() { |
| makeVisible(UiUtilities.getView(getView(), R.id.always_show_pictures_button), false); |
| Utility.showToast(getActivity(), R.string.message_view_always_show_pictures_confirmation); |
| |
| // Force redraw of the container. |
| updateTabs(mTabFlags); |
| |
| Address[] fromList = Address.unpack(mMessage.mFrom); |
| Preferences prefs = Preferences.getPreferences(getActivity()); |
| for (Address sender : fromList) { |
| String email = sender.getAddress(); |
| prefs.setSenderAsTrusted(email); |
| } |
| } |
| |
| public boolean isMessageLoadedForTest() { |
| return mIsMessageLoadedForTest; |
| } |
| |
| public void clearIsMessageLoadedForTest() { |
| mIsMessageLoadedForTest = true; |
| } |
| } |
