path: root/WordPress/src/main/java/org/wordpress/android/ui/main/MeFragment.java

package org.wordpress.android.ui.main;

import com.android.volley.Cache;
import com.android.volley.Request;
import com.github.xizzhu.simpletooltip.ToolTip;
import com.github.xizzhu.simpletooltip.ToolTipView;
import com.yalantis.ucrop.UCrop;
import com.yalantis.ucrop.UCropActivity;

import android.annotation.TargetApi;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Fragment;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.res.Resources;
import android.database.Cursor;
import android.graphics.Color;
import android.graphics.Outline;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Bundle;
import android.provider.MediaStore;
import android.support.annotation.NonNull;
import android.support.v4.content.ContextCompat;
import android.support.v4.content.CursorLoader;
import android.text.TextUtils;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewOutlineProvider;
import android.widget.TextView;
import android.widget.Toast;

import org.wordpress.android.BuildConfig;
import org.wordpress.android.R;
import org.wordpress.android.WordPress;
import org.wordpress.android.analytics.AnalyticsTracker;
import org.wordpress.android.models.Account;
import org.wordpress.android.models.AccountHelper;
import org.wordpress.android.networking.GravatarApi;
import org.wordpress.android.ui.ActivityLauncher;
import org.wordpress.android.ui.RequestCodes;
import org.wordpress.android.ui.media.WordPressMediaUtils;
import org.wordpress.android.ui.prefs.AppPrefs;
import org.wordpress.android.ui.prefs.PrefsEvents;
import org.wordpress.android.util.AppLog;
import org.wordpress.android.util.GravatarUtils;
import org.wordpress.android.util.HelpshiftHelper.Tag;
import org.wordpress.android.util.MediaUtils;
import org.wordpress.android.util.PermissionUtils;
import org.wordpress.android.util.StringUtils;
import org.wordpress.android.util.ToastUtils;
import org.wordpress.android.widgets.WPNetworkImageView;

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.ref.WeakReference;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import de.greenrobot.event.EventBus;

public class MeFragment extends Fragment {
    private static final String IS_DISCONNECTING = "IS_DISCONNECTING";
    private static final String IS_UPDATING_GRAVATAR = "IS_UPDATING_GRAVATAR";
    private static final String MEDIA_CAPTURE_PATH = "MEDIA_CAPTURE_PATH";

    private static final int CAMERA_AND_MEDIA_PERMISSION_REQUEST_CODE = 1;

    private ViewGroup mAvatarFrame;
    private View mProgressBar;
    private ToolTipView mGravatarToolTipView;
    private View mAvatarTooltipAnchor;
    private ViewGroup mAvatarContainer;
    private WPNetworkImageView mAvatarImageView;
    private TextView mDisplayNameTextView;
    private TextView mUsernameTextView;
    private TextView mLoginLogoutTextView;
    private View mMyProfileView;
    private View mAccountSettingsView;
    private View mNotificationsView;
    private View mNotificationsDividerView;
    private ProgressDialog mDisconnectProgressDialog;
    private String mMediaCapturePath;

    // setUserVisibleHint is not available so we need to manually handle the UserVisibleHint state
    private boolean mIsUserVisible;

    private boolean mIsUpdatingGravatar;

    public static MeFragment newInstance() {
        return new MeFragment();
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        if (savedInstanceState != null) {
            mMediaCapturePath = savedInstanceState.getString(MEDIA_CAPTURE_PATH);
            mIsUpdatingGravatar = savedInstanceState.getBoolean(IS_UPDATING_GRAVATAR);
        }
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);

        mIsUserVisible = isVisibleToUser;

