/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * 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 com.android.contacts.list;

import android.accounts.Account;
import android.app.Activity;
import android.content.ActivityNotFoundException;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.content.CursorLoader;
import android.content.Intent;
import android.content.Loader;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.res.Resources;
import android.database.Cursor;
import android.graphics.PorterDuff;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.provider.ContactsContract;
import android.provider.ContactsContract.Directory;
import androidx.core.content.ContextCompat;
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
import android.text.TextUtils;
import android.util.Log;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.accessibility.AccessibilityEvent;
import android.view.accessibility.AccessibilityManager;
import android.widget.Button;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout.LayoutParams;
import android.widget.TextView;
import android.widget.Toast;

import com.android.contacts.ContactSaveService;
import com.android.contacts.Experiments;
import com.android.contacts.R;
import com.android.contacts.activities.ActionBarAdapter;
import com.android.contacts.activities.PeopleActivity;
import com.android.contacts.compat.CompatUtils;
import com.android.contacts.interactions.ContactDeletionInteraction;
import com.android.contacts.interactions.ContactMultiDeletionInteraction;
import com.android.contacts.interactions.ContactMultiDeletionInteraction.MultiContactDeleteListener;
import com.android.contacts.logging.ListEvent;
import com.android.contacts.logging.Logger;
import com.android.contacts.logging.ScreenEvent;
import com.android.contacts.model.AccountTypeManager;
import com.android.contacts.model.account.AccountInfo;
import com.android.contacts.model.account.AccountWithDataSet;
import com.android.contacts.quickcontact.QuickContactActivity;
import com.android.contacts.util.AccountFilterUtil;
import com.android.contacts.util.ImplicitIntentsUtil;
import com.android.contacts.util.SharedPreferenceUtil;
import com.android.contacts.util.SyncUtil;
import com.android.contactsbind.FeatureHighlightHelper;
import com.android.contactsbind.experiments.Flags;
import com.google.common.util.concurrent.Futures;

import java.util.List;
import java.util.Locale;
import java.util.concurrent.Future;

/**
 * Fragment containing a contact list used for browsing (as compared to
 * picking a contact with one of the PICK intents).
 */
public class DefaultContactBrowseListFragment extends ContactBrowseListFragment
        implements EnableGlobalSyncDialogFragment.Listener {

    private static final String TAG = "DefaultListFragment";
    private static final String ENABLE_DEBUG_OPTIONS_HIDDEN_CODE = "debug debug!";
    private static final String KEY_DELETION_IN_PROGRESS = "deletionInProgress";
    private static final String KEY_SEARCH_RESULT_CLICKED = "search_result_clicked";

    private static final int ACTIVITY_REQUEST_CODE_SHARE = 0;

    private View mSearchHeaderView;
    private View mSearchProgress;
    private View mEmptyAccountView;
    private View mEmptyHomeView;
    private View mAccountFilterContainer;
    private TextView mSearchProgressText;

    private SwipeRefreshLayout mSwipeRefreshLayout;
    private final Handler mHandler = new Handler();
    private final Runnable mCancelRefresh = new Runnable() {
        @Override
        public void run() {
            if (mSwipeRefreshLayout.isRefreshing()) {
                mSwipeRefreshLayout.setRefreshing(false);
            }
        }
    };

    private View mAlertContainer;
    private TextView mAlertText;
    private ImageView mAlertDismissIcon;
    private int mReasonSyncOff = SyncUtil.SYNC_SETTING_SYNC_ON;

    private boolean mContactsAvailable;
    private boolean mEnableDebugMenuOptions;
    private boolean mIsRecreatedInstance;
    private boolean mOptionsMenuContactsAvailable;

    private boolean mCanSetActionBar = false;

    /**
     * If {@link #configureFragment()} is already called. Used to avoid calling it twice
     * in {@link #onResume()}.
     * (This initialization only needs to be done once in onResume() when the Activity was just
     * created from scratch -- i.e. onCreate() was just called)
     */
    private boolean mFragmentInitialized;

    private boolean mFromOnNewIntent;

    /**
     * This is to tell whether we need to restart ContactMultiDeletionInteraction and set listener.
     * if screen is rotated while deletion dialog is shown.
     */
    private boolean mIsDeletionInProgress;

    /**
     * This is to disable {@link #onOptionsItemSelected} when we trying to stop the
     * activity/fragment.
     */
    private boolean mDisableOptionItemSelected;

    private boolean mSearchResultClicked;

    private ActionBarAdapter mActionBarAdapter;
    private PeopleActivity mActivity;
    private ContactsRequest mContactsRequest;
    private ContactListFilterController mContactListFilterController;

    private Future<List<AccountInfo>> mWritableAccountsFuture;

    private final ActionBarAdapter.Listener mActionBarListener = new ActionBarAdapter.Listener() {
        @Override
        public void onAction(int action) {
            switch (action) {
                case ActionBarAdapter.Listener.Action.START_SELECTION_MODE:
                    displayCheckBoxes(true);
                    startSearchOrSelectionMode();
                    break;
                case ActionBarAdapter.Listener.Action.START_SEARCH_MODE:
                    if (!mIsRecreatedInstance) {
                        Logger.logScreenView(mActivity, ScreenEvent.ScreenType.SEARCH);
                    }
                    startSearchOrSelectionMode();
                    break;
                case ActionBarAdapter.Listener.Action.BEGIN_STOPPING_SEARCH_AND_SELECTION_MODE:
                    mActivity.showFabWithAnimation(/* showFab */ true);
                    break;
                case ActionBarAdapter.Listener.Action.STOP_SEARCH_AND_SELECTION_MODE:
                    // If queryString is empty, fragment data will not be reloaded,
                    // so hamburger promo should be checked now.
                    // Otherwise, promo should be checked and displayed after reloading, b/30706521.
                    if (TextUtils.isEmpty(getQueryString())) {
                        maybeShowHamburgerFeatureHighlight();
                    }
                    setQueryTextToFragment("");
                    maybeHideCheckBoxes();
                    mActivity.invalidateOptionsMenu();
                    mActivity.showFabWithAnimation(/* showFab */ true);

                    // Alert user if sync is off and not dismissed before
                    setSyncOffAlert();

                    // Determine whether the account has pullToRefresh feature
                    setSwipeRefreshLayoutEnabledOrNot(getFilter());
                    break;
                case ActionBarAdapter.Listener.Action.CHANGE_SEARCH_QUERY:
                    final String queryString = mActionBarAdapter.getQueryString();
                    setQueryTextToFragment(queryString);
                    updateDebugOptionsVisibility(
                            ENABLE_DEBUG_OPTIONS_HIDDEN_CODE.equals(queryString));
                    break;
                default:
                    throw new IllegalStateException("Unknown ActionBarAdapter action: " + action);
            }
        }

        private void startSearchOrSelectionMode() {
            configureContactListFragment();
            maybeHideCheckBoxes();
            mActivity.invalidateOptionsMenu();
            mActivity.showFabWithAnimation(/* showFab */ false);

            final Context context = getContext();
            if (!SharedPreferenceUtil.getHamburgerPromoTriggerActionHappenedBefore(context)) {
                SharedPreferenceUtil.setHamburgerPromoTriggerActionHappenedBefore(context);
            }
        }

        private void updateDebugOptionsVisibility(boolean visible) {
            if (mEnableDebugMenuOptions != visible) {
                mEnableDebugMenuOptions = visible;
                mActivity.invalidateOptionsMenu();
            }
        }

        private void setQueryTextToFragment(String query) {
            setQueryString(query, true);
            setVisibleScrollbarEnabled(!isSearchMode());
        }

        @Override
        public void onUpButtonPressed() {
            mActivity.onBackPressed();
        }
    };

    private final View.OnClickListener mAddContactListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            AccountFilterUtil.startEditorIntent(getContext(), mActivity.getIntent(), getFilter());
        }
    };

    public DefaultContactBrowseListFragment() {
        setPhotoLoaderEnabled(true);
        // Don't use a QuickContactBadge. Just use a regular ImageView. Using a QuickContactBadge
        // inside the ListView prevents us from using MODE_FULLY_EXPANDED and messes up ripples.
        setQuickContactEnabled(false);
        setSectionHeaderDisplayEnabled(true);
        setVisibleScrollbarEnabled(true);
        setDisplayDirectoryHeader(false);
        setHasOptionsMenu(true);
    }

    /**
     * Whether a search result was clicked by the user. Tracked so that we can distinguish
     * between exiting the search mode after a result was clicked from exiting w/o clicking
     * any search result.
     */
    public boolean wasSearchResultClicked() {
        return mSearchResultClicked;
    }

    /**
     * Resets whether a search result was clicked by the user to false.
     */
    public void resetSearchResultClicked() {
        mSearchResultClicked = false;
    }

    @Override
    public CursorLoader createCursorLoader(Context context) {
        return new FavoritesAndContactsLoader(context);
    }

    @Override
    public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
        if (loader.getId() == Directory.DEFAULT) {
            bindListHeader(data == null ? 0 : data.getCount());
        }
        super.onLoadFinished(loader, data);
        if (!isSearchMode()) {
            maybeShowHamburgerFeatureHighlight();
        }
        if (mActionBarAdapter != null) {
            mActionBarAdapter.updateOverflowButtonColor();
        }
    }

    private void maybeShowHamburgerFeatureHighlight() {
        if (mActionBarAdapter!= null && !mActionBarAdapter.isSearchMode()
                && !mActionBarAdapter.isSelectionMode()
                && !isTalkbackOnAndOnPreLollipopMr1()
                && SharedPreferenceUtil.getShouldShowHamburgerPromo(getContext())) {
            if (FeatureHighlightHelper.showHamburgerFeatureHighlight(mActivity)) {
                SharedPreferenceUtil.setHamburgerPromoDisplayedBefore(getContext());
            }
        }
    }

    // There's a crash if we show feature highlight when Talkback is on, on API 21 and below.
    // See b/31180524.
    private boolean isTalkbackOnAndOnPreLollipopMr1(){
        return ((AccessibilityManager) getContext().getSystemService(Context.ACCESSIBILITY_SERVICE))
                .isTouchExplorationEnabled()
                    && !CompatUtils.isLollipopMr1Compatible();
    }

    private void bindListHeader(int numberOfContacts) {
        final ContactListFilter filter = getFilter();
        // If the phone has at least one Google account whose sync status is unsyncable or pending
        // or active, we have to make mAccountFilterContainer visible.
        if (!isSearchMode() && numberOfContacts <= 0 && shouldShowEmptyView(filter)) {
            if (filter != null && filter.isContactsFilterType()) {
                makeViewVisible(mEmptyHomeView);
            } else {
                makeViewVisible(mEmptyAccountView);
            }
            return;
        }
        makeViewVisible(mAccountFilterContainer);
        if (isSearchMode()) {
            hideHeaderAndAddPadding(getContext(), getListView(), mAccountFilterContainer);
        } else if (filter.filterType == ContactListFilter.FILTER_TYPE_CUSTOM) {
            bindListHeaderCustom(getListView(), mAccountFilterContainer);
        } else if (filter.filterType != ContactListFilter.FILTER_TYPE_ALL_ACCOUNTS) {
            final AccountWithDataSet accountWithDataSet = new AccountWithDataSet(
                    filter.accountName, filter.accountType, filter.dataSet);
            bindListHeader(getContext(), getListView(), mAccountFilterContainer,
                    accountWithDataSet, numberOfContacts);
        } else {
            hideHeaderAndAddPadding(getContext(), getListView(), mAccountFilterContainer);
        }
    }

    /**
     * If at least one Google account is unsyncable or its sync status is pending or active, we
     * should not show empty view even if the number of contacts is 0. We should show sync status
     * with empty list instead.
     */
    private boolean shouldShowEmptyView(ContactListFilter filter) {
        if (filter == null) {
            return true;
        }
        // TODO(samchen) : Check ContactListFilter.FILTER_TYPE_CUSTOM
        if (ContactListFilter.FILTER_TYPE_DEFAULT == filter.filterType
                || ContactListFilter.FILTER_TYPE_ALL_ACCOUNTS == filter.filterType) {
            final List<AccountInfo> syncableAccounts =
                    AccountTypeManager.getInstance(getContext()).getWritableGoogleAccounts();

            if (syncableAccounts != null && syncableAccounts.size() > 0) {
                for (AccountInfo info : syncableAccounts) {
                    // Won't be null because Google accounts have a non-null name and type.
                    final Account account = info.getAccount().getAccountOrNull();
                    if (SyncUtil.isSyncStatusPendingOrActive(account)
                            || SyncUtil.isUnsyncableGoogleAccount(account)) {
                        return false;
                    }
                }
            }
        } else if (ContactListFilter.FILTER_TYPE_ACCOUNT == filter.filterType) {
            final Account account = new Account(filter.accountName, filter.accountType);
            return !(SyncUtil.isSyncStatusPendingOrActive(account)
                    || SyncUtil.isUnsyncableGoogleAccount(account));
        }
        return true;
    }

    // Show the view that's specified by id and hide the other two.
    private void makeViewVisible(View view) {
        mEmptyAccountView.setVisibility(view == mEmptyAccountView ? View.VISIBLE : View.GONE);
        mEmptyHomeView.setVisibility(view == mEmptyHomeView ? View.VISIBLE : View.GONE);
        mAccountFilterContainer.setVisibility(
                view == mAccountFilterContainer ? View.VISIBLE : View.GONE);
    }

    public void scrollToTop() {
        if (getListView() != null) {
            getListView().setSelection(0);
        }
    }

    @Override
    protected void onItemClick(int position, long id) {
        final Uri uri = getAdapter().getContactUri(position);
        if (uri == null) {
            return;
        }
        if (getAdapter().isDisplayingCheckBoxes()) {
            super.onItemClick(position, id);
            return;
        } else {
            if (isSearchMode()) {
                mSearchResultClicked = true;
                Logger.logSearchEvent(createSearchStateForSearchResultClick(position));
            }
        }
        viewContact(position, uri, getAdapter().isEnterpriseContact(position));
    }

    @Override
    protected ContactListAdapter createListAdapter() {
        DefaultContactListAdapter adapter = new DefaultContactListAdapter(getContext());
        adapter.setSectionHeaderDisplayEnabled(isSectionHeaderDisplayEnabled());
        adapter.setDisplayPhotos(true);
        adapter.setPhotoPosition(
                ContactListItemView.getDefaultPhotoPosition(/* opposite = */ false));
        return adapter;
    }

    @Override
    public ContactListFilter getFilter() {
        return mContactListFilterController.getFilter();
    }

    @Override
    protected View inflateView(LayoutInflater inflater, ViewGroup container) {
        final View view = inflater.inflate(R.layout.contact_list_content, null);

        mAccountFilterContainer = view.findViewById(R.id.account_filter_header_container);

        // Add empty main view and account view to list.
        final FrameLayout contactListLayout = (FrameLayout) view.findViewById(R.id.contact_list);
        mEmptyAccountView = getEmptyAccountView(inflater);
        mEmptyHomeView = getEmptyHomeView(inflater);
        contactListLayout.addView(mEmptyAccountView);
        contactListLayout.addView(mEmptyHomeView);

        return view;
    }

    private View getEmptyHomeView(LayoutInflater inflater) {
        final View emptyHomeView = inflater.inflate(R.layout.empty_home_view, null);
        // Set image margins.
        final ImageView image = (ImageView) emptyHomeView.findViewById(R.id.empty_home_image);
        final LayoutParams params = (LayoutParams) image.getLayoutParams();
        final int screenHeight = getResources().getDisplayMetrics().heightPixels;
        final int marginTop = screenHeight / 2 -
                getResources().getDimensionPixelSize(R.dimen.empty_home_view_image_offset) ;
        params.setMargins(0, marginTop, 0, 0);
        params.gravity = Gravity.CENTER_HORIZONTAL;
        image.setLayoutParams(params);

        // Set up add contact button.
        final Button addContactButton =
                (Button) emptyHomeView.findViewById(R.id.add_contact_button);
        addContactButton.setOnClickListener(mAddContactListener);
        return emptyHomeView;
    }

    private View getEmptyAccountView(LayoutInflater inflater) {
        final View emptyAccountView = inflater.inflate(R.layout.empty_account_view, null);
        // Set image margins.
        final ImageView image = (ImageView) emptyAccountView.findViewById(R.id.empty_account_image);
        final LayoutParams params = (LayoutParams) image.getLayoutParams();
        final int height = getResources().getDisplayMetrics().heightPixels;
        final int divisor =
                getResources().getInteger(R.integer.empty_account_view_image_margin_divisor);
        final int offset =
                getResources().getDimensionPixelSize(R.dimen.empty_account_view_image_offset);
        params.setMargins(0, height / divisor + offset, 0, 0);
        params.gravity = Gravity.CENTER_HORIZONTAL;
        image.setLayoutParams(params);

        // Set up add contact button.
        final Button addContactButton =
                (Button) emptyAccountView.findViewById(R.id.add_contact_button);
        addContactButton.setOnClickListener(mAddContactListener);
        return emptyAccountView;
    }

    @Override
    public void onCreate(Bundle savedState) {
        super.onCreate(savedState);
        mIsRecreatedInstance = (savedState != null);
        mContactListFilterController = ContactListFilterController.getInstance(getContext());
        mContactListFilterController.checkFilterValidity(false);
        // Use FILTER_TYPE_ALL_ACCOUNTS filter if the instance is not a re-created one.
        // This is useful when user upgrades app while an account filter was
        // stored in sharedPreference in a previous version of Contacts app.
        final ContactListFilter filter = mIsRecreatedInstance
                ? getFilter()
                : AccountFilterUtil.createContactsFilter(getContext());
        setContactListFilter(filter);
    }

    @Override
    protected void onCreateView(LayoutInflater inflater, ViewGroup container) {
        super.onCreateView(inflater, container);

        initSwipeRefreshLayout();

        // Putting the header view inside a container will allow us to make
        // it invisible later. See checkHeaderViewVisibility()
        final FrameLayout headerContainer = new FrameLayout(inflater.getContext());
        mSearchHeaderView = inflater.inflate(R.layout.search_header, null, false);
        headerContainer.addView(mSearchHeaderView);
        getListView().addHeaderView(headerContainer, null, false);
        checkHeaderViewVisibility();

        mSearchProgress = getView().findViewById(R.id.search_progress);
        mSearchProgressText = (TextView) mSearchHeaderView.findViewById(R.id.totalContactsText);

        mAlertContainer = getView().findViewById(R.id.alert_container);
        mAlertText = (TextView) mAlertContainer.findViewById(R.id.alert_text);
        mAlertDismissIcon = (ImageView) mAlertContainer.findViewById(R.id.alert_dismiss_icon);
        mAlertText.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                turnSyncOn();
            }
        });
        mAlertDismissIcon.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                dismiss();
            }
        });

        mAlertContainer.setVisibility(View.GONE);
    }

    private void turnSyncOn() {
        final ContactListFilter filter = getFilter();
        if (filter.filterType == ContactListFilter.FILTER_TYPE_ACCOUNT
                && mReasonSyncOff == SyncUtil.SYNC_SETTING_ACCOUNT_SYNC_OFF) {
            ContentResolver.setSyncAutomatically(
                    new Account(filter.accountName, filter.accountType),
                    ContactsContract.AUTHORITY, true);
            mAlertContainer.setVisibility(View.GONE);
        } else {
            final EnableGlobalSyncDialogFragment dialog = new
                    EnableGlobalSyncDialogFragment();
            dialog.show(this, filter);
        }
    }

    @Override
    public void onEnableAutoSync(ContactListFilter filter) {
        // Turn on auto-sync
        ContentResolver.setMasterSyncAutomatically(true);

        // This should be OK (won't block) because this only happens after a user action
        final List<AccountInfo> accountInfos = Futures.getUnchecked(mWritableAccountsFuture);
        // Also enable Contacts sync
        final List<AccountWithDataSet> accounts = AccountInfo.extractAccounts(accountInfos);
        final List<Account> syncableAccounts = filter.getSyncableAccounts(accounts);
        if (syncableAccounts != null && syncableAccounts.size() > 0) {
            for (Account account : syncableAccounts) {
                ContentResolver.setSyncAutomatically(new Account(account.name, account.type),
                        ContactsContract.AUTHORITY, true);
            }
        }
        mAlertContainer.setVisibility(View.GONE);
    }

    private void dismiss() {
        if (mReasonSyncOff == SyncUtil.SYNC_SETTING_GLOBAL_SYNC_OFF) {
            SharedPreferenceUtil.incNumOfDismissesForAutoSyncOff(getContext());
        } else if (mReasonSyncOff == SyncUtil.SYNC_SETTING_ACCOUNT_SYNC_OFF) {
            SharedPreferenceUtil.incNumOfDismissesForAccountSyncOff(
                    getContext(), getFilter().accountName);
        }
        mAlertContainer.setVisibility(View.GONE);
    }

    private void initSwipeRefreshLayout() {
        mSwipeRefreshLayout = (SwipeRefreshLayout) mView.findViewById(R.id.swipe_refresh);
        if (mSwipeRefreshLayout == null) {
            return;
        }

        mSwipeRefreshLayout.setEnabled(true);
        // Request sync contacts
        mSwipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
            @Override
            public void onRefresh() {
                mHandler.removeCallbacks(mCancelRefresh);

                final boolean isNetworkConnected = SyncUtil.isNetworkConnected(getContext());
                if (!isNetworkConnected) {
                    mSwipeRefreshLayout.setRefreshing(false);
                    ((PeopleActivity)getActivity()).showConnectionErrorMsg();
                    return;
                }

                syncContacts(getFilter());
                mHandler.postDelayed(mCancelRefresh, Flags.getInstance()
                        .getInteger(Experiments.PULL_TO_REFRESH_CANCEL_REFRESH_MILLIS));
            }
        });
        mSwipeRefreshLayout.setColorSchemeResources(
                R.color.swipe_refresh_color1,
                R.color.swipe_refresh_color2,
                R.color.swipe_refresh_color3,
                R.color.swipe_refresh_color4);
        mSwipeRefreshLayout.setDistanceToTriggerSync(
                (int) getResources().getDimension(R.dimen.pull_to_refresh_distance));
    }

    /**
     * Request sync for the Google accounts (not include Google+ accounts) specified by the given
     * filter.
     */
    private void syncContacts(ContactListFilter filter) {
        if (filter == null) {
            return;
        }

        final Bundle bundle = new Bundle();
        bundle.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true);
        bundle.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);

        final List<AccountWithDataSet> accounts = AccountInfo.extractAccounts(
                Futures.getUnchecked(mWritableAccountsFuture));
        final List<Account> syncableAccounts = filter.getSyncableAccounts(accounts);
        if (syncableAccounts != null && syncableAccounts.size() > 0) {
            for (Account account : syncableAccounts) {
                // We can prioritize Contacts sync if sync is not initialized yet.
                if (!SyncUtil.isSyncStatusPendingOrActive(account)
                        || SyncUtil.isUnsyncableGoogleAccount(account)) {
                    ContentResolver.requestSync(account, ContactsContract.AUTHORITY, bundle);
                }
            }
        }
    }

    private void setSyncOffAlert() {
        final ContactListFilter filter = getFilter();
        final Account account =  filter.filterType == ContactListFilter.FILTER_TYPE_ACCOUNT
                && filter.isGoogleAccountType()
                ? new Account(filter.accountName, filter.accountType) : null;

        if (account == null && !filter.isContactsFilterType()) {
            mAlertContainer.setVisibility(View.GONE);
        } else {
            mReasonSyncOff = SyncUtil.calculateReasonSyncOff(getContext(), account);
            final boolean isAlertVisible =
                    SyncUtil.isAlertVisible(getContext(), account, mReasonSyncOff);
            setSyncOffMsg(mReasonSyncOff);
            mAlertContainer.setVisibility(isAlertVisible ? View.VISIBLE : View.GONE);
        }
    }

    private void setSyncOffMsg(int reason) {
        final Resources resources = getResources();
        switch (reason) {
            case SyncUtil.SYNC_SETTING_GLOBAL_SYNC_OFF:
                mAlertText.setText(resources.getString(R.string.auto_sync_off));
                break;
            case SyncUtil.SYNC_SETTING_ACCOUNT_SYNC_OFF:
                mAlertText.setText(resources.getString(R.string.account_sync_off));
                break;
            default:
        }
    }

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

        mActivity = (PeopleActivity) getActivity();
        mActionBarAdapter = new ActionBarAdapter(mActivity, mActionBarListener,
                mActivity.getSupportActionBar(), mActivity.getToolbar(),
                R.string.enter_contact_name);
        mActionBarAdapter.setShowHomeIcon(true);
        initializeActionBarAdapter(savedInstanceState);
        if (isSearchMode()) {
            mActionBarAdapter.setFocusOnSearchView();
        }

        setCheckBoxListListener(new CheckBoxListListener());
        setOnContactListActionListener(new ContactBrowserActionListener());
        if (savedInstanceState != null) {
            if (savedInstanceState.getBoolean(KEY_DELETION_IN_PROGRESS)) {
                deleteSelectedContacts();
            }
            mSearchResultClicked = savedInstanceState.getBoolean(KEY_SEARCH_RESULT_CLICKED);
        }

        setDirectorySearchMode();
        mCanSetActionBar = true;
    }

    public void initializeActionBarAdapter(Bundle savedInstanceState) {
        if (mActionBarAdapter != null) {
            mActionBarAdapter.initialize(savedInstanceState, mContactsRequest);
        }
    }

    private void configureFragment() {
        if (mFragmentInitialized && !mFromOnNewIntent) {
            return;
        }

        mFragmentInitialized = true;

        if (mFromOnNewIntent || !mIsRecreatedInstance) {
            mFromOnNewIntent = false;
            configureFragmentForRequest();
        }

        configureContactListFragment();
    }

    private void configureFragmentForRequest() {
        ContactListFilter filter = null;
        final int actionCode = mContactsRequest.getActionCode();
        boolean searchMode = mContactsRequest.isSearchMode();
        switch (actionCode) {
            case ContactsRequest.ACTION_ALL_CONTACTS:
                filter = AccountFilterUtil.createContactsFilter(getContext());
                break;
            case ContactsRequest.ACTION_CONTACTS_WITH_PHONES:
                filter = ContactListFilter.createFilterWithType(
                        ContactListFilter.FILTER_TYPE_WITH_PHONE_NUMBERS_ONLY);
                break;

            case ContactsRequest.ACTION_FREQUENT:
            case ContactsRequest.ACTION_STREQUENT:
            case ContactsRequest.ACTION_STARRED:
            case ContactsRequest.ACTION_VIEW_CONTACT:
            default:
                break;
        }

        if (filter != null) {
            setContactListFilter(filter);
            searchMode = false;
        }

        if (mContactsRequest.getContactUri() != null) {
            searchMode = false;
        }

        mActionBarAdapter.setSearchMode(searchMode);
        configureContactListFragmentForRequest();
    }

    private void configureContactListFragmentForRequest() {
        final Uri contactUri = mContactsRequest.getContactUri();
        if (contactUri != null) {
            setSelectedContactUri(contactUri);
        }

        setQueryString(mActionBarAdapter.getQueryString(), true);
        setVisibleScrollbarEnabled(!isSearchMode());
    }

    private void setDirectorySearchMode() {
        if (mContactsRequest != null && mContactsRequest.isDirectorySearchEnabled()) {
            setDirectorySearchMode(DirectoryListLoader.SEARCH_MODE_DEFAULT);
        } else {
            setDirectorySearchMode(DirectoryListLoader.SEARCH_MODE_NONE);
        }
    }

    @Override
    public void onResume() {
        super.onResume();
        configureFragment();
        maybeShowHamburgerFeatureHighlight();
        // Re-register the listener, which may have been cleared when onSaveInstanceState was
        // called. See also: onSaveInstanceState
        mActionBarAdapter.setListener(mActionBarListener);
        mDisableOptionItemSelected = false;
        maybeHideCheckBoxes();

        mWritableAccountsFuture = AccountTypeManager.getInstance(getContext()).filterAccountsAsync(
                AccountTypeManager.writableFilter());
    }

    private void maybeHideCheckBoxes() {
        if (!mActionBarAdapter.isSelectionMode()) {
            displayCheckBoxes(false);
        }
    }

    public ActionBarAdapter getActionBarAdapter(){
        return mActionBarAdapter;
    }

    @Override
    protected void setSearchMode(boolean flag) {
        super.setSearchMode(flag);
        checkHeaderViewVisibility();
        if (!flag) showSearchProgress(false);
    }

    /** Show or hide the directory-search progress spinner. */
    private void showSearchProgress(boolean show) {
        if (mSearchProgress != null) {
            mSearchProgress.setVisibility(show ? View.VISIBLE : View.GONE);
        }
    }

    private void checkHeaderViewVisibility() {
        // Hide the search header by default.
        if (mSearchHeaderView != null) {
            mSearchHeaderView.setVisibility(View.GONE);
        }
    }

    @Override
    protected void setListHeader() {
        if (!isSearchMode()) {
            return;
        }
        ContactListAdapter adapter = getAdapter();
        if (adapter == null) {
            return;
        }

        // In search mode we only display the header if there is nothing found
        if (TextUtils.isEmpty(getQueryString()) || !adapter.areAllPartitionsEmpty()) {
            mSearchHeaderView.setVisibility(View.GONE);
            showSearchProgress(false);
        } else {
            mSearchHeaderView.setVisibility(View.VISIBLE);
            if (adapter.isLoading()) {
                mSearchProgressText.setText(R.string.search_results_searching);
                showSearchProgress(true);
            } else {
                mSearchProgressText.setText(R.string.listFoundAllContactsZero);
                mSearchProgressText.sendAccessibilityEvent(
                        AccessibilityEvent.TYPE_VIEW_SELECTED);
                showSearchProgress(false);
            }
        }
    }

    public SwipeRefreshLayout getSwipeRefreshLayout() {
        return mSwipeRefreshLayout;
    }

    private final class CheckBoxListListener implements OnCheckBoxListActionListener {
        @Override
        public void onStartDisplayingCheckBoxes() {
            mActionBarAdapter.setSelectionMode(true);
            mActivity.invalidateOptionsMenu();
        }

        @Override
        public void onSelectedContactIdsChanged() {
            mActionBarAdapter.setSelectionCount(getSelectedContactIds().size());
            mActivity.invalidateOptionsMenu();
            mActionBarAdapter.updateOverflowButtonColor();
        }

        @Override
        public void onStopDisplayingCheckBoxes() {
            mActionBarAdapter.setSelectionMode(false);
        }
    }

    public void setFilterAndUpdateTitle(ContactListFilter filter) {
        setFilterAndUpdateTitle(filter, true);
    }

    private void setFilterAndUpdateTitle(ContactListFilter filter, boolean restoreSelectedUri) {
        setContactListFilter(filter);
        updateListFilter(filter, restoreSelectedUri);
        mActivity.setTitle(AccountFilterUtil.getActionBarTitleForFilter(mActivity, filter));

        // Alert user if sync is off and not dismissed before
        setSyncOffAlert();

        // Determine whether the account has pullToRefresh feature
        setSwipeRefreshLayoutEnabledOrNot(filter);
    }

    private void setSwipeRefreshLayoutEnabledOrNot(ContactListFilter filter) {
        final SwipeRefreshLayout swipeRefreshLayout = getSwipeRefreshLayout();
        if (swipeRefreshLayout == null) {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "Can not load swipeRefreshLayout, swipeRefreshLayout is null");
            }
            return;
        }

        swipeRefreshLayout.setRefreshing(false);
        swipeRefreshLayout.setEnabled(false);

        if (filter != null && !mActionBarAdapter.isSearchMode()
                && !mActionBarAdapter.isSelectionMode()) {
            if (filter.isSyncable()
                    || (filter.shouldShowSyncState()
                    && SyncUtil.hasSyncableAccount(AccountTypeManager.getInstance(getContext())))) {
                swipeRefreshLayout.setEnabled(true);
            }
        }
    }

    private void configureContactListFragment() {
        // Filter may be changed when activity is in background.
        setFilterAndUpdateTitle(getFilter());
        setVerticalScrollbarPosition(getScrollBarPosition());
        setSelectionVisible(false);
        mActivity.invalidateOptionsMenu();
    }

    private int getScrollBarPosition() {
        final Locale locale = Locale.getDefault();
        final boolean isRTL =
                TextUtils.getLayoutDirectionFromLocale(locale) == View.LAYOUT_DIRECTION_RTL;
        return isRTL ? View.SCROLLBAR_POSITION_LEFT : View.SCROLLBAR_POSITION_RIGHT;
    }

    private final class ContactBrowserActionListener implements OnContactBrowserActionListener {
        ContactBrowserActionListener() {}

        @Override
        public void onSelectionChange() {
        }

        @Override
        public void onViewContactAction(int position, Uri contactLookupUri,
                boolean isEnterpriseContact) {
            if (isEnterpriseContact) {
                // No implicit intent as user may have a different contacts app in work profile.
                ContactsContract.QuickContact.showQuickContact(getContext(), new Rect(),
                        contactLookupUri, QuickContactActivity.MODE_FULLY_EXPANDED, null);
            } else {
                final int previousScreen;
                if (isSearchMode()) {
                    previousScreen = ScreenEvent.ScreenType.SEARCH;
                } else {
                    if (isAllContactsFilter(getFilter())) {
                        if (position < getAdapter().getNumberOfFavorites()) {
                            previousScreen = ScreenEvent.ScreenType.FAVORITES;
                        } else {
                            previousScreen = ScreenEvent.ScreenType.ALL_CONTACTS;
                        }
                    } else {
                        previousScreen = ScreenEvent.ScreenType.LIST_ACCOUNT;
                    }
                }

                Logger.logListEvent(ListEvent.ActionType.CLICK,
                        /* listType */ getListTypeIncludingSearch(),
                        /* count */ getAdapter().getCount(),
                        /* clickedIndex */ position, /* numSelected */ 0);

                ImplicitIntentsUtil.startQuickContact(
                        getActivity(), contactLookupUri, previousScreen);
            }
        }

        @Override
        public void onDeleteContactAction(Uri contactUri) {
            ContactDeletionInteraction.start(mActivity, contactUri, false);
        }

        @Override
        public void onFinishAction() {
            mActivity.onBackPressed();
        }

        @Override
        public void onInvalidSelection() {
            ContactListFilter filter;
            ContactListFilter currentFilter = getFilter();
            if (currentFilter != null
                    && currentFilter.filterType == ContactListFilter.FILTER_TYPE_SINGLE_CONTACT) {
                filter = AccountFilterUtil.createContactsFilter(getContext());
                setFilterAndUpdateTitle(filter);
            } else {
                filter = ContactListFilter.createFilterWithType(
                        ContactListFilter.FILTER_TYPE_SINGLE_CONTACT);
                setFilterAndUpdateTitle(filter, /* restoreSelectedUri */ false);
            }
            setContactListFilter(filter);
        }
    }

    private boolean isAllContactsFilter(ContactListFilter filter) {
        return filter != null && filter.isContactsFilterType();
    }

    public void setContactsAvailable(boolean contactsAvailable) {
        mContactsAvailable = contactsAvailable;
    }

    /**
     * Set filter via ContactListFilterController
     */
    private void setContactListFilter(ContactListFilter filter) {
        mContactListFilterController.setContactListFilter(filter,
                /* persistent */ isAllContactsFilter(filter));
    }

    @Override
    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
        if (!mContactsAvailable || mActivity.isInSecondLevel()) {
            // If contacts aren't available or this fragment is not visible, hide all menu items.
            return;
        }
        super.onCreateOptionsMenu(menu, inflater);
        inflater.inflate(R.menu.people_options, menu);
    }

    @Override
    public void onPrepareOptionsMenu(Menu menu) {
        mOptionsMenuContactsAvailable = mContactsAvailable;
        if (!mOptionsMenuContactsAvailable) {
            return;
        }

        final boolean isSearchOrSelectionMode = mActionBarAdapter.isSearchMode()
                || mActionBarAdapter.isSelectionMode();
        makeMenuItemVisible(menu, R.id.menu_search, !isSearchOrSelectionMode);

        final boolean showSelectedContactOptions = mActionBarAdapter.isSelectionMode()
                && getSelectedContactIds().size() != 0;
        makeMenuItemVisible(menu, R.id.menu_share, showSelectedContactOptions);
        makeMenuItemVisible(menu, R.id.menu_delete, showSelectedContactOptions);
        final boolean showLinkContactsOptions = mActionBarAdapter.isSelectionMode()
                && getSelectedContactIds().size() > 1;
        makeMenuItemVisible(menu, R.id.menu_join, showLinkContactsOptions);

        // Debug options need to be visible even in search mode.
        makeMenuItemVisible(menu, R.id.export_database, mEnableDebugMenuOptions &&
                hasExportIntentHandler());

        // Light tint the icons for normal mode, dark tint for search or selection mode.
        for (int i = 0; i < menu.size(); ++i) {
            final Drawable icon = menu.getItem(i).getIcon();
            if (icon != null && !isSearchOrSelectionMode) {
                icon.mutate().setColorFilter(ContextCompat.getColor(getContext(),
                        R.color.actionbar_icon_color), PorterDuff.Mode.SRC_ATOP);
            }
        }
    }

    private void makeMenuItemVisible(Menu menu, int itemId, boolean visible) {
        final MenuItem item = menu.findItem(itemId);
        if (item != null) {
            item.setVisible(visible);
        }
    }

    private boolean hasExportIntentHandler() {
        final Intent intent = new Intent();
        intent.setAction("com.android.providers.contacts.DUMP_DATABASE");
        final List<ResolveInfo> receivers =
                getContext().getPackageManager().queryIntentActivities(intent,
                PackageManager.MATCH_DEFAULT_ONLY);
        return receivers != null && receivers.size() > 0;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        if (mDisableOptionItemSelected) {
            return false;
        }

        final int id = item.getItemId();
        if (id == android.R.id.home) {
            if (mActionBarAdapter.isUpShowing()) {
                // "UP" icon press -- should be treated as "back".
                mActivity.onBackPressed();
            }
            return true;
        } else if (id == R.id.menu_search) {
            if (!mActionBarAdapter.isSelectionMode()) {
                mActionBarAdapter.setSearchMode(true);
            }
            return true;
        } else if (id == R.id.menu_share) {
            shareSelectedContacts();
            return true;
        } else if (id == R.id.menu_join) {
            Logger.logListEvent(ListEvent.ActionType.LINK,
                        /* listType */ getListTypeIncludingSearch(),
                        /* count */ getAdapter().getCount(), /* clickedIndex */ -1,
                        /* numSelected */ getAdapter().getSelectedContactIds().size());
            joinSelectedContacts();
            return true;
        } else if (id == R.id.menu_delete) {
            deleteSelectedContacts();
            return true;
        } else if (id == R.id.export_database) {
            final Intent intent = new Intent("com.android.providers.contacts.DUMP_DATABASE");
            intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
            ImplicitIntentsUtil.startActivityOutsideApp(getContext(), intent);
            return true;
        }
        return super.onOptionsItemSelected(item);
    }

    /**
     * Share all contacts that are currently selected. This method is pretty inefficient for
     * handling large numbers of contacts. I don't expect this to be a problem.
     */
    private void shareSelectedContacts() {
        final StringBuilder uriListBuilder = new StringBuilder();
        for (Long contactId : getSelectedContactIds()) {
            final Uri contactUri = ContentUris.withAppendedId(
                    ContactsContract.Contacts.CONTENT_URI, contactId);
            final Uri lookupUri = ContactsContract.Contacts.getLookupUri(
                    getContext().getContentResolver(), contactUri);
            if (lookupUri == null) {
                continue;
            }
            final List<String> pathSegments = lookupUri.getPathSegments();
            if (pathSegments.size() < 2) {
                continue;
            }
            final String lookupKey = pathSegments.get(pathSegments.size() - 2);
            if (uriListBuilder.length() > 0) {
                uriListBuilder.append(':');
            }
            uriListBuilder.append(Uri.encode(lookupKey));
        }
        if (uriListBuilder.length() == 0) {
            return;
        }
        final Uri uri = Uri.withAppendedPath(
                ContactsContract.Contacts.CONTENT_MULTI_VCARD_URI,
                Uri.encode(uriListBuilder.toString()));
        final Intent intent = new Intent(Intent.ACTION_SEND);
        intent.setType(ContactsContract.Contacts.CONTENT_VCARD_TYPE);
        intent.putExtra(Intent.EXTRA_STREAM, uri);
        try {
            startActivityForResult(Intent.createChooser(intent, getResources().getQuantityString(
                    R.plurals.title_share_via,/* quantity */ getSelectedContactIds().size()))
                    , ACTIVITY_REQUEST_CODE_SHARE);
        } catch (final ActivityNotFoundException ex) {
            Toast.makeText(getContext(), R.string.share_error, Toast.LENGTH_SHORT).show();
        }
    }

    private void joinSelectedContacts() {
        final Context context = getContext();
        final Intent intent = ContactSaveService.createJoinSeveralContactsIntent(
                context, getSelectedContactIdsArray());
        context.startService(intent);

        mActionBarAdapter.setSelectionMode(false);
    }

    private void deleteSelectedContacts() {
        final ContactMultiDeletionInteraction multiDeletionInteraction =
                ContactMultiDeletionInteraction.start(this, getSelectedContactIds());
        multiDeletionInteraction.setListener(new MultiDeleteListener());
        mIsDeletionInProgress = true;
    }

    private final class MultiDeleteListener implements MultiContactDeleteListener {
        @Override
        public void onDeletionFinished() {
            // The parameters count and numSelected are both the number of contacts before deletion.
            Logger.logListEvent(ListEvent.ActionType.DELETE,
                /* listType */ getListTypeIncludingSearch(),
                /* count */ getAdapter().getCount(), /* clickedIndex */ -1,
                /* numSelected */ getSelectedContactIds().size());
            mActionBarAdapter.setSelectionMode(false);
            mIsDeletionInProgress = false;
        }
    }

    private int getListTypeIncludingSearch() {
        return isSearchMode() ? ListEvent.ListType.SEARCH_RESULT : getListType();
    }

    public void setParameters(ContactsRequest contactsRequest, boolean fromOnNewIntent) {
        mContactsRequest = contactsRequest;
        mFromOnNewIntent = fromOnNewIntent;
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        switch (requestCode) {
            // TODO: Using the new startActivityWithResultFromFragment API this should not be needed
            // anymore
            case ContactEntryListFragment.ACTIVITY_REQUEST_CODE_PICKER:
                if (resultCode == Activity.RESULT_OK) {
                    onPickerResult(data);
                }
            case ACTIVITY_REQUEST_CODE_SHARE:
                Logger.logListEvent(ListEvent.ActionType.SHARE,
                    /* listType */ getListTypeIncludingSearch(),
                    /* count */ getAdapter().getCount(), /* clickedIndex */ -1,
                    /* numSelected */ getAdapter().getSelectedContactIds().size());

// TODO fix or remove multipicker code: ag/54762
//                else if (resultCode == RESULT_CANCELED && mMode == MODE_PICK_MULTIPLE_PHONES) {
//                    // Finish the activity if the sub activity was canceled as back key is used
//                    // to confirm user selection in MODE_PICK_MULTIPLE_PHONES.
//                    finish();
//                }
//                break;
        }
    }

    public boolean getOptionsMenuContactsAvailable() {
        return mOptionsMenuContactsAvailable;
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        // Clear the listener to make sure we don't get callbacks after onSaveInstanceState,
        // in order to avoid doing fragment transactions after it.
        // TODO Figure out a better way to deal with the issue (ag/120686).
        if (mActionBarAdapter != null) {
            mActionBarAdapter.setListener(null);
            mActionBarAdapter.onSaveInstanceState(outState);
        }
        mDisableOptionItemSelected = true;
        outState.putBoolean(KEY_DELETION_IN_PROGRESS, mIsDeletionInProgress);
        outState.putBoolean(KEY_SEARCH_RESULT_CLICKED, mSearchResultClicked);
    }

    @Override
    public void onPause() {
        mOptionsMenuContactsAvailable = false;
        super.onPause();
    }

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

    public boolean onKeyDown(int unicodeChar) {
        if (mActionBarAdapter != null && mActionBarAdapter.isSelectionMode()) {
            // Ignore keyboard input when in selection mode.
            return true;
        }

        if (mActionBarAdapter != null && !mActionBarAdapter.isSearchMode()) {
            final String query = new String(new int[]{unicodeChar}, 0, 1);
            mActionBarAdapter.setSearchMode(true);
            mActionBarAdapter.setQueryString(query);
            return true;
        }

        return false;
    }

    public boolean canSetActionBar() {
        return mCanSetActionBar;
    }
}