/*
 * Copyright (C) 2021 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.providers.media.photopicker;

import static android.content.Intent.ACTION_GET_CONTENT;
import static android.provider.MediaStore.ACTION_PICK_IMAGES;
import static android.provider.MediaStore.ACTION_USER_SELECT_IMAGES_FOR_APP;
import static android.provider.MediaStore.grantMediaReadForPackage;

import static com.android.providers.media.photopicker.PhotoPickerSettingsActivity.EXTRA_CURRENT_USER_ID;
import static com.android.providers.media.photopicker.data.PickerResult.getPickerResponseIntent;
import static com.android.providers.media.photopicker.data.PickerResult.getPickerUrisForItems;
import static com.android.providers.media.photopicker.util.LayoutModeUtils.MODE_PHOTOS_TAB;

import android.annotation.UserIdInt;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.content.res.Configuration;
import android.content.res.TypedArray;
import android.graphics.Color;
import android.graphics.Outline;
import android.graphics.Rect;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.Binder;
import android.os.Build;
import android.os.Bundle;
import android.os.UserHandle;
import android.provider.MediaStore;
import android.util.Log;
import android.util.TypedValue;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewOutlineProvider;
import android.view.WindowInsetsController;
import android.view.WindowManager;
import android.view.accessibility.AccessibilityManager;
import android.widget.TextView;

import androidx.annotation.ColorInt;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.VisibleForTesting;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import androidx.fragment.app.FragmentManager;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.ViewModel;
import androidx.lifecycle.ViewModelProvider;

import com.android.providers.media.ConfigStore;
import com.android.providers.media.R;
import com.android.providers.media.photopicker.data.PickerResult;
import com.android.providers.media.photopicker.data.Selection;
import com.android.providers.media.photopicker.data.UserIdManager;
import com.android.providers.media.photopicker.data.model.Item;
import com.android.providers.media.photopicker.data.model.UserId;
import com.android.providers.media.photopicker.ui.TabContainerFragment;
import com.android.providers.media.photopicker.util.LayoutModeUtils;
import com.android.providers.media.photopicker.util.MimeFilterUtils;
import com.android.providers.media.photopicker.viewmodel.PickerViewModel;
import com.android.providers.media.util.ForegroundThread;

import com.google.android.material.bottomsheet.BottomSheetBehavior;
import com.google.android.material.bottomsheet.BottomSheetBehavior.BottomSheetCallback;
import com.google.android.material.tabs.TabLayout;
import com.google.common.collect.Lists;

import java.util.List;

/**
 * Photo Picker allows users to choose one or more photos and/or videos to share with an app. The
 * app does not get access to all photos/videos.
 */
public class PhotoPickerActivity extends AppCompatActivity {
    private static final String TAG =  "PhotoPickerActivity";
    private static final float BOTTOM_SHEET_PEEK_HEIGHT_PERCENTAGE = 0.60f;
    private static final float HIDE_PROFILE_BUTTON_THRESHOLD = -0.5f;
    private static final String LOGGER_INSTANCE_ID_ARG = "loggerInstanceIdArg";
    private static final String EXTRA_PRELOAD_SELECTED =
            "com.android.providers.media.photopicker.extra.PRELOAD_SELECTED";

    private ViewModelProvider mViewModelProvider;
    private PickerViewModel mPickerViewModel;
    private PreloaderInstanceHolder mPreloaderInstanceHolder;

    private Selection mSelection;
    private BottomSheetBehavior mBottomSheetBehavior;
    private View mBottomBar;
    private View mBottomSheetView;
    private View mFragmentContainerView;
    private View mDragBar;
    private View mProfileButton;
    private TextView mPrivacyText;
    private TabLayout mTabLayout;
    private Toolbar mToolbar;
    private CrossProfileListeners mCrossProfileListeners;

    @NonNull
    private final MutableLiveData<Boolean> mIsItemPhotoGridViewChanged =
            new MutableLiveData<>(false);

    @ColorInt
    private int mDefaultBackgroundColor;

    @ColorInt
    private int mToolBarIconColor;

    private int mToolbarHeight = 0;
    private boolean mShouldLogCancelledResult = true;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        // This is required as GET_CONTENT with type "*/*" is also received by PhotoPicker due
        // to higher priority than DocumentsUi. "*/*" mime type filter is caught as it is a superset
        // of "image/*" and "video/*".
        if (rerouteGetContentRequestIfRequired()) {
            // This activity is finishing now: we should not run the setup below,
            // BUT before we return we have to call super.onCreate() (otherwise we are we will get
            // SuperNotCalledException: Activity did not call through to super.onCreate())
            super.onCreate(savedInstanceState);
            return;
        }