        if (isResumed()) {
            showGravatarTooltipIfNeeded();
        }
    }

    private void showGravatarTooltipIfNeeded() {
        if (!isAdded() || !AccountHelper.isSignedInWordPressDotCom() || !AppPrefs.isGravatarChangePromoRequired() ||
                !mIsUserVisible || mGravatarToolTipView != null) {
            return;
        }

        ToolTip toolTip = createGravatarPromoToolTip(getString(R.string.gravatar_tip), ContextCompat.getColor
                (getActivity(), R.color.color_primary));
        mGravatarToolTipView = new ToolTipView.Builder(getActivity())
                .withAnchor(mAvatarTooltipAnchor)
                .withToolTip(toolTip)
                .withGravity(Gravity.END)
                .build();
        mGravatarToolTipView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                AnalyticsTracker.track(AnalyticsTracker.Stat.ME_GRAVATAR_TOOLTIP_TAPPED);

                mGravatarToolTipView.remove();
                AppPrefs.setGravatarChangePromoRequired(false);
            }
        });
        mGravatarToolTipView.showDelayed(500);
    }

    private ToolTip createGravatarPromoToolTip(CharSequence text, int backgroundColor) {
        Resources resources = getResources();
        int padding = resources.getDimensionPixelSize(R.dimen.tooltip_padding);
        int textSize = resources.getDimensionPixelSize(R.dimen.tooltip_text_size);
        int radius = resources.getDimensionPixelSize(R.dimen.tooltip_radius);
        return new ToolTip.Builder()
                .withText(text)
                .withTextColor(Color.WHITE)
                .withTextSize(textSize)
                .withBackgroundColor(backgroundColor)
                .withPadding(padding, padding, padding, padding)
                .withCornerRadius(radius)
                .build();
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        final ViewGroup rootView = (ViewGroup) inflater.inflate(R.layout.me_fragment, container, false);

        mAvatarFrame = (ViewGroup) rootView.findViewById(R.id.frame_avatar);
        mAvatarContainer = (ViewGroup) rootView.findViewById(R.id.avatar_container);
        mAvatarImageView = (WPNetworkImageView) rootView.findViewById(R.id.me_avatar);
        mAvatarTooltipAnchor = rootView.findViewById(R.id.avatar_tooltip_anchor);
        mProgressBar = rootView.findViewById(R.id.avatar_progress);
        mDisplayNameTextView = (TextView) rootView.findViewById(R.id.me_display_name);
        mUsernameTextView = (TextView) rootView.findViewById(R.id.me_username);
        mLoginLogoutTextView = (TextView) rootView.findViewById(R.id.me_login_logout_text_view);
        mMyProfileView = rootView.findViewById(R.id.row_my_profile);
        mAccountSettingsView = rootView.findViewById(R.id.row_account_settings);
        mNotificationsView = rootView.findViewById(R.id.row_notifications);
        mNotificationsDividerView = rootView.findViewById(R.id.me_notifications_divider);

        addDropShadowToAvatar();

        mAvatarContainer.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                AnalyticsTracker.track(AnalyticsTracker.Stat.ME_GRAVATAR_TAPPED);

                // User tapped the Gravatar so dismiss the tooltip
                if (mGravatarToolTipView != null) {
                    mGravatarToolTipView.remove();
                }
                // and no need to promote the feature any more
                AppPrefs.setGravatarChangePromoRequired(false);

                if (PermissionUtils.checkAndRequestCameraAndStoragePermissions(MeFragment.this,
                        CAMERA_AND_MEDIA_PERMISSION_REQUEST_CODE)) {
                    askForCameraOrGallery();
                }
            }
        });
        mMyProfileView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ActivityLauncher.viewMyProfile(getActivity());
            }
        });

        mAccountSettingsView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ActivityLauncher.viewAccountSettings(getActivity());
            }
        });

        rootView.findViewById(R.id.row_app_settings).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ActivityLauncher.viewAppSettings(getActivity());
            }
        });

        mNotificationsView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ActivityLauncher.viewNotificationsSettings(getActivity());
            }
        });

        rootView.findViewById(R.id.row_support).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ActivityLauncher.viewHelpAndSupport(getActivity(), Tag.ORIGIN_ME_SCREEN_HELP);
            }
        });

        rootView.findViewById(R.id.row_logout).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (AccountHelper.isSignedInWordPressDotCom()) {
                    signOutWordPressComWithConfirmation();
                } else {
                    ActivityLauncher.showSignInForResult(getActivity());
                }
            }
        });

        if (savedInstanceState != null) {
            if (savedInstanceState.getBoolean(IS_DISCONNECTING, false)) {
                showDisconnectDialog(getActivity());
            }

            if (savedInstanceState.getBoolean(IS_UPDATING_GRAVATAR, false)) {
                showGravatarProgressBar(true);
            }
        }

        return rootView;
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        if (mDisconnectProgressDialog != null) {
            outState.putBoolean(IS_DISCONNECTING, true);
        }

        if (mMediaCapturePath != null) {
            outState.putString(MEDIA_CAPTURE_PATH, mMediaCapturePath);
        }

        outState.putBoolean(IS_UPDATING_GRAVATAR, mIsUpdatingGravatar);

        super.onSaveInstanceState(outState);
    }

    @Override
    public void onStart() {
        super.onStart();
        EventBus.getDefault().register(this);
    }

    @Override
    public void onStop() {
        EventBus.getDefault().unregister(this);
        super.onStop();
    }

    @Override
    public void onResume() {
        super.onResume();
        refreshAccountDetails();

        showGravatarTooltipIfNeeded();
    }

    @Override
    public void onDestroy() {
        if (mDisconnectProgressDialog != null) {
            mDisconnectProgressDialog.dismiss();
            mDisconnectProgressDialog = null;
        }
        super.onDestroy();
    }

    /**
     * adds a circular drop shadow to the avatar's parent view (Lollipop+ only)
     */
    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    private void addDropShadowToAvatar() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            mAvatarImageView.setOutlineProvider(new ViewOutlineProvider() {
                @Override
                public void getOutline(View view, Outline outline) {
                    outline.setOval(0, 0, view.getWidth(), view.getHeight());
                }
            });
            mAvatarImageView.setElevation(mAvatarImageView.getResources().getDimensionPixelSize(R.dimen.card_elevation));
        }
    }

    private void refreshAccountDetails() {
        // we only want to show user details for WordPress.com users
        if (AccountHelper.isSignedInWordPressDotCom()) {
            Account defaultAccount = AccountHelper.getDefaultAccount();

            mDisplayNameTextView.setVisibility(View.VISIBLE);
            mUsernameTextView.setVisibility(View.VISIBLE);
            mAvatarFrame.setVisibility(View.VISIBLE);
            mMyProfileView.setVisibility(View.VISIBLE);
            mNotificationsView.setVisibility(View.VISIBLE);
            mNotificationsDividerView.setVisibility(View.VISIBLE);

            final String avatarUrl = constructGravatarUrl(AccountHelper.getDefaultAccount());
            loadAvatar(avatarUrl, null);

            mUsernameTextView.setText("@" + defaultAccount.getUserName());
            mLoginLogoutTextView.setText(R.string.me_disconnect_from_wordpress_com);

            String displayName = StringUtils.unescapeHTML(defaultAccount.getDisplayName());
            if (!TextUtils.isEmpty(displayName)) {
                mDisplayNameTextView.setText(displayName);
            } else {
                mDisplayNameTextView.setText(defaultAccount.getUserName());
            }
        } else {
            mDisplayNameTextView.setVisibility(View.GONE);
            mUsernameTextView.setVisibility(View.GONE);
            mAvatarFrame.setVisibility(View.GONE);
            mProgressBar.setVisibility(View.GONE);
            mMyProfileView.setVisibility(View.GONE);
            mAccountSettingsView.setVisibility(View.GONE);
            mNotificationsView.setVisibility(View.GONE);
            mNotificationsDividerView.setVisibility(View.GONE);
            mLoginLogoutTextView.setText(R.string.me_connect_to_wordpress_com);
        }
    }

    private void showGravatarProgressBar(boolean isUpdating) {
        mProgressBar.setVisibility(isUpdating ? View.VISIBLE : View.GONE);
        mIsUpdatingGravatar = isUpdating;
    }

    private String constructGravatarUrl(Account account) {
        int avatarSz = getResources().getDimensionPixelSize(R.dimen.avatar_sz_large);
        return GravatarUtils.fixGravatarUrl(account.getAvatarUrl(), avatarSz);
    }

    private void loadAvatar(String avatarUrl, String injectFilePath) {
        if (injectFilePath != null && !injectFilePath.isEmpty()) {
            // invalidate the specific gravatar entry from the bitmap cache. It will be updated via the injected
            // request cache.
            WordPress.getBitmapCache().removeSimilar(avatarUrl);

            try {
                // fool the network requests cache by injecting the new image. The Gravatar backend (plus CDNs)
                // can't be trusted to have updated the image quick enough.
                injectCache(new File(injectFilePath), avatarUrl);
            } catch (IOException e) {
                EventBus.getDefault().post(new GravatarLoadFinished(false));
            }

            // invalidate the WPNetworkImageView
            mAvatarImageView.invalidateImage();
        }

        mAvatarImageView.setImageUrl(avatarUrl, WPNetworkImageView.ImageType.AVATAR, new WPNetworkImageView
                .ImageLoadListener() {
            @Override
            public void onLoaded() {
                EventBus.getDefault().post(new GravatarLoadFinished(true));
            }

            @Override
            public void onError() {
                EventBus.getDefault().post(new GravatarLoadFinished(false));
            }
        });
    }

    private void signOutWordPressComWithConfirmation() {
        String message = String.format(getString(R.string.sign_out_wpcom_confirm), AccountHelper.getDefaultAccount()
                .getUserName());

        new AlertDialog.Builder(getActivity())
                .setMessage(message)
                .setPositiveButton(R.string.signout, new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int whichButton) {
                        signOutWordPressCom();
                    }
                })
                .setNegativeButton(R.string.cancel, null)
                .setCancelable(true)
                .create().show();
    }

    private void signOutWordPressCom() {
        // note that signing out sends a CoreEvents.UserSignedOutWordPressCom EventBus event,
        // which will cause the main activity to recreate this fragment
        (new SignOutWordPressComAsync(getActivity())).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
    }

    private void showDisconnectDialog(Context context) {
        mDisconnectProgressDialog = ProgressDialog.show(context, null, context.getText(R.string.signing_out), false);
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[]
            grantResults) {
        switch (requestCode) {
            case CAMERA_AND_MEDIA_PERMISSION_REQUEST_CODE:
                if (permissions.length == 0) {
                    AnalyticsTracker.track(AnalyticsTracker.Stat.ME_GRAVATAR_PERMISSIONS_INTERRUPTED);
                }  else {
                    List<String> granted = new ArrayList<>();
                    List<String> denied = new ArrayList<>();

                    for (int i = 0; i < grantResults.length; i++) {
                        if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                            granted.add(permissions[i]);
                        } else {
                            denied.add(permissions[i]);
                        }
                    }

                    if (denied.size() == 0) {
                        AnalyticsTracker.track(AnalyticsTracker.Stat.ME_GRAVATAR_PERMISSIONS_ACCEPTED);
                        askForCameraOrGallery();
                    } else {
                        ToastUtils.showToast(this.getActivity(), getString(R.string
                                .gravatar_camera_and_media_permission_required), ToastUtils.Duration.LONG);
                        Map<String, Object> properties = new HashMap<>();
                        properties.put("permissions granted", granted.size() == 0 ? "[none]" : TextUtils
                                .join(",", granted));
                        properties.put("permissions denied", TextUtils.join(",", denied));
                        AnalyticsTracker.track(AnalyticsTracker.Stat.ME_GRAVATAR_PERMISSIONS_DENIED, properties);
                    }
                }
                break;
        }
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        switch (requestCode) {
            case RequestCodes.PICTURE_LIBRARY_OR_CAPTURE:
                if (resultCode == Activity.RESULT_OK) {
                    Uri imageUri;

                    if (data == null || data.getData() == null) {
                        // image is from a capture
                        imageUri = Uri.fromFile(new File(mMediaCapturePath));
                        AnalyticsTracker.track(AnalyticsTracker.Stat.ME_GRAVATAR_SHOT_NEW);
                    } else {
                        imageUri = data.getData();
                        AnalyticsTracker.track(AnalyticsTracker.Stat.ME_GRAVATAR_GALLERY_PICKED);
                    }

                    if (imageUri != null) {
                        startCropActivity(imageUri);
                    } else {
                        AppLog.e(AppLog.T.UTILS, "Can't resolve picked or captured image");
                    }
                }
                break;
            case UCrop.REQUEST_CROP:
                AnalyticsTracker.track(AnalyticsTracker.Stat.ME_GRAVATAR_CROPPED);

                if (resultCode == Activity.RESULT_OK) {
                    fetchMedia(UCrop.getOutput(data));
                } else if (resultCode == UCrop.RESULT_ERROR) {
                    Toast.makeText(getActivity(), getString(R.string.error_cropping_image), Toast.LENGTH_SHORT).show();

                    final Throwable cropError = UCrop.getError(data);
                    AppLog.e(AppLog.T.MAIN, "Image cropping failed!", cropError);
                }
                break;
        }
    }

    private void askForCameraOrGallery() {
        WordPressMediaUtils
                .launchPictureLibraryOrCapture(MeFragment.this, BuildConfig.APPLICATION_ID,
                        new WordPressMediaUtils.LaunchCameraCallback() {
                            @Override
                            public void onMediaCapturePathReady(String mediaCapturePath) {
                                mMediaCapturePath = mediaCapturePath;
                            }
                        });
    }

    private void startCropActivity(Uri uri) {
        final Context context = getActivity();

        if (context == null) {
            return;
        }

        UCrop.Options options = new UCrop.Options();
        options.setShowCropGrid(false);
        options.setStatusBarColor(ContextCompat.getColor(context, R.color.status_bar_tint));
        options.setToolbarColor(ContextCompat.getColor(context, R.color.color_primary));
        options.setAllowedGestures(UCropActivity.ALL, UCropActivity.ALL, UCropActivity.ALL);
        options.setHideBottomControls(true);

        UCrop.of(uri, Uri.fromFile(new File(context.getCacheDir(), "cropped_for_gravatar.jpg")))
                .withAspectRatio(1, 1)
                .withOptions(options)
                .start(getActivity(), this);
    }

    private void fetchMedia(Uri mediaUri) {
        if (!MediaUtils.isInMediaStore(mediaUri)) {
            // Create an AsyncTask to download the file
            new DownloadMediaTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, mediaUri);
        } else {
            // It is a regular local media file
            startGravatarUpload(getRealPathFromURI(mediaUri));
        }
    }

    private String getRealPathFromURI(Uri uri) {
        String path;
        if ("content".equals(uri.getScheme())) {
            path = getRealPathFromContentURI(uri);
        } else if ("file".equals(uri.getScheme())) {
            path = uri.getPath();
        } else {
            path = uri.toString();
        }
        return path;
    }

    private String getRealPathFromContentURI(Uri contentUri) {
        if (contentUri == null)
            return null;

        String[] proj = { MediaStore.Images.Media.DATA };
        CursorLoader loader = new CursorLoader(getActivity(), contentUri, proj, null, null, null);
        Cursor cursor = loader.loadInBackground();

        if (cursor == null)
            return null;

        int column_index = cursor.getColumnIndex(MediaStore.Images.Media.DATA);
        if (column_index == -1) {
            cursor.close();
            return null;
        }

        String path;
        if (cursor.moveToFirst()) {
            path = cursor.getString(column_index);
        } else {
            path = null;
        }

        cursor.close();
        return path;
    }

    private class DownloadMediaTask extends AsyncTask<Uri, Integer, Uri> {
        @Override
        protected Uri doInBackground(Uri... uris) {
            Uri imageUri = uris[0];
            return MediaUtils.downloadExternalMedia(getActivity(), imageUri);
        }

        protected void onPostExecute(Uri newUri) {
            if (getActivity() == null)
                return;

            if (newUri != null) {
                String path = getRealPathFromURI(newUri);
                startGravatarUpload(path);
            } else {
                Toast.makeText(getActivity(), getString(R.string.error_downloading_image), Toast.LENGTH_SHORT).show();
            }
        }
    }

    private void startGravatarUpload(final String filePath) {
        File file = new File(filePath);
        if (!file.exists()) {
            Toast.makeText(getActivity(), getString(R.string.error_locating_image), Toast.LENGTH_SHORT).show();
            return;
        }

        showGravatarProgressBar(true);

        GravatarApi.uploadGravatar(file, new GravatarApi.GravatarUploadListener() {
            @Override
            public void onSuccess() {
                EventBus.getDefault().post(new GravatarUploadFinished(filePath, true));
            }

            @Override
            public void onError() {
                EventBus.getDefault().post(new GravatarUploadFinished(filePath, false));
            }
        });
    }

    static public class GravatarUploadFinished {
        public final String filePath;
        public final boolean success;

        public GravatarUploadFinished(String filePath, boolean success) {
            this.filePath = filePath;
            this.success = success;
        }
    }

    public void onEventMainThread(GravatarUploadFinished event) {
        if (event.success) {
            AnalyticsTracker.track(AnalyticsTracker.Stat.ME_GRAVATAR_UPLOADED);
            final String avatarUrl = constructGravatarUrl(AccountHelper.getDefaultAccount());
            loadAvatar(avatarUrl, event.filePath);
        } else {
            showGravatarProgressBar(false);
            Toast.makeText(getActivity(), getString(R.string.error_updating_gravatar), Toast.LENGTH_SHORT).show();
        }
    }

    static public class GravatarLoadFinished {
        public final boolean success;

        public GravatarLoadFinished(boolean success) {
            this.success = success;
        }
    }

    public void onEventMainThread(GravatarLoadFinished event) {
        showGravatarProgressBar(false);

        if (!event.success) {
            Toast.makeText(getActivity(), getString(R.string.error_refreshing_gravatar), Toast.LENGTH_SHORT).show();
        }
    }

    // injects a fabricated cache entry to the request cache
    private void injectCache(File file, String avatarUrl) throws IOException {
        final SimpleDateFormat sdf = new SimpleDateFormat("E, dd MMM yyyy HH:mm:ss z");
        final long currentTimeMs = System.currentTimeMillis();
        final Date currentTime = new Date(currentTimeMs);
        final long fiveMinutesLaterMs = currentTimeMs + 5 * 60 * 1000;
        final Date fiveMinutesLater = new Date(fiveMinutesLaterMs);

        Cache.Entry entry = new Cache.Entry();

        entry.data = new byte[(int) file.length()];
        DataInputStream dis = new DataInputStream(new FileInputStream(file));
        dis.readFully(entry.data);
        dis.close();

        entry.etag = null;
        entry.softTtl = fiveMinutesLaterMs;
        entry.ttl = fiveMinutesLaterMs;
        entry.serverDate = currentTimeMs;
        entry.lastModified = currentTimeMs;

        entry.responseHeaders = new TreeMap<>();
        entry.responseHeaders.put("Accept-Ranges", "bytes");
        entry.responseHeaders.put("Access-Control-Allow-Origin", "*");
        entry.responseHeaders.put("Cache-Control", "max-age=300");
        entry.responseHeaders.put("Content-Disposition", "inline; filename=\"" + AccountHelper.getDefaultAccount()
                .getAvatarUrl() + ".jpeg\"");
        entry.responseHeaders.put("Content-Length", String.valueOf(file.length()));
        entry.responseHeaders.put("Content-Type", "image/jpeg");
        entry.responseHeaders.put("Date", sdf.format(currentTime));
        entry.responseHeaders.put("Expires", sdf.format(fiveMinutesLater));
        entry.responseHeaders.put("Last-Modified", sdf.format(currentTime));
        entry.responseHeaders.put("Link", "<" + avatarUrl + ">; rel=\"canonical\"");
        entry.responseHeaders.put("Server", "injected cache");
        entry.responseHeaders.put("Source-Age", "0");
        entry.responseHeaders.put("X-Android-Received-Millis", String.valueOf(currentTimeMs));
        entry.responseHeaders.put("X-Android-Response-Source", "NETWORK 200");
        entry.responseHeaders.put("X-Android-Selected-Protocol", "http/1.1");
        entry.responseHeaders.put("X-Android-Sent-Millis", String.valueOf(currentTimeMs));

        WordPress.requestQueue.getCache().put(Request.Method.GET + ":" + avatarUrl, entry);
    }

    private class SignOutWordPressComAsync extends AsyncTask<Void, Void, Void> {
        WeakReference<Context> mWeakContext;

        public SignOutWordPressComAsync(Context context) {
            mWeakContext = new WeakReference<Context>(context);
        }

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            Context context = mWeakContext.get();
            if (context != null) {
                showDisconnectDialog(context);
            }
        }

        @Override
        protected Void doInBackground(Void... params) {
            Context context = mWeakContext.get();
            if (context != null) {
                WordPress.WordPressComSignOut(context);
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void aVoid) {
            super.onPostExecute(aVoid);
            if (mDisconnectProgressDialog != null && mDisconnectProgressDialog.isShowing()) {
                mDisconnectProgressDialog.dismiss();
            }
            mDisconnectProgressDialog = null;
        }
    }

    public void onEventMainThread(PrefsEvents.AccountSettingsFetchSuccess event) {
        refreshAccountDetails();
    }
}