| 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(); |
| } |
| } |
