2014-12-01 08:00:37 +01:00
|
|
|
/*
|
|
|
|
* Twidere - Twitter client for Android
|
|
|
|
*
|
|
|
|
* Copyright (C) 2012-2014 Mariotaku Lee <mariotaku.lee@gmail.com>
|
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2014-07-03 07:48:39 +02:00
|
|
|
package org.mariotaku.twidere.fragment.support;
|
|
|
|
|
2014-12-01 08:00:37 +01:00
|
|
|
import android.annotation.TargetApi;
|
|
|
|
import android.app.Activity;
|
|
|
|
import android.content.ActivityNotFoundException;
|
|
|
|
import android.content.ContentResolver;
|
|
|
|
import android.content.ContentValues;
|
|
|
|
import android.content.Context;
|
|
|
|
import android.content.Intent;
|
|
|
|
import android.content.SharedPreferences;
|
|
|
|
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
|
|
|
|
import android.content.res.Resources;
|
|
|
|
import android.graphics.Canvas;
|
|
|
|
import android.graphics.Color;
|
|
|
|
import android.graphics.ColorFilter;
|
|
|
|
import android.graphics.Outline;
|
|
|
|
import android.graphics.Paint;
|
|
|
|
import android.graphics.PixelFormat;
|
2014-12-24 05:39:21 +01:00
|
|
|
import android.graphics.PorterDuff.Mode;
|
2014-12-01 08:00:37 +01:00
|
|
|
import android.graphics.Rect;
|
2015-01-17 19:58:29 +01:00
|
|
|
import android.graphics.RectF;
|
2014-12-01 08:00:37 +01:00
|
|
|
import android.graphics.drawable.ColorDrawable;
|
|
|
|
import android.graphics.drawable.Drawable;
|
|
|
|
import android.graphics.drawable.LayerDrawable;
|
|
|
|
import android.net.Uri;
|
2015-03-14 16:11:20 +01:00
|
|
|
import android.nfc.NdefMessage;
|
|
|
|
import android.nfc.NdefRecord;
|
|
|
|
import android.nfc.NfcAdapter.CreateNdefMessageCallback;
|
|
|
|
import android.nfc.NfcEvent;
|
2014-12-01 08:00:37 +01:00
|
|
|
import android.os.Build;
|
|
|
|
import android.os.Bundle;
|
|
|
|
import android.os.Parcelable;
|
|
|
|
import android.support.v4.app.Fragment;
|
|
|
|
import android.support.v4.app.FragmentActivity;
|
|
|
|
import android.support.v4.app.LoaderManager;
|
|
|
|
import android.support.v4.app.LoaderManager.LoaderCallbacks;
|
2015-01-17 19:58:29 +01:00
|
|
|
import android.support.v4.app.SharedElementCallback;
|
2014-12-01 08:00:37 +01:00
|
|
|
import android.support.v4.content.AsyncTaskLoader;
|
|
|
|
import android.support.v4.content.Loader;
|
2015-03-31 13:05:19 +02:00
|
|
|
import android.support.v4.content.res.ResourcesCompat;
|
2014-12-01 08:00:37 +01:00
|
|
|
import android.support.v4.view.ViewCompat;
|
|
|
|
import android.support.v4.view.ViewPager;
|
2015-01-17 19:58:29 +01:00
|
|
|
import android.support.v7.app.ActionBar;
|
2014-12-01 17:29:34 +01:00
|
|
|
import android.support.v7.widget.CardView;
|
2014-12-01 08:00:37 +01:00
|
|
|
import android.text.Html;
|
2014-12-13 16:14:47 +01:00
|
|
|
import android.text.SpannableStringBuilder;
|
|
|
|
import android.text.Spanned;
|
2014-12-01 08:00:37 +01:00
|
|
|
import android.text.TextUtils;
|
|
|
|
import android.util.Log;
|
|
|
|
import android.view.LayoutInflater;
|
|
|
|
import android.view.Menu;
|
|
|
|
import android.view.MenuInflater;
|
|
|
|
import android.view.MenuItem;
|
|
|
|
import android.view.MotionEvent;
|
|
|
|
import android.view.View;
|
|
|
|
import android.view.View.OnClickListener;
|
|
|
|
import android.view.View.OnTouchListener;
|
|
|
|
import android.view.ViewGroup;
|
|
|
|
import android.widget.Button;
|
|
|
|
import android.widget.ImageView;
|
2014-12-07 16:13:07 +01:00
|
|
|
import android.widget.ProgressBar;
|
2014-12-01 08:00:37 +01:00
|
|
|
import android.widget.TextView;
|
|
|
|
|
2014-12-07 16:13:07 +01:00
|
|
|
import com.squareup.otto.Bus;
|
|
|
|
import com.squareup.otto.Subscribe;
|
2014-12-01 08:00:37 +01:00
|
|
|
|
2014-12-04 15:31:29 +01:00
|
|
|
import org.mariotaku.querybuilder.Expression;
|
2014-12-01 08:00:37 +01:00
|
|
|
import org.mariotaku.twidere.R;
|
2014-12-08 16:16:33 +01:00
|
|
|
import org.mariotaku.twidere.activity.iface.IThemedActivity;
|
2014-12-01 08:00:37 +01:00
|
|
|
import org.mariotaku.twidere.activity.support.AccountSelectorActivity;
|
|
|
|
import org.mariotaku.twidere.activity.support.ColorPickerDialogActivity;
|
|
|
|
import org.mariotaku.twidere.activity.support.LinkHandlerActivity;
|
|
|
|
import org.mariotaku.twidere.activity.support.UserListSelectorActivity;
|
|
|
|
import org.mariotaku.twidere.activity.support.UserProfileEditorActivity;
|
|
|
|
import org.mariotaku.twidere.adapter.support.SupportTabsAdapter;
|
2014-12-07 16:13:07 +01:00
|
|
|
import org.mariotaku.twidere.app.TwidereApplication;
|
2014-12-01 10:15:20 +01:00
|
|
|
import org.mariotaku.twidere.fragment.iface.IBaseFragment.SystemWindowsInsetsCallback;
|
2014-12-01 08:00:37 +01:00
|
|
|
import org.mariotaku.twidere.fragment.iface.SupportFragmentCallback;
|
2014-12-08 16:16:33 +01:00
|
|
|
import org.mariotaku.twidere.graphic.ActionBarColorDrawable;
|
2015-01-17 19:58:29 +01:00
|
|
|
import org.mariotaku.twidere.graphic.ActionIconDrawable;
|
2014-12-01 08:00:37 +01:00
|
|
|
import org.mariotaku.twidere.loader.support.ParcelableUserLoader;
|
2014-12-24 05:39:21 +01:00
|
|
|
import org.mariotaku.twidere.model.ParcelableAccount.ParcelableCredentials;
|
2015-01-23 17:09:03 +01:00
|
|
|
import org.mariotaku.twidere.model.ParcelableMedia;
|
2014-12-01 08:00:37 +01:00
|
|
|
import org.mariotaku.twidere.model.ParcelableUser;
|
|
|
|
import org.mariotaku.twidere.model.ParcelableUserList;
|
|
|
|
import org.mariotaku.twidere.model.SingleResponse;
|
2015-01-11 10:28:45 +01:00
|
|
|
import org.mariotaku.twidere.provider.TwidereDataStore.CachedUsers;
|
|
|
|
import org.mariotaku.twidere.provider.TwidereDataStore.Filters;
|
2014-12-13 16:14:47 +01:00
|
|
|
import org.mariotaku.twidere.text.TextAlphaSpan;
|
2014-12-01 08:00:37 +01:00
|
|
|
import org.mariotaku.twidere.util.AsyncTwitterWrapper;
|
|
|
|
import org.mariotaku.twidere.util.ContentValuesCreator;
|
2015-03-14 16:11:20 +01:00
|
|
|
import org.mariotaku.twidere.util.LinkCreator;
|
2014-12-01 08:00:37 +01:00
|
|
|
import org.mariotaku.twidere.util.MathUtils;
|
2015-03-29 20:19:25 +02:00
|
|
|
import org.mariotaku.twidere.util.MediaLoaderWrapper;
|
2014-12-01 08:00:37 +01:00
|
|
|
import org.mariotaku.twidere.util.ParseUtils;
|
|
|
|
import org.mariotaku.twidere.util.ThemeUtils;
|
|
|
|
import org.mariotaku.twidere.util.TwidereLinkify;
|
|
|
|
import org.mariotaku.twidere.util.TwidereLinkify.OnLinkClickListener;
|
2015-01-03 16:16:50 +01:00
|
|
|
import org.mariotaku.twidere.util.UserColorNameUtils;
|
2014-12-01 08:00:37 +01:00
|
|
|
import org.mariotaku.twidere.util.Utils;
|
|
|
|
import org.mariotaku.twidere.util.menu.TwidereMenuInfo;
|
2014-12-07 16:13:07 +01:00
|
|
|
import org.mariotaku.twidere.util.message.FriendshipUpdatedEvent;
|
|
|
|
import org.mariotaku.twidere.util.message.ProfileUpdatedEvent;
|
|
|
|
import org.mariotaku.twidere.util.message.TaskStateChangedEvent;
|
2014-12-01 17:04:55 +01:00
|
|
|
import org.mariotaku.twidere.view.HeaderDrawerLayout;
|
|
|
|
import org.mariotaku.twidere.view.HeaderDrawerLayout.DrawerCallback;
|
2014-12-01 08:00:37 +01:00
|
|
|
import org.mariotaku.twidere.view.ProfileBannerImageView;
|
2014-12-24 05:39:21 +01:00
|
|
|
import org.mariotaku.twidere.view.ShapedImageView;
|
2014-12-12 14:53:18 +01:00
|
|
|
import org.mariotaku.twidere.view.TabPagerIndicator;
|
2014-12-01 17:04:55 +01:00
|
|
|
import org.mariotaku.twidere.view.TintedStatusFrameLayout;
|
2014-12-03 11:27:11 +01:00
|
|
|
import org.mariotaku.twidere.view.iface.IColorLabelView;
|
2014-12-01 08:00:37 +01:00
|
|
|
import org.mariotaku.twidere.view.iface.IExtendedView.OnSizeChangedListener;
|
|
|
|
|
2015-01-17 19:58:29 +01:00
|
|
|
import java.util.List;
|
2014-12-01 08:00:37 +01:00
|
|
|
import java.util.Locale;
|
|
|
|
|
|
|
|
import twitter4j.Relationship;
|
|
|
|
import twitter4j.Twitter;
|
|
|
|
import twitter4j.TwitterException;
|
|
|
|
|
|
|
|
import static android.text.TextUtils.isEmpty;
|
|
|
|
import static org.mariotaku.twidere.util.ParseUtils.parseLong;
|
2015-01-03 16:16:50 +01:00
|
|
|
import static org.mariotaku.twidere.util.UserColorNameUtils.clearUserColor;
|
|
|
|
import static org.mariotaku.twidere.util.UserColorNameUtils.clearUserNickname;
|
|
|
|
import static org.mariotaku.twidere.util.UserColorNameUtils.getUserColor;
|
|
|
|
import static org.mariotaku.twidere.util.UserColorNameUtils.getUserNickname;
|
2014-12-01 08:00:37 +01:00
|
|
|
import static org.mariotaku.twidere.util.Utils.addIntentToMenu;
|
|
|
|
import static org.mariotaku.twidere.util.Utils.formatToLongTimeString;
|
|
|
|
import static org.mariotaku.twidere.util.Utils.getAccountColor;
|
|
|
|
import static org.mariotaku.twidere.util.Utils.getAccountScreenName;
|
|
|
|
import static org.mariotaku.twidere.util.Utils.getErrorMessage;
|
|
|
|
import static org.mariotaku.twidere.util.Utils.getLocalizedNumber;
|
|
|
|
import static org.mariotaku.twidere.util.Utils.getOriginalTwitterProfileImage;
|
|
|
|
import static org.mariotaku.twidere.util.Utils.getTwitterInstance;
|
|
|
|
import static org.mariotaku.twidere.util.Utils.getUserTypeIconRes;
|
2015-01-10 16:17:02 +01:00
|
|
|
import static org.mariotaku.twidere.util.Utils.openIncomingFriendships;
|
2014-12-24 05:39:21 +01:00
|
|
|
import static org.mariotaku.twidere.util.Utils.openMutesUsers;
|
2014-12-01 08:00:37 +01:00
|
|
|
import static org.mariotaku.twidere.util.Utils.openStatus;
|
|
|
|
import static org.mariotaku.twidere.util.Utils.openTweetSearch;
|
2014-12-24 05:39:21 +01:00
|
|
|
import static org.mariotaku.twidere.util.Utils.openUserBlocks;
|
2014-12-01 08:00:37 +01:00
|
|
|
import static org.mariotaku.twidere.util.Utils.openUserFollowers;
|
|
|
|
import static org.mariotaku.twidere.util.Utils.openUserFriends;
|
2014-12-01 10:15:20 +01:00
|
|
|
import static org.mariotaku.twidere.util.Utils.openUserLists;
|
2014-12-01 08:00:37 +01:00
|
|
|
import static org.mariotaku.twidere.util.Utils.openUserProfile;
|
|
|
|
import static org.mariotaku.twidere.util.Utils.setMenuItemAvailability;
|
|
|
|
import static org.mariotaku.twidere.util.Utils.showInfoMessage;
|
|
|
|
|
2014-12-01 17:04:55 +01:00
|
|
|
public class UserFragment extends BaseSupportFragment implements OnClickListener,
|
2014-12-24 05:39:21 +01:00
|
|
|
OnLinkClickListener, OnSizeChangedListener, OnSharedPreferenceChangeListener,
|
2015-03-15 15:40:45 +01:00
|
|
|
OnTouchListener, DrawerCallback, SupportFragmentCallback, SystemWindowsInsetsCallback {
|
2014-12-01 08:00:37 +01:00
|
|
|
|
|
|
|
public static final String TRANSITION_NAME_PROFILE_IMAGE = "profile_image";
|
|
|
|
public static final String TRANSITION_NAME_PROFILE_TYPE = "profile_type";
|
2014-12-01 17:29:34 +01:00
|
|
|
public static final String TRANSITION_NAME_CARD = "card";
|
2014-12-01 08:00:37 +01:00
|
|
|
|
|
|
|
private static final int LOADER_ID_USER = 1;
|
|
|
|
private static final int LOADER_ID_FRIENDSHIP = 2;
|
|
|
|
|
2015-03-22 18:06:25 +01:00
|
|
|
private MediaLoaderWrapper mProfileImageLoader;
|
2014-12-01 08:00:37 +01:00
|
|
|
|
2014-12-24 05:39:21 +01:00
|
|
|
private ShapedImageView mProfileImageView;
|
2014-12-01 08:00:37 +01:00
|
|
|
private ImageView mProfileTypeView;
|
|
|
|
private ProfileBannerImageView mProfileBannerView;
|
|
|
|
private TextView mNameView, mScreenNameView, mDescriptionView, mLocationView, mURLView, mCreatedAtView,
|
2014-12-01 10:15:20 +01:00
|
|
|
mListedCount, mFollowersCount, mFriendsCount, mErrorMessageView;
|
|
|
|
private View mDescriptionContainer, mLocationContainer, mURLContainer, mListedContainer, mFollowersContainer,
|
2014-12-01 08:00:37 +01:00
|
|
|
mFriendsContainer;
|
|
|
|
private Button mRetryButton;
|
2014-12-03 11:27:11 +01:00
|
|
|
private IColorLabelView mProfileNameContainer;
|
2014-12-01 08:00:37 +01:00
|
|
|
private View mProgressContainer, mErrorRetryContainer;
|
2014-12-03 11:27:11 +01:00
|
|
|
private View mCardContent;
|
2014-12-01 08:00:37 +01:00
|
|
|
private View mProfileBannerSpace;
|
2014-12-01 17:04:55 +01:00
|
|
|
private TintedStatusFrameLayout mTintedStatusContent;
|
|
|
|
private HeaderDrawerLayout mHeaderDrawerLayout;
|
2014-12-01 08:00:37 +01:00
|
|
|
private ViewPager mViewPager;
|
2014-12-12 14:53:18 +01:00
|
|
|
private TabPagerIndicator mPagerIndicator;
|
2014-12-01 17:29:34 +01:00
|
|
|
private CardView mCardView;
|
|
|
|
private View mUuckyFooter;
|
2014-12-03 11:27:11 +01:00
|
|
|
private View mProfileBannerContainer;
|
|
|
|
private Button mFollowButton;
|
2014-12-07 16:13:07 +01:00
|
|
|
private ProgressBar mFollowProgress;
|
2015-01-17 19:58:29 +01:00
|
|
|
private View mPagesContent, mPagesErrorContainer;
|
|
|
|
private ImageView mPagesErrorIcon;
|
|
|
|
private TextView mPagesErrorText;
|
2014-12-01 08:00:37 +01:00
|
|
|
|
|
|
|
private SupportTabsAdapter mPagerAdapter;
|
|
|
|
|
|
|
|
private Relationship mRelationship;
|
|
|
|
private ParcelableUser mUser = null;
|
2014-12-01 17:29:34 +01:00
|
|
|
|
|
|
|
private Locale mLocale;
|
|
|
|
private boolean mGetUserInfoLoaderInitialized, mGetFriendShipLoaderInitialized;
|
|
|
|
private int mBannerWidth;
|
|
|
|
private ActionBarDrawable mActionBarBackground;
|
|
|
|
private Fragment mCurrentVisibleFragment;
|
|
|
|
|
2014-12-01 08:00:37 +01:00
|
|
|
|
2014-12-07 16:13:07 +01:00
|
|
|
@Subscribe
|
|
|
|
public void notifyTaskStateChanged(TaskStateChangedEvent event) {
|
|
|
|
updateRefreshState();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Subscribe
|
|
|
|
public void notifyFriendshipUpdated(FriendshipUpdatedEvent event) {
|
2014-12-08 16:16:33 +01:00
|
|
|
if (!event.user.equals(mUser)) return;
|
|
|
|
getFriendship();
|
2014-12-07 16:13:07 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private void updateRefreshState() {
|
2015-03-14 16:11:20 +01:00
|
|
|
final ParcelableUser user = getUser();
|
2014-12-15 12:21:15 +01:00
|
|
|
if (user == null) return;
|
2014-12-07 16:13:07 +01:00
|
|
|
final AsyncTwitterWrapper twitter = getTwitterWrapper();
|
|
|
|
final boolean is_creating_friendship = twitter != null
|
2014-12-15 12:21:15 +01:00
|
|
|
&& twitter.isCreatingFriendship(user.account_id, user.id);
|
2014-12-07 16:13:07 +01:00
|
|
|
final boolean is_destroying_friendship = twitter != null
|
2014-12-15 12:21:15 +01:00
|
|
|
&& twitter.isDestroyingFriendship(user.account_id, user.id);
|
2014-12-07 16:13:07 +01:00
|
|
|
setProgressBarIndeterminateVisibility(is_creating_friendship || is_destroying_friendship);
|
|
|
|
invalidateOptionsMenu();
|
|
|
|
}
|
|
|
|
|
2014-12-01 08:00:37 +01:00
|
|
|
private final LoaderCallbacks<SingleResponse<ParcelableUser>> mUserInfoLoaderCallbacks = new LoaderCallbacks<SingleResponse<ParcelableUser>>() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Loader<SingleResponse<ParcelableUser>> onCreateLoader(final int id, final Bundle args) {
|
2014-12-03 11:27:11 +01:00
|
|
|
final boolean omitIntentExtra = args.getBoolean(EXTRA_OMIT_INTENT_EXTRA, true);
|
|
|
|
final long accountId = args.getLong(EXTRA_ACCOUNT_ID, -1);
|
|
|
|
final long userId = args.getLong(EXTRA_USER_ID, -1);
|
|
|
|
final String screenName = args.getString(EXTRA_SCREEN_NAME);
|
|
|
|
if (mUser == null && (!omitIntentExtra || !args.containsKey(EXTRA_USER))) {
|
|
|
|
mCardContent.setVisibility(View.GONE);
|
2014-12-01 08:00:37 +01:00
|
|
|
mErrorRetryContainer.setVisibility(View.GONE);
|
|
|
|
mProgressContainer.setVisibility(View.VISIBLE);
|
|
|
|
mErrorMessageView.setText(null);
|
|
|
|
mErrorMessageView.setVisibility(View.GONE);
|
|
|
|
setListShown(false);
|
|
|
|
}
|
|
|
|
setProgressBarIndeterminateVisibility(true);
|
|
|
|
final ParcelableUser user = mUser;
|
|
|
|
return new ParcelableUserLoader(getActivity(), accountId, userId, screenName, getArguments(),
|
|
|
|
omitIntentExtra, user == null || !user.is_cache && userId != user.id);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onLoaderReset(final Loader<SingleResponse<ParcelableUser>> loader) {
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onLoadFinished(final Loader<SingleResponse<ParcelableUser>> loader,
|
|
|
|
final SingleResponse<ParcelableUser> data) {
|
|
|
|
if (getActivity() == null) return;
|
2014-12-24 05:39:21 +01:00
|
|
|
if (data.hasData()) {
|
2014-12-01 08:00:37 +01:00
|
|
|
final ParcelableUser user = data.getData();
|
2014-12-03 11:27:11 +01:00
|
|
|
mCardContent.setVisibility(View.VISIBLE);
|
2014-12-01 08:00:37 +01:00
|
|
|
mErrorRetryContainer.setVisibility(View.GONE);
|
|
|
|
mProgressContainer.setVisibility(View.GONE);
|
|
|
|
setListShown(true);
|
|
|
|
displayUser(user);
|
|
|
|
if (user.is_cache) {
|
|
|
|
final Bundle args = new Bundle();
|
|
|
|
args.putLong(EXTRA_ACCOUNT_ID, user.account_id);
|
|
|
|
args.putLong(EXTRA_USER_ID, user.id);
|
|
|
|
args.putString(EXTRA_SCREEN_NAME, user.screen_name);
|
|
|
|
args.putBoolean(EXTRA_OMIT_INTENT_EXTRA, true);
|
|
|
|
getLoaderManager().restartLoader(LOADER_ID_USER, args, this);
|
|
|
|
}
|
|
|
|
} else if (mUser != null && mUser.is_cache) {
|
2014-12-03 11:27:11 +01:00
|
|
|
mCardContent.setVisibility(View.VISIBLE);
|
2014-12-01 08:00:37 +01:00
|
|
|
mErrorRetryContainer.setVisibility(View.GONE);
|
|
|
|
mProgressContainer.setVisibility(View.GONE);
|
|
|
|
setListShown(true);
|
|
|
|
displayUser(mUser);
|
|
|
|
} else {
|
|
|
|
if (data.hasException()) {
|
|
|
|
mErrorMessageView.setText(getErrorMessage(getActivity(), data.getException()));
|
|
|
|
mErrorMessageView.setVisibility(View.VISIBLE);
|
|
|
|
}
|
2014-12-03 11:27:11 +01:00
|
|
|
mCardContent.setVisibility(View.GONE);
|
2014-12-01 08:00:37 +01:00
|
|
|
mErrorRetryContainer.setVisibility(View.VISIBLE);
|
|
|
|
mProgressContainer.setVisibility(View.GONE);
|
|
|
|
}
|
|
|
|
setProgressBarIndeterminateVisibility(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
};
|
|
|
|
private final LoaderCallbacks<SingleResponse<Relationship>> mFriendshipLoaderCallbacks = new LoaderCallbacks<SingleResponse<Relationship>>() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Loader<SingleResponse<Relationship>> onCreateLoader(final int id, final Bundle args) {
|
|
|
|
invalidateOptionsMenu();
|
2014-12-03 11:27:11 +01:00
|
|
|
mFollowButton.setVisibility(View.GONE);
|
2014-12-07 16:13:07 +01:00
|
|
|
mFollowProgress.setVisibility(View.VISIBLE);
|
2014-12-01 08:00:37 +01:00
|
|
|
final long accountId = args.getLong(EXTRA_ACCOUNT_ID, -1);
|
|
|
|
final long userId = args.getLong(EXTRA_USER_ID, -1);
|
2014-12-04 16:01:16 +01:00
|
|
|
return new RelationshipLoader(getActivity(), accountId, userId);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onLoaderReset(final Loader<SingleResponse<Relationship>> loader) {
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onLoadFinished(final Loader<SingleResponse<Relationship>> loader,
|
|
|
|
final SingleResponse<Relationship> data) {
|
2014-12-07 16:13:07 +01:00
|
|
|
mFollowProgress.setVisibility(View.GONE);
|
2015-03-14 16:11:20 +01:00
|
|
|
final ParcelableUser user = getUser();
|
2014-12-07 16:13:07 +01:00
|
|
|
final Relationship relationship = data.getData();
|
|
|
|
mRelationship = relationship;
|
2014-12-01 08:00:37 +01:00
|
|
|
if (user == null) return;
|
|
|
|
invalidateOptionsMenu();
|
2014-12-03 11:27:11 +01:00
|
|
|
final boolean isMyself = user.account_id == user.id;
|
|
|
|
if (isMyself) {
|
|
|
|
mFollowButton.setText(R.string.edit);
|
|
|
|
mFollowButton.setVisibility(View.VISIBLE);
|
|
|
|
} else if (relationship != null) {
|
2014-12-24 05:39:21 +01:00
|
|
|
final int drawableRes;
|
2015-01-06 16:46:07 +01:00
|
|
|
mFollowButton.setEnabled(!relationship.isSourceBlockedByTarget());
|
2015-01-17 19:58:29 +01:00
|
|
|
if (relationship.isSourceBlockedByTarget()) {
|
|
|
|
mPagesErrorContainer.setVisibility(View.VISIBLE);
|
|
|
|
final String displayName = UserColorNameUtils.getDisplayName(getActivity(), user);
|
|
|
|
mPagesErrorText.setText(getString(R.string.blocked_by_user_summary, displayName));
|
2015-03-19 21:13:01 +01:00
|
|
|
mPagesErrorIcon.setImageResource(R.drawable.ic_info_error_generic);
|
|
|
|
mPagesContent.setVisibility(View.GONE);
|
2015-03-20 12:31:27 +01:00
|
|
|
} else if (!relationship.isSourceFollowingTarget() && user.is_protected) {
|
2015-03-19 21:13:01 +01:00
|
|
|
mPagesErrorContainer.setVisibility(View.VISIBLE);
|
|
|
|
final String displayName = UserColorNameUtils.getDisplayName(getActivity(), user);
|
|
|
|
mPagesErrorText.setText(getString(R.string.user_protected_summary, displayName));
|
|
|
|
mPagesErrorIcon.setImageResource(R.drawable.ic_info_locked);
|
2015-01-17 19:58:29 +01:00
|
|
|
mPagesContent.setVisibility(View.GONE);
|
|
|
|
} else {
|
|
|
|
mPagesErrorContainer.setVisibility(View.GONE);
|
|
|
|
mPagesErrorText.setText(null);
|
|
|
|
mPagesContent.setVisibility(View.VISIBLE);
|
|
|
|
}
|
2014-12-03 11:27:11 +01:00
|
|
|
if (relationship.isSourceBlockingTarget()) {
|
|
|
|
mFollowButton.setText(R.string.unblock);
|
2014-12-24 05:39:21 +01:00
|
|
|
drawableRes = R.drawable.ic_follow_blocked;
|
2014-12-03 11:27:11 +01:00
|
|
|
} else if (relationship.isSourceFollowingTarget()) {
|
|
|
|
mFollowButton.setText(R.string.unfollow);
|
2014-12-24 05:39:21 +01:00
|
|
|
if (relationship.isTargetFollowingSource()) {
|
|
|
|
drawableRes = R.drawable.ic_follow_bidirectional;
|
|
|
|
} else {
|
|
|
|
drawableRes = R.drawable.ic_follow_outgoing;
|
|
|
|
}
|
|
|
|
} else if (user.is_follow_request_sent) {
|
|
|
|
mFollowButton.setText(R.string.requested);
|
|
|
|
if (relationship.isTargetFollowingSource()) {
|
|
|
|
drawableRes = R.drawable.ic_follow_incoming;
|
|
|
|
} else {
|
|
|
|
drawableRes = R.drawable.ic_follow_requested;
|
|
|
|
}
|
2014-12-03 11:27:11 +01:00
|
|
|
} else {
|
|
|
|
mFollowButton.setText(R.string.follow);
|
2014-12-24 05:39:21 +01:00
|
|
|
if (relationship.isTargetFollowingSource()) {
|
|
|
|
drawableRes = R.drawable.ic_follow_incoming;
|
|
|
|
} else {
|
|
|
|
drawableRes = R.drawable.ic_follow_none;
|
|
|
|
}
|
2014-12-03 11:27:11 +01:00
|
|
|
}
|
2015-03-31 13:05:19 +02:00
|
|
|
final Drawable icon = ResourcesCompat.getDrawable(getResources(), drawableRes, null);
|
2014-12-24 05:39:21 +01:00
|
|
|
final int iconSize = Math.round(mFollowButton.getTextSize() * 1.4f);
|
|
|
|
icon.setBounds(0, 0, iconSize, iconSize);
|
|
|
|
icon.setColorFilter(mFollowButton.getCurrentTextColor(), Mode.SRC_ATOP);
|
|
|
|
mFollowButton.setCompoundDrawables(icon, null, null, null);
|
|
|
|
mFollowButton.setCompoundDrawablePadding(Math.round(mFollowButton.getTextSize() * 0.25f));
|
|
|
|
|
2014-12-01 08:00:37 +01:00
|
|
|
final ContentResolver resolver = getContentResolver();
|
2014-12-04 15:31:29 +01:00
|
|
|
final String where = Expression.equals(CachedUsers.USER_ID, user.id).getSQL();
|
2015-01-10 16:17:02 +01:00
|
|
|
final ContentValues cachedValues = ParcelableUser.makeCachedUserContentValues(user);
|
|
|
|
resolver.insert(CachedUsers.CONTENT_URI, cachedValues);
|
2014-12-01 08:00:37 +01:00
|
|
|
// I bet you don't want to see blocked user in your auto
|
|
|
|
// complete list.
|
|
|
|
if (!data.getData().isSourceBlockingTarget()) {
|
|
|
|
}
|
2014-12-03 11:27:11 +01:00
|
|
|
mFollowButton.setVisibility(View.VISIBLE);
|
2014-12-01 08:00:37 +01:00
|
|
|
} else {
|
2014-12-03 11:27:11 +01:00
|
|
|
mFollowButton.setText(null);
|
|
|
|
mFollowButton.setVisibility(View.GONE);
|
2015-01-17 19:58:29 +01:00
|
|
|
mPagesErrorContainer.setVisibility(View.GONE);
|
|
|
|
mPagesContent.setVisibility(View.VISIBLE);
|
2014-12-03 11:27:11 +01:00
|
|
|
// mFollowingYouIndicator.setVisibility(View.GONE);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
public void displayUser(final ParcelableUser user) {
|
2014-12-13 16:14:47 +01:00
|
|
|
mUser = user;
|
|
|
|
final FragmentActivity activity = getActivity();
|
|
|
|
if (user == null || user.id <= 0 || activity == null) return;
|
2014-12-01 08:00:37 +01:00
|
|
|
final Resources res = getResources();
|
|
|
|
final LoaderManager lm = getLoaderManager();
|
|
|
|
lm.destroyLoader(LOADER_ID_USER);
|
|
|
|
lm.destroyLoader(LOADER_ID_FRIENDSHIP);
|
|
|
|
final boolean userIsMe = user.account_id == user.id;
|
2014-12-03 11:27:11 +01:00
|
|
|
mCardContent.setVisibility(View.VISIBLE);
|
2014-12-01 08:00:37 +01:00
|
|
|
mErrorRetryContainer.setVisibility(View.GONE);
|
|
|
|
mProgressContainer.setVisibility(View.GONE);
|
|
|
|
mUser = user;
|
2014-12-13 16:14:47 +01:00
|
|
|
final int userColor = getUserColor(activity, user.id, true);
|
2014-12-15 12:21:15 +01:00
|
|
|
mProfileImageView.setBorderColor(userColor != 0 ? userColor : Color.WHITE);
|
2014-12-13 16:14:47 +01:00
|
|
|
mProfileNameContainer.drawEnd(getAccountColor(activity, user.account_id));
|
|
|
|
final String nick = getUserNickname(activity, user.id, true);
|
2014-12-01 08:00:37 +01:00
|
|
|
mNameView
|
|
|
|
.setText(TextUtils.isEmpty(nick) ? user.name : getString(R.string.name_with_nickname, user.name, nick));
|
|
|
|
final int typeIconRes = getUserTypeIconRes(user.is_verified, user.is_protected);
|
|
|
|
if (typeIconRes != 0) {
|
|
|
|
mProfileTypeView.setImageResource(typeIconRes);
|
|
|
|
mProfileTypeView.setVisibility(View.VISIBLE);
|
|
|
|
} else {
|
|
|
|
mProfileTypeView.setImageDrawable(null);
|
|
|
|
mProfileTypeView.setVisibility(View.GONE);
|
|
|
|
}
|
|
|
|
mScreenNameView.setText("@" + user.screen_name);
|
2015-01-17 19:58:29 +01:00
|
|
|
mDescriptionContainer.setVisibility(isEmpty(user.description_html) ? View.GONE : View.VISIBLE);
|
|
|
|
mDescriptionView.setText(user.description_html != null ? Html.fromHtml(user.description_html) : user.description_plain);
|
2014-12-01 08:00:37 +01:00
|
|
|
final TwidereLinkify linkify = new TwidereLinkify(this);
|
|
|
|
linkify.applyAllLinks(mDescriptionView, user.account_id, false);
|
|
|
|
mDescriptionView.setMovementMethod(null);
|
2015-01-17 19:58:29 +01:00
|
|
|
mLocationContainer.setVisibility(isEmpty(user.location) ? View.GONE : View.VISIBLE);
|
2014-12-01 08:00:37 +01:00
|
|
|
mLocationView.setText(user.location);
|
2015-01-17 19:58:29 +01:00
|
|
|
mURLContainer.setVisibility(isEmpty(user.url) && isEmpty(user.url_expanded) ? View.GONE : View.VISIBLE);
|
2014-12-01 08:00:37 +01:00
|
|
|
mURLView.setText(isEmpty(user.url_expanded) ? user.url : user.url_expanded);
|
|
|
|
mURLView.setMovementMethod(null);
|
2014-12-13 16:14:47 +01:00
|
|
|
final String createdAt = formatToLongTimeString(activity, user.created_at);
|
2015-01-17 19:58:29 +01:00
|
|
|
final float daysSinceCreation = (System.currentTimeMillis() - user.created_at) / 1000 / 60 / 60 / 24;
|
|
|
|
final int dailyTweets = Math.round(user.statuses_count / Math.max(1, daysSinceCreation));
|
2014-12-01 08:00:37 +01:00
|
|
|
mCreatedAtView.setText(res.getQuantityString(R.plurals.created_at_with_N_tweets_per_day, dailyTweets,
|
|
|
|
createdAt, dailyTweets));
|
2014-12-01 10:15:20 +01:00
|
|
|
mListedCount.setText(getLocalizedNumber(mLocale, user.listed_count));
|
2014-12-01 08:00:37 +01:00
|
|
|
mFollowersCount.setText(getLocalizedNumber(mLocale, user.followers_count));
|
|
|
|
mFriendsCount.setText(getLocalizedNumber(mLocale, user.friends_count));
|
2015-01-17 19:58:29 +01:00
|
|
|
|
|
|
|
mProfileImageLoader.displayProfileImage(mProfileImageView, getOriginalTwitterProfileImage(user.profile_image_url));
|
2014-12-01 08:00:37 +01:00
|
|
|
if (userColor != 0) {
|
2015-01-22 12:16:22 +01:00
|
|
|
setUserUiColor(userColor);
|
2014-12-01 08:00:37 +01:00
|
|
|
} else {
|
2015-01-22 12:16:22 +01:00
|
|
|
setUserUiColor(user.link_color);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
|
|
|
final int defWidth = res.getDisplayMetrics().widthPixels;
|
|
|
|
final int width = mBannerWidth > 0 ? mBannerWidth : defWidth;
|
|
|
|
mProfileImageLoader.displayProfileBanner(mProfileBannerView, user.profile_banner_url, width);
|
2014-12-01 17:04:55 +01:00
|
|
|
mUuckyFooter.setVisibility(isUucky(user.id, user.screen_name, user) ? View.VISIBLE : View.GONE);
|
2014-12-07 16:13:07 +01:00
|
|
|
final Relationship relationship = mRelationship;
|
|
|
|
if (relationship == null || relationship.getTargetUserId() != user.id) {
|
2014-12-01 08:00:37 +01:00
|
|
|
getFriendship();
|
|
|
|
}
|
2015-01-03 16:16:50 +01:00
|
|
|
activity.setTitle(UserColorNameUtils.getDisplayName(activity, user, true));
|
2014-12-13 16:14:47 +01:00
|
|
|
updateTitleColor();
|
2014-12-01 08:00:37 +01:00
|
|
|
invalidateOptionsMenu();
|
|
|
|
}
|
|
|
|
|
2014-12-01 17:04:55 +01:00
|
|
|
@Override
|
|
|
|
public void fling(float velocity) {
|
|
|
|
final Fragment fragment = mCurrentVisibleFragment;
|
|
|
|
if (fragment instanceof DrawerCallback) {
|
|
|
|
((DrawerCallback) fragment).fling(velocity);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void scrollBy(float dy) {
|
|
|
|
final Fragment fragment = mCurrentVisibleFragment;
|
|
|
|
if (fragment instanceof DrawerCallback) {
|
|
|
|
((DrawerCallback) fragment).scrollBy(dy);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public boolean canScroll(float dy) {
|
|
|
|
final Fragment fragment = mCurrentVisibleFragment;
|
|
|
|
return fragment instanceof DrawerCallback && ((DrawerCallback) fragment).canScroll(dy);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public boolean isScrollContent(float x, float y) {
|
|
|
|
final ViewPager v = mViewPager;
|
|
|
|
final int[] location = new int[2];
|
|
|
|
v.getLocationOnScreen(location);
|
|
|
|
return x >= location[0] && x <= location[0] + v.getWidth()
|
|
|
|
&& y >= location[1] && y <= location[1] + v.getHeight();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void cancelTouch() {
|
|
|
|
final Fragment fragment = mCurrentVisibleFragment;
|
|
|
|
if (fragment instanceof DrawerCallback) {
|
|
|
|
((DrawerCallback) fragment).cancelTouch();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void topChanged(int top) {
|
|
|
|
final HeaderDrawerLayout drawer = mHeaderDrawerLayout;
|
|
|
|
if (drawer == null) return;
|
|
|
|
final int offset = drawer.getPaddingTop() - top;
|
|
|
|
updateScrollOffset(offset);
|
|
|
|
|
|
|
|
final Fragment fragment = mCurrentVisibleFragment;
|
|
|
|
if (fragment instanceof DrawerCallback) {
|
|
|
|
((DrawerCallback) fragment).topChanged(top);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-03 11:27:11 +01:00
|
|
|
@Override
|
|
|
|
public boolean shouldLayoutHeaderBottom() {
|
|
|
|
final HeaderDrawerLayout drawer = mHeaderDrawerLayout;
|
|
|
|
final CardView card = mCardView;
|
|
|
|
if (drawer == null || card == null) return false;
|
|
|
|
return card.getTop() + drawer.getHeaderTop() - drawer.getPaddingTop() <= 0;
|
|
|
|
}
|
|
|
|
|
2014-12-01 17:04:55 +01:00
|
|
|
@Override
|
|
|
|
public Fragment getCurrentVisibleFragment() {
|
|
|
|
return mCurrentVisibleFragment;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onDetachFragment(Fragment fragment) {
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onSetUserVisibleHint(Fragment fragment, boolean isVisibleToUser) {
|
|
|
|
mCurrentVisibleFragment = isVisibleToUser ? fragment : null;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public boolean triggerRefresh(int position) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public boolean getSystemWindowsInsets(Rect insets) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-12-01 08:00:37 +01:00
|
|
|
public void getUserInfo(final long accountId, final long userId, final String screenName,
|
|
|
|
final boolean omitIntentExtra) {
|
|
|
|
final LoaderManager lm = getLoaderManager();
|
|
|
|
lm.destroyLoader(LOADER_ID_USER);
|
|
|
|
lm.destroyLoader(LOADER_ID_FRIENDSHIP);
|
|
|
|
final Bundle args = new Bundle();
|
|
|
|
args.putLong(EXTRA_ACCOUNT_ID, accountId);
|
|
|
|
args.putLong(EXTRA_USER_ID, userId);
|
|
|
|
args.putString(EXTRA_SCREEN_NAME, screenName);
|
|
|
|
args.putBoolean(EXTRA_OMIT_INTENT_EXTRA, omitIntentExtra);
|
|
|
|
if (!mGetUserInfoLoaderInitialized) {
|
|
|
|
lm.initLoader(LOADER_ID_USER, args, mUserInfoLoaderCallbacks);
|
|
|
|
mGetUserInfoLoaderInitialized = true;
|
|
|
|
} else {
|
|
|
|
lm.restartLoader(LOADER_ID_USER, args, mUserInfoLoaderCallbacks);
|
|
|
|
}
|
|
|
|
if (accountId == -1 || userId == -1 && screenName == null) {
|
2014-12-03 11:27:11 +01:00
|
|
|
mCardContent.setVisibility(View.GONE);
|
2014-12-01 08:00:37 +01:00
|
|
|
mErrorRetryContainer.setVisibility(View.GONE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onActivityResult(final int requestCode, final int resultCode, final Intent data) {
|
2015-03-14 16:11:20 +01:00
|
|
|
final ParcelableUser user = getUser();
|
2014-12-01 08:00:37 +01:00
|
|
|
switch (requestCode) {
|
|
|
|
case REQUEST_SET_COLOR: {
|
|
|
|
if (user == null) return;
|
|
|
|
if (resultCode == Activity.RESULT_OK) {
|
|
|
|
if (data == null) return;
|
|
|
|
final int color = data.getIntExtra(EXTRA_COLOR, Color.TRANSPARENT);
|
2015-01-03 16:16:50 +01:00
|
|
|
UserColorNameUtils.setUserColor(getActivity(), mUser.id, color);
|
2014-12-01 08:00:37 +01:00
|
|
|
} else if (resultCode == ColorPickerDialogActivity.RESULT_CLEARED) {
|
|
|
|
clearUserColor(getActivity(), mUser.id);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case REQUEST_ADD_TO_LIST: {
|
|
|
|
if (user == null) return;
|
|
|
|
if (resultCode == Activity.RESULT_OK && data != null) {
|
|
|
|
final AsyncTwitterWrapper twitter = getTwitterWrapper();
|
|
|
|
final ParcelableUserList list = data.getParcelableExtra(EXTRA_USER_LIST);
|
|
|
|
if (list == null || twitter == null) return;
|
|
|
|
twitter.addUserListMembersAsync(user.account_id, list.id, user);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case REQUEST_SELECT_ACCOUNT: {
|
|
|
|
if (user == null) return;
|
|
|
|
if (resultCode == Activity.RESULT_OK) {
|
|
|
|
if (data == null || !data.hasExtra(EXTRA_ID)) return;
|
|
|
|
final long accountId = data.getLongExtra(EXTRA_ID, -1);
|
2014-12-01 17:29:34 +01:00
|
|
|
openUserProfile(getActivity(), accountId, user.id, user.screen_name, null);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2014-12-01 17:04:55 +01:00
|
|
|
@Override
|
|
|
|
public void onAttach(Activity activity) {
|
|
|
|
super.onAttach(activity);
|
|
|
|
mTintedStatusContent = (TintedStatusFrameLayout) activity.findViewById(R.id.main_content);
|
|
|
|
}
|
|
|
|
|
2014-12-01 10:15:20 +01:00
|
|
|
@Override
|
|
|
|
public View onCreateView(final LayoutInflater inflater, final ViewGroup container, final Bundle savedInstanceState) {
|
2015-01-17 19:58:29 +01:00
|
|
|
final View view = inflater.inflate(R.layout.fragment_user, container, false);
|
|
|
|
final ViewGroup profileDetailsContainer = (ViewGroup) view.findViewById(R.id.profile_details_container);
|
|
|
|
final boolean isCompact = Utils.isCompactCards(getActivity());
|
|
|
|
if (isCompact) {
|
|
|
|
inflater.inflate(R.layout.layout_user_details_compact, profileDetailsContainer);
|
|
|
|
} else {
|
|
|
|
inflater.inflate(R.layout.layout_user_details, profileDetailsContainer);
|
|
|
|
}
|
|
|
|
return view;
|
2014-12-01 10:15:20 +01:00
|
|
|
}
|
|
|
|
|
2015-01-17 19:58:29 +01:00
|
|
|
|
2014-12-01 10:15:20 +01:00
|
|
|
@Override
|
|
|
|
public void onActivityCreated(final Bundle savedInstanceState) {
|
|
|
|
super.onActivityCreated(savedInstanceState);
|
|
|
|
setHasOptionsMenu(true);
|
|
|
|
getSharedPreferences(USER_COLOR_PREFERENCES_NAME, Context.MODE_PRIVATE)
|
|
|
|
.registerOnSharedPreferenceChangeListener(this);
|
|
|
|
getSharedPreferences(USER_NICKNAME_PREFERENCES_NAME, Context.MODE_PRIVATE)
|
|
|
|
.registerOnSharedPreferenceChangeListener(this);
|
|
|
|
mLocale = getResources().getConfiguration().locale;
|
|
|
|
final Bundle args = getArguments();
|
|
|
|
long accountId = -1, userId = -1;
|
|
|
|
String screenName = null;
|
|
|
|
if (savedInstanceState != null) {
|
|
|
|
args.putAll(savedInstanceState);
|
|
|
|
} else {
|
|
|
|
accountId = args.getLong(EXTRA_ACCOUNT_ID, -1);
|
|
|
|
userId = args.getLong(EXTRA_USER_ID, -1);
|
|
|
|
screenName = args.getString(EXTRA_SCREEN_NAME);
|
|
|
|
}
|
2015-03-30 18:32:50 +02:00
|
|
|
mProfileImageLoader = getApplication().getMediaLoaderWrapper();
|
2014-12-01 10:15:20 +01:00
|
|
|
final FragmentActivity activity = getActivity();
|
|
|
|
|
2015-03-15 15:40:45 +01:00
|
|
|
Utils.setNdefPushMessageCallback(activity, new CreateNdefMessageCallback() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public NdefMessage createNdefMessage(NfcEvent event) {
|
|
|
|
final ParcelableUser user = getUser();
|
|
|
|
if (user == null) return null;
|
|
|
|
return new NdefMessage(new NdefRecord[]{
|
|
|
|
NdefRecord.createUri(LinkCreator.getTwitterUserLink(user.screen_name)),
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
2015-03-14 16:11:20 +01:00
|
|
|
|
2015-01-17 19:58:29 +01:00
|
|
|
activity.setEnterSharedElementCallback(new SharedElementCallback() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onSharedElementEnd(List<String> sharedElementNames, List<View> sharedElements, List<View> sharedElementSnapshots) {
|
|
|
|
int idx = sharedElementNames.indexOf(TRANSITION_NAME_PROFILE_IMAGE);
|
|
|
|
if (idx != -1) {
|
|
|
|
final View view = sharedElements.get(idx);
|
|
|
|
int[] location = new int[2];
|
|
|
|
final RectF bounds = new RectF(0, 0, view.getWidth(), view.getHeight());
|
|
|
|
view.getLocationOnScreen(location);
|
|
|
|
bounds.offsetTo(location[0], location[1]);
|
|
|
|
mProfileImageView.setTransitionDestination(bounds);
|
|
|
|
}
|
|
|
|
super.onSharedElementEnd(sharedElementNames, sharedElements, sharedElementSnapshots);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onSharedElementStart(List<String> sharedElementNames, List<View> sharedElements, List<View> sharedElementSnapshots) {
|
|
|
|
final int idx = sharedElementNames.indexOf(TRANSITION_NAME_PROFILE_IMAGE);
|
|
|
|
if (idx != -1) {
|
|
|
|
final View view = sharedElements.get(idx);
|
|
|
|
int[] location = new int[2];
|
|
|
|
final RectF bounds = new RectF(0, 0, view.getWidth(), view.getHeight());
|
|
|
|
view.getLocationOnScreen(location);
|
|
|
|
bounds.offsetTo(location[0], location[1]);
|
|
|
|
mProfileImageView.setTransitionSource(bounds);
|
|
|
|
}
|
|
|
|
super.onSharedElementStart(sharedElementNames, sharedElements, sharedElementSnapshots);
|
|
|
|
}
|
|
|
|
|
|
|
|
});
|
|
|
|
|
2014-12-01 10:15:20 +01:00
|
|
|
ViewCompat.setTransitionName(mProfileImageView, TRANSITION_NAME_PROFILE_IMAGE);
|
|
|
|
ViewCompat.setTransitionName(mProfileTypeView, TRANSITION_NAME_PROFILE_TYPE);
|
2014-12-01 17:29:34 +01:00
|
|
|
ViewCompat.setTransitionName(mCardView, TRANSITION_NAME_CARD);
|
2014-12-01 10:15:20 +01:00
|
|
|
|
2014-12-01 17:04:55 +01:00
|
|
|
mHeaderDrawerLayout.setDrawerCallback(this);
|
2014-12-01 10:15:20 +01:00
|
|
|
|
|
|
|
mPagerAdapter = new SupportTabsAdapter(activity, getChildFragmentManager());
|
|
|
|
|
2014-12-03 11:27:11 +01:00
|
|
|
mViewPager.setOffscreenPageLimit(3);
|
2014-12-01 10:15:20 +01:00
|
|
|
mViewPager.setAdapter(mPagerAdapter);
|
|
|
|
mPagerIndicator.setViewPager(mViewPager);
|
2014-12-12 14:53:18 +01:00
|
|
|
mPagerIndicator.setTabDisplayOption(TabPagerIndicator.LABEL);
|
2014-12-01 10:15:20 +01:00
|
|
|
|
2014-12-04 16:01:16 +01:00
|
|
|
mFollowButton.setOnClickListener(this);
|
2014-12-01 10:15:20 +01:00
|
|
|
mProfileImageView.setOnClickListener(this);
|
|
|
|
mProfileBannerView.setOnClickListener(this);
|
|
|
|
mListedContainer.setOnClickListener(this);
|
|
|
|
mFollowersContainer.setOnClickListener(this);
|
|
|
|
mFriendsContainer.setOnClickListener(this);
|
|
|
|
mRetryButton.setOnClickListener(this);
|
|
|
|
mProfileBannerView.setOnSizeChangedListener(this);
|
|
|
|
mProfileBannerSpace.setOnTouchListener(this);
|
|
|
|
|
2014-12-24 05:39:21 +01:00
|
|
|
|
|
|
|
mCardView.setCardBackgroundColor(ThemeUtils.getCardBackgroundColor(getActivity()));
|
|
|
|
|
2014-12-01 10:15:20 +01:00
|
|
|
getUserInfo(accountId, userId, screenName, false);
|
|
|
|
|
|
|
|
setupBaseActionBar();
|
|
|
|
|
|
|
|
setupUserPages();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onStart() {
|
|
|
|
super.onStart();
|
2014-12-07 16:13:07 +01:00
|
|
|
final Bus bus = TwidereApplication.getInstance(getActivity()).getMessageBus();
|
|
|
|
bus.register(this);
|
2014-12-01 10:15:20 +01:00
|
|
|
}
|
|
|
|
|
2014-12-07 16:13:07 +01:00
|
|
|
|
|
|
|
@Subscribe
|
|
|
|
public void notifyProfileUpdated(ProfileUpdatedEvent event) {
|
2015-03-14 16:11:20 +01:00
|
|
|
final ParcelableUser user = getUser();
|
2014-12-07 16:13:07 +01:00
|
|
|
if (user == null || !user.equals(event.user)) return;
|
|
|
|
displayUser(event.user);
|
2014-12-01 10:15:20 +01:00
|
|
|
}
|
|
|
|
|
2015-03-14 16:11:20 +01:00
|
|
|
public ParcelableUser getUser() {
|
|
|
|
return mUser;
|
|
|
|
}
|
|
|
|
|
2014-12-01 10:15:20 +01:00
|
|
|
@Override
|
|
|
|
public void onStop() {
|
2014-12-07 16:13:07 +01:00
|
|
|
final Bus bus = TwidereApplication.getInstance(getActivity()).getMessageBus();
|
|
|
|
bus.unregister(this);
|
2014-12-01 10:15:20 +01:00
|
|
|
super.onStop();
|
|
|
|
}
|
|
|
|
|
2014-12-07 16:13:07 +01:00
|
|
|
@Override
|
|
|
|
public void onSaveInstanceState(final Bundle outState) {
|
2015-03-14 16:11:20 +01:00
|
|
|
outState.putParcelable(EXTRA_USER, getUser());
|
2014-12-07 16:13:07 +01:00
|
|
|
super.onSaveInstanceState(outState);
|
|
|
|
}
|
|
|
|
|
2014-12-01 10:15:20 +01:00
|
|
|
@Override
|
|
|
|
public void onDestroyView() {
|
|
|
|
mUser = null;
|
|
|
|
mRelationship = null;
|
|
|
|
final LoaderManager lm = getLoaderManager();
|
|
|
|
lm.destroyLoader(LOADER_ID_USER);
|
|
|
|
lm.destroyLoader(LOADER_ID_FRIENDSHIP);
|
|
|
|
super.onDestroyView();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onCreateOptionsMenu(final Menu menu, final MenuInflater inflater) {
|
|
|
|
if (!shouldUseNativeMenu()) return;
|
|
|
|
inflater.inflate(R.menu.menu_user_profile, menu);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onPrepareOptionsMenu(final Menu menu) {
|
|
|
|
if (!shouldUseNativeMenu() || !menu.hasVisibleItems()) return;
|
2014-12-24 05:39:21 +01:00
|
|
|
final AsyncTwitterWrapper twitter = getTwitterWrapper();
|
2015-03-14 16:11:20 +01:00
|
|
|
final ParcelableUser user = getUser();
|
2014-12-24 05:39:21 +01:00
|
|
|
final Relationship relationship = mRelationship;
|
|
|
|
if (twitter == null || user == null) return;
|
|
|
|
final boolean isMyself = user.account_id == user.id;
|
|
|
|
final MenuItem mentionItem = menu.findItem(MENU_MENTION);
|
|
|
|
if (mentionItem != null) {
|
2015-01-03 16:16:50 +01:00
|
|
|
mentionItem.setTitle(getString(R.string.mention_user_name, UserColorNameUtils.getDisplayName(getActivity(), user)));
|
2014-12-24 05:39:21 +01:00
|
|
|
}
|
|
|
|
Utils.setMenuItemAvailability(menu, MENU_MENTION, !isMyself);
|
2015-02-17 06:49:23 +01:00
|
|
|
Utils.setMenuItemAvailability(menu, R.id.incoming_friendships, isMyself);
|
2014-12-24 05:39:21 +01:00
|
|
|
// final MenuItem followItem = menu.findItem(MENU_FOLLOW);
|
|
|
|
// followItem.setVisible(!isMyself);
|
|
|
|
// final boolean shouldShowFollowItem = !creatingFriendship && !destroyingFriendship && !isMyself
|
|
|
|
// && relationship != null;
|
|
|
|
// followItem.setEnabled(shouldShowFollowItem);
|
|
|
|
// if (shouldShowFollowItem) {
|
|
|
|
// followItem.setTitle(isFollowing ? R.string.unfollow : isProtected ? R.string.send_follow_request
|
|
|
|
// : R.string.follow);
|
|
|
|
// followItem.setIcon(isFollowing ? R.drawable.ic_action_cancel : R.drawable.ic_action_add);
|
|
|
|
// } else {
|
|
|
|
// followItem.setTitle(null);
|
|
|
|
// followItem.setIcon(null);
|
|
|
|
// }
|
|
|
|
if (!isMyself && relationship != null) {
|
|
|
|
setMenuItemAvailability(menu, MENU_SEND_DIRECT_MESSAGE, relationship.canSourceDMTarget());
|
|
|
|
setMenuItemAvailability(menu, MENU_BLOCK, true);
|
|
|
|
setMenuItemAvailability(menu, MENU_MUTE_USER, true);
|
|
|
|
final MenuItem blockItem = menu.findItem(MENU_BLOCK);
|
|
|
|
if (blockItem != null) {
|
|
|
|
final boolean blocking = relationship.isSourceBlockingTarget();
|
2015-01-17 19:58:29 +01:00
|
|
|
ActionIconDrawable.setMenuHighlight(blockItem, new TwidereMenuInfo(blocking));
|
2014-12-24 05:39:21 +01:00
|
|
|
blockItem.setTitle(blocking ? R.string.unblock : R.string.block);
|
|
|
|
}
|
|
|
|
final MenuItem muteItem = menu.findItem(MENU_MUTE_USER);
|
|
|
|
if (muteItem != null) {
|
|
|
|
final boolean muting = relationship.isSourceMutingTarget();
|
2015-01-17 19:58:29 +01:00
|
|
|
ActionIconDrawable.setMenuHighlight(muteItem, new TwidereMenuInfo(muting));
|
2014-12-24 05:39:21 +01:00
|
|
|
muteItem.setTitle(muting ? R.string.unmute : R.string.mute);
|
|
|
|
}
|
|
|
|
final MenuItem filterItem = menu.findItem(MENU_ADD_TO_FILTER);
|
|
|
|
if (filterItem != null) {
|
|
|
|
final boolean filtering = Utils.isFilteringUser(getActivity(), user.id);
|
2015-01-17 19:58:29 +01:00
|
|
|
ActionIconDrawable.setMenuHighlight(filterItem, new TwidereMenuInfo(filtering));
|
2014-12-24 05:39:21 +01:00
|
|
|
filterItem.setTitle(filtering ? R.string.remove_from_filter : R.string.add_to_filter);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
setMenuItemAvailability(menu, MENU_SEND_DIRECT_MESSAGE, false);
|
|
|
|
setMenuItemAvailability(menu, MENU_BLOCK, false);
|
|
|
|
setMenuItemAvailability(menu, MENU_MUTE_USER, false);
|
|
|
|
setMenuItemAvailability(menu, MENU_REPORT_SPAM, false);
|
|
|
|
}
|
|
|
|
setMenuItemAvailability(menu, R.id.muted_users, isMyself);
|
|
|
|
setMenuItemAvailability(menu, R.id.blocked_users, isMyself);
|
|
|
|
final Intent intent = new Intent(INTENT_ACTION_EXTENSION_OPEN_USER);
|
|
|
|
final Bundle extras = new Bundle();
|
|
|
|
extras.putParcelable(EXTRA_USER, user);
|
|
|
|
intent.putExtras(extras);
|
|
|
|
menu.removeGroup(MENU_GROUP_USER_EXTENSION);
|
|
|
|
addIntentToMenu(getActivity(), menu, intent, MENU_GROUP_USER_EXTENSION);
|
2014-12-01 10:15:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public boolean onOptionsItemSelected(final MenuItem item) {
|
2014-12-24 05:39:21 +01:00
|
|
|
final AsyncTwitterWrapper twitter = getTwitterWrapper();
|
2015-03-14 16:11:20 +01:00
|
|
|
final ParcelableUser user = getUser();
|
2014-12-24 05:39:21 +01:00
|
|
|
final Relationship relationship = mRelationship;
|
|
|
|
if (user == null || twitter == null) return false;
|
|
|
|
switch (item.getItemId()) {
|
|
|
|
case MENU_BLOCK: {
|
|
|
|
if (mRelationship != null) {
|
|
|
|
if (mRelationship.isSourceBlockingTarget()) {
|
|
|
|
twitter.destroyBlockAsync(user.account_id, user.id);
|
|
|
|
} else {
|
|
|
|
CreateUserBlockDialogFragment.show(getFragmentManager(), user);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MENU_REPORT_SPAM: {
|
|
|
|
ReportSpamDialogFragment.show(getFragmentManager(), user);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MENU_ADD_TO_FILTER: {
|
|
|
|
final boolean filtering = Utils.isFilteringUser(getActivity(), user.id);
|
|
|
|
final ContentResolver cr = getContentResolver();
|
|
|
|
if (filtering) {
|
|
|
|
final Expression where = Expression.equals(Filters.Users.USER_ID, user.id);
|
|
|
|
cr.delete(Filters.Users.CONTENT_URI, where.getSQL(), null);
|
|
|
|
showInfoMessage(getActivity(), R.string.message_user_unmuted, false);
|
|
|
|
} else {
|
2015-01-08 10:13:20 +01:00
|
|
|
cr.insert(Filters.Users.CONTENT_URI, ContentValuesCreator.createFilteredUser(user));
|
2014-12-24 05:39:21 +01:00
|
|
|
showInfoMessage(getActivity(), R.string.message_user_muted, false);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MENU_MUTE_USER: {
|
|
|
|
if (mRelationship != null) {
|
|
|
|
if (mRelationship.isSourceMutingTarget()) {
|
|
|
|
twitter.destroyMuteAsync(user.account_id, user.id);
|
|
|
|
} else {
|
|
|
|
CreateUserMuteDialogFragment.show(getFragmentManager(), user);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MENU_MENTION: {
|
|
|
|
final Intent intent = new Intent(INTENT_ACTION_MENTION);
|
|
|
|
final Bundle bundle = new Bundle();
|
|
|
|
bundle.putParcelable(EXTRA_USER, user);
|
|
|
|
intent.putExtras(bundle);
|
|
|
|
startActivity(intent);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MENU_SEND_DIRECT_MESSAGE: {
|
|
|
|
final Uri.Builder builder = new Uri.Builder();
|
|
|
|
builder.scheme(SCHEME_TWIDERE);
|
|
|
|
builder.authority(AUTHORITY_DIRECT_MESSAGES_CONVERSATION);
|
|
|
|
builder.appendQueryParameter(QUERY_PARAM_ACCOUNT_ID, String.valueOf(user.account_id));
|
|
|
|
builder.appendQueryParameter(QUERY_PARAM_USER_ID, String.valueOf(user.id));
|
|
|
|
final Intent intent = new Intent(Intent.ACTION_VIEW, builder.build());
|
|
|
|
intent.putExtra(EXTRA_ACCOUNT, ParcelableCredentials.getAccount(getActivity(), user.account_id));
|
|
|
|
intent.putExtra(EXTRA_USER, user);
|
|
|
|
startActivity(intent);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MENU_SET_COLOR: {
|
|
|
|
final Intent intent = new Intent(getActivity(), ColorPickerDialogActivity.class);
|
|
|
|
intent.putExtra(EXTRA_COLOR, getUserColor(getActivity(), user.id, true));
|
|
|
|
intent.putExtra(EXTRA_ALPHA_SLIDER, false);
|
|
|
|
intent.putExtra(EXTRA_CLEAR_BUTTON, true);
|
|
|
|
startActivityForResult(intent, REQUEST_SET_COLOR);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MENU_CLEAR_NICKNAME: {
|
|
|
|
clearUserNickname(getActivity(), user.id);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MENU_SET_NICKNAME: {
|
|
|
|
final String nick = getUserNickname(getActivity(), user.id, true);
|
|
|
|
SetUserNicknameDialogFragment.show(getFragmentManager(), user.id, nick);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MENU_ADD_TO_LIST: {
|
|
|
|
final Intent intent = new Intent(INTENT_ACTION_SELECT_USER_LIST);
|
|
|
|
intent.setClass(getActivity(), UserListSelectorActivity.class);
|
|
|
|
intent.putExtra(EXTRA_ACCOUNT_ID, user.account_id);
|
|
|
|
intent.putExtra(EXTRA_SCREEN_NAME, getAccountScreenName(getActivity(), user.account_id));
|
|
|
|
startActivityForResult(intent, REQUEST_ADD_TO_LIST);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MENU_OPEN_WITH_ACCOUNT: {
|
|
|
|
final Intent intent = new Intent(INTENT_ACTION_SELECT_ACCOUNT);
|
|
|
|
intent.setClass(getActivity(), AccountSelectorActivity.class);
|
|
|
|
intent.putExtra(EXTRA_SINGLE_SELECTION, true);
|
|
|
|
startActivityForResult(intent, REQUEST_SELECT_ACCOUNT);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MENU_FOLLOW: {
|
|
|
|
if (relationship == null) return false;
|
|
|
|
final boolean isFollowing = relationship.isSourceFollowingTarget();
|
|
|
|
final boolean isCreatingFriendship = twitter.isCreatingFriendship(user.account_id, user.id);
|
|
|
|
final boolean isDestroyingFriendship = twitter.isDestroyingFriendship(user.account_id, user.id);
|
|
|
|
if (!isCreatingFriendship && !isDestroyingFriendship) {
|
|
|
|
if (isFollowing) {
|
|
|
|
DestroyFriendshipDialogFragment.show(getFragmentManager(), user);
|
|
|
|
} else {
|
|
|
|
twitter.createFriendshipAsync(user.account_id, user.id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case R.id.muted_users: {
|
|
|
|
openMutesUsers(getActivity(), user.account_id);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case R.id.blocked_users: {
|
|
|
|
openUserBlocks(getActivity(), user.account_id);
|
|
|
|
return true;
|
|
|
|
}
|
2015-01-10 16:17:02 +01:00
|
|
|
case R.id.incoming_friendships: {
|
|
|
|
openIncomingFriendships(getActivity(), user.account_id);
|
|
|
|
return true;
|
|
|
|
}
|
2014-12-24 05:39:21 +01:00
|
|
|
default: {
|
|
|
|
if (item.getIntent() != null) {
|
|
|
|
try {
|
|
|
|
startActivity(item.getIntent());
|
|
|
|
} catch (final ActivityNotFoundException e) {
|
|
|
|
Log.w(LOGTAG, e);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
2014-12-01 10:15:20 +01:00
|
|
|
}
|
|
|
|
|
2014-12-01 08:00:37 +01:00
|
|
|
@Override
|
|
|
|
public void onClick(final View view) {
|
|
|
|
final FragmentActivity activity = getActivity();
|
2015-03-14 16:11:20 +01:00
|
|
|
final ParcelableUser user = getUser();
|
2014-12-01 08:00:37 +01:00
|
|
|
if (activity == null || user == null) return;
|
|
|
|
switch (view.getId()) {
|
|
|
|
case R.id.retry: {
|
|
|
|
getUserInfo(true);
|
|
|
|
break;
|
|
|
|
}
|
2014-12-04 16:01:16 +01:00
|
|
|
case R.id.follow: {
|
2014-12-10 13:15:09 +01:00
|
|
|
if (user.id == user.account_id) {
|
|
|
|
final Bundle extras = new Bundle();
|
|
|
|
extras.putLong(EXTRA_ACCOUNT_ID, user.account_id);
|
|
|
|
final Intent intent = new Intent(INTENT_ACTION_EDIT_USER_PROFILE);
|
|
|
|
intent.setClass(getActivity(), UserProfileEditorActivity.class);
|
|
|
|
intent.putExtras(extras);
|
|
|
|
startActivity(intent);
|
|
|
|
break;
|
|
|
|
}
|
2014-12-04 16:01:16 +01:00
|
|
|
final Relationship relationship = mRelationship;
|
|
|
|
final AsyncTwitterWrapper twitter = getTwitterWrapper();
|
|
|
|
if (relationship == null || twitter == null) return;
|
|
|
|
if (relationship.isSourceBlockingTarget()) {
|
|
|
|
twitter.destroyBlockAsync(user.account_id, user.id);
|
|
|
|
} else if (relationship.isSourceFollowingTarget()) {
|
|
|
|
DestroyFriendshipDialogFragment.show(getFragmentManager(), user);
|
|
|
|
} else {
|
|
|
|
twitter.createFriendshipAsync(user.account_id, user.id);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-12-01 08:00:37 +01:00
|
|
|
case R.id.profile_image: {
|
2015-01-23 17:09:03 +01:00
|
|
|
final String url = getOriginalTwitterProfileImage(user.profile_image_url);
|
|
|
|
final ParcelableMedia[] media = {ParcelableMedia.newImage(url, url)};
|
|
|
|
Utils.openMedia(activity, user.account_id, false, null, media);
|
2014-12-01 08:00:37 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case R.id.profile_banner: {
|
2015-01-23 17:09:03 +01:00
|
|
|
if (user.profile_banner_url == null) return;
|
|
|
|
final String url = user.profile_banner_url + "/ipad_retina";
|
|
|
|
final ParcelableMedia[] media = {ParcelableMedia.newImage(url, url)};
|
|
|
|
Utils.openMedia(activity, user.account_id, false, null, media);
|
2014-12-01 08:00:37 +01:00
|
|
|
break;
|
|
|
|
}
|
2014-12-01 10:15:20 +01:00
|
|
|
case R.id.listed_container: {
|
|
|
|
openUserLists(getActivity(), user.account_id, user.id, user.screen_name);
|
2014-12-01 08:00:37 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case R.id.followers_container: {
|
|
|
|
openUserFollowers(getActivity(), user.account_id, user.id, user.screen_name);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case R.id.friends_container: {
|
|
|
|
openUserFriends(getActivity(), user.account_id, user.id, user.screen_name);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case R.id.name_container: {
|
|
|
|
if (user.account_id != user.id) return;
|
|
|
|
startActivity(new Intent(getActivity(), UserProfileEditorActivity.class));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onLinkClick(final String link, final String orig, final long account_id, final int type,
|
2015-01-23 17:09:03 +01:00
|
|
|
final boolean sensitive, int start, int end) {
|
2015-03-14 16:11:20 +01:00
|
|
|
final ParcelableUser user = getUser();
|
2014-12-01 08:00:37 +01:00
|
|
|
if (user == null) return;
|
|
|
|
switch (type) {
|
|
|
|
case TwidereLinkify.LINK_TYPE_MENTION: {
|
|
|
|
openUserProfile(getActivity(), user.account_id, -1, link, null);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case TwidereLinkify.LINK_TYPE_HASHTAG: {
|
|
|
|
openTweetSearch(getActivity(), user.account_id, "#" + link);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case TwidereLinkify.LINK_TYPE_LINK: {
|
|
|
|
final Uri uri = Uri.parse(link);
|
|
|
|
final Intent intent;
|
|
|
|
if (uri.getScheme() != null) {
|
|
|
|
intent = new Intent(Intent.ACTION_VIEW, uri);
|
|
|
|
} else {
|
|
|
|
intent = new Intent(Intent.ACTION_VIEW, uri.buildUpon().scheme("http").build());
|
|
|
|
}
|
|
|
|
startActivity(intent);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case TwidereLinkify.LINK_TYPE_LIST: {
|
|
|
|
if (link == null) break;
|
|
|
|
final String[] mentionList = link.split("/");
|
|
|
|
if (mentionList.length != 2) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case TwidereLinkify.LINK_TYPE_STATUS: {
|
|
|
|
openStatus(getActivity(), account_id, parseLong(link));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onSharedPreferenceChanged(final SharedPreferences sharedPreferences, final String key) {
|
|
|
|
if (mUser == null || !ParseUtils.parseString(mUser.id).equals(key)) return;
|
|
|
|
displayUser(mUser);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onSizeChanged(final View view, final int w, final int h, final int oldw, final int oldh) {
|
|
|
|
mBannerWidth = w;
|
|
|
|
if (w != oldw || h != oldh) {
|
|
|
|
requestFitSystemWindows();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public boolean onTouch(final View v, final MotionEvent event) {
|
|
|
|
return mProfileBannerView.dispatchTouchEvent(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2015-01-26 17:09:02 +01:00
|
|
|
public void onBaseViewCreated(final View view, final Bundle savedInstanceState) {
|
|
|
|
super.onBaseViewCreated(view, savedInstanceState);
|
2014-12-01 17:04:55 +01:00
|
|
|
mHeaderDrawerLayout = (HeaderDrawerLayout) view.findViewById(R.id.user_profile_drawer);
|
|
|
|
final View headerView = mHeaderDrawerLayout.getHeader();
|
|
|
|
final View contentView = mHeaderDrawerLayout.getContent();
|
2014-12-03 11:27:11 +01:00
|
|
|
mCardContent = headerView.findViewById(R.id.card_content);
|
|
|
|
mErrorRetryContainer = headerView.findViewById(R.id.error_retry_container);
|
|
|
|
mProgressContainer = headerView.findViewById(R.id.progress_container);
|
|
|
|
mRetryButton = (Button) headerView.findViewById(R.id.retry);
|
|
|
|
mErrorMessageView = (TextView) headerView.findViewById(R.id.error_message);
|
|
|
|
mProfileBannerView = (ProfileBannerImageView) view.findViewById(R.id.profile_banner);
|
|
|
|
mProfileBannerContainer = view.findViewById(R.id.profile_banner_container);
|
2014-12-01 17:29:34 +01:00
|
|
|
mCardView = (CardView) headerView.findViewById(R.id.card);
|
2014-12-01 08:00:37 +01:00
|
|
|
mNameView = (TextView) headerView.findViewById(R.id.name);
|
|
|
|
mScreenNameView = (TextView) headerView.findViewById(R.id.screen_name);
|
|
|
|
mDescriptionView = (TextView) headerView.findViewById(R.id.description);
|
|
|
|
mLocationView = (TextView) headerView.findViewById(R.id.location);
|
|
|
|
mURLView = (TextView) headerView.findViewById(R.id.url);
|
|
|
|
mCreatedAtView = (TextView) headerView.findViewById(R.id.created_at);
|
2014-12-01 10:15:20 +01:00
|
|
|
mListedContainer = headerView.findViewById(R.id.listed_container);
|
|
|
|
mListedCount = (TextView) headerView.findViewById(R.id.listed_count);
|
2014-12-01 08:00:37 +01:00
|
|
|
mFollowersContainer = headerView.findViewById(R.id.followers_container);
|
|
|
|
mFollowersCount = (TextView) headerView.findViewById(R.id.followers_count);
|
|
|
|
mFriendsContainer = headerView.findViewById(R.id.friends_container);
|
|
|
|
mFriendsCount = (TextView) headerView.findViewById(R.id.friends_count);
|
2014-12-03 11:27:11 +01:00
|
|
|
mProfileNameContainer = (IColorLabelView) headerView.findViewById(R.id.profile_name_container);
|
2014-12-24 05:39:21 +01:00
|
|
|
mProfileImageView = (ShapedImageView) headerView.findViewById(R.id.profile_image);
|
2014-12-01 08:00:37 +01:00
|
|
|
mProfileTypeView = (ImageView) headerView.findViewById(R.id.profile_type);
|
|
|
|
mDescriptionContainer = headerView.findViewById(R.id.description_container);
|
|
|
|
mLocationContainer = headerView.findViewById(R.id.location_container);
|
|
|
|
mURLContainer = headerView.findViewById(R.id.url_container);
|
|
|
|
mProfileBannerSpace = headerView.findViewById(R.id.profile_banner_space);
|
|
|
|
mViewPager = (ViewPager) contentView.findViewById(R.id.view_pager);
|
2014-12-12 14:53:18 +01:00
|
|
|
mPagerIndicator = (TabPagerIndicator) contentView.findViewById(R.id.view_pager_tabs);
|
2014-12-03 11:27:11 +01:00
|
|
|
mFollowButton = (Button) headerView.findViewById(R.id.follow);
|
2014-12-07 16:13:07 +01:00
|
|
|
mFollowProgress = (ProgressBar) headerView.findViewById(R.id.follow_progress);
|
2014-12-01 17:04:55 +01:00
|
|
|
mUuckyFooter = headerView.findViewById(R.id.uucky_footer);
|
2015-01-17 19:58:29 +01:00
|
|
|
mPagesContent = view.findViewById(R.id.pages_content);
|
|
|
|
mPagesErrorContainer = view.findViewById(R.id.pages_error_container);
|
2015-03-19 21:13:01 +01:00
|
|
|
mPagesErrorIcon = (ImageView) view.findViewById(R.id.pages_error_icon);
|
2015-01-17 19:58:29 +01:00
|
|
|
mPagesErrorText = (TextView) view.findViewById(R.id.pages_error_text);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
|
|
|
|
2014-12-01 10:15:20 +01:00
|
|
|
@Override
|
|
|
|
protected void fitSystemWindows(Rect insets) {
|
|
|
|
super.fitSystemWindows(insets);
|
2014-12-01 17:04:55 +01:00
|
|
|
mHeaderDrawerLayout.setPadding(insets.left, insets.top, insets.right, insets.bottom);
|
2014-12-08 16:16:33 +01:00
|
|
|
final FragmentActivity activity = getActivity();
|
|
|
|
final boolean isTransparentBackground;
|
|
|
|
if (activity instanceof IThemedActivity) {
|
|
|
|
final int themeRes = ((IThemedActivity) activity).getCurrentThemeResourceId();
|
|
|
|
isTransparentBackground = ThemeUtils.isTransparentBackground(themeRes);
|
|
|
|
} else {
|
|
|
|
isTransparentBackground = ThemeUtils.isTransparentBackground(getActivity());
|
|
|
|
}
|
|
|
|
mHeaderDrawerLayout.setClipToPadding(isTransparentBackground);
|
2014-12-01 10:15:20 +01:00
|
|
|
}
|
|
|
|
|
2014-12-01 17:04:55 +01:00
|
|
|
public void setListShown(boolean shown) {
|
|
|
|
final TintedStatusFrameLayout tintedStatus = mTintedStatusContent;
|
|
|
|
if (tintedStatus == null) return;
|
|
|
|
final FragmentActivity activity = getActivity();
|
|
|
|
final LinkHandlerActivity linkHandler = (LinkHandlerActivity) activity;
|
|
|
|
final boolean drawColor = !ThemeUtils.isDarkTheme(linkHandler.getCurrentThemeResourceId());
|
|
|
|
tintedStatus.setDrawShadow(shown);
|
|
|
|
tintedStatus.setDrawColor(drawColor);
|
|
|
|
}
|
|
|
|
|
2014-12-01 08:00:37 +01:00
|
|
|
private void getFriendship() {
|
2014-12-08 16:16:33 +01:00
|
|
|
mRelationship = null;
|
2015-03-14 16:11:20 +01:00
|
|
|
final ParcelableUser user = getUser();
|
2014-12-01 08:00:37 +01:00
|
|
|
final LoaderManager lm = getLoaderManager();
|
|
|
|
lm.destroyLoader(LOADER_ID_FRIENDSHIP);
|
|
|
|
final Bundle args = new Bundle();
|
|
|
|
args.putLong(EXTRA_ACCOUNT_ID, user.account_id);
|
|
|
|
args.putLong(EXTRA_USER_ID, user.id);
|
|
|
|
if (!mGetFriendShipLoaderInitialized) {
|
|
|
|
lm.initLoader(LOADER_ID_FRIENDSHIP, args, mFriendshipLoaderCallbacks);
|
|
|
|
mGetFriendShipLoaderInitialized = true;
|
|
|
|
} else {
|
|
|
|
lm.restartLoader(LOADER_ID_FRIENDSHIP, args, mFriendshipLoaderCallbacks);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private void getUserInfo(final boolean omitIntentExtra) {
|
|
|
|
final ParcelableUser user = mUser;
|
|
|
|
if (user == null) return;
|
|
|
|
getUserInfo(user.account_id, user.id, user.screen_name, omitIntentExtra);
|
|
|
|
}
|
|
|
|
|
2014-12-01 17:04:55 +01:00
|
|
|
private boolean isUucky(long userId, String screenName, Parcelable parcelable) {
|
|
|
|
if (userId == UUCKY_ID || UUCKY_SCREEN_NAME.equalsIgnoreCase(screenName)) return true;
|
|
|
|
if (parcelable instanceof ParcelableUser) {
|
|
|
|
final ParcelableUser user = (ParcelableUser) parcelable;
|
|
|
|
return user.id == UUCKY_ID || UUCKY_SCREEN_NAME.equalsIgnoreCase(user.screen_name);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-12-07 16:13:07 +01:00
|
|
|
private void updateFollowProgressState() {
|
|
|
|
final AsyncTwitterWrapper twitter = getTwitterWrapper();
|
2015-03-14 16:11:20 +01:00
|
|
|
final ParcelableUser user = getUser();
|
2014-12-07 16:13:07 +01:00
|
|
|
if (twitter == null || user == null) {
|
|
|
|
mFollowButton.setVisibility(View.GONE);
|
|
|
|
mFollowProgress.setVisibility(View.GONE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
final LoaderManager lm = getLoaderManager();
|
|
|
|
final boolean loadingRelationship = lm.getLoader(LOADER_ID_FRIENDSHIP) != null;
|
|
|
|
final boolean creatingFriendship = twitter.isCreatingFriendship(user.account_id, user.id);
|
|
|
|
final boolean destroyingFriendship = twitter.isDestroyingFriendship(user.account_id, user.id);
|
|
|
|
final boolean creatingBlock = twitter.isCreatingFriendship(user.account_id, user.id);
|
|
|
|
final boolean destroyingBlock = twitter.isDestroyingFriendship(user.account_id, user.id);
|
|
|
|
if (loadingRelationship || creatingFriendship || destroyingFriendship || creatingBlock || destroyingBlock) {
|
|
|
|
mFollowButton.setVisibility(View.GONE);
|
|
|
|
mFollowProgress.setVisibility(View.VISIBLE);
|
|
|
|
} else if (mRelationship != null) {
|
|
|
|
mFollowButton.setVisibility(View.VISIBLE);
|
|
|
|
mFollowProgress.setVisibility(View.GONE);
|
|
|
|
} else {
|
|
|
|
mFollowButton.setVisibility(View.GONE);
|
|
|
|
mFollowProgress.setVisibility(View.GONE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-01 17:04:55 +01:00
|
|
|
private void setupBaseActionBar() {
|
|
|
|
final FragmentActivity activity = getActivity();
|
|
|
|
if (!(activity instanceof LinkHandlerActivity)) return;
|
|
|
|
final LinkHandlerActivity linkHandler = (LinkHandlerActivity) activity;
|
2015-01-17 19:58:29 +01:00
|
|
|
final ActionBar actionBar = linkHandler.getSupportActionBar();
|
2014-12-01 17:04:55 +01:00
|
|
|
if (actionBar == null) return;
|
|
|
|
final int themeResId = linkHandler.getCurrentThemeResourceId();
|
2015-03-31 13:05:19 +02:00
|
|
|
final Drawable shadow = ResourcesCompat.getDrawable(activity.getResources(), R.drawable.shadow_user_banner_action_bar, null);
|
2014-12-01 17:04:55 +01:00
|
|
|
final Drawable background = ThemeUtils.getActionBarBackground(activity, themeResId);
|
|
|
|
mActionBarBackground = new ActionBarDrawable(getResources(), shadow, background, ThemeUtils.isDarkTheme(themeResId));
|
2014-12-04 15:31:29 +01:00
|
|
|
mActionBarBackground.setAlpha(linkHandler.getCurrentThemeBackgroundAlpha());
|
|
|
|
mProfileBannerView.setAlpha(linkHandler.getCurrentThemeBackgroundAlpha() / 255f);
|
2014-12-01 17:04:55 +01:00
|
|
|
actionBar.setBackgroundDrawable(mActionBarBackground);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
|
|
|
|
2015-01-22 12:16:22 +01:00
|
|
|
private void setUserUiColor(int color) {
|
2014-12-01 17:04:55 +01:00
|
|
|
if (mActionBarBackground == null) {
|
|
|
|
setupBaseActionBar();
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
2014-12-01 17:04:55 +01:00
|
|
|
mActionBarBackground.setColor(color);
|
|
|
|
mTintedStatusContent.setColor(color, ThemeUtils.getThemeAlpha(getActivity()));
|
2014-12-12 14:53:18 +01:00
|
|
|
mPagerIndicator.setStripColor(color);
|
2014-12-24 05:39:21 +01:00
|
|
|
mDescriptionView.setLinkTextColor(color);
|
|
|
|
mLocationView.setLinkTextColor(color);
|
|
|
|
mURLView.setLinkTextColor(color);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
|
|
|
|
2014-12-01 17:04:55 +01:00
|
|
|
private void setupUserPages() {
|
|
|
|
final Context context = getActivity();
|
|
|
|
final Bundle args = getArguments(), tabArgs = new Bundle();
|
|
|
|
final long accountId;
|
|
|
|
if (args.containsKey(EXTRA_USER)) {
|
|
|
|
final ParcelableUser user = args.getParcelable(EXTRA_USER);
|
|
|
|
tabArgs.putLong(EXTRA_ACCOUNT_ID, accountId = user.account_id);
|
|
|
|
tabArgs.putLong(EXTRA_USER_ID, user.id);
|
|
|
|
tabArgs.putString(EXTRA_SCREEN_NAME, user.screen_name);
|
|
|
|
} else {
|
|
|
|
accountId = args.getLong(EXTRA_ACCOUNT_ID, -1);
|
|
|
|
tabArgs.putLong(EXTRA_ACCOUNT_ID, accountId);
|
|
|
|
tabArgs.putLong(EXTRA_USER_ID, args.getLong(EXTRA_USER_ID, -1));
|
|
|
|
tabArgs.putString(EXTRA_SCREEN_NAME, args.getString(EXTRA_SCREEN_NAME));
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
2014-12-12 14:53:18 +01:00
|
|
|
mPagerAdapter.addTab(UserTimelineFragment.class, tabArgs, getString(R.string.statuses), R.drawable.ic_action_quote, 0);
|
2014-12-01 17:04:55 +01:00
|
|
|
if (Utils.isOfficialKeyAccount(context, accountId)) {
|
2014-12-12 14:53:18 +01:00
|
|
|
mPagerAdapter.addTab(UserMediaTimelineFragment.class, tabArgs, getString(R.string.media), R.drawable.ic_action_gallery, 1);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
2014-12-12 14:53:18 +01:00
|
|
|
mPagerAdapter.addTab(UserFavoritesFragment.class, tabArgs, getString(R.string.favorites), R.drawable.ic_action_star, 2);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
|
|
|
|
2014-12-01 17:04:55 +01:00
|
|
|
private boolean shouldUseNativeMenu() {
|
|
|
|
return getActivity() instanceof LinkHandlerActivity;
|
2014-12-01 10:15:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private void updateScrollOffset(int offset) {
|
|
|
|
final View space = mProfileBannerSpace;
|
2014-12-03 11:27:11 +01:00
|
|
|
final ProfileBannerImageView profileBannerView = mProfileBannerView;
|
|
|
|
final View profileBannerContainer = mProfileBannerContainer;
|
2014-12-01 17:04:55 +01:00
|
|
|
final int spaceHeight = space.getHeight();
|
|
|
|
final float factor = MathUtils.clamp(offset / (float) spaceHeight, 0, 1);
|
2014-12-04 15:31:29 +01:00
|
|
|
profileBannerContainer.setTranslationY(Math.max(-offset, -spaceHeight));
|
2014-12-03 11:27:11 +01:00
|
|
|
profileBannerView.setTranslationY(Math.min(offset, spaceHeight) / 2);
|
2014-12-01 08:00:37 +01:00
|
|
|
|
2014-12-01 17:04:55 +01:00
|
|
|
if (mActionBarBackground != null && mTintedStatusContent != null) {
|
2014-12-01 08:00:37 +01:00
|
|
|
mActionBarBackground.setFactor(factor);
|
2014-12-01 17:04:55 +01:00
|
|
|
mTintedStatusContent.setFactor(factor);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
2014-12-13 16:14:47 +01:00
|
|
|
updateTitleColor();
|
|
|
|
}
|
|
|
|
|
|
|
|
private void updateTitleColor() {
|
|
|
|
final int[] location = new int[2];
|
|
|
|
mNameView.getLocationOnScreen(location);
|
|
|
|
final float nameShowingRatio = (mHeaderDrawerLayout.getPaddingTop() - location[1])
|
|
|
|
/ (float) mNameView.getHeight();
|
|
|
|
final int textAlpha = Math.round(0xFF * MathUtils.clamp(nameShowingRatio, 0, 1));
|
|
|
|
final FragmentActivity activity = getActivity();
|
|
|
|
final SpannableStringBuilder spannedTitle;
|
|
|
|
final CharSequence title = activity.getTitle();
|
|
|
|
if (title instanceof SpannableStringBuilder) {
|
|
|
|
spannedTitle = (SpannableStringBuilder) title;
|
|
|
|
} else {
|
|
|
|
spannedTitle = SpannableStringBuilder.valueOf(title);
|
|
|
|
}
|
|
|
|
final TextAlphaSpan[] spans = spannedTitle.getSpans(0, spannedTitle.length(), TextAlphaSpan.class);
|
|
|
|
if (spans.length > 0) {
|
|
|
|
spans[0].setAlpha(textAlpha);
|
|
|
|
} else {
|
|
|
|
spannedTitle.setSpan(new TextAlphaSpan(textAlpha), 0, spannedTitle.length(),
|
|
|
|
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
|
|
}
|
|
|
|
activity.setTitle(spannedTitle);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
|
|
|
|
2014-12-04 16:01:16 +01:00
|
|
|
static class RelationshipLoader extends AsyncTaskLoader<SingleResponse<Relationship>> {
|
2014-12-01 08:00:37 +01:00
|
|
|
|
|
|
|
private final Context context;
|
|
|
|
private final long account_id, user_id;
|
|
|
|
|
2014-12-04 16:01:16 +01:00
|
|
|
public RelationshipLoader(final Context context, final long account_id, final long user_id) {
|
2014-12-01 08:00:37 +01:00
|
|
|
super(context);
|
|
|
|
this.context = context;
|
|
|
|
this.account_id = account_id;
|
|
|
|
this.user_id = user_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public SingleResponse<Relationship> loadInBackground() {
|
2015-01-10 16:17:02 +01:00
|
|
|
if (account_id == user_id) return SingleResponse.getInstance();
|
2014-12-01 08:00:37 +01:00
|
|
|
final Twitter twitter = getTwitterInstance(context, account_id, false);
|
2015-01-10 16:17:02 +01:00
|
|
|
if (twitter == null) return SingleResponse.getInstance();
|
2014-12-01 08:00:37 +01:00
|
|
|
try {
|
2015-01-14 09:47:51 +01:00
|
|
|
final Relationship relationship = twitter.showFriendship(account_id, user_id);
|
|
|
|
if (relationship.isSourceBlockingTarget() || relationship.isSourceBlockedByTarget()) {
|
2015-01-10 16:17:02 +01:00
|
|
|
Utils.setLastSeen(context, user_id, -1);
|
|
|
|
} else {
|
|
|
|
Utils.setLastSeen(context, user_id, System.currentTimeMillis());
|
|
|
|
}
|
2015-01-14 09:47:51 +01:00
|
|
|
Utils.updateRelationship(context, relationship, account_id);
|
|
|
|
return SingleResponse.getInstance(relationship);
|
2014-12-01 08:00:37 +01:00
|
|
|
} catch (final TwitterException e) {
|
2015-01-10 16:17:02 +01:00
|
|
|
return SingleResponse.getInstance(e);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
protected void onStartLoading() {
|
|
|
|
forceLoad();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private static class ActionBarDrawable extends LayerDrawable {
|
|
|
|
|
|
|
|
private final Drawable mShadowDrawable;
|
|
|
|
private final Drawable mBackgroundDrawable;
|
|
|
|
private final LineBackgroundDrawable mLineDrawable;
|
|
|
|
private final ColorDrawable mColorDrawable;
|
|
|
|
private final boolean mColorLineOnly;
|
|
|
|
|
|
|
|
private float mFactor;
|
|
|
|
private int mColor;
|
2014-12-01 17:04:55 +01:00
|
|
|
private int mAlpha;
|
2014-12-01 08:00:37 +01:00
|
|
|
|
|
|
|
public ActionBarDrawable(Resources resources, Drawable shadow, Drawable background,
|
|
|
|
boolean colorLineOnly) {
|
|
|
|
super(new Drawable[]{shadow, background, new LineBackgroundDrawable(resources, 2.0f),
|
2015-04-01 12:28:26 +02:00
|
|
|
new ActionBarColorDrawable(true)});
|
2015-01-17 19:58:29 +01:00
|
|
|
mShadowDrawable = getDrawable(0);
|
2014-12-01 08:00:37 +01:00
|
|
|
mBackgroundDrawable = getDrawable(1);
|
|
|
|
mLineDrawable = (LineBackgroundDrawable) getDrawable(2);
|
|
|
|
mColorDrawable = (ColorDrawable) getDrawable(3);
|
|
|
|
mColorLineOnly = colorLineOnly;
|
2014-12-01 17:04:55 +01:00
|
|
|
setAlpha(0xFF);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
|
|
|
|
@Override
|
|
|
|
public void getOutline(Outline outline) {
|
|
|
|
final boolean showColor = !mColorLineOnly && mColor != 0;
|
|
|
|
if (showColor) {
|
|
|
|
mColorDrawable.getOutline(outline);
|
|
|
|
} else {
|
|
|
|
mBackgroundDrawable.getOutline(outline);
|
|
|
|
}
|
2014-12-08 16:16:33 +01:00
|
|
|
outline.setAlpha(mFactor * 0.99f);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
|
|
|
|
2014-12-01 17:04:55 +01:00
|
|
|
@Override
|
|
|
|
public void setAlpha(int alpha) {
|
|
|
|
mAlpha = alpha;
|
|
|
|
setFactor(mFactor);
|
|
|
|
}
|
|
|
|
|
2014-12-01 08:00:37 +01:00
|
|
|
@Override
|
|
|
|
public int getIntrinsicWidth() {
|
|
|
|
final boolean showColor = !mColorLineOnly && mColor != 0;
|
|
|
|
if (showColor) {
|
|
|
|
return mColorDrawable.getIntrinsicWidth();
|
|
|
|
} else {
|
|
|
|
return mBackgroundDrawable.getIntrinsicWidth();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public int getIntrinsicHeight() {
|
|
|
|
final boolean showColor = !mColorLineOnly && mColor != 0;
|
|
|
|
if (showColor) {
|
|
|
|
return mColorDrawable.getIntrinsicHeight();
|
|
|
|
} else {
|
|
|
|
return mBackgroundDrawable.getIntrinsicHeight();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-01 17:04:55 +01:00
|
|
|
public void setColor(int color) {
|
|
|
|
mColor = color;
|
2015-01-22 12:16:22 +01:00
|
|
|
mColorDrawable.setColor(color);
|
2014-12-01 17:04:55 +01:00
|
|
|
mLineDrawable.setColor(color);
|
|
|
|
setFactor(mFactor);
|
|
|
|
}
|
|
|
|
|
2014-12-01 08:00:37 +01:00
|
|
|
public void setFactor(float f) {
|
|
|
|
mFactor = f;
|
2014-12-01 17:04:55 +01:00
|
|
|
mShadowDrawable.setAlpha(Math.round(mAlpha * MathUtils.clamp(1 - f, 0, 1)));
|
2014-12-01 08:00:37 +01:00
|
|
|
final boolean hasColor = mColor != 0;
|
|
|
|
final boolean showBackground = mColorLineOnly || !hasColor;
|
|
|
|
final boolean showLine = mColorLineOnly && hasColor;
|
|
|
|
final boolean showColor = !mColorLineOnly && hasColor;
|
2014-12-01 17:04:55 +01:00
|
|
|
mBackgroundDrawable.setAlpha(showBackground ? Math.round(mAlpha * MathUtils.clamp(f, 0, 1)) : 0);
|
|
|
|
mLineDrawable.setAlpha(showLine ? Math.round(mAlpha * MathUtils.clamp(f, 0, 1)) : 0);
|
|
|
|
mColorDrawable.setAlpha(showColor ? Math.round(mAlpha * MathUtils.clamp(f, 0, 1)) : 0);
|
2014-12-01 08:00:37 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
|
|
|
|
private static class LineBackgroundDrawable extends Drawable {
|
|
|
|
|
|
|
|
private final Rect mBounds;
|
|
|
|
private final Paint mPaint;
|
|
|
|
private final float mLineSize;
|
|
|
|
|
|
|
|
private int mAlpha;
|
|
|
|
private int mColor;
|
|
|
|
|
|
|
|
LineBackgroundDrawable(Resources resources, float lineSizeDp) {
|
|
|
|
mBounds = new Rect();
|
|
|
|
mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
|
|
|
|
mLineSize = resources.getDisplayMetrics().density * lineSizeDp;
|
|
|
|
setColor(Color.TRANSPARENT);
|
|
|
|
}
|
|
|
|
|
2014-12-01 10:15:20 +01:00
|
|
|
@Override
|
|
|
|
public void draw(Canvas canvas) {
|
|
|
|
canvas.drawRect(mBounds.left, mBounds.bottom - mLineSize, mBounds.right,
|
|
|
|
mBounds.bottom, mPaint);
|
|
|
|
}
|
|
|
|
|
2014-12-01 17:04:55 +01:00
|
|
|
public int getColor() {
|
|
|
|
return mColor;
|
|
|
|
}
|
|
|
|
|
2014-12-01 17:29:34 +01:00
|
|
|
public void setColor(int color) {
|
|
|
|
mColor = color;
|
|
|
|
updatePaint();
|
|
|
|
}
|
|
|
|
|
2014-12-01 08:00:37 +01:00
|
|
|
@Override
|
|
|
|
protected void onBoundsChange(Rect bounds) {
|
|
|
|
super.onBoundsChange(bounds);
|
|
|
|
mBounds.set(bounds);
|
|
|
|
}
|
|
|
|
|
2014-12-01 10:15:20 +01:00
|
|
|
private void updatePaint() {
|
|
|
|
mPaint.setColor(mColor);
|
|
|
|
mPaint.setAlpha(Color.alpha(mColor) * mAlpha / 0xFF);
|
|
|
|
invalidateSelf();
|
|
|
|
}
|
|
|
|
|
2014-12-01 17:29:34 +01:00
|
|
|
|
2014-12-01 08:00:37 +01:00
|
|
|
@Override
|
|
|
|
public int getAlpha() {
|
|
|
|
return mAlpha;
|
|
|
|
}
|
|
|
|
|
2014-12-01 10:15:20 +01:00
|
|
|
|
2014-12-01 08:00:37 +01:00
|
|
|
@Override
|
|
|
|
public void setAlpha(int alpha) {
|
|
|
|
mAlpha = alpha;
|
|
|
|
updatePaint();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void setColorFilter(ColorFilter cf) {
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public int getOpacity() {
|
|
|
|
return PixelFormat.TRANSLUCENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
2015-01-17 19:58:29 +01:00
|
|
|
|
|
|
|
|
2014-07-03 07:48:39 +02:00
|
|
|
}
|