Home | History | Annotate | Download | only in utils
      1 /**
      2  * Copyright (c) 2011, Google Inc.
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *     http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.mail.utils;
     18 
     19 import android.annotation.TargetApi;
     20 import android.app.Activity;
     21 import android.app.ActivityManager;
     22 import android.app.Fragment;
     23 import android.content.ComponentCallbacks;
     24 import android.content.Context;
     25 import android.content.Intent;
     26 import android.content.pm.PackageManager.NameNotFoundException;
     27 import android.content.res.Configuration;
     28 import android.content.res.Resources;
     29 import android.database.Cursor;
     30 import android.graphics.Bitmap;
     31 import android.net.ConnectivityManager;
     32 import android.net.NetworkInfo;
     33 import android.net.Uri;
     34 import android.os.AsyncTask;
     35 import android.os.Build;
     36 import android.os.Bundle;
     37 import android.provider.Browser;
     38 import android.support.annotation.Nullable;
     39 import android.support.annotation.VisibleForTesting;
     40 import android.text.SpannableString;
     41 import android.text.Spanned;
     42 import android.text.TextUtils;
     43 import android.text.style.TextAppearanceSpan;
     44 import android.view.Menu;
     45 import android.view.MenuItem;
     46 import android.view.View;
     47 import android.view.View.MeasureSpec;
     48 import android.view.ViewGroup;
     49 import android.view.ViewGroup.MarginLayoutParams;
     50 import android.view.Window;
     51 import android.webkit.WebSettings;
     52 import android.webkit.WebView;
     53 
     54 import com.android.emailcommon.mail.Address;
     55 import com.android.mail.R;
     56 import com.android.mail.browse.ConversationCursor;
     57 import com.android.mail.compose.ComposeActivity;
     58 import com.android.mail.perf.SimpleTimer;
     59 import com.android.mail.providers.Account;
     60 import com.android.mail.providers.Conversation;
     61 import com.android.mail.providers.Folder;
     62 import com.android.mail.providers.UIProvider;
     63 import com.android.mail.providers.UIProvider.EditSettingsExtras;
     64 import com.android.mail.ui.HelpActivity;
     65 import com.google.android.mail.common.html.parser.HtmlDocument;
     66 import com.google.android.mail.common.html.parser.HtmlParser;
     67 import com.google.android.mail.common.html.parser.HtmlTree;
     68 import com.google.android.mail.common.html.parser.HtmlTreeBuilder;
     69 
     70 import org.json.JSONObject;
     71 
     72 import java.io.FileDescriptor;
     73 import java.io.PrintWriter;
     74 import java.io.StringWriter;
     75 import java.util.Locale;
     76 import java.util.Map;
     77 
     78 public class Utils {
     79     /**
     80      * longest extension we recognize is 4 characters (e.g. "html", "docx")
     81      */
     82     private static final int FILE_EXTENSION_MAX_CHARS = 4;
     83     public static final String SENDER_LIST_TOKEN_ELIDED = "e";
     84     public static final String SENDER_LIST_TOKEN_NUM_MESSAGES = "n";
     85     public static final String SENDER_LIST_TOKEN_NUM_DRAFTS = "d";
     86     public static final String SENDER_LIST_TOKEN_LITERAL = "l";
     87     public static final String SENDER_LIST_TOKEN_SENDING = "s";
     88     public static final String SENDER_LIST_TOKEN_SEND_FAILED = "f";
     89     public static final Character SENDER_LIST_SEPARATOR = '\n';
     90 
     91     public static final String EXTRA_ACCOUNT = "account";
     92     public static final String EXTRA_ACCOUNT_URI = "accountUri";
     93     public static final String EXTRA_FOLDER_URI = "folderUri";
     94     public static final String EXTRA_FOLDER = "folder";
     95     public static final String EXTRA_COMPOSE_URI = "composeUri";
     96     public static final String EXTRA_CONVERSATION = "conversationUri";
     97     public static final String EXTRA_FROM_NOTIFICATION = "notification";
     98     public static final String EXTRA_IGNORE_INITIAL_CONVERSATION_LIMIT =
     99             "ignore-initial-conversation-limit";
    100 
    101     public static final String MAILTO_SCHEME = "mailto";
    102 
    103     /** Extra tag for debugging the blank fragment problem. */
    104     public static final String VIEW_DEBUGGING_TAG = "MailBlankFragment";
    105 
    106     /*
    107      * Notifies that changes happened. Certain UI components, e.g., widgets, can
    108      * register for this {@link Intent} and update accordingly. However, this
    109      * can be very broad and is NOT the preferred way of getting notification.
    110      */
    111     // TODO: UI Provider has this notification URI?
    112     public static final String ACTION_NOTIFY_DATASET_CHANGED =
    113             "com.android.mail.ACTION_NOTIFY_DATASET_CHANGED";
    114 
    115     /** Parameter keys for context-aware help. */
    116     private static final String SMART_HELP_LINK_PARAMETER_NAME = "p";
    117 
    118     private static final String SMART_LINK_APP_VERSION = "version";
    119     private static String sVersionCode = null;
    120 
    121     private static final int SCALED_SCREENSHOT_MAX_HEIGHT_WIDTH = 600;
    122 
    123     private static final String APP_VERSION_QUERY_PARAMETER = "appVersion";
    124     private static final String FOLDER_URI_QUERY_PARAMETER = "folderUri";
    125 
    126     private static final String LOG_TAG = LogTag.getLogTag();
    127 
    128     public static final boolean ENABLE_CONV_LOAD_TIMER = false;
    129     public static final SimpleTimer sConvLoadTimer =
    130             new SimpleTimer(ENABLE_CONV_LOAD_TIMER).withSessionName("ConvLoadTimer");
    131 
    132     public static boolean isRunningJellybeanOrLater() {
    133         return Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN;
    134     }
    135 
    136     public static boolean isRunningJBMR1OrLater() {
    137         return Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1;
    138     }
    139 
    140     public static boolean isRunningKitkatOrLater() {
    141         return Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;
    142     }
    143 
    144     public static boolean isRunningLOrLater() {
    145         return Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP;
    146     }
    147 
    148     public static boolean isRunningNOrLater() {
    149         return Build.VERSION.SDK_INT >= Build.VERSION_CODES.N;
    150     }
    151 
    152     /**
    153      * @return Whether we are running on a low memory device.  This is used to disable certain
    154      * memory intensive features in the app.
    155      */
    156     @TargetApi(Build.VERSION_CODES.KITKAT)
    157     public static boolean isLowRamDevice(Context context) {
    158         if (isRunningKitkatOrLater()) {
    159             final ActivityManager am = (ActivityManager) context.getSystemService(
    160                     Context.ACTIVITY_SERVICE);
    161             // This will be null when running unit tests
    162             return am != null && am.isLowRamDevice();
    163         } else {
    164             return false;
    165         }
    166     }
    167 
    168     /**
    169      * Sets WebView in a restricted mode suitable for email use.
    170      *
    171      * @param webView The WebView to restrict
    172      */
    173     public static void restrictWebView(WebView webView) {
    174         WebSettings webSettings = webView.getSettings();
    175         webSettings.setSavePassword(false);
    176         webSettings.setSaveFormData(false);
    177         webSettings.setJavaScriptEnabled(false);
    178         webSettings.setSupportZoom(false);
    179     }
    180 
    181     /**
    182      * Sets custom user agent to WebView so we don't get GAIA interstitials b/13990689.
    183      *
    184      * @param webView The WebView to customize.
    185      */
    186     public static void setCustomUserAgent(WebView webView, Context context) {
    187         final WebSettings settings = webView.getSettings();
    188         final String version = getVersionCode(context);
    189         final String originalUserAgent = settings.getUserAgentString();
    190         final String userAgent = context.getResources().getString(
    191                 R.string.user_agent_format, originalUserAgent, version);
    192         settings.setUserAgentString(userAgent);
    193     }
    194 
    195     /**
    196      * Returns the version code for the package, or null if it cannot be retrieved.
    197      */
    198     public static String getVersionCode(Context context) {
    199         if (sVersionCode == null) {
    200             try {
    201                 sVersionCode = String.valueOf(context.getPackageManager()
    202                         .getPackageInfo(context.getPackageName(), 0 /* flags */)
    203                         .versionCode);
    204             } catch (NameNotFoundException e) {
    205                 LogUtils.e(Utils.LOG_TAG, "Error finding package %s",
    206                         context.getApplicationInfo().packageName);
    207             }
    208         }
    209         return sVersionCode;
    210     }
    211 
    212     /**
    213      * Format a plural string.
    214      *
    215      * @param resource The identity of the resource, which must be a R.plurals
    216      * @param count The number of items.
    217      */
    218     public static String formatPlural(Context context, int resource, int count) {
    219         final CharSequence formatString = context.getResources().getQuantityText(resource, count);
    220         return String.format(formatString.toString(), count);
    221     }
    222 
    223     /**
    224      * @return an ellipsized String that's at most maxCharacters long. If the
    225      *         text passed is longer, it will be abbreviated. If it contains a
    226      *         suffix, the ellipses will be inserted in the middle and the
    227      *         suffix will be preserved.
    228      */
    229     public static String ellipsize(String text, int maxCharacters) {
    230         int length = text.length();
    231         if (length < maxCharacters)
    232             return text;
    233 
    234         int realMax = Math.min(maxCharacters, length);
    235         // Preserve the suffix if any
    236         int index = text.lastIndexOf(".");
    237         String extension = "\u2026"; // "...";
    238         if (index >= 0) {
    239             // Limit the suffix to dot + four characters
    240             if (length - index <= FILE_EXTENSION_MAX_CHARS + 1) {
    241                 extension = extension + text.substring(index + 1);
    242             }
    243         }
    244         realMax -= extension.length();
    245         if (realMax < 0)
    246             realMax = 0;
    247         return text.substring(0, realMax) + extension;
    248     }
    249 
    250     /**
    251      * This lock must be held before accessing any of the following fields
    252      */
    253     private static final Object sStaticResourcesLock = new Object();
    254     private static ComponentCallbacksListener sComponentCallbacksListener;
    255     private static int sMaxUnreadCount = -1;
    256     private static String sUnreadText;
    257     private static String sUnseenText;
    258     private static String sLargeUnseenText;
    259     private static int sDefaultFolderBackgroundColor = -1;
    260 
    261     private static class ComponentCallbacksListener implements ComponentCallbacks {
    262 
    263         @Override
    264         public void onConfigurationChanged(Configuration configuration) {
    265             synchronized (sStaticResourcesLock) {
    266                 sMaxUnreadCount = -1;
    267                 sUnreadText = null;
    268                 sUnseenText = null;
    269                 sLargeUnseenText = null;
    270                 sDefaultFolderBackgroundColor = -1;
    271             }
    272         }
    273 
    274         @Override
    275         public void onLowMemory() {}
    276     }
    277 
    278     public static void getStaticResources(Context context) {
    279         synchronized (sStaticResourcesLock) {
    280             if (sUnreadText == null) {
    281                 final Resources r = context.getResources();
    282                 sMaxUnreadCount = r.getInteger(R.integer.maxUnreadCount);
    283                 sUnreadText = r.getString(R.string.widget_large_unread_count);
    284                 sUnseenText = r.getString(R.string.unseen_count);
    285                 sLargeUnseenText = r.getString(R.string.large_unseen_count);
    286                 sDefaultFolderBackgroundColor = r.getColor(R.color.default_folder_background_color);
    287 
    288                 if (sComponentCallbacksListener == null) {
    289                     sComponentCallbacksListener = new ComponentCallbacksListener();
    290                     context.getApplicationContext()
    291                             .registerComponentCallbacks(sComponentCallbacksListener);
    292                 }
    293             }
    294         }
    295     }
    296 
    297     private static int getMaxUnreadCount(Context context) {
    298         synchronized (sStaticResourcesLock) {
    299             getStaticResources(context);
    300             return sMaxUnreadCount;
    301         }
    302     }
    303 
    304     private static String getUnreadText(Context context) {
    305         synchronized (sStaticResourcesLock) {
    306             getStaticResources(context);
    307             return sUnreadText;
    308         }
    309     }
    310 
    311     private static String getUnseenText(Context context) {
    312         synchronized (sStaticResourcesLock) {
    313             getStaticResources(context);
    314             return sUnseenText;
    315         }
    316     }
    317 
    318     private static String getLargeUnseenText(Context context) {
    319         synchronized (sStaticResourcesLock) {
    320             getStaticResources(context);
    321             return sLargeUnseenText;
    322         }
    323     }
    324 
    325     public static int getDefaultFolderBackgroundColor(Context context) {
    326         synchronized (sStaticResourcesLock) {
    327             getStaticResources(context);
    328             return sDefaultFolderBackgroundColor;
    329         }
    330     }
    331 
    332     /**
    333      * Returns a boolean indicating whether the table UI should be shown.
    334      */
    335     public static boolean useTabletUI(Resources res) {
    336         return res.getBoolean(R.bool.use_tablet_ui);
    337     }
    338 
    339     /**
    340      * Returns displayable text from the provided HTML string.
    341      * @param htmlText HTML string
    342      * @return Plain text string representation of the specified Html string
    343      */
    344     public static String convertHtmlToPlainText(String htmlText) {
    345         if (TextUtils.isEmpty(htmlText)) {
    346             return "";
    347         }
    348         return getHtmlTree(htmlText, new HtmlParser(), new HtmlTreeBuilder()).getPlainText();
    349     }
    350 
    351     public static String convertHtmlToPlainText(String htmlText, HtmlParser parser,
    352             HtmlTreeBuilder builder) {
    353         if (TextUtils.isEmpty(htmlText)) {
    354             return "";
    355         }
    356         return getHtmlTree(htmlText, parser, builder).getPlainText();
    357     }
    358 
    359     /**
    360      * Returns a {@link HtmlTree} representation of the specified HTML string.
    361      */
    362     public static HtmlTree getHtmlTree(String htmlText) {
    363         return getHtmlTree(htmlText, new HtmlParser(), new HtmlTreeBuilder());
    364     }
    365 
    366     /**
    367      * Returns a {@link HtmlTree} representation of the specified HTML string.
    368      */
    369     private static HtmlTree getHtmlTree(String htmlText, HtmlParser parser,
    370             HtmlTreeBuilder builder) {
    371         final HtmlDocument doc = parser.parse(htmlText);
    372         doc.accept(builder);
    373 
    374         return builder.getTree();
    375     }
    376 
    377     /**
    378      * Perform a simulated measure pass on the given child view, assuming the
    379      * child has a ViewGroup parent and that it should be laid out within that
    380      * parent with a matching width but variable height. Code largely lifted
    381      * from AnimatedAdapter.measureChildHeight().
    382      *
    383      * @param child a child view that has already been placed within its parent
    384      *            ViewGroup
    385      * @param parent the parent ViewGroup of child
    386      * @return measured height of the child in px
    387      */
    388     public static int measureViewHeight(View child, ViewGroup parent) {
    389         final ViewGroup.LayoutParams lp = child.getLayoutParams();
    390         final int childSideMargin;
    391         if (lp instanceof MarginLayoutParams) {
    392             final MarginLayoutParams mlp = (MarginLayoutParams) lp;
    393             childSideMargin = mlp.leftMargin + mlp.rightMargin;
    394         } else {
    395             childSideMargin = 0;
    396         }
    397 
    398         final int parentWSpec = MeasureSpec.makeMeasureSpec(parent.getWidth(), MeasureSpec.EXACTLY);
    399         final int wSpec = ViewGroup.getChildMeasureSpec(parentWSpec,
    400                 parent.getPaddingLeft() + parent.getPaddingRight() + childSideMargin,
    401                 ViewGroup.LayoutParams.MATCH_PARENT);
    402         final int hSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
    403         child.measure(wSpec, hSpec);
    404         return child.getMeasuredHeight();
    405     }
    406 
    407     /**
    408      * Encode the string in HTML.
    409      *
    410      * @param removeEmptyDoubleQuotes If true, also remove any occurrence of ""
    411      *            found in the string
    412      */
    413     public static Object cleanUpString(String string, boolean removeEmptyDoubleQuotes) {
    414         return !TextUtils.isEmpty(string) ? TextUtils.htmlEncode(removeEmptyDoubleQuotes ? string
    415                 .replace("\"\"", "") : string) : "";
    416     }
    417 
    418     /**
    419      * Get the correct display string for the unread count of a folder.
    420      */
    421     public static String getUnreadCountString(Context context, int unreadCount) {
    422         final String unreadCountString;
    423         final int maxUnreadCount = getMaxUnreadCount(context);
    424         if (unreadCount > maxUnreadCount) {
    425             final String unreadText = getUnreadText(context);
    426             // Localize "99+" according to the device language
    427             unreadCountString = String.format(unreadText, maxUnreadCount);
    428         } else if (unreadCount <= 0) {
    429             unreadCountString = "";
    430         } else {
    431             // Localize unread count according to the device language
    432             unreadCountString = String.format("%d", unreadCount);
    433         }
    434         return unreadCountString;
    435     }
    436 
    437     /**
    438      * Get the correct display string for the unseen count of a folder.
    439      */
    440     public static String getUnseenCountString(Context context, int unseenCount) {
    441         final String unseenCountString;
    442         final int maxUnreadCount = getMaxUnreadCount(context);
    443         if (unseenCount > maxUnreadCount) {
    444             final String largeUnseenText = getLargeUnseenText(context);
    445             // Localize "99+" according to the device language
    446             unseenCountString = String.format(largeUnseenText, maxUnreadCount);
    447         } else if (unseenCount <= 0) {
    448             unseenCountString = "";
    449         } else {
    450             // Localize unseen count according to the device language
    451             unseenCountString = String.format(getUnseenText(context), unseenCount);
    452         }
    453         return unseenCountString;
    454     }
    455 
    456     /**
    457      * Get text matching the last sync status.
    458      */
    459     public static CharSequence getSyncStatusText(Context context, int packedStatus) {
    460         final String[] errors = context.getResources().getStringArray(R.array.sync_status);
    461         final int status = packedStatus & 0x0f;
    462         if (status >= errors.length) {
    463             return "";
    464         }
    465         return errors[status];
    466     }
    467 
    468     /**
    469      * Create an intent to show a conversation.
    470      * @param conversation Conversation to open.
    471      * @param folderUri
    472      * @param account
    473      * @return
    474      */
    475     public static Intent createViewConversationIntent(final Context context,
    476             Conversation conversation, final Uri folderUri, Account account) {
    477         final Intent intent = new Intent(Intent.ACTION_VIEW);
    478         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK
    479                 | Intent.FLAG_ACTIVITY_TASK_ON_HOME);
    480         final Uri versionedUri = appendVersionQueryParameter(context, conversation.uri);
    481         // We need the URI to be unique, even if it's for the same message, so append the folder URI
    482         final Uri uniqueUri = versionedUri.buildUpon().appendQueryParameter(
    483                 FOLDER_URI_QUERY_PARAMETER, folderUri.toString()).build();
    484         intent.setDataAndType(uniqueUri, account.mimeType);
    485         intent.putExtra(Utils.EXTRA_ACCOUNT, account.serialize());
    486         intent.putExtra(Utils.EXTRA_FOLDER_URI, folderUri);
    487         intent.putExtra(Utils.EXTRA_CONVERSATION, conversation);
    488         return intent;
    489     }
    490 
    491     /**
    492      * Create an intent to open a folder.
    493      *
    494      * @param folderUri Folder to open.
    495      * @param account
    496      * @return
    497      */
    498     public static Intent createViewFolderIntent(final Context context, final Uri folderUri,
    499             Account account) {
    500         if (folderUri == null || account == null) {
    501             LogUtils.wtf(LOG_TAG, "Utils.createViewFolderIntent(%s,%s): Bad input", folderUri,
    502                     account);
    503             return null;
    504         }
    505         final Intent intent = new Intent(Intent.ACTION_VIEW);
    506         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK
    507                 | Intent.FLAG_ACTIVITY_TASK_ON_HOME);
    508         intent.setDataAndType(appendVersionQueryParameter(context, folderUri), account.mimeType);
    509         intent.putExtra(Utils.EXTRA_ACCOUNT, account.serialize());
    510         intent.putExtra(Utils.EXTRA_FOLDER_URI, folderUri);
    511         return intent;
    512     }
    513 
    514     /**
    515      * Creates an intent to open the default inbox for the given account.
    516      *
    517      * @param account
    518      * @return
    519      */
    520     public static Intent createViewInboxIntent(Account account) {
    521         if (account == null) {
    522             LogUtils.wtf(LOG_TAG, "Utils.createViewInboxIntent(%s): Bad input", account);
    523             return null;
    524         }
    525         final Intent intent = new Intent(Intent.ACTION_VIEW);
    526         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK
    527                 | Intent.FLAG_ACTIVITY_TASK_ON_HOME);
    528         intent.setDataAndType(account.settings.defaultInbox, account.mimeType);
    529         intent.putExtra(Utils.EXTRA_ACCOUNT, account.serialize());
    530         return intent;
    531     }
    532 
    533     /**
    534      * Helper method to show context-aware help.
    535      *
    536      * @param context Context to be used to open the help.
    537      * @param account Account from which the help URI is extracted
    538      * @param helpTopic Information about the activity the user was in
    539      *      when they requested help which specifies the help topic to display
    540      */
    541     public static void showHelp(Context context, Account account, String helpTopic) {
    542         final String urlString = account.helpIntentUri != null ?
    543                 account.helpIntentUri.toString() : null;
    544         if (TextUtils.isEmpty(urlString)) {
    545             LogUtils.e(LOG_TAG, "unable to show help for account: %s", account);
    546             return;
    547         }
    548         showHelp(context, account.helpIntentUri, helpTopic);
    549     }
    550 
    551     /**
    552      * Helper method to show context-aware help.
    553      *
    554      * @param context Context to be used to open the help.
    555      * @param helpIntentUri URI of the help content to display
    556      * @param helpTopic Information about the activity the user was in
    557      *      when they requested help which specifies the help topic to display
    558      */
    559     public static void showHelp(Context context, Uri helpIntentUri, String helpTopic) {
    560         final String urlString = helpIntentUri == null ? null : helpIntentUri.toString();
    561         if (TextUtils.isEmpty(urlString)) {
    562             LogUtils.e(LOG_TAG, "unable to show help for help URI: %s", helpIntentUri);
    563             return;
    564         }
    565 
    566         // generate the full URL to the requested help section
    567         final Uri helpUrl = HelpUrl.getHelpUrl(context, helpIntentUri, helpTopic);
    568 
    569         final boolean useBrowser = context.getResources().getBoolean(R.bool.openHelpWithBrowser);
    570         if (useBrowser) {
    571             // open a browser with the full help URL
    572             openUrl(context, helpUrl, null);
    573         } else {
    574             // start the help activity with the full help URL
    575             final Intent intent = new Intent(context, HelpActivity.class);
    576             intent.putExtra(HelpActivity.PARAM_HELP_URL, helpUrl);
    577             context.startActivity(intent);
    578         }
    579     }
    580 
    581     /**
    582      * Helper method to open a link in a browser.
    583      *
    584      * @param context Context
    585      * @param uri Uri to open.
    586      */
    587     private static void openUrl(Context context, Uri uri, Bundle optionalExtras) {
    588         if(uri == null || TextUtils.isEmpty(uri.toString())) {
    589             LogUtils.wtf(LOG_TAG, "invalid url in Utils.openUrl(): %s", uri);
    590             return;
    591         }
    592         final Intent intent = new Intent(Intent.ACTION_VIEW, uri);
    593         // Fill in any of extras that have been requested.
    594         if (optionalExtras != null) {
    595             intent.putExtras(optionalExtras);
    596         }
    597         intent.putExtra(Browser.EXTRA_APPLICATION_ID, context.getPackageName());
    598         intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
    599 
    600         context.startActivity(intent);
    601     }
    602 
    603     /**
    604      * Show the top level settings screen for the supplied account.
    605      */
    606     public static void showSettings(Context context, Account account) {
    607         if (account == null) {
    608             LogUtils.e(LOG_TAG, "Invalid attempt to show setting screen with null account");
    609             return;
    610         }
    611         final Intent settingsIntent = new Intent(Intent.ACTION_EDIT, account.settingsIntentUri);
    612 
    613         settingsIntent.setPackage(context.getPackageName());
    614         settingsIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
    615 
    616         context.startActivity(settingsIntent);
    617     }
    618 
    619     /**
    620      * Show the account level settings screen for the supplied account.
    621      */
    622     public static void showAccountSettings(Context context, Account account) {
    623         if (account == null) {
    624             LogUtils.e(LOG_TAG, "Invalid attempt to show setting screen with null account");
    625             return;
    626         }
    627         final Intent settingsIntent = new Intent(Intent.ACTION_EDIT,
    628                 appendVersionQueryParameter(context, account.settingsIntentUri));
    629 
    630         settingsIntent.setPackage(context.getPackageName());
    631         settingsIntent.putExtra(EditSettingsExtras.EXTRA_ACCOUNT, account);
    632         settingsIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
    633 
    634         context.startActivity(settingsIntent);
    635     }
    636 
    637     /**
    638      * Show the feedback screen for the supplied account.
    639      */
    640     public static void sendFeedback(Activity activity, Account account, boolean reportingProblem) {
    641         if (activity != null && account != null) {
    642             sendFeedback(activity, account.sendFeedbackIntentUri, reportingProblem);
    643         }
    644     }
    645 
    646     public static void sendFeedback(Activity activity, Uri feedbackIntentUri,
    647             boolean reportingProblem) {
    648         if (activity != null &&  !isEmpty(feedbackIntentUri)) {
    649             final Bundle optionalExtras = new Bundle(2);
    650             optionalExtras.putBoolean(
    651                     UIProvider.SendFeedbackExtras.EXTRA_REPORTING_PROBLEM, reportingProblem);
    652             final Bitmap screenBitmap = getReducedSizeBitmap(activity);
    653             if (screenBitmap != null) {
    654                 optionalExtras.putParcelable(
    655                         UIProvider.SendFeedbackExtras.EXTRA_SCREEN_SHOT, screenBitmap);
    656             }
    657             openUrl(activity, feedbackIntentUri, optionalExtras);
    658         }
    659     }
    660 
    661     private static Bitmap getReducedSizeBitmap(Activity activity) {
    662         final Window activityWindow = activity.getWindow();
    663         final View currentView = activityWindow != null ? activityWindow.getDecorView() : null;
    664         final View rootView = currentView != null ? currentView.getRootView() : null;
    665         if (rootView != null) {
    666             rootView.setDrawingCacheEnabled(true);
    667             final Bitmap drawingCache = rootView.getDrawingCache();
    668             // Null check to avoid NPE discovered from monkey crash:
    669             if (drawingCache != null) {
    670                 try {
    671                     final Bitmap originalBitmap = drawingCache.copy(Bitmap.Config.RGB_565, false);
    672                     double originalHeight = originalBitmap.getHeight();
    673                     double originalWidth = originalBitmap.getWidth();
    674                     int newHeight = SCALED_SCREENSHOT_MAX_HEIGHT_WIDTH;
    675                     int newWidth = SCALED_SCREENSHOT_MAX_HEIGHT_WIDTH;
    676                     double scaleX, scaleY;
    677                     scaleX = newWidth  / originalWidth;
    678                     scaleY = newHeight / originalHeight;
    679                     final double scale = Math.min(scaleX, scaleY);
    680                     newWidth = (int)Math.round(originalWidth * scale);
    681                     newHeight = (int)Math.round(originalHeight * scale);
    682                     return Bitmap.createScaledBitmap(originalBitmap, newWidth, newHeight, true);
    683                 } catch (OutOfMemoryError e) {
    684                     LogUtils.e(LOG_TAG, e, "OOME when attempting to scale screenshot");
    685                 }
    686             }
    687         }
    688         return null;
    689     }
    690 
    691     /**
    692      * Split out a filename's extension and return it.
    693      * @param filename a file name
    694      * @return the file extension (max of 5 chars including period, like ".docx"), or null
    695      */
    696     public static String getFileExtension(String filename) {
    697         String extension = null;
    698         int index = !TextUtils.isEmpty(filename) ? filename.lastIndexOf('.') : -1;
    699         // Limit the suffix to dot + four characters
    700         if (index >= 0 && filename.length() - index <= FILE_EXTENSION_MAX_CHARS + 1) {
    701             extension = filename.substring(index);
    702         }
    703         return extension;
    704     }
    705 
    706    /**
    707     * (copied from {@link Intent#normalizeMimeType(String)} for pre-J)
    708     *
    709     * Normalize a MIME data type.
    710     *
    711     * <p>A normalized MIME type has white-space trimmed,
    712     * content-type parameters removed, and is lower-case.
    713     * This aligns the type with Android best practices for
    714     * intent filtering.
    715     *
    716     * <p>For example, "text/plain; charset=utf-8" becomes "text/plain".
    717     * "text/x-vCard" becomes "text/x-vcard".
    718     *
    719     * <p>All MIME types received from outside Android (such as user input,
    720     * or external sources like Bluetooth, NFC, or the Internet) should
    721     * be normalized before they are used to create an Intent.
    722     *
    723     * @param type MIME data type to normalize
    724     * @return normalized MIME data type, or null if the input was null
    725     * @see {@link android.content.Intent#setType}
    726     * @see {@link android.content.Intent#setTypeAndNormalize}
    727     */
    728    public static String normalizeMimeType(String type) {
    729        if (type == null) {
    730            return null;
    731        }
    732 
    733        type = type.trim().toLowerCase(Locale.US);
    734 
    735        final int semicolonIndex = type.indexOf(';');
    736        if (semicolonIndex != -1) {
    737            type = type.substring(0, semicolonIndex);
    738        }
    739        return type;
    740    }
    741 
    742    /**
    743     * (copied from {@link android.net.Uri#normalizeScheme()} for pre-J)
    744     *
    745     * Return a normalized representation of this Uri.
    746     *
    747     * <p>A normalized Uri has a lowercase scheme component.
    748     * This aligns the Uri with Android best practices for
    749     * intent filtering.
    750     *
    751     * <p>For example, "HTTP://www.android.com" becomes
    752     * "http://www.android.com"
    753     *
    754     * <p>All URIs received from outside Android (such as user input,
    755     * or external sources like Bluetooth, NFC, or the Internet) should
    756     * be normalized before they are used to create an Intent.
    757     *
    758     * <p class="note">This method does <em>not</em> validate bad URI's,
    759     * or 'fix' poorly formatted URI's - so do not use it for input validation.
    760     * A Uri will always be returned, even if the Uri is badly formatted to
    761     * begin with and a scheme component cannot be found.
    762     *
    763     * @return normalized Uri (never null)
    764     * @see {@link android.content.Intent#setData}
    765     */
    766    public static Uri normalizeUri(Uri uri) {
    767        String scheme = uri.getScheme();
    768        if (scheme == null) return uri;  // give up
    769        String lowerScheme = scheme.toLowerCase(Locale.US);
    770        if (scheme.equals(lowerScheme)) return uri;  // no change
    771 
    772        return uri.buildUpon().scheme(lowerScheme).build();
    773    }
    774 
    775    public static Intent setIntentTypeAndNormalize(Intent intent, String type) {
    776        return intent.setType(normalizeMimeType(type));
    777    }
    778 
    779    public static Intent setIntentDataAndTypeAndNormalize(Intent intent, Uri data, String type) {
    780        return intent.setDataAndType(normalizeUri(data), normalizeMimeType(type));
    781    }
    782 
    783    public static int getTransparentColor(int color) {
    784        return 0x00ffffff & color;
    785    }
    786 
    787     /**
    788      * Note that this function sets both the visibility and enabled flags for the menu item so that
    789      * if shouldShow is false then the menu item is also no longer valid for keyboard shortcuts.
    790      */
    791     public static void setMenuItemPresent(Menu menu, int itemId, boolean shouldShow) {
    792         setMenuItemPresent(menu.findItem(itemId), shouldShow);
    793     }
    794 
    795     /**
    796      * Note that this function sets both the visibility and enabled flags for the menu item so that
    797      * if shouldShow is false then the menu item is also no longer valid for keyboard shortcuts.
    798      */
    799     public static void setMenuItemPresent(MenuItem item, boolean shouldShow) {
    800         if (item == null) {
    801             return;
    802         }
    803         item.setVisible(shouldShow);
    804         item.setEnabled(shouldShow);
    805     }
    806 
    807     /**
    808      * Parse a string (possibly null or empty) into a URI. If the string is null
    809      * or empty, null is returned back. Otherwise an empty URI is returned.
    810      *
    811      * @param uri
    812      * @return a valid URI, possibly {@link android.net.Uri#EMPTY}
    813      */
    814     public static Uri getValidUri(String uri) {
    815         if (TextUtils.isEmpty(uri) || uri == JSONObject.NULL)
    816             return Uri.EMPTY;
    817         return Uri.parse(uri);
    818     }
    819 
    820     public static boolean isEmpty(Uri uri) {
    821         return uri == null || Uri.EMPTY.equals(uri);
    822     }
    823 
    824     public static String dumpFragment(Fragment f) {
    825         final StringWriter sw = new StringWriter();
    826         f.dump("", new FileDescriptor(), new PrintWriter(sw), new String[0]);
    827         return sw.toString();
    828     }
    829 
    830     /**
    831      * Executes an out-of-band command on the cursor.
    832      * @param cursor
    833      * @param request Bundle with all keys and values set for the command.
    834      * @param key The string value against which we will check for success or failure
    835      * @return true if the operation was a success.
    836      */
    837     private static boolean executeConversationCursorCommand(
    838             Cursor cursor, Bundle request, String key) {
    839         final Bundle response = cursor.respond(request);
    840         final String result = response.getString(key,
    841                 UIProvider.ConversationCursorCommand.COMMAND_RESPONSE_FAILED);
    842 
    843         return UIProvider.ConversationCursorCommand.COMMAND_RESPONSE_OK.equals(result);
    844     }
    845 
    846     /**
    847      * Commands a cursor representing a set of conversations to indicate that an item is being shown
    848      * in the UI.
    849      *
    850      * @param cursor a conversation cursor
    851      * @param position position of the item being shown.
    852      */
    853     public static boolean notifyCursorUIPositionChange(Cursor cursor, int position) {
    854         final Bundle request = new Bundle();
    855         final String key =
    856                 UIProvider.ConversationCursorCommand.COMMAND_NOTIFY_CURSOR_UI_POSITION_CHANGE;
    857         request.putInt(key, position);
    858         return executeConversationCursorCommand(cursor, request, key);
    859     }
    860 
    861     /**
    862      * Commands a cursor representing a set of conversations to set its visibility state.
    863      *
    864      * @param cursor a conversation cursor
    865      * @param visible true if the conversation list is visible, false otherwise.
    866      * @param isFirstSeen true if you want to notify the cursor that this conversation list was seen
    867      *        for the first time: the user launched the app into it, or the user switched from some
    868      *        other folder into it.
    869      */
    870     public static void setConversationCursorVisibility(
    871             Cursor cursor, boolean visible, boolean isFirstSeen) {
    872         new MarkConversationCursorVisibleTask(cursor, visible, isFirstSeen).execute();
    873     }
    874 
    875     /**
    876      * Async task for  marking conversations "seen" and informing the cursor that the folder was
    877      * seen for the first time by the UI.
    878      */
    879     private static class MarkConversationCursorVisibleTask extends AsyncTask<Void, Void, Void> {
    880         private final Cursor mCursor;
    881         private final boolean mVisible;
    882         private final boolean mIsFirstSeen;
    883 
    884         /**
    885          * Create a new task with the given cursor, with the given visibility and
    886          *
    887          * @param cursor
    888          * @param isVisible true if the conversation list is visible, false otherwise.
    889          * @param isFirstSeen true if the folder was shown for the first time: either the user has
    890          *        just switched to it, or the user started the app in this folder.
    891          */
    892         public MarkConversationCursorVisibleTask(
    893                 Cursor cursor, boolean isVisible, boolean isFirstSeen) {
    894             mCursor = cursor;
    895             mVisible = isVisible;
    896             mIsFirstSeen = isFirstSeen;
    897         }
    898 
    899         @Override
    900         protected Void doInBackground(Void... params) {
    901             if (mCursor == null) {
    902                 return null;
    903             }
    904             final Bundle request = new Bundle();
    905             if (mIsFirstSeen) {
    906                 request.putBoolean(
    907                         UIProvider.ConversationCursorCommand.COMMAND_KEY_ENTERED_FOLDER, true);
    908             }
    909             final String key = UIProvider.ConversationCursorCommand.COMMAND_KEY_SET_VISIBILITY;
    910             request.putBoolean(key, mVisible);
    911             executeConversationCursorCommand(mCursor, request, key);
    912             return null;
    913         }
    914     }
    915 
    916 
    917     /**
    918      * This utility method returns the conversation ID at the current cursor position.
    919      * @return the conversation id at the cursor.
    920      */
    921     public static long getConversationId(ConversationCursor cursor) {
    922         return cursor.getLong(UIProvider.CONVERSATION_ID_COLUMN);
    923     }
    924 
    925     /**
    926      * Sets the layer type of a view to hardware if the view is attached and hardware acceleration
    927      * is enabled. Does nothing otherwise.
    928      */
    929     public static void enableHardwareLayer(View v) {
    930         if (v != null && v.isHardwareAccelerated() &&
    931                 v.getLayerType() != View.LAYER_TYPE_HARDWARE) {
    932             v.setLayerType(View.LAYER_TYPE_HARDWARE, null);
    933             v.buildLayer();
    934         }
    935     }
    936 
    937     /**
    938      * Returns the count that should be shown for the specified folder.  This method should be used
    939      * when the UI wants to display an "unread" count.  For most labels, the returned value will be
    940      * the unread count, but for some folder types (outbox, drafts, trash) this will return the
    941      * total count.
    942      */
    943     public static int getFolderUnreadDisplayCount(final Folder folder) {
    944         if (folder != null) {
    945             if (folder.supportsCapability(UIProvider.FolderCapabilities.UNSEEN_COUNT_ONLY)) {
    946                 return 0;
    947             } else if (folder.isUnreadCountHidden()) {
    948                 return folder.totalCount;
    949             } else {
    950                 return folder.unreadCount;
    951             }
    952         }
    953         return 0;
    954     }
    955 
    956     public static Uri appendVersionQueryParameter(final Context context, final Uri uri) {
    957         return uri.buildUpon().appendQueryParameter(APP_VERSION_QUERY_PARAMETER,
    958                 getVersionCode(context)).build();
    959     }
    960 
    961     /**
    962      * Convenience method for diverting mailto: uris directly to our compose activity. Using this
    963      * method ensures that the Account object is not accidentally sent to a different process.
    964      *
    965      * @param context for sending the intent
    966      * @param uri mailto: or other uri
    967      * @param account desired account for potential compose activity
    968      * @return true if a compose activity was started, false if uri should be sent to a view intent
    969      */
    970     public static boolean divertMailtoUri(final Context context, final Uri uri,
    971             final Account account) {
    972         final String scheme = normalizeUri(uri).getScheme();
    973         if (TextUtils.equals(MAILTO_SCHEME, scheme)) {
    974             ComposeActivity.composeMailto(context, account, uri);
    975             return true;
    976         }
    977         return false;
    978     }
    979 
    980     /**
    981      * Gets the specified {@link Folder} object.
    982      *
    983      * @param folderUri The {@link Uri} for the folder
    984      * @param allowHidden <code>true</code> to allow a hidden folder to be returned,
    985      *        <code>false</code> to return <code>null</code> instead
    986      * @return the specified {@link Folder} object, or <code>null</code>
    987      */
    988     public static Folder getFolder(final Context context, final Uri folderUri,
    989             final boolean allowHidden) {
    990         final Uri uri = folderUri
    991                 .buildUpon()
    992                 .appendQueryParameter(UIProvider.ALLOW_HIDDEN_FOLDERS_QUERY_PARAM,
    993                         Boolean.toString(allowHidden))
    994                 .build();
    995 
    996         final Cursor cursor = context.getContentResolver().query(uri,
    997                 UIProvider.FOLDERS_PROJECTION, null, null, null);
    998 
    999         if (cursor == null) {
   1000             return null;
   1001         }
   1002 
   1003         try {
   1004             if (cursor.moveToFirst()) {
   1005                 return new Folder(cursor);
   1006             } else {
   1007                 return null;
   1008             }
   1009         } finally {
   1010             cursor.close();
   1011         }
   1012     }
   1013 
   1014     /**
   1015      * Begins systrace tracing for a given tag. No-op on unsupported platform versions.
   1016      *
   1017      * @param tag systrace tag to use
   1018      *
   1019      * @see android.os.Trace#beginSection(String)
   1020      */
   1021     public static void traceBeginSection(String tag) {
   1022         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
   1023             android.os.Trace.beginSection(tag);
   1024         }
   1025     }
   1026 
   1027     /**
   1028      * Ends systrace tracing for the most recently begun section. No-op on unsupported platform
   1029      * versions.
   1030      *
   1031      * @see android.os.Trace#endSection()
   1032      */
   1033     public static void traceEndSection() {
   1034         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
   1035             android.os.Trace.endSection();
   1036         }
   1037     }
   1038 
   1039     /**
   1040      * Given a value and a set of upper-bounds to use as buckets, return the smallest upper-bound
   1041      * that is greater than the value.<br>
   1042      * <br>
   1043      * Useful for turning a continuous value into one of a set of discrete ones.
   1044      *
   1045      * @param value a value to bucketize
   1046      * @param upperBounds list of upper-bound buckets to clamp to, sorted from smallest-greatest
   1047      * @return the smallest upper-bound larger than the value, or -1 if the value is larger than
   1048      * all upper-bounds
   1049      */
   1050     public static long getUpperBound(long value, long[] upperBounds) {
   1051         for (long ub : upperBounds) {
   1052             if (value < ub) {
   1053                 return ub;
   1054             }
   1055         }
   1056         return -1;
   1057     }
   1058 
   1059     public static @Nullable Address getAddress(Map<String, Address> cache, String emailStr) {
   1060         Address addr;
   1061         synchronized (cache) {
   1062             addr = cache.get(emailStr);
   1063             if (addr == null) {
   1064                 addr = Address.getEmailAddress(emailStr);
   1065                 if (addr != null) {
   1066                     cache.put(emailStr, addr);
   1067                 }
   1068             }
   1069         }
   1070         return addr;
   1071     }
   1072 
   1073     /**
   1074      * Applies the given appearance on the given subString, and inserts that as a parameter in the
   1075      * given parentString.
   1076      */
   1077     @VisibleForTesting
   1078     public static Spanned insertStringWithStyle(Context context,
   1079             String entireString, String subString, int appearance) {
   1080         final int index = entireString.indexOf(subString);
   1081         final SpannableString descriptionText = new SpannableString(entireString);
   1082         if (index >= 0) {
   1083             descriptionText.setSpan(
   1084                     new TextAppearanceSpan(context, appearance),
   1085                     index,
   1086                     index + subString.length(),
   1087                     0);
   1088         }
   1089         return descriptionText;
   1090     }
   1091 
   1092     /**
   1093      * Email addresses are supposed to be treated as case-insensitive for the host-part and
   1094      * case-sensitive for the local-part, but nobody really wants email addresses to match
   1095      * case-sensitive on the local-part, so just smash everything to lower case.
   1096      * @param email Hello (at) Example.COM
   1097      * @return hello (at) example.com
   1098      */
   1099     public static String normalizeEmailAddress(String email) {
   1100         /*
   1101         // The RFC5321 version
   1102         if (TextUtils.isEmpty(email)) {
   1103             return email;
   1104         }
   1105         String[] parts = email.split("@");
   1106         if (parts.length != 2) {
   1107             LogUtils.d(LOG_TAG, "Tried to normalize a malformed email address: ", email);
   1108             return email;
   1109         }
   1110 
   1111         return parts[0] + "@" + parts[1].toLowerCase(Locale.US);
   1112         */
   1113         if (TextUtils.isEmpty(email)) {
   1114             return email;
   1115         } else {
   1116             // Doing this for other locales might really screw things up, so do US-version only
   1117             return email.toLowerCase(Locale.US);
   1118         }
   1119     }
   1120 
   1121     /**
   1122      * Returns whether the device currently has network connection. This does not guarantee that
   1123      * the connection is reliable.
   1124      */
   1125     public static boolean isConnected(final Context context) {
   1126         final ConnectivityManager connectivityManager =
   1127                 ((ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE));
   1128         final NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
   1129         return (networkInfo != null) && networkInfo.isConnected();
   1130     }
   1131 }
   1132