Java tutorial
/* * Copyright 2014 Google Inc. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package xyz.template.material.menu.ui; import android.accounts.Account; import android.accounts.AccountManager; import android.animation.Animator; import android.animation.AnimatorListenerAdapter; import android.animation.AnimatorSet; import android.animation.ArgbEvaluator; import android.animation.ObjectAnimator; import android.animation.TypeEvaluator; import android.animation.ValueAnimator; import android.app.AlertDialog; import android.content.ContentResolver; import android.content.Context; import android.content.DialogInterface; import android.content.Intent; import android.content.SharedPreferences; import android.content.SyncStatusObserver; import android.content.pm.PackageManager; import android.graphics.Color; import android.graphics.Rect; import android.net.ConnectivityManager; import android.net.NetworkInfo; import android.net.Uri; import android.os.AsyncTask; import android.os.Bundle; import android.os.Handler; import android.preference.PreferenceManager; import android.provider.Settings; import android.support.v4.view.ViewCompat; import android.support.v4.widget.DrawerLayout; import android.support.v4.widget.SwipeRefreshLayout; import android.support.v7.app.ActionBar; import android.support.v7.app.ActionBarActivity; import android.support.v7.widget.Toolbar; import android.text.TextUtils; import android.view.Gravity; import android.view.KeyEvent; import android.view.LayoutInflater; import android.view.Menu; import android.view.MenuItem; import android.view.View; import android.view.ViewGroup; import android.view.animation.DecelerateInterpolator; import android.widget.AbsListView; import android.widget.ImageView; import android.widget.LinearLayout; import android.widget.ListView; import android.widget.TextView; import android.widget.Toast; import com.yzxIM.IMManager; import com.yzxtcp.UCSManager; import com.yzxtcp.data.UcsReason; import com.yzxtcp.listener.ILoginListener; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import xyz.template.material.menu.BuildConfig; import xyz.template.material.menu.Config; import xyz.template.material.menu.MainActivity; import xyz.template.material.menu.R; import xyz.template.material.menu.data.ConferenceDataHandler; import xyz.template.material.menu.io.JSONHandler; import xyz.template.material.menu.model.LoginData; import xyz.template.material.menu.provider.ScheduleContract; import xyz.template.material.menu.ui.widget.MultiSwipeRefreshLayout; import xyz.template.material.menu.ui.widget.ScrimInsetsScrollView; import xyz.template.material.menu.utils.AccountUtils; import xyz.template.material.menu.utils.HelpUtils; import xyz.template.material.menu.utils.ImageLoader; import xyz.template.material.menu.utils.LUtils; import xyz.template.material.menu.utils.LoginAndAuthHelper; import xyz.template.material.menu.utils.PrefUtils; import xyz.template.material.menu.utils.RecentTasksStyler; import xyz.template.material.menu.utils.UIUtils; import xyz.template.material.menu.utils.WiFiUtils; import static xyz.template.material.menu.utils.LogUtils.*; import static xyz.template.material.menu.utils.LogUtils.makeLogTag; /** * A base activity that handles common functionality in the app. This includes the * navigation drawer, login and authentication, Action Bar tweaks, amongst others. */ public abstract class BaseActivity extends ActionBarActivity implements LoginAndAuthHelper.Callbacks, SharedPreferences.OnSharedPreferenceChangeListener, MultiSwipeRefreshLayout.CanChildScrollUpCallback { private static final String TAG = makeLogTag(BaseActivity.class); // the LoginAndAuthHelper handles signing in to Google Play Services and OAuth private LoginAndAuthHelper mLoginAndAuthHelper; // Navigation drawer: private DrawerLayout mDrawerLayout; // Helper methods for L APIs private LUtils mLUtils; private ObjectAnimator mStatusBarColorAnimator; private LinearLayout mAccountListContainer; private ViewGroup mDrawerItemsListContainer; private Handler mHandler; private ImageView mExpandAccountBoxIndicator; private boolean mAccountBoxExpanded = false; // When set, these components will be shown/hidden in sync with the action bar // to implement the "quick recall" effect (the Action Bar and the header views disappear // when you scroll down a list, and reappear quickly when you scroll up). private ArrayList<View> mHideableHeaderViews = new ArrayList<View>(); // Durations for certain animations we use: private static final int HEADER_HIDE_ANIM_DURATION = 300; private static final int ACCOUNT_BOX_EXPAND_ANIM_DURATION = 200; // symbols for navdrawer items (indices must correspond to array below). This is // not a list of items that are necessarily *present* in the Nav Drawer; rather, // it's a list of all possible items. protected static final int NAVDRAWER_ITEM_MY_SCHEDULE = 0; protected static final int NAVDRAWER_ITEM_EXPLORE = 1; protected static final int NAVDRAWER_ITEM_MAP = 2; protected static final int NAVDRAWER_ITEM_SOCIAL = 3; protected static final int NAVDRAWER_ITEM_VIDEO_LIBRARY = 4; protected static final int NAVDRAWER_ITEM_SIGN_IN = 5; protected static final int NAVDRAWER_ITEM_SETTINGS = 6; protected static final int NAVDRAWER_ITEM_EXPERTS_DIRECTORY = 7; protected static final int NAVDRAWER_ITEM_PEOPLE_IVE_MET = 8; protected static final int NAVDRAWER_ITEM_INVALID = -1; protected static final int NAVDRAWER_ITEM_SEPARATOR = -2; protected static final int NAVDRAWER_ITEM_SEPARATOR_SPECIAL = -3; // titles for navdrawer items (indices must correspond to the above) private static final int[] NAVDRAWER_TITLE_RES_ID = new int[] { R.string.navdrawer_item_my_friend, R.string.navdrawer_item_my_talklist, R.string.navdrawer_item_my_care, R.string.navdrawer_item_my_note, R.string.navdrawer_item_my_beautiful, R.string.navdrawer_item_video_library, R.string.navdrawer_item_settings, }; // icons for navdrawer items (indices must correspond to above array) private static final int[] NAVDRAWER_ICON_RES_ID = new int[] { R.drawable.ic_drawer_people_met, // My Schedule R.drawable.ic_drawer_social, // Explore R.drawable.ic_drawer_map, // Map R.drawable.ic_drawer_my_schedule, // Social R.drawable.ic_drawer_experts, // Video Library R.drawable.ic_drawer_video_library, R.drawable.ic_drawer_settings, }; // delay to launch nav drawer item, to allow close animation to play private static final int NAVDRAWER_LAUNCH_DELAY = 250; // fade in and fade out durations for the main content when switching between // different Activities of the app through the Nav Drawer private static final int MAIN_CONTENT_FADEOUT_DURATION = 150; private static final int MAIN_CONTENT_FADEIN_DURATION = 250; // list of navdrawer items that were actually added to the navdrawer, in order private ArrayList<Integer> mNavDrawerItems = new ArrayList<Integer>(); // views that correspond to each navdrawer item, null if not yet created private View[] mNavDrawerItemViews = null; // SwipeRefreshLayout allows the user to swipe the screen down to trigger a manual refresh private SwipeRefreshLayout mSwipeRefreshLayout; // Primary toolbar and drawer toggle private Toolbar mActionBarToolbar; // asynctask that performs GCM registration in the backgorund private AsyncTask<Void, Void, Void> mGCMRegisterTask; // handle to our sync observer (that notifies us about changes in our sync state) private Object mSyncObserverHandle; // data bootstrap thread. Data bootstrap is the process of initializing the database // with the data cache that ships with the app. Thread mDataBootstrapThread = null; // variables that control the Action Bar auto hide behavior (aka "quick recall") private boolean mActionBarAutoHideEnabled = false; private int mActionBarAutoHideSensivity = 0; private int mActionBarAutoHideMinY = 0; private int mActionBarAutoHideSignal = 0; private boolean mActionBarShown = true; // A Runnable that we should execute when the navigation drawer finishes its closing animation private Runnable mDeferredOnDrawerClosedRunnable; private boolean mManualSyncRequest; private int mThemedStatusBarColor; private int mNormalStatusBarColor; private int mProgressBarTopWhenActionBarShown; private static final TypeEvaluator ARGB_EVALUATOR = new ArgbEvaluator(); private ImageLoader mImageLoader; private void connect(final LoginData loginData) { UCSManager.connect(loginData.getToken(), new ILoginListener() { @Override public void onLogin(UcsReason arg0) { if (arg0.getReason() == 0) { //? LOGD("wangyl", "onLogin success"); // Toast.makeText(BaseActivity.this, "??", Toast.LENGTH_SHORT).show(); } else { // startActivity(new Intent(BaseActivity.this, LoginActivity.class)); finish(); // Toast.makeText(BaseActivity.this, "?" + arg0.getMsg(), Toast.LENGTH_SHORT).show(); } } }); } @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); RecentTasksStyler.styleRecentTasksEntry(this); PrefUtils.init(this); if (!PrefUtils.isLogin(this)) { Intent intent = new Intent(this, LoginActivity.class); startActivity(intent); finish(); // } else { // connect(PrefUtils.getUserInfo(this)); } mImageLoader = new ImageLoader(this); mHandler = new Handler(); // Enable or disable each Activity depending on the form factor. This is necessary // because this app uses many implicit intents where we don't name the exact Activity // in the Intent, so there should only be one enabled Activity that handles each // Intent in the app. UIUtils.enableDisableActivitiesByFormFactor(this); if (savedInstanceState == null) { registerGCMClient(); } SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this); sp.registerOnSharedPreferenceChangeListener(this); ActionBar ab = getSupportActionBar(); if (ab != null) { ab.setDisplayHomeAsUpEnabled(true); } mLUtils = LUtils.getInstance(this); mThemedStatusBarColor = getResources().getColor(R.color.theme_primary_dark); mNormalStatusBarColor = mThemedStatusBarColor; } private void trySetupSwipeRefresh() { mSwipeRefreshLayout = (SwipeRefreshLayout) findViewById(R.id.swipe_refresh_layout); if (mSwipeRefreshLayout != null) { mSwipeRefreshLayout.setColorSchemeResources(R.color.refresh_progress_1, R.color.refresh_progress_2, R.color.refresh_progress_3); mSwipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() { @Override public void onRefresh() { requestDataRefresh(); } }); if (mSwipeRefreshLayout instanceof MultiSwipeRefreshLayout) { MultiSwipeRefreshLayout mswrl = (MultiSwipeRefreshLayout) mSwipeRefreshLayout; mswrl.setCanChildScrollUpCallback(this); } } } protected void setProgressBarTopWhenActionBarShown(int progressBarTopWhenActionBarShown) { mProgressBarTopWhenActionBarShown = progressBarTopWhenActionBarShown; updateSwipeRefreshProgressBarTop(); } private void updateSwipeRefreshProgressBarTop() { if (mSwipeRefreshLayout == null) { return; } int progressBarStartMargin = getResources() .getDimensionPixelSize(R.dimen.swipe_refresh_progress_bar_start_margin); int progressBarEndMargin = getResources() .getDimensionPixelSize(R.dimen.swipe_refresh_progress_bar_end_margin); int top = mActionBarShown ? mProgressBarTopWhenActionBarShown : 0; mSwipeRefreshLayout.setProgressViewOffset(false, top + progressBarStartMargin, top + progressBarEndMargin); } /** * Returns the navigation drawer item that corresponds to this Activity. Subclasses * of BaseActivity override this to indicate what nav drawer item corresponds to them * Return NAVDRAWER_ITEM_INVALID to mean that this Activity should not have a Nav Drawer. */ protected int getSelfNavDrawerItem() { return NAVDRAWER_ITEM_INVALID; } /** * Sets up the navigation drawer as appropriate. Note that the nav drawer will be * different depending on whether the attendee indicated that they are attending the * event on-site vs. attending remotely. */ private void setupNavDrawer() { // What nav drawer item should be selected? int selfItem = getSelfNavDrawerItem(); mDrawerLayout = (DrawerLayout) findViewById(R.id.drawer_layout); if (mDrawerLayout == null) { return; } mDrawerLayout.setStatusBarBackgroundColor(getResources().getColor(R.color.theme_primary_dark)); ScrimInsetsScrollView navDrawer = (ScrimInsetsScrollView) mDrawerLayout.findViewById(R.id.navdrawer); if (selfItem == NAVDRAWER_ITEM_INVALID) { // do not show a nav drawer if (navDrawer != null) { ((ViewGroup) navDrawer.getParent()).removeView(navDrawer); } mDrawerLayout = null; return; } if (navDrawer != null) { final View chosenAccountContentView = findViewById(R.id.chosen_account_content_view); final View chosenAccountView = findViewById(R.id.chosen_account_view); final int navDrawerChosenAccountHeight = getResources() .getDimensionPixelSize(R.dimen.navdrawer_chosen_account_height); navDrawer.setOnInsetsCallback(new ScrimInsetsScrollView.OnInsetsCallback() { @Override public void onInsetsChanged(Rect insets) { ViewGroup.MarginLayoutParams lp = (ViewGroup.MarginLayoutParams) chosenAccountContentView .getLayoutParams(); lp.topMargin = insets.top; chosenAccountContentView.setLayoutParams(lp); ViewGroup.LayoutParams lp2 = chosenAccountView.getLayoutParams(); lp2.height = navDrawerChosenAccountHeight + insets.top; chosenAccountView.setLayoutParams(lp2); } }); } if (mActionBarToolbar != null) { mActionBarToolbar.setNavigationIcon(R.drawable.ic_drawer); mActionBarToolbar.setNavigationOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { mDrawerLayout.openDrawer(Gravity.START); } }); } mDrawerLayout.setDrawerListener(new DrawerLayout.DrawerListener() { @Override public void onDrawerClosed(View drawerView) { // run deferred action, if we have one if (mDeferredOnDrawerClosedRunnable != null) { mDeferredOnDrawerClosedRunnable.run(); mDeferredOnDrawerClosedRunnable = null; } if (mAccountBoxExpanded) { mAccountBoxExpanded = false; setupAccountBoxToggle(); } onNavDrawerStateChanged(false, false); } @Override public void onDrawerOpened(View drawerView) { onNavDrawerStateChanged(true, false); } @Override public void onDrawerStateChanged(int newState) { onNavDrawerStateChanged(isNavDrawerOpen(), newState != DrawerLayout.STATE_IDLE); } @Override public void onDrawerSlide(View drawerView, float slideOffset) { onNavDrawerSlide(slideOffset); } }); mDrawerLayout.setDrawerShadow(R.drawable.drawer_shadow, Gravity.START); // populate the nav drawer with the correct items populateNavDrawer(); // When the user runs the app for the first time, we want to land them with the // navigation drawer open. But just the first time. if (!PrefUtils.isWelcomeDone(this)) { // first run of the app starts with the nav drawer open PrefUtils.markWelcomeDone(this); mDrawerLayout.openDrawer(Gravity.START); } } @Override public void setContentView(int layoutResID) { super.setContentView(layoutResID); getActionBarToolbar(); } // Subclasses can override this for custom behavior protected void onNavDrawerStateChanged(boolean isOpen, boolean isAnimating) { if (mActionBarAutoHideEnabled && isOpen) { autoShowOrHideActionBar(true); } } protected void onNavDrawerSlide(float offset) { } protected boolean isNavDrawerOpen() { return mDrawerLayout != null && mDrawerLayout.isDrawerOpen(Gravity.START); } protected void closeNavDrawer() { if (mDrawerLayout != null) { mDrawerLayout.closeDrawer(Gravity.START); } } /** Populates the navigation drawer with the appropriate items. */ private void populateNavDrawer() { // boolean attendeeAtVenue = PrefUtils.isAttendeeAtVenue(this); mNavDrawerItems.clear(); // decide which items will appear in the nav drawer mNavDrawerItems.add(NAVDRAWER_ITEM_MY_SCHEDULE); // Explore is always shown mNavDrawerItems.add(NAVDRAWER_ITEM_EXPLORE); mNavDrawerItems.add(NAVDRAWER_ITEM_MAP); mNavDrawerItems.add(NAVDRAWER_ITEM_SEPARATOR); // If attendee is on-site, show the People I've Met item mNavDrawerItems.add(NAVDRAWER_ITEM_SOCIAL); // If the experts directory hasn't expired, show it // if (!Config.hasExpertsDirectoryExpired()) { mNavDrawerItems.add(NAVDRAWER_ITEM_VIDEO_LIBRARY); // } mNavDrawerItems.add(NAVDRAWER_ITEM_SIGN_IN); mNavDrawerItems.add(NAVDRAWER_ITEM_SEPARATOR_SPECIAL); mNavDrawerItems.add(NAVDRAWER_ITEM_SETTINGS); createNavDrawerItems(); } @Override public void onBackPressed() { if (isNavDrawerOpen()) { closeNavDrawer(); } else { super.onBackPressed(); } } private void createNavDrawerItems() { mDrawerItemsListContainer = (ViewGroup) findViewById(R.id.navdrawer_items_list); if (mDrawerItemsListContainer == null) { return; } mNavDrawerItemViews = new View[mNavDrawerItems.size()]; mDrawerItemsListContainer.removeAllViews(); int i = 0; for (int itemId : mNavDrawerItems) { mNavDrawerItemViews[i] = makeNavDrawerItem(itemId, mDrawerItemsListContainer); mDrawerItemsListContainer.addView(mNavDrawerItemViews[i]); ++i; } } /** * Sets up the given navdrawer item's appearance to the selected state. Note: this could * also be accomplished (perhaps more cleanly) with state-based layouts. */ private void setSelectedNavDrawerItem(int itemId) { if (mNavDrawerItemViews != null) { for (int i = 0; i < mNavDrawerItemViews.length; i++) { if (i < mNavDrawerItems.size()) { int thisItemId = mNavDrawerItems.get(i); formatNavDrawerItem(mNavDrawerItemViews[i], thisItemId, itemId == thisItemId); } } } } @Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { if (key.equals(PrefUtils.PREF_ATTENDEE_AT_VENUE)) { LOGD(TAG, "Attendee at venue preference changed, repopulating nav drawer and menu."); populateNavDrawer(); invalidateOptionsMenu(); } else if (key.equals(PrefUtils.PREF_TOS_LOGIN)) { LOGD(TAG, "User has quict the current account."); if (!PrefUtils.isLogin(BaseActivity.this)) { finish(); } } } @Override protected void onPostCreate(Bundle savedInstanceState) { super.onPostCreate(savedInstanceState); setupNavDrawer(); setupAccountBox(); trySetupSwipeRefresh(); updateSwipeRefreshProgressBarTop(); View mainContent = findViewById(R.id.main_content); if (mainContent != null) { mainContent.setAlpha(0); mainContent.animate().alpha(1).setDuration(MAIN_CONTENT_FADEIN_DURATION); } else { LOGW(TAG, "No view with ID main_content to fade in."); } } /** * Sets up the account box. The account box is the area at the top of the nav drawer that * shows which account the user is logged in as, and lets them switch accounts. It also * shows the user's Google+ cover photo as background. */ private void setupAccountBox() { mAccountListContainer = (LinearLayout) findViewById(R.id.account_list); if (mAccountListContainer == null) { //This activity does not have an account box return; } final View chosenAccountView = findViewById(R.id.chosen_account_view); Account chosenAccount = AccountUtils.getActiveAccount(this); if (chosenAccount == null) { // No account logged in; hide account box // chosenAccountView.setVisibility(View.GONE); // mAccountListContainer.setVisibility(View.GONE); // return; } else { chosenAccountView.setVisibility(View.VISIBLE); mAccountListContainer.setVisibility(View.INVISIBLE); } // AccountManager am = AccountManager.get(this); // Account[] accountArray = am.getAccountsByType("com.google"); // List<Account> accounts = new ArrayList<Account>(Arrays.asList(accountArray)); // accounts.remove(chosenAccount); ImageView coverImageView = (ImageView) chosenAccountView.findViewById(R.id.profile_cover_image); ImageView profileImageView = (ImageView) chosenAccountView.findViewById(R.id.profile_image); TextView nameTextView = (TextView) chosenAccountView.findViewById(R.id.profile_name_text); TextView email = (TextView) chosenAccountView.findViewById(R.id.profile_email_text); mExpandAccountBoxIndicator = (ImageView) findViewById(R.id.expand_account_box_indicator); String name = AccountUtils.getPlusName(this); if (name == null) { nameTextView.setVisibility(View.GONE); } else { nameTextView.setVisibility(View.VISIBLE); nameTextView.setText(name); } String imageUrl = AccountUtils.getPlusImageUrl(this); if (imageUrl != null) { mImageLoader.loadImage(imageUrl, profileImageView); } String coverImageUrl = AccountUtils.getPlusCoverUrl(this); if (coverImageUrl != null) { mImageLoader.loadImage(coverImageUrl, coverImageView); } else { coverImageView.setImageResource(R.drawable.default_cover); } // email.setText(PrefUtils.getCurSyncInterval()); // if (accounts.isEmpty()) { // // There's only one account on the device, so no need for a switcher. // mExpandAccountBoxIndicator.setVisibility(View.GONE); // mAccountListContainer.setVisibility(View.GONE); // chosenAccountView.setEnabled(false); // return; // } chosenAccountView.setEnabled(true); mExpandAccountBoxIndicator.setVisibility(View.VISIBLE); chosenAccountView.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { mAccountBoxExpanded = !mAccountBoxExpanded; setupAccountBoxToggle(); } }); setupAccountBoxToggle(); // populateAccountList(accounts); } private void populateAccountList(List<Account> accounts) { mAccountListContainer.removeAllViews(); LayoutInflater layoutInflater = LayoutInflater.from(this); for (Account account : accounts) { View itemView = layoutInflater.inflate(R.layout.list_item_account, mAccountListContainer, false); ((TextView) itemView.findViewById(R.id.profile_email_text)).setText(account.name); final String accountName = account.name; String imageUrl = AccountUtils.getPlusImageUrl(this, accountName); if (!TextUtils.isEmpty(imageUrl)) { mImageLoader.loadImage(imageUrl, (ImageView) itemView.findViewById(R.id.profile_image)); } itemView.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { ConnectivityManager cm = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE); NetworkInfo activeNetwork = cm.getActiveNetworkInfo(); if (activeNetwork == null || !activeNetwork.isConnected()) { // if there's no network, don't try to change the selected account Toast.makeText(BaseActivity.this, R.string.no_connection_cant_login, Toast.LENGTH_SHORT) .show(); mDrawerLayout.closeDrawer(Gravity.START); return; } else { LOGD(TAG, "User requested switch to account: " + accountName); AccountUtils.setActiveAccount(BaseActivity.this, accountName); onAccountChangeRequested(); startLoginProcess(); mAccountBoxExpanded = false; setupAccountBoxToggle(); mDrawerLayout.closeDrawer(Gravity.START); setupAccountBox(); } } }); mAccountListContainer.addView(itemView); } } protected void onAccountChangeRequested() { // override if you want to be notified when another account has been selected account has changed } private void setupAccountBoxToggle() { int selfItem = getSelfNavDrawerItem(); if (mDrawerLayout == null || selfItem == NAVDRAWER_ITEM_INVALID) { // this Activity does not have a nav drawer return; } mExpandAccountBoxIndicator.setImageResource(mAccountBoxExpanded ? R.drawable.ic_drawer_accounts_collapse : R.drawable.ic_drawer_accounts_expand); int hideTranslateY = -mAccountListContainer.getHeight() / 4; // last 25% of animation if (mAccountBoxExpanded && mAccountListContainer.getTranslationY() == 0) { // initial setup mAccountListContainer.setAlpha(0); mAccountListContainer.setTranslationY(hideTranslateY); } AnimatorSet set = new AnimatorSet(); set.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { mDrawerItemsListContainer.setVisibility(mAccountBoxExpanded ? View.INVISIBLE : View.VISIBLE); mAccountListContainer.setVisibility(mAccountBoxExpanded ? View.VISIBLE : View.INVISIBLE); } @Override public void onAnimationCancel(Animator animation) { onAnimationEnd(animation); } }); if (mAccountBoxExpanded) { mAccountListContainer.setVisibility(View.VISIBLE); AnimatorSet subSet = new AnimatorSet(); subSet.playTogether( ObjectAnimator.ofFloat(mAccountListContainer, View.ALPHA, 1) .setDuration(ACCOUNT_BOX_EXPAND_ANIM_DURATION), ObjectAnimator.ofFloat(mAccountListContainer, View.TRANSLATION_Y, 0) .setDuration(ACCOUNT_BOX_EXPAND_ANIM_DURATION)); set.playSequentially(ObjectAnimator.ofFloat(mDrawerItemsListContainer, View.ALPHA, 0) .setDuration(ACCOUNT_BOX_EXPAND_ANIM_DURATION), subSet); set.start(); } else { mDrawerItemsListContainer.setVisibility(View.VISIBLE); AnimatorSet subSet = new AnimatorSet(); subSet.playTogether( ObjectAnimator.ofFloat(mAccountListContainer, View.ALPHA, 0) .setDuration(ACCOUNT_BOX_EXPAND_ANIM_DURATION), ObjectAnimator.ofFloat(mAccountListContainer, View.TRANSLATION_Y, hideTranslateY) .setDuration(ACCOUNT_BOX_EXPAND_ANIM_DURATION)); set.playSequentially(subSet, ObjectAnimator.ofFloat(mDrawerItemsListContainer, View.ALPHA, 1) .setDuration(ACCOUNT_BOX_EXPAND_ANIM_DURATION)); set.start(); } set.start(); } @Override public boolean onOptionsItemSelected(MenuItem item) { int id = item.getItemId(); switch (id) { case R.id.menu_about: HelpUtils.showAbout(this); return true; case R.id.menu_wifi: WiFiUtils.showWiFiDialog(this); return true; case R.id.menu_i_o_hunt: // launchIoHunt(); //todo wangyl need to show select friends dialog startActivity(new Intent(this, TalkActivity.class)); return true; case R.id.menu_debug: // if (BuildConfig.DEBUG) { startActivity(new Intent(this, TalkActivity.class)); // } return true; case R.id.menu_refresh: requestDataRefresh(); break; case R.id.menu_io_extended: startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(Config.IO_EXTENDED_LINK))); break; case R.id.menu_map: // startActivity(new Intent(this, UIUtils.getMapActivityClass(this))); // finish(); break; } return super.onOptionsItemSelected(item); } private void launchIoHunt() { if (!TextUtils.isEmpty(Config.IO_HUNT_PACKAGE_NAME)) { LOGD(TAG, "Attempting to launch I/O hunt."); PackageManager pm = getPackageManager(); Intent launchIntent = pm.getLaunchIntentForPackage(Config.IO_HUNT_PACKAGE_NAME); if (launchIntent != null) { // start I/O Hunt LOGD(TAG, "I/O hunt intent found, launching."); startActivity(launchIntent); } else { // send user to the Play Store to download it LOGD(TAG, "I/O hunt intent NOT found, going to Play Store."); Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(Config.PLAY_STORE_URL_PREFIX + Config.IO_HUNT_PACKAGE_NAME)); startActivity(intent); } } } protected void requestDataRefresh() { // Account activeAccount = AccountUtils.getActiveAccount(this); // ContentResolver contentResolver = getContentResolver(); // if (contentResolver.isSyncActive(activeAccount, ScheduleContract.CONTENT_AUTHORITY)) { // LOGD(TAG, "Ignoring manual sync request because a sync is already in progress."); // return; // } // mManualSyncRequest = true; // LOGD(TAG, "Requesting manual data refresh."); // SyncHelper.requestManualSync(activeAccount); } private void goToNavDrawerItem(int item) { Intent intent; Toast.makeText(this, "goToNavDrawerItem item=" + item, Toast.LENGTH_SHORT).show(); switch (item) { case NAVDRAWER_ITEM_MY_SCHEDULE: intent = new Intent(this, TalkActivity.class); startActivity(intent); finish(); break; case NAVDRAWER_ITEM_EXPLORE: intent = new Intent(this, MainActivity.class); startActivity(intent); finish(); break; case NAVDRAWER_ITEM_MAP: intent = new Intent(this, TalkActivity.class); startActivity(intent); finish(); break; case NAVDRAWER_ITEM_SOCIAL: intent = new Intent(this, TalkActivity.class); startActivity(intent); finish(); break; case NAVDRAWER_ITEM_VIDEO_LIBRARY: intent = new Intent(this, TalkActivity.class); startActivity(intent); finish(); break; case NAVDRAWER_ITEM_SIGN_IN: intent = new Intent(this, TalkActivity.class); startActivity(intent); finish(); break; case NAVDRAWER_ITEM_SETTINGS: intent = new Intent(this, SettingsActivity.class); startActivity(intent); break; // case NAVDRAWER_ITEM_VIDEO_LIBRARY: // intent = new Intent(this, VideoLibraryActivity.class); // startActivity(intent); // finish(); // break; } } private void signInOrCreateAnAccount() { //Get list of accounts on device. AccountManager am = AccountManager.get(BaseActivity.this); Account[] accountArray = am.getAccountsByType("com.google"); if (accountArray.length == 0) { //Send the user to the "Add Account" page. Intent intent = new Intent(Settings.ACTION_ADD_ACCOUNT); intent.putExtra(Settings.EXTRA_ACCOUNT_TYPES, new String[] { "com.google" }); startActivity(intent); } else { //Try to log the user in with the first account on the device. startLoginProcess(); mDrawerLayout.closeDrawer(Gravity.START); } } private void onNavDrawerItemClicked(final int itemId) { if (itemId == getSelfNavDrawerItem()) { mDrawerLayout.closeDrawer(Gravity.START); return; } if (isSpecialItem(itemId)) { goToNavDrawerItem(itemId); } else { // launch the target Activity after a short delay, to allow the close animation to play mHandler.postDelayed(new Runnable() { @Override public void run() { goToNavDrawerItem(itemId); } }, NAVDRAWER_LAUNCH_DELAY); // change the active item on the list so the user can see the item changed setSelectedNavDrawerItem(itemId); // fade out the main content View mainContent = findViewById(R.id.main_content); if (mainContent != null) { mainContent.animate().alpha(0).setDuration(MAIN_CONTENT_FADEOUT_DURATION); } } mDrawerLayout.closeDrawer(Gravity.START); } protected void configureStandardMenuItems(Menu menu) { MenuItem wifiItem = menu.findItem(R.id.menu_wifi); if (wifiItem != null && !WiFiUtils.shouldOfferToSetupWifi(this, false)) { wifiItem.setVisible(false); } MenuItem debugItem = menu.findItem(R.id.menu_debug); if (debugItem != null) { debugItem.setVisible(BuildConfig.DEBUG); } MenuItem ioExtendedItem = menu.findItem(R.id.menu_io_extended); if (ioExtendedItem != null) { ioExtendedItem.setVisible(PrefUtils.shouldOfferIOExtended(this, false)); } // if attendee is remote, show map on the overflow instead of on the nav bar final boolean isRemote = !PrefUtils.isAttendeeAtVenue(this); final MenuItem mapItem = menu.findItem(R.id.menu_map); if (mapItem != null) { mapItem.setVisible(isRemote); } MenuItem ioHuntItem = menu.findItem(R.id.menu_i_o_hunt); if (ioHuntItem != null) { ioHuntItem.setVisible(!isRemote && !TextUtils.isEmpty(Config.IO_HUNT_PACKAGE_NAME)); } } @Override protected void onResume() { super.onResume(); // Verifies the proper version of Google Play Services exists on the device. // PlayServicesUtils.checkGooglePlaySevices(this); // Watch for sync state changes mSyncStatusObserver.onStatusChanged(0); final int mask = ContentResolver.SYNC_OBSERVER_TYPE_PENDING | ContentResolver.SYNC_OBSERVER_TYPE_ACTIVE; mSyncObserverHandle = ContentResolver.addStatusChangeListener(mask, mSyncStatusObserver); } @Override protected void onPause() { super.onPause(); if (mSyncObserverHandle != null) { ContentResolver.removeStatusChangeListener(mSyncObserverHandle); mSyncObserverHandle = null; } } /** * Converts an intent into a {@link Bundle} suitable for use as fragment arguments. */ public static Bundle intentToFragmentArguments(Intent intent) { Bundle arguments = new Bundle(); if (intent == null) { return arguments; } final Uri data = intent.getData(); if (data != null) { arguments.putParcelable("_uri", data); } final Bundle extras = intent.getExtras(); if (extras != null) { arguments.putAll(intent.getExtras()); } return arguments; } /** * Converts a fragment arguments bundle into an intent. */ public static Intent fragmentArgumentsToIntent(Bundle arguments) { Intent intent = new Intent(); if (arguments == null) { return intent; } final Uri data = arguments.getParcelable("_uri"); if (data != null) { intent.setData(data); } intent.putExtras(arguments); intent.removeExtra("_uri"); return intent; } @Override public void onStart() { LOGD(TAG, "onStart"); super.onStart(); // Perform one-time bootstrap setup, if needed if (!PrefUtils.isDataBootstrapDone(this) && mDataBootstrapThread == null) { LOGD(TAG, "One-time data bootstrap not done yet. Doing now."); performDataBootstrap(); } startLoginProcess(); } /** * Performs the one-time data bootstrap. This means taking our prepackaged conference data * from the R.raw.bootstrap_data resource, and parsing it to populate the database. This * data contains the sessions, speakers, etc. */ private void performDataBootstrap() { final Context appContext = getApplicationContext(); LOGD(TAG, "Starting data bootstrap background thread."); mDataBootstrapThread = new Thread(new Runnable() { @Override public void run() { LOGD(TAG, "Starting data bootstrap process."); try { // Load data from bootstrap raw resource String bootstrapJson = JSONHandler.parseResource(appContext, R.raw.bootstrap_data); // Apply the data we read to the database with the help of the ConferenceDataHandler ConferenceDataHandler dataHandler = new ConferenceDataHandler(appContext); // dataHandler.applyConferenceData(new String[]{bootstrapJson}, // Config.BOOTSTRAP_DATA_TIMESTAMP, false); // SyncHelper.performPostSyncChores(appContext); LOGI(TAG, "End of bootstrap -- successful. Marking boostrap as done."); PrefUtils.markSyncSucceededNow(appContext); PrefUtils.markDataBootstrapDone(appContext); getContentResolver().notifyChange(Uri.parse(ScheduleContract.CONTENT_AUTHORITY), null, false); } catch (IOException ex) { // This is serious -- if this happens, the app won't work :-( // This is unlikely to happen in production, but IF it does, we apply // this workaround as a fallback: we pretend we managed to do the bootstrap // and hope that a remote sync will work. LOGE(TAG, "*** ERROR DURING BOOTSTRAP! Problem in bootstrap data?"); LOGE(TAG, "Applying fallback -- marking boostrap as done; sync might fix problem."); PrefUtils.markDataBootstrapDone(appContext); } mDataBootstrapThread = null; // Request a manual sync immediately after the bootstrapping process, in case we // have an active connection. Otherwise, the scheduled sync could take a while. // SyncHelper.requestManualSync(AccountUtils.getActiveAccount(appContext)); } }); mDataBootstrapThread.start(); } /** * Returns the default account on the device. We use the rule that the first account * should be the default. It's arbitrary, but the alternative would be showing an account * chooser popup which wouldn't be a smooth first experience with the app. Since the user * can easily switch the account with the nav drawer, we opted for this implementation. */ private String getDefaultAccount() { // Choose first account on device. LOGD(TAG, "Choosing default account (first account on device)"); AccountManager am = AccountManager.get(this); Account[] accounts = am.getAccountsByType("com.google"); if (accounts.length == 0) { // No Google accounts on device. LOGW(TAG, "No Google accounts on device; not setting default account."); return null; } LOGD(TAG, "Default account is: " + accounts[0].name); return accounts[0].name; } private void complainMustHaveGoogleAccount() { LOGD(TAG, "Complaining about missing Google account."); // new AlertDialog.Builder(this) // .setTitle(R.string.google_account_required_title) // .setMessage(R.string.google_account_required_message) // .setPositiveButton(R.string.add_account, new DialogInterface.OnClickListener() { // @Override // public void onClick(DialogInterface dialog, int which) { // promptAddAccount(); // } // }) // .setNegativeButton(R.string.not_now, new DialogInterface.OnClickListener() { // @Override // public void onClick(DialogInterface dialog, int which) { // finish(); // } // }) // .show(); } private void promptAddAccount() { Intent intent = new Intent(Settings.ACTION_ADD_ACCOUNT); intent.putExtra(Settings.EXTRA_ACCOUNT_TYPES, new String[] { "com.google" }); startActivity(intent); finish(); } private void startLoginProcess() { LOGD(TAG, "Starting login process."); if (!AccountUtils.hasActiveAccount(this)) { LOGD(TAG, "No active account, attempting to pick a default."); String defaultAccount = getDefaultAccount(); if (defaultAccount == null) { LOGE(TAG, "Failed to pick default account (no accounts). Failing."); complainMustHaveGoogleAccount(); return; } LOGD(TAG, "Default to: " + defaultAccount); AccountUtils.setActiveAccount(this, defaultAccount); } if (!AccountUtils.hasActiveAccount(this)) { LOGD(TAG, "Can't proceed with login -- no account chosen."); return; } else { LOGD(TAG, "Chosen account: " + AccountUtils.getActiveAccountName(this)); } String accountName = AccountUtils.getActiveAccountName(this); LOGD(TAG, "Chosen account: " + AccountUtils.getActiveAccountName(this)); if (mLoginAndAuthHelper != null && mLoginAndAuthHelper.getAccountName().equals(accountName)) { LOGD(TAG, "Helper already set up; simply starting it."); mLoginAndAuthHelper.start(); return; } LOGD(TAG, "Starting login process with account " + accountName); if (mLoginAndAuthHelper != null) { LOGD(TAG, "Tearing down old Helper, was " + mLoginAndAuthHelper.getAccountName()); if (mLoginAndAuthHelper.isStarted()) { LOGD(TAG, "Stopping old Helper"); mLoginAndAuthHelper.stop(); } mLoginAndAuthHelper = null; } LOGD(TAG, "Creating and starting new Helper with account: " + accountName); mLoginAndAuthHelper = new LoginAndAuthHelper(this, this, accountName); mLoginAndAuthHelper.start(); } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (mLoginAndAuthHelper == null || !mLoginAndAuthHelper.onActivityResult(requestCode, resultCode, data)) { super.onActivityResult(requestCode, resultCode, data); } } @Override public void onStop() { LOGD(TAG, "onStop"); super.onStop(); if (mLoginAndAuthHelper != null) { mLoginAndAuthHelper.stop(); } } @Override public void onPlusInfoLoaded(String accountName) { setupAccountBox(); populateNavDrawer(); } /** * Called when authentication succeeds. This may either happen because the user just * authenticated for the first time (and went through the sign in flow), or because it's * a returning user. * @param accountName name of the account that just authenticated successfully. * @param newlyAuthenticated If true, this user just authenticated for the first time. * If false, it's a returning user. */ @Override public void onAuthSuccess(String accountName, boolean newlyAuthenticated) { Account account = new Account(accountName, "com.google"); LOGD(TAG, "onAuthSuccess, account " + accountName + ", newlyAuthenticated=" + newlyAuthenticated); refreshAccountDependantData(); if (newlyAuthenticated) { LOGD(TAG, "Enabling auto sync on content provider for account " + accountName); // SyncHelper.updateSyncInterval(this, account); // SyncHelper.requestManualSync(account); } setupAccountBox(); populateNavDrawer(); registerGCMClient(); } @Override public void onAuthFailure(String accountName) { LOGD(TAG, "Auth failed for account " + accountName); refreshAccountDependantData(); } protected void refreshAccountDependantData() { // Force local data refresh for data that depends on the logged user: LOGD(TAG, "Refreshing MySchedule data"); getContentResolver().notifyChange(ScheduleContract.MySchedule.CONTENT_URI, null, false); } protected void retryAuth() { mLoginAndAuthHelper.retryAuthByUserRequest(); } /** * Initializes the Action Bar auto-hide (aka Quick Recall) effect. */ private void initActionBarAutoHide() { mActionBarAutoHideEnabled = true; mActionBarAutoHideMinY = getResources().getDimensionPixelSize(R.dimen.action_bar_auto_hide_min_y); mActionBarAutoHideSensivity = getResources().getDimensionPixelSize(R.dimen.action_bar_auto_hide_sensivity); } /** * Indicates that the main content has scrolled (for the purposes of showing/hiding * the action bar for the "action bar auto hide" effect). currentY and deltaY may be exact * (if the underlying view supports it) or may be approximate indications: * deltaY may be INT_MAX to mean "scrolled forward indeterminately" and INT_MIN to mean * "scrolled backward indeterminately". currentY may be 0 to mean "somewhere close to the * start of the list" and INT_MAX to mean "we don't know, but not at the start of the list" */ private void onMainContentScrolled(int currentY, int deltaY) { if (deltaY > mActionBarAutoHideSensivity) { deltaY = mActionBarAutoHideSensivity; } else if (deltaY < -mActionBarAutoHideSensivity) { deltaY = -mActionBarAutoHideSensivity; } if (Math.signum(deltaY) * Math.signum(mActionBarAutoHideSignal) < 0) { // deltaY is a motion opposite to the accumulated signal, so reset signal mActionBarAutoHideSignal = deltaY; } else { // add to accumulated signal mActionBarAutoHideSignal += deltaY; } boolean shouldShow = currentY < mActionBarAutoHideMinY || (mActionBarAutoHideSignal <= -mActionBarAutoHideSensivity); autoShowOrHideActionBar(shouldShow); } protected Toolbar getActionBarToolbar() { if (mActionBarToolbar == null) { mActionBarToolbar = (Toolbar) findViewById(R.id.toolbar_actionbar); if (mActionBarToolbar != null) { setSupportActionBar(mActionBarToolbar); } } return mActionBarToolbar; } protected void autoShowOrHideActionBar(boolean show) { if (show == mActionBarShown) { return; } mActionBarShown = show; onActionBarAutoShowOrHide(show); } protected void enableActionBarAutoHide(final ListView listView) { initActionBarAutoHide(); listView.setOnScrollListener(new AbsListView.OnScrollListener() { final static int ITEMS_THRESHOLD = 3; int lastFvi = 0; @Override public void onScrollStateChanged(AbsListView view, int scrollState) { } @Override public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) { onMainContentScrolled(firstVisibleItem <= ITEMS_THRESHOLD ? 0 : Integer.MAX_VALUE, lastFvi - firstVisibleItem > 0 ? Integer.MIN_VALUE : lastFvi == firstVisibleItem ? 0 : Integer.MAX_VALUE); lastFvi = firstVisibleItem; } }); } private View makeNavDrawerItem(final int itemId, ViewGroup container) { boolean selected = getSelfNavDrawerItem() == itemId; int layoutToInflate = 0; if (itemId == NAVDRAWER_ITEM_SEPARATOR) { layoutToInflate = R.layout.navdrawer_separator; } else if (itemId == NAVDRAWER_ITEM_SEPARATOR_SPECIAL) { layoutToInflate = R.layout.navdrawer_separator; } else { layoutToInflate = R.layout.navdrawer_item; } View view = getLayoutInflater().inflate(layoutToInflate, container, false); if (isSeparator(itemId)) { // we are done UIUtils.setAccessibilityIgnore(view); return view; } ImageView iconView = (ImageView) view.findViewById(R.id.icon); TextView titleView = (TextView) view.findViewById(R.id.title); int iconId = itemId >= 0 && itemId < NAVDRAWER_ICON_RES_ID.length ? NAVDRAWER_ICON_RES_ID[itemId] : 0; int titleId = itemId >= 0 && itemId < NAVDRAWER_TITLE_RES_ID.length ? NAVDRAWER_TITLE_RES_ID[itemId] : 0; // set icon and text iconView.setVisibility(iconId > 0 ? View.VISIBLE : View.GONE); if (iconId > 0) { iconView.setImageResource(iconId); } titleView.setText(getString(titleId)); formatNavDrawerItem(view, itemId, selected); view.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { onNavDrawerItemClicked(itemId); } }); return view; } private boolean isSpecialItem(int itemId) { return itemId == NAVDRAWER_ITEM_SETTINGS; } private boolean isSeparator(int itemId) { return itemId == NAVDRAWER_ITEM_SEPARATOR || itemId == NAVDRAWER_ITEM_SEPARATOR_SPECIAL; } private void formatNavDrawerItem(View view, int itemId, boolean selected) { if (isSeparator(itemId)) { // not applicable return; } ImageView iconView = (ImageView) view.findViewById(R.id.icon); TextView titleView = (TextView) view.findViewById(R.id.title); if (selected) { view.setBackgroundResource(R.drawable.selected_navdrawer_item_background); } // configure its appearance according to whether or not it's selected titleView.setTextColor(selected ? getResources().getColor(R.color.navdrawer_text_color_selected) : getResources().getColor(R.color.navdrawer_text_color)); iconView.setColorFilter(selected ? getResources().getColor(R.color.navdrawer_icon_tint_selected) : getResources().getColor(R.color.navdrawer_icon_tint)); } /** Registers device on the GCM server, if necessary. */ private void registerGCMClient() { } @Override protected void onDestroy() { super.onDestroy(); if (mGCMRegisterTask != null) { LOGD(TAG, "Cancelling GCM registration task."); mGCMRegisterTask.cancel(true); } SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this); sp.unregisterOnSharedPreferenceChangeListener(this); } private SyncStatusObserver mSyncStatusObserver = new SyncStatusObserver() { @Override public void onStatusChanged(int which) { runOnUiThread(new Runnable() { @Override public void run() { String accountName = AccountUtils.getActiveAccountName(BaseActivity.this); if (TextUtils.isEmpty(accountName)) { onRefreshingStateChanged(false); mManualSyncRequest = false; return; } Account account = new Account(accountName, "com.google"); boolean syncActive = ContentResolver.isSyncActive(account, ScheduleContract.CONTENT_AUTHORITY); boolean syncPending = ContentResolver.isSyncPending(account, ScheduleContract.CONTENT_AUTHORITY); if (!syncActive && !syncPending) { mManualSyncRequest = false; } onRefreshingStateChanged(false); } }); } }; protected void onRefreshingStateChanged(boolean refreshing) { if (mSwipeRefreshLayout != null) { mSwipeRefreshLayout.setRefreshing(refreshing); } } protected void enableDisableSwipeRefresh(boolean enable) { if (mSwipeRefreshLayout != null) { mSwipeRefreshLayout.setEnabled(enable); } } protected void registerHideableHeaderView(View hideableHeaderView) { if (!mHideableHeaderViews.contains(hideableHeaderView)) { mHideableHeaderViews.add(hideableHeaderView); } } protected void deregisterHideableHeaderView(View hideableHeaderView) { if (mHideableHeaderViews.contains(hideableHeaderView)) { mHideableHeaderViews.remove(hideableHeaderView); } } public LUtils getLUtils() { return mLUtils; } public int getThemedStatusBarColor() { return mThemedStatusBarColor; } public void setNormalStatusBarColor(int color) { mNormalStatusBarColor = color; if (mDrawerLayout != null) { mDrawerLayout.setStatusBarBackgroundColor(mNormalStatusBarColor); } } protected void onActionBarAutoShowOrHide(boolean shown) { if (mStatusBarColorAnimator != null) { mStatusBarColorAnimator.cancel(); } mStatusBarColorAnimator = ObjectAnimator .ofInt((mDrawerLayout != null) ? mDrawerLayout : mLUtils, (mDrawerLayout != null) ? "statusBarBackgroundColor" : "statusBarColor", shown ? Color.BLACK : mNormalStatusBarColor, shown ? mNormalStatusBarColor : Color.BLACK) .setDuration(250); if (mDrawerLayout != null) { mStatusBarColorAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { @Override public void onAnimationUpdate(ValueAnimator valueAnimator) { ViewCompat.postInvalidateOnAnimation(mDrawerLayout); } }); } mStatusBarColorAnimator.setEvaluator(ARGB_EVALUATOR); mStatusBarColorAnimator.start(); updateSwipeRefreshProgressBarTop(); for (View view : mHideableHeaderViews) { if (shown) { view.animate().translationY(0).alpha(1).setDuration(HEADER_HIDE_ANIM_DURATION) .setInterpolator(new DecelerateInterpolator()); } else { view.animate().translationY(-view.getBottom()).alpha(0).setDuration(HEADER_HIDE_ANIM_DURATION) .setInterpolator(new DecelerateInterpolator()); } } } @Override public boolean canSwipeRefreshChildScrollUp() { return false; } }