        // We use the device default theme as the base theme. Apply the material them for the
        // material components. We use force "false" here, only values that are not already defined
        // in the base theme will be copied.
        getTheme().applyStyle(R.style.PickerMaterialTheme, /* force */ false);

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_photo_picker);
        mToolbar = findViewById(R.id.toolbar);
        setSupportActionBar(mToolbar);
        getSupportActionBar().setDisplayHomeAsUpEnabled(true);

        final int[] attrs = new int[]{R.attr.actionBarSize, R.attr.pickerTextColor};
        final TypedArray ta = obtainStyledAttributes(attrs);
        // Save toolbar height so that we can use it as padding for FragmentContainerView
        mToolbarHeight = ta.getDimensionPixelSize(/* index */ 0, /* defValue */ -1);
        mToolBarIconColor = ta.getColor(/* index */ 1,/* defValue */ -1);
        ta.recycle();

        mDefaultBackgroundColor = getColor(R.color.picker_background_color);

        mViewModelProvider = new ViewModelProvider(this);
        mPickerViewModel = getOrCreateViewModel();

        final Intent intent = getIntent();
        try {
            mPickerViewModel.parseValuesFromIntent(intent);
        } catch (IllegalArgumentException e) {
            Log.e(TAG, "Finish activity due to an exception while parsing extras", e);
            finishWithoutLoggingCancelledResult();
            return;
        }
        mSelection = mPickerViewModel.getSelection();
        mDragBar = findViewById(R.id.drag_bar);
        mPrivacyText = findViewById(R.id.privacy_text);
        mBottomBar = findViewById(R.id.picker_bottom_bar);
        mProfileButton = findViewById(R.id.profile_button);

        mTabLayout = findViewById(R.id.tab_layout);

        initBottomSheetBehavior();

        // Save the fragment container layout so that we can adjust the padding based on preview or
        // non-preview mode.
        mFragmentContainerView = findViewById(R.id.fragment_container);

        mCrossProfileListeners = new CrossProfileListeners();

        mPreloaderInstanceHolder = mViewModelProvider.get(PreloaderInstanceHolder.class);
        if (mPreloaderInstanceHolder.preloader != null) {
            subscribeToSelectedMediaPreloader(mPreloaderInstanceHolder.preloader);
        }

        observeRefreshUiNotificationLiveData();
        // Restore state operation should always be kept at the end of this method.
        restoreState(savedInstanceState);
        // Call this after state is restored, to use the correct LOGGER_INSTANCE_ID_ARG
        if (savedInstanceState == null) {
            final String intentAction = intent != null ? intent.getAction() : null;
            mPickerViewModel.logPickerOpened(Binder.getCallingUid(), getCallingPackage(),
                    intentAction);
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        if (mCrossProfileListeners != null) {
            // This is required to unregister any broadcast receivers.
            mCrossProfileListeners.onDestroy();
        }
    }

    /**
     * Warning: This method is needed for tests, we are not customizing anything here.
     * Allowing ourselves to control ViewModel creation helps us mock the ViewModel for test.
     */
    @VisibleForTesting
    @NonNull
    protected PickerViewModel getOrCreateViewModel() {
        return mViewModelProvider.get(PickerViewModel.class);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent event){
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            if (mBottomSheetBehavior.getState() == BottomSheetBehavior.STATE_COLLAPSED) {

                Rect outRect = new Rect();
                mBottomSheetView.getGlobalVisibleRect(outRect);

                if (!outRect.contains((int)event.getRawX(), (int)event.getRawY())) {
                    mBottomSheetBehavior.setState(BottomSheetBehavior.STATE_HIDDEN);
                }
            }
        }
        return super.dispatchTouchEvent(event);
    }

    /**
     * This method is called on action bar home button clicks if
     * {@link androidx.appcompat.app.ActionBar#setDisplayHomeAsUpEnabled(boolean)} is set
     * {@code true}.
     */
    @Override
    public boolean onSupportNavigateUp() {
        int backStackEntryCount = getSupportFragmentManager().getBackStackEntryCount();
        mPickerViewModel.logActionBarHomeButtonClick(backStackEntryCount);
        super.onBackPressed();
        return true;
    }

    @Override
    public void onBackPressed() {
        int backStackEntryCount = getSupportFragmentManager().getBackStackEntryCount();
        mPickerViewModel.logBackGestureWithStackCount(backStackEntryCount);
        super.onBackPressed();
    }

    @Override
    public boolean onMenuOpened(int featureId, Menu menu) {
        mPickerViewModel.logMenuOpened();
        return super.onMenuOpened(featureId, menu);
    }

    @Override
    public void setTitle(CharSequence title) {
        super.setTitle(title);
        getSupportActionBar().setTitle(title);
    }

    /**
     * Called when owning activity is saving state to be used to restore state during creation.
     *
     * @param state Bundle to save state
     */
    @Override
    public void onSaveInstanceState(Bundle state) {
        super.onSaveInstanceState(state);
        saveBottomSheetState();
        state.putParcelable(LOGGER_INSTANCE_ID_ARG, mPickerViewModel.getInstanceId());
    }

    @Override
    public boolean onCreateOptionsMenu(@NonNull Menu menu) {
        getMenuInflater().inflate(R.menu.picker_overflow_menu, menu);
        return true;
    }

    @Override
    public boolean onPrepareOptionsMenu(@NonNull Menu menu) {
        super.onPrepareOptionsMenu(menu);
        // All logic to hide/show an item in the menu must be in this method
        final MenuItem settingsMenuItem = menu.findItem(R.id.settings);

        // TODO(b/195009187): Settings menu item is hidden by default till Settings page is
        // completely developed.
        settingsMenuItem.setVisible(shouldShowSettingsScreen());

        // Browse menu item allows users to launch DocumentsUI. This item should only be shown if
        // PhotoPicker was opened via {@link #ACTION_GET_CONTENT}.
        menu.findItem(R.id.browse).setVisible(isGetContentAction());

        return menu.hasVisibleItems();
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.browse:
                mPickerViewModel.logBrowseToDocumentsUi(Binder.getCallingUid(),
                        getCallingPackage());
                launchDocumentsUiAndFinishPicker();
                return true;
            case R.id.settings:
                startSettingsActivity();
                return true;
            default:
                // Continue to return the result of base class' onOptionsItemSelected(item)
        }
        return super.onOptionsItemSelected(item);
    }

    /**
     * Launch the Photo Picker settings page where user can view/edit current cloud media provider.
     */
    public void startSettingsActivity() {
        final Intent intent = new Intent(this, PhotoPickerSettingsActivity.class);
        intent.putExtra(EXTRA_CURRENT_USER_ID, getCurrentUserId());
        startActivity(intent);
    }

    /**
     * @return {@code true} if the intent was re-routed to the DocumentsUI (and this
     *  {@code PhotoPickerActivity} is {@link #isFinishing()} now). {@code false} - otherwise.
     */
    private boolean rerouteGetContentRequestIfRequired() {
        final Intent intent = getIntent();
        if (!ACTION_GET_CONTENT.equals(intent.getAction())) {
            return false;
        }

        // TODO(b/232775643): Workaround to support PhotoPicker invoked from DocumentsUi.
        // GET_CONTENT for all (media and non-media) files opens DocumentsUi, but it still shows
        // "Photo Picker app option. When the user clicks on "Photo Picker", the same intent which
        // includes filters to show non-media files as well is forwarded to PhotoPicker.
        // Make sure Photo Picker is opened when the intent is explicitly forwarded by documentsUi
        if (isIntentReferredByDocumentsUi(getReferrer())) {
            Log.i(TAG, "Open PhotoPicker when a forwarded ACTION_GET_CONTENT intent is received");
            return false;
        }

        // Check if we can handle the specified MIME types.
        // If we can - do not reroute and thus return false.
        if (!MimeFilterUtils.requiresUnsupportedFilters(intent)) return false;

        launchDocumentsUiAndFinishPicker();
        return true;
    }

    private boolean isIntentReferredByDocumentsUi(Uri referrerAppUri) {
        ComponentName documentsUiComponentName = getDocumentsUiComponentName(this);
        String documentsUiPackageName = documentsUiComponentName != null
                ? documentsUiComponentName.getPackageName() : null;
        return referrerAppUri != null && referrerAppUri.getHost().equals(documentsUiPackageName);
    }

    private void launchDocumentsUiAndFinishPicker() {
        Log.i(TAG, "Launch DocumentsUI and finish picker");

        startActivityAsUser(getDocumentsUiForwardingIntent(this, getIntent()),
                UserId.CURRENT_USER.getUserHandle());
        // RESULT_CANCELLED is not returned to the calling app as the DocumentsUi result will be
        // returned. We don't have to log as this flow can be called in 2 cases:
        // 1. GET_CONTENT had non-media filters, so the user or the app should be unaffected as they
        // see that DocumentsUi was opened directly.
        // 2. User clicked on "Browse.." button, in that case we already log that event separately.
        finishWithoutLoggingCancelledResult();
    }

    @VisibleForTesting
    static Intent getDocumentsUiForwardingIntent(Context context, Intent intent) {
        intent.addFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT);
        intent.addFlags(Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP);
        intent.setComponent(getDocumentsUiComponentName(context));
        return intent;
    }

    private static ComponentName getDocumentsUiComponentName(Context context) {
        final PackageManager pm = context.getPackageManager();
        // DocumentsUI is the default handler for ACTION_OPEN_DOCUMENT
        final Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
        intent.addCategory(Intent.CATEGORY_OPENABLE);
        intent.setType("*/*");
        return intent.resolveActivity(pm);
    }

    private void restoreState(Bundle savedInstanceState) {
        if (savedInstanceState != null) {
            restoreBottomSheetState();
            mPickerViewModel.setInstanceId(
                    savedInstanceState.getParcelable(LOGGER_INSTANCE_ID_ARG));
        } else {
            setupInitialLaunchState();
        }
    }

    /**
     * Sets up states for the initial launch. This includes updating common layouts, selecting
     * Photos tab item and saving the current bottom sheet state for later.
     */
    private void setupInitialLaunchState() {
        updateCommonLayouts(MODE_PHOTOS_TAB, /* title */ "");
        TabContainerFragment.show(getSupportFragmentManager());
        saveBottomSheetState();
    }

    private void initBottomSheetBehavior() {
        mBottomSheetView = findViewById(R.id.bottom_sheet);
        mBottomSheetBehavior = BottomSheetBehavior.from(mBottomSheetView);
        initStateForBottomSheet();

        mBottomSheetBehavior.addBottomSheetCallback(createBottomSheetCallBack());
        setRoundedCornersForBottomSheet();
    }

    private BottomSheetCallback createBottomSheetCallBack() {
        return new BottomSheetCallback() {
            private boolean mIsHiddenDueToBottomSheetClosing = false;
            @Override
            public void onStateChanged(@NonNull View bottomSheet, int newState) {
                if (newState == BottomSheetBehavior.STATE_HIDDEN) {
                    mPickerViewModel.logSwipeDownExit();
                    finish();
                } else if (newState == BottomSheetBehavior.STATE_EXPANDED) {
                    mPickerViewModel.logExpandToFullScreen();
                }
                saveBottomSheetState();
            }

            @Override
            public void onSlide(@NonNull View bottomSheet, float slideOffset) {
                // slideOffset = -1 is when bottomsheet is completely hidden
                // slideOffset = 0 is when bottomsheet is in collapsed mode
                // slideOffset = 1 is when bottomsheet is in expanded mode
                // We hide the Profile button if the bottomsheet is 50% in between collapsed state
                // and hidden state.
                if (slideOffset < HIDE_PROFILE_BUTTON_THRESHOLD &&
                        mProfileButton.getVisibility() == View.VISIBLE) {
                    mProfileButton.setVisibility(View.GONE);
                    mIsHiddenDueToBottomSheetClosing = true;
                    return;
                }

                // We need to handle this state if the user is swiping till the bottom of the
                // screen but then swipes up bottom sheet suddenly
                if (slideOffset > HIDE_PROFILE_BUTTON_THRESHOLD &&
                        mIsHiddenDueToBottomSheetClosing) {
                    mProfileButton.setVisibility(View.VISIBLE);
                    mIsHiddenDueToBottomSheetClosing = false;
                }
            }
        };
    }

    private void setRoundedCornersForBottomSheet() {
        final float cornerRadius =
                getResources().getDimensionPixelSize(R.dimen.picker_top_corner_radius);
        final ViewOutlineProvider viewOutlineProvider = new ViewOutlineProvider() {
            @Override
            public void getOutline(final View view, final Outline outline) {
                outline.setRoundRect(0, 0, view.getWidth(),
                        (int)(view.getHeight() + cornerRadius), cornerRadius);
            }
        };
        mBottomSheetView.setOutlineProvider(viewOutlineProvider);
    }

    private void initStateForBottomSheet() {
        if (!isAccessibilityEnabled() && !mSelection.canSelectMultiple()
                && !isOrientationLandscape()) {
            final int peekHeight = getBottomSheetPeekHeight(this);
            mBottomSheetBehavior.setPeekHeight(peekHeight);
            mBottomSheetBehavior.setState(BottomSheetBehavior.STATE_COLLAPSED);
        } else {
            mBottomSheetBehavior.setState(BottomSheetBehavior.STATE_EXPANDED);
            mBottomSheetBehavior.setSkipCollapsed(true);
        }
    }

    /**
     * Warning: This method is visible for espresso tests, we are not customizing anything here.
     * Allowing ourselves to control the accessibility state helps us mock it for these tests.
     */
    @VisibleForTesting
    protected boolean isAccessibilityEnabled() {
        return getSystemService(AccessibilityManager.class).isEnabled();
    }

    private static int getBottomSheetPeekHeight(Context context) {
        final WindowManager windowManager = context.getSystemService(WindowManager.class);
        final Rect displayBounds = windowManager.getCurrentWindowMetrics().getBounds();
        return (int) (displayBounds.height() * BOTTOM_SHEET_PEEK_HEIGHT_PERCENTAGE);
    }

    private void restoreBottomSheetState() {
        // BottomSheet is always EXPANDED for landscape
        if (isOrientationLandscape()) {
            return;
        }
        final int savedState = mPickerViewModel.getBottomSheetState();
        if (isValidBottomSheetState(savedState)) {
            mBottomSheetBehavior.setState(savedState);
        }
    }

    private void saveBottomSheetState() {
        // Do not save state for landscape or preview mode. This is because they are always in
        // STATE_EXPANDED state.
        if (isOrientationLandscape() || !mBottomSheetView.getClipToOutline()) {
            return;
        }
        mPickerViewModel.setBottomSheetState(mBottomSheetBehavior.getState());
    }

    private boolean isValidBottomSheetState(int state) {
        return state == BottomSheetBehavior.STATE_COLLAPSED ||
                state == BottomSheetBehavior.STATE_EXPANDED;
    }

    private boolean isOrientationLandscape() {
        return getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE;
    }

    public LiveData<Boolean> isItemPhotoGridViewChanged() {
        return mIsItemPhotoGridViewChanged;
    }

    public void setResultAndFinishSelf() {
        logPickerSelectionConfirmed(mSelection.getSelectedItems().size());
        if (shouldPreloadSelectedItems()) {
            final var uris = PickerResult.getPickerUrisForItems(
                    mSelection.getSelectedItems());
            mPickerViewModel.logPreloadingStarted(uris.size());
            mPreloaderInstanceHolder.preloader =
                    SelectedMediaPreloader.preload(/* activity */ this, uris);
            deSelectUnavailableMedia(mPreloaderInstanceHolder.preloader);
            subscribeToSelectedMediaPreloader(mPreloaderInstanceHolder.preloader);
        } else {
            setResultAndFinishSelfInternal();
        }
    }

    private void setResultAndFinishSelfInternal() {
        // In addition to the activity result, add the selected files to the MediaProvider
        // media_grants database.
        if (isUserSelectImagesForAppAction()) {
            setResultForUserSelectImagesForAppAction();
        } else {
            setResultForPickImagesOrGetContentAction();
        }

        finishWithoutLoggingCancelledResult();
    }

    private void setResultForUserSelectImagesForAppAction() {
        // Since Photopicker is in permission mode, don't send back URI grants.
        setResult(RESULT_OK);
        // The permission controller will pass the requesting package's UID here
        final Bundle extras = getIntent().getExtras();
        final int uid = extras.getInt(Intent.EXTRA_UID);
        final List<Uri> uris = getPickerUrisForItems(mSelection.getSelectedItemsWithoutGrants());
        if (!uris.isEmpty()) {
            ForegroundThread.getExecutor().execute(() -> {
                // Handle grants in another thread to not block the UI.
                grantMediaReadForPackage(getApplicationContext(), uid, uris);
                mPickerViewModel.logPickerChoiceAddedGrantsCount(uris.size(), extras);
            });
        }

        // Revoke READ_GRANT for items that were pre-granted but now in the current session user has
        // deselected them.
        if (mPickerViewModel.isManagedSelectionEnabled()) {
            final List<Uri> urisForItemsWhoseGrantsNeedsToBeRevoked = getPickerUrisForItems(
                    mSelection.getPreGrantedItemsToBeRevoked());
            if (!urisForItemsWhoseGrantsNeedsToBeRevoked.isEmpty()) {
                ForegroundThread.getExecutor().execute(() -> {
                    // Handle grants in another thread to not block the UI.
                    MediaStore.revokeMediaReadForPackages(getApplicationContext(), uid,
                            urisForItemsWhoseGrantsNeedsToBeRevoked);
                    mPickerViewModel.logPickerChoiceRevokedGrantsCount(
                            urisForItemsWhoseGrantsNeedsToBeRevoked.size(), extras);
                });
            }
        }
    }

    private void setResultForPickImagesOrGetContentAction() {
        final Intent resultData = getPickerResponseIntent(
                mSelection.canSelectMultiple(),
                mSelection.getSelectedItems());
        setResult(RESULT_OK, resultData);
    }

    private boolean shouldPreloadSelectedItems() {
        // Only preload if the cloud media may be shown in the PhotoPicker.
        if (!isCloudMediaAvailable()) {
            return false;
        }

        final boolean isGetContent = isGetContentAction();
        final boolean isPickImages = isPickImagesAction();
        final ConfigStore cs = mPickerViewModel.getConfigStore();

        if (getIntent().hasExtra(EXTRA_PRELOAD_SELECTED)) {
            if (Build.isDebuggable()
                    || (isPickImages && cs.shouldPickerRespectPreloadArgumentForPickImages())) {
                return getIntent().getBooleanExtra(EXTRA_PRELOAD_SELECTED,
                        /* default, not used */ false);
            }
        }

        if (isGetContent) {
            return cs.shouldPickerPreloadForGetContent();
        } else if (isPickImages) {
            return cs.shouldPickerPreloadForPickImages();
        } else {
            Log.w(TAG, "Not preloading selection for \"" + getIntent().getAction() + "\" action");
            return false;
        }
    }

    private void subscribeToSelectedMediaPreloader(@NonNull SelectedMediaPreloader preloader) {
        preloader.getIsFinishedLiveData().observe(
                /* lifecycleOwner */ PhotoPickerActivity.this,
                isFinished -> {
                    if (isFinished) {
                        mPickerViewModel.logPreloadingFinished();
                        setResultAndFinishSelfInternal();
                    }
                });
    }

    // This method is responsible for deselecting all  unavailable items from selection list
    // when user tries selecting unavailable could only media (not cached) while offline
    private void deSelectUnavailableMedia(@NonNull SelectedMediaPreloader preloader) {
        preloader.getUnavailableMediaIndexes().observe(
                /* lifecycleOwner */ PhotoPickerActivity.this,
                unavailableMediaIndexes -> {
                    if (unavailableMediaIndexes.size() > 0) {
                        // To notify the fragment to uncheck the unavailable items at UI those are
                        // no longer available in the selection list.
                        mIsItemPhotoGridViewChanged.postValue(true);

                        // Checking if preloading was intentionally be cancelled by the user
                        if (unavailableMediaIndexes.get(unavailableMediaIndexes.size() - 1) != -1) {
                            // Displaying  error dialog with an error message when the user tries
                            // to add unavailable cloud only media (not cached) while offline.
                            DialogUtils.showDialog(this,
                                    getResources().getString(R.string.dialog_error_title),
                                    getResources().getString(R.string.dialog_error_message));
                            mPickerViewModel.logPreloadingFailed(unavailableMediaIndexes.size());
                        } else {
                            unavailableMediaIndexes.remove(
                                    unavailableMediaIndexes.size() - 1);
                            mPickerViewModel.logPreloadingCancelled(unavailableMediaIndexes.size());
                        }
                        List<Item> selectedItems = mSelection.getSelectedItems();
                        for (var mediaIndex : unavailableMediaIndexes) {
                            mSelection.removeSelectedItem(selectedItems.get(mediaIndex));
                        }
                    }
                });
    }

    /**
     * NOTE: this may wrongly return {@code false} if called before {@link PickerViewModel} had a
     * chance to fetch the authority and the account of the current
     * {@link android.provider.CloudMediaProvider}.
     * However, this may only happen very early on in the lifecycle.
     */
    private boolean isCloudMediaAvailable() {
        return mPickerViewModel.getCloudMediaProviderAuthorityLiveData().getValue() != null
                && mPickerViewModel.getCloudMediaAccountNameLiveData().getValue() != null;
    }

    /**
     * This should be called if:
     * * We are finishing Picker explicitly before the user has seen PhotoPicker UI due to known
     *   checks/workflow.
     * * We are not returning {@link Activity#RESULT_CANCELED}
     */
    private void finishWithoutLoggingCancelledResult() {
        mShouldLogCancelledResult = false;
        finish();
    }

    @Override
    public void finish() {
        if (mShouldLogCancelledResult) {
            logPickerCancelled();
        }
        super.finish();
    }

    private void logPickerSelectionConfirmed(int countOfItemsConfirmed) {
        mPickerViewModel.logPickerConfirm(Binder.getCallingUid(), getCallingPackage(),
                countOfItemsConfirmed);
    }

    private void logPickerCancelled() {
        mPickerViewModel.logPickerCancel(Binder.getCallingUid(), getCallingPackage());
    }

    @UserIdInt
    private int getCurrentUserId() {
        final UserIdManager userIdManager = mPickerViewModel.getUserIdManager();
        return userIdManager.getCurrentUserProfileId().getIdentifier();
    }

    /**
     * Updates the common views such as Title, Toolbar, Navigation bar, status bar and bottom sheet
     * behavior
     *
     * @param mode {@link LayoutModeUtils.Mode} which describes the layout mode to update.
     * @param title the title to set for the Activity
     */
    public void updateCommonLayouts(LayoutModeUtils.Mode mode, String title) {
        updateTitle(title);
        updateToolbar(mode);
        updateStatusBarAndNavigationBar(mode);
        updateBottomSheetBehavior(mode);
        updateFragmentContainerViewPadding(mode);
        updateDragBarVisibility(mode);
        updateHeaderTextVisibility(mode);
        // The bottom bar and profile button are not shown on preview, hide them in preview. We
        // handle the visibility of them in TabFragment. We don't need to make them shown in
        // non-preview page here.
        if (mode.isPreview) {
            mBottomBar.setVisibility(View.GONE);
            mProfileButton.setVisibility(View.GONE);
        }
    }

    private void updateTitle(String title) {
        setTitle(title);
    }

    /**
     * Updates the icons and show/hide the tab layout with {@code mode}.
     *
     * @param mode {@link LayoutModeUtils.Mode} which describes the layout mode to update.
     */
    private void updateToolbar(@NonNull LayoutModeUtils.Mode mode) {
        final boolean isPreview = mode.isPreview;
        final boolean shouldShowTabLayout = mode.isPhotosTabOrAlbumsTab;
        // 1. Set the tabLayout visibility
        mTabLayout.setVisibility(shouldShowTabLayout ? View.VISIBLE : View.GONE);

        // 2. Set the toolbar color
        final ColorDrawable toolbarColor;
        if (isPreview && !shouldShowTabLayout) {
            if (isOrientationLandscape()) {
                // Toolbar in Preview will have transparent color in Landscape mode.
                toolbarColor = new ColorDrawable(getColor(android.R.color.transparent));
            } else {
                // Toolbar in Preview will have a solid color with 90% opacity in Portrait mode.
                toolbarColor = new ColorDrawable(getColor(R.color.preview_scrim_solid_color));
            }
        } else {
            toolbarColor = new ColorDrawable(mDefaultBackgroundColor);
        }
        getSupportActionBar().setBackgroundDrawable(toolbarColor);

        // 3. Set the toolbar icon.
        final Drawable icon;
        if (shouldShowTabLayout) {
            icon = getDrawable(R.drawable.ic_close);
        } else {
            icon = getDrawable(R.drawable.ic_arrow_back);
            // Preview mode has dark background, hence icons will be WHITE in color
            icon.setTint(isPreview ? Color.WHITE : mToolBarIconColor);
        }
        getSupportActionBar().setHomeAsUpIndicator(icon);
        getSupportActionBar().setHomeActionContentDescription(
                shouldShowTabLayout ? android.R.string.cancel
                        : R.string.abc_action_bar_up_description);
        if (mToolbar.getOverflowIcon() != null) {
            mToolbar.getOverflowIcon().setTint(isPreview ? Color.WHITE : mToolBarIconColor);
        }
    }

    /**
     * Updates status bar and navigation bar
     *
     * @param mode {@link LayoutModeUtils.Mode} which describes the layout mode to update.
     */
    private void updateStatusBarAndNavigationBar(@NonNull LayoutModeUtils.Mode mode) {
        final boolean isPreview = mode.isPreview;
        final int navigationBarColor = isPreview ? getColor(R.color.preview_background_color) :
                mDefaultBackgroundColor;
        getWindow().setNavigationBarColor(navigationBarColor);

        final int statusBarColor = isPreview ? getColor(R.color.preview_background_color) :
                getColor(android.R.color.transparent);
        getWindow().setStatusBarColor(statusBarColor);

        // Update the system bar appearance
        final int mask = WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS;
        int appearance = 0;
        if (!isPreview) {
            final int uiModeNight =
                    getResources().getConfiguration().uiMode & Configuration.UI_MODE_NIGHT_MASK;

            if (uiModeNight == Configuration.UI_MODE_NIGHT_NO) {
                // If the system is not in Dark theme, set the system bars to light mode.
                appearance = mask;
            }
        }
        getWindow().getInsetsController().setSystemBarsAppearance(appearance, mask);
    }

    /**
     * Updates the bottom sheet behavior
     *
     * @param mode {@link LayoutModeUtils.Mode} which describes the layout mode to update.
     */
    private void updateBottomSheetBehavior(@NonNull LayoutModeUtils.Mode mode) {
        final boolean isPreview = mode.isPreview;
        if (mBottomSheetView != null) {
            mBottomSheetView.setClipToOutline(!isPreview);
            // TODO(b/197241815): Add animation downward swipe for preview should go back to
            // the photo in photos grid
            mBottomSheetBehavior.setDraggable(!isPreview);
        }
        if (isPreview) {
            if (mBottomSheetBehavior.getState() != BottomSheetBehavior.STATE_EXPANDED) {
                // Sets bottom sheet behavior state to STATE_EXPANDED if it's not already expanded.
                // This is useful when user goes to Preview mode which is always Full screen.
                // TODO(b/197241815): Add animation preview to full screen and back transition to
                // partial screen. This is similar to long press animation.
                mBottomSheetBehavior.setState(BottomSheetBehavior.STATE_EXPANDED);
            }
        } else {
            restoreBottomSheetState();
        }
    }

    /**
     * Updates the FragmentContainerView padding.
     * <p>
     * For Preview mode, toolbar overlaps the Fragment content, hence the padding will be set to 0.
     * For Non-Preview mode, toolbar doesn't overlap the contents of the fragment, hence we set the
     * padding as the height of the toolbar.
     */
    private void updateFragmentContainerViewPadding(@NonNull LayoutModeUtils.Mode mode) {
        if (mFragmentContainerView == null) return;

        final int topPadding;
        if (mode.isPreview) {
            topPadding = 0;
        } else {
            topPadding = mToolbarHeight;
        }

        mFragmentContainerView.setPadding(mFragmentContainerView.getPaddingLeft(),
                topPadding, mFragmentContainerView.getPaddingRight(),
                mFragmentContainerView.getPaddingBottom());
    }

    private void updateDragBarVisibility(@NonNull LayoutModeUtils.Mode mode) {
        final boolean shouldShowDragBar = !mode.isPreview;
        mDragBar.setVisibility(shouldShowDragBar ? View.VISIBLE : View.GONE);
    }

    private void updateHeaderTextVisibility(@NonNull LayoutModeUtils.Mode mode) {
        // The privacy text is only shown on the Photos tab and Albums tab when not in
        // permission select mode.
        final boolean shouldShowPrivacyMessage = mode.isPhotosTabOrAlbumsTab;

        if (!shouldShowPrivacyMessage) {
            mPrivacyText.setVisibility(View.GONE);
            return;
        }

        if (mPickerViewModel.isUserSelectForApp()) {
            mPrivacyText.setText(R.string.picker_header_permissions);
            mPrivacyText.setTextSize(
                    TypedValue.COMPLEX_UNIT_PX,
                    getResources().getDimension(R.dimen.picker_user_select_header_text_size));
        } else {
            mPrivacyText.setText(R.string.picker_privacy_message);
            mPrivacyText.setTextSize(
                    TypedValue.COMPLEX_UNIT_PX,
                    getResources().getDimension(R.dimen.picker_privacy_text_size));
        }

        mPrivacyText.setVisibility(View.VISIBLE);
    }

    /**
     * Reset to Photo Picker initial launch state (Photos grid tab) in personal profile mode.
     */
    private void resetToPersonalProfile() {
        // Clear all the fragments in the FragmentManager
        final FragmentManager fragmentManager = getSupportFragmentManager();
        fragmentManager.popBackStackImmediate(/* name */ null,
                FragmentManager.POP_BACK_STACK_INCLUSIVE);

        // Reset all content to the personal profile
        mPickerViewModel.resetToPersonalProfile();

        // Set up the fragments same as the initial launch state
        setupInitialLaunchState();
    }

    /**
     * Reset to Photo Picker initial launch state (Photos grid tab) in the current profile mode.
     */
    private void resetInCurrentProfile() {
        // Clear all the fragments in the FragmentManager
        final FragmentManager fragmentManager = getSupportFragmentManager();
        fragmentManager.popBackStackImmediate(/* name */ null,
                FragmentManager.POP_BACK_STACK_INCLUSIVE);

        // Reset all content in the current profile
        mPickerViewModel.resetAllContentInCurrentProfile();

        // Set up the fragments same as the initial launch state
        setupInitialLaunchState();
    }

    /**
     * Returns {@code true} if settings page is enabled.
     */
    private boolean shouldShowSettingsScreen() {
        if (mPickerViewModel.shouldShowOnlyLocalFeatures()) {
            return false;
        }

        final ComponentName componentName = new ComponentName(this,
                PhotoPickerSettingsActivity.class);
        return getPackageManager().getComponentEnabledSetting(componentName)
                == PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
    }

    /**
     * Returns {@code true} if intent action is {@link ACTION_GET_CONTENT}.
     */
    private boolean isGetContentAction() {
        return ACTION_GET_CONTENT.equals(getIntent().getAction());
    }

    /**
     * Returns {@code true} if intent action is {@link ACTION_PICK_IMAGES}.
     */
    private boolean isPickImagesAction() {
        return ACTION_PICK_IMAGES.equals(getIntent().getAction());
    }

    /**
     * Returns {@code true} if intent action is {@link ACTION_USER_SELECT_IMAGES_FOR_APP}
     * (the 3-way storage permission grant flow)
     */
    private boolean isUserSelectImagesForAppAction() {
        return ACTION_USER_SELECT_IMAGES_FOR_APP.equals(getIntent().getAction());
    }

    private class CrossProfileListeners {

        private final List<String> MANAGED_PROFILE_FILTER_ACTIONS = Lists.newArrayList(
                Intent.ACTION_MANAGED_PROFILE_ADDED, // add profile button switch
                Intent.ACTION_MANAGED_PROFILE_REMOVED, // remove profile button switch
                Intent.ACTION_MANAGED_PROFILE_UNLOCKED, // activate profile button switch
                Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE // disable profile button switch
        );

        private final UserIdManager mUserIdManager;

        public CrossProfileListeners() {
            mUserIdManager = mPickerViewModel.getUserIdManager();

            registerBroadcastReceivers();
        }

        public void onDestroy() {
            unregisterReceiver(mReceiver);
        }

        private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                final String action = intent.getAction();

                final UserHandle userHandle = intent.getParcelableExtra(Intent.EXTRA_USER);
                final UserId userId = UserId.of(userHandle);

                // We only need to refresh the layout when the received profile user is the
                // managed user corresponding to the current profile or a new work profile is added
                // for the current user.
                if (!userId.equals(mUserIdManager.getManagedUserId()) &&
                        !action.equals(Intent.ACTION_MANAGED_PROFILE_ADDED)) {
                    return;
                }

                switch (action) {
                    case Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE:
                        handleWorkProfileOff();
                        break;
                    case Intent.ACTION_MANAGED_PROFILE_REMOVED:
                        handleWorkProfileRemoved();
                        break;
                    case Intent.ACTION_MANAGED_PROFILE_UNLOCKED:
                        handleWorkProfileOn();
                        break;
                    case Intent.ACTION_MANAGED_PROFILE_ADDED:
                        handleWorkProfileAdded();
                        break;
                    default:
                        // do nothing
                }
            }
        };

        private void registerBroadcastReceivers() {
            final IntentFilter managedProfileFilter = new IntentFilter();
            for (String managedProfileAction : MANAGED_PROFILE_FILTER_ACTIONS) {
                managedProfileFilter.addAction(managedProfileAction);
            }
            registerReceiver(mReceiver, managedProfileFilter);
        }

        private void handleWorkProfileOff() {
            if (mUserIdManager.isManagedUserSelected()) {
                switchToPersonalProfileInitialLaunchState();
            }
            mUserIdManager.updateWorkProfileOffValue();
        }

        private void handleWorkProfileRemoved() {
            if (mUserIdManager.isManagedUserSelected()) {
                switchToPersonalProfileInitialLaunchState();
            }
            mUserIdManager.resetUserIds();
        }

        private void handleWorkProfileAdded() {
            mUserIdManager.resetUserIds();
        }

        private void handleWorkProfileOn() {
            // Update UI for switch to profile button
            // When the managed profile becomes available, the provider may not be available
            // immediately, we need to check if it is ready before we reload the content.
            mUserIdManager.waitForMediaProviderToBeAvailable();
        }

        private void switchToPersonalProfileInitialLaunchState() {
            // We reset the state of the PhotoPicker as we do not want to make any
            // assumptions on the state of the PhotoPicker when it was in Work Profile mode.
            resetToPersonalProfile();
        }
    }

    /**
     * A {@link ViewModel} class only responsible for keeping track of "active"
     * {@link SelectedMediaPreloader} instance (if any).
     * This class has to be public, since somewhere in {@link ViewModelProvider} it will try to use
     * reflection to create an instance of this class.
     */
    public static class PreloaderInstanceHolder extends ViewModel {
        @Nullable
        SelectedMediaPreloader preloader;
    }

    /**
     * Reset the Picker view model content when launched with cloud features and notified to
     * refresh the UI.
     */
    private void observeRefreshUiNotificationLiveData() {
        mPickerViewModel.shouldRefreshUiLiveData()
                .observe(this, shouldRefresh -> {
                    if (shouldRefresh && !mPickerViewModel.shouldShowOnlyLocalFeatures()) {
                        resetInCurrentProfile();
                    }
                });
    }
}