/*
 * Copyright (C) 2015 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.tv;

import static com.android.tv.common.feature.SystemAppFeature.SYSTEM_APP_FEATURE;

import android.app.Activity;
import android.app.PendingIntent;
import android.app.SearchManager;
import android.content.ActivityNotFoundException;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.ContentUris;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.content.res.Configuration;
import android.database.Cursor;
import android.hardware.display.DisplayManager;
import android.media.tv.TvContentRating;
import android.media.tv.TvContract;
import android.media.tv.TvContract.Channels;
import android.media.tv.TvInputInfo;
import android.media.tv.TvInputManager;
import android.media.tv.TvInputManager.TvInputCallback;
import android.media.tv.TvTrackInfo;
import android.media.tv.TvView.OnUnhandledInputEventListener;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.PowerManager;
import android.provider.BaseColumns;
import android.provider.Settings;
import android.support.annotation.IntDef;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.VisibleForTesting;
import android.text.TextUtils;
import android.util.ArraySet;
import android.util.Log;
import android.view.Display;
import android.view.Gravity;
import android.view.InputEvent;
import android.view.KeyEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewTreeObserver;
import android.view.Window;
import android.view.WindowManager;
import android.view.accessibility.AccessibilityEvent;
import android.view.accessibility.AccessibilityManager;
import android.widget.FrameLayout;
import android.widget.Toast;

import com.android.tv.MainActivity.MySingletons;
import com.android.tv.analytics.Tracker;
import com.android.tv.audio.AudioManagerHelper;
import com.android.tv.audiotvservice.AudioOnlyTvServiceUtil;
import com.android.tv.common.BuildConfig;
import com.android.tv.common.CommonConstants;
import com.android.tv.common.CommonPreferences;
import com.android.tv.common.SoftPreconditions;
import com.android.tv.common.TvContentRatingCache;
import com.android.tv.common.WeakHandler;
import com.android.tv.common.compat.TvInputInfoCompat;
import com.android.tv.common.dev.DeveloperPreferences;
import com.android.tv.common.feature.CommonFeatures;
import com.android.tv.common.memory.MemoryManageable;
import com.android.tv.common.singletons.HasSingletons;
import com.android.tv.common.ui.setup.OnActionClickListener;
import com.android.tv.common.util.CommonUtils;
import com.android.tv.common.util.ContentUriUtils;
import com.android.tv.common.util.Debug;
import com.android.tv.common.util.DurationTimer;
import com.android.tv.common.util.PermissionUtils;
import com.android.tv.common.util.SystemProperties;
import com.android.tv.data.ChannelDataManager;
import com.android.tv.data.ChannelImpl;
import com.android.tv.data.OnCurrentProgramUpdatedListener;
import com.android.tv.data.ProgramDataManager;
import com.android.tv.data.ProgramImpl;
import com.android.tv.data.StreamInfo;
import com.android.tv.data.WatchedHistoryManager;
import com.android.tv.data.api.Channel;
import com.android.tv.data.api.Program;
import com.android.tv.data.epg.EpgFetcher;
import com.android.tv.dialog.HalfSizedDialogFragment;
import com.android.tv.dialog.PinDialogFragment;
import com.android.tv.dialog.PinDialogFragment.OnPinCheckedListener;
import com.android.tv.dialog.SafeDismissDialogFragment;
import com.android.tv.dvr.DvrManager;
import com.android.tv.dvr.data.ScheduledRecording;
import com.android.tv.dvr.recorder.ConflictChecker;
import com.android.tv.dvr.ui.DvrAlreadyRecordedFragment;
import com.android.tv.dvr.ui.DvrAlreadyScheduledFragment;
import com.android.tv.dvr.ui.DvrScheduleFragment;
import com.android.tv.dvr.ui.DvrStopRecordingFragment;
import com.android.tv.dvr.ui.DvrUiHelper;
import com.android.tv.features.TvFeatures;
import com.android.tv.guide.ProgramItemView;
import com.android.tv.menu.Menu;
import com.android.tv.onboarding.OnboardingActivity;
import com.android.tv.parental.ContentRatingsManager;
import com.android.tv.parental.ParentalControlSettings;
import com.android.tv.perf.StartupMeasureFactory;
import com.android.tv.receiver.AudioCapabilitiesReceiver;
import com.android.tv.recommendation.ChannelPreviewUpdater;
import com.android.tv.recommendation.NotificationService;
import com.android.tv.search.ProgramGuideSearchFragment;
import com.android.tv.tunerinputcontroller.BuiltInTunerManager;
import com.android.tv.ui.ChannelBannerView;
import com.android.tv.ui.DetailsActivity;
import com.android.tv.ui.InputBannerView;
import com.android.tv.ui.KeypadChannelSwitchView;
import com.android.tv.ui.SelectInputView;
import com.android.tv.ui.SelectInputView.OnInputSelectedCallback;
import com.android.tv.ui.TunableTvView;
import com.android.tv.ui.TunableTvView.BlockScreenType;
import com.android.tv.ui.TunableTvView.OnTuneListener;
import com.android.tv.ui.TvOverlayManager;
import com.android.tv.ui.TvOverlayManagerFactory;
import com.android.tv.ui.TvViewUiManager;
import com.android.tv.ui.sidepanel.ClosedCaptionFragment;
import com.android.tv.ui.sidepanel.CustomizeChannelListFragment;
import com.android.tv.ui.sidepanel.DeveloperOptionFragment;
import com.android.tv.ui.sidepanel.DisplayModeFragment;
import com.android.tv.ui.sidepanel.MultiAudioFragment;
import com.android.tv.ui.sidepanel.SettingsFragment;
import com.android.tv.ui.sidepanel.SideFragment;
import com.android.tv.ui.sidepanel.parentalcontrols.ParentalControlsFragment;
import com.android.tv.ui.sidepanel.parentalcontrols.RatingsFragment;
import com.android.tv.util.AsyncDbTask;
import com.android.tv.util.AsyncDbTask.DbExecutor;
import com.android.tv.util.CaptionSettings;
import com.android.tv.util.OnboardingUtils;
import com.android.tv.util.SetupUtils;
import com.android.tv.util.TvInputManagerHelper;
import com.android.tv.util.TvSettings;
import com.android.tv.util.TvTrackInfoUtils;
import com.android.tv.util.Utils;
import com.android.tv.util.ViewCache;
import com.android.tv.util.account.AccountHelper;
import com.android.tv.util.images.ImageCache;

import com.google.common.base.Optional;

import dagger.android.AndroidInjection;
import dagger.android.AndroidInjector;
import dagger.android.ContributesAndroidInjector;
import dagger.android.DispatchingAndroidInjector;
import dagger.android.HasAndroidInjector;

import com.android.tv.common.flags.BackendKnobsFlags;
import com.android.tv.common.flags.LegacyFlags;
import com.android.tv.common.flags.StartupFlags;
import com.android.tv.common.flags.UiFlags;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;

import javax.inject.Inject;
import javax.inject.Provider;

/** The main activity for the TV app. */
public class MainActivity extends Activity
        implements OnActionClickListener,
                OnPinCheckedListener,
                ChannelChanger,
                HasSingletons<MySingletons>,
                HasAndroidInjector {
    private static final String TAG = "MainActivity";
    private static final boolean DEBUG = false;
    private AudioCapabilitiesReceiver mAudioCapabilitiesReceiver;

    /** Singletons needed for this class. */
    public interface MySingletons extends ChannelBannerView.MySingletons {}

    @Retention(RetentionPolicy.SOURCE)
    @IntDef({
        KEY_EVENT_HANDLER_RESULT_PASSTHROUGH,
        KEY_EVENT_HANDLER_RESULT_NOT_HANDLED,
        KEY_EVENT_HANDLER_RESULT_HANDLED,
        KEY_EVENT_HANDLER_RESULT_DISPATCH_TO_OVERLAY
    })
    public @interface KeyHandlerResultType {}

    public static final int KEY_EVENT_HANDLER_RESULT_PASSTHROUGH = 0;
    public static final int KEY_EVENT_HANDLER_RESULT_NOT_HANDLED = 1;
    public static final int KEY_EVENT_HANDLER_RESULT_HANDLED = 2;
    public static final int KEY_EVENT_HANDLER_RESULT_DISPATCH_TO_OVERLAY = 3;

    private static final boolean USE_BACK_KEY_LONG_PRESS = false;

    private static final float FRAME_RATE_FOR_FILM = 23.976f;
    private static final float FRAME_RATE_EPSILON = 0.1f;

// AOSP_Comment_Out     private static final String PLUTO_TV_PACKAGE_NAME = "tv.pluto.android";

    private static final int PERMISSIONS_REQUEST_READ_TV_LISTINGS = 1;
    private static final String PERMISSION_READ_TV_LISTINGS = "android.permission.READ_TV_LISTINGS";

    // Tracker screen names.
    public static final String SCREEN_NAME = "Main";
    private static final String SCREEN_PIP = "PIP";
    private static final String SCREEN_BEHIND_NAME = "Behind";

    private static final float REFRESH_RATE_EPSILON = 0.01f;
    private static final HashSet<Integer> BLACKLIST_KEYCODE_TO_TIS;
    // These keys won't be passed to TIS in addition to gamepad buttons.
    static {
        BLACKLIST_KEYCODE_TO_TIS = new HashSet<>();
        BLACKLIST_KEYCODE_TO_TIS.add(KeyEvent.KEYCODE_TV_INPUT);
        BLACKLIST_KEYCODE_TO_TIS.add(KeyEvent.KEYCODE_MENU);
        BLACKLIST_KEYCODE_TO_TIS.add(KeyEvent.KEYCODE_CHANNEL_UP);
        BLACKLIST_KEYCODE_TO_TIS.add(KeyEvent.KEYCODE_CHANNEL_DOWN);
        BLACKLIST_KEYCODE_TO_TIS.add(KeyEvent.KEYCODE_VOLUME_UP);
        BLACKLIST_KEYCODE_TO_TIS.add(KeyEvent.KEYCODE_VOLUME_DOWN);
        BLACKLIST_KEYCODE_TO_TIS.add(KeyEvent.KEYCODE_VOLUME_MUTE);
        BLACKLIST_KEYCODE_TO_TIS.add(KeyEvent.KEYCODE_MUTE);
        BLACKLIST_KEYCODE_TO_TIS.add(KeyEvent.KEYCODE_SEARCH);
        BLACKLIST_KEYCODE_TO_TIS.add(KeyEvent.KEYCODE_WINDOW);
    }

    private static final IntentFilter SYSTEM_INTENT_FILTER = new IntentFilter();

    static {
        SYSTEM_INTENT_FILTER.addAction(TvInputManager.ACTION_PARENTAL_CONTROLS_ENABLED_CHANGED);
        SYSTEM_INTENT_FILTER.addAction(Intent.ACTION_SCREEN_OFF);
        SYSTEM_INTENT_FILTER.addAction(Intent.ACTION_SCREEN_ON);
        SYSTEM_INTENT_FILTER.addAction(Intent.ACTION_TIME_CHANGED);
    }

    private static final int REQUEST_CODE_START_SETUP_ACTIVITY = 1;
    private static final int REQUEST_CODE_NOW_PLAYING = 2;

    private static final String KEY_INIT_CHANNEL_ID = "com.android.tv.init_channel_id";

    // Change channels with key long press.
    private static final int CHANNEL_CHANGE_NORMAL_SPEED_DURATION_MS = 3000;
    private static final int CHANNEL_CHANGE_DELAY_MS_IN_MAX_SPEED = 50;
    private static final int CHANNEL_CHANGE_DELAY_MS_IN_NORMAL_SPEED = 200;
    private static final int CHANNEL_CHANGE_INITIAL_DELAY_MILLIS = 500;

    private static final int MSG_CHANNEL_DOWN_PRESSED = 1000;
    private static final int MSG_CHANNEL_UP_PRESSED = 1001;

    private static final int TVVIEW_SET_MAIN_TIMEOUT_MS = 3000;

    // Lazy initialization.
    // Delay 1 second in order not to interrupt the first tune.
    private static final long LAZY_INITIALIZATION_DELAY = TimeUnit.SECONDS.toMillis(1);

    private static final int UNDEFINED_TRACK_INDEX = -1;
    private static final int HIGHEST_PRIORITY = -1;
    private static final long START_UP_TIMER_RESET_THRESHOLD_MS = TimeUnit.SECONDS.toMillis(3);

    {
        StartupMeasureFactory.create().onActivityInit();
    }

    private final MySingletonsImpl mMySingletons = new MySingletonsImpl();
    @Inject DispatchingAndroidInjector<Object> mAndroidInjector;
    @Inject @DbExecutor Executor mDbExecutor;

    private AccessibilityManager mAccessibilityManager;
    @Inject ChannelDataManager mChannelDataManager;
    @Inject ProgramDataManager mProgramDataManager;
    @Inject TvInputManagerHelper mTvInputManagerHelper;
    private ChannelTuner mChannelTuner;
    private final TvOptionsManager mTvOptionsManager = new TvOptionsManager(this);
    private TvViewUiManager mTvViewUiManager;
    private TimeShiftManager mTimeShiftManager;
    private Tracker mTracker;
    private final DurationTimer mMainDurationTimer = new DurationTimer();
    private final DurationTimer mTuneDurationTimer = new DurationTimer();
    private DvrManager mDvrManager;
    private ConflictChecker mDvrConflictChecker;
    @Inject BackendKnobsFlags mBackendKnobs;
    @Inject LegacyFlags mLegacyFlags;
    @Inject StartupFlags mStartupFlags;
    @Inject UiFlags mUiFlags;
    @Inject SetupUtils mSetupUtils;
    @Inject Optional<BuiltInTunerManager> mOptionalBuiltInTunerManager;
    @Inject AccountHelper mAccountHelper;
    @Inject EpgFetcher mEpgFetcher;

    @VisibleForTesting protected TunableTvView mTvView;
    private View mContentView;
    private Bundle mTuneParams;
    @Nullable private Uri mInitChannelUri;
    @Nullable private String mParentInputIdWhenScreenOff;
    private boolean mScreenOffIntentReceived;
    private boolean mShowProgramGuide;
    private boolean mShowSelectInputView;
    private TvInputInfo mInputToSetUp;
    private final List<MemoryManageable> mMemoryManageables = new ArrayList<>();
    private MediaSessionWrapper mMediaSessionWrapper;
    private final MyOnTuneListener mOnTuneListener = new MyOnTuneListener();

    private String mInputIdUnderSetup;
    private boolean mIsSetupActivityCalledByPopup;
    private AudioManagerHelper mAudioManagerHelper;
    private boolean mTunePending;
    private boolean mDebugNonFullSizeScreen;
    private boolean mActivityResumed;
    private boolean mActivityStarted;
    private boolean mShouldTuneToTunerChannel;
    private boolean mUseKeycodeBlacklist;
    private boolean mShowLockedChannelsTemporarily;
    private boolean mBackKeyPressed;
    private boolean mNeedShowBackKeyGuide;
    private boolean mVisibleBehind;
    private boolean mShowNewSourcesFragment = true;
    private boolean mOtherActivityLaunched;

    private boolean mIsInPIPMode;
    private boolean mIsFilmModeSet;
    private float mDefaultRefreshRate;

    @Inject TvOverlayManagerFactory mOverlayFactory;
    private TvOverlayManager mOverlayManager;

    // mIsCurrentChannelUnblockedByUser and mWasChannelUnblockedBeforeShrunkenByUser are used for
    // keeping the channel unblocking status while TV view is shrunken.
    private boolean mIsCurrentChannelUnblockedByUser;
    private boolean mWasChannelUnblockedBeforeShrunkenByUser;
    private Channel mChannelBeforeShrunkenTvView;
    private boolean mIsCompletingShrunkenTvView;

    private TvContentRating mLastAllowedRatingForCurrentChannel;
    private TvContentRating mAllowedRatingBeforeShrunken;

    private CaptionSettings mCaptionSettings;
    // Lazy initialization
    private boolean mLazyInitialized;

    private static final int MAX_RECENT_CHANNELS = 5;
    private final ArrayDeque<Long> mRecentChannels = new ArrayDeque<>(MAX_RECENT_CHANNELS);

    private String mLastInputIdFromIntent;

    private final Handler mHandler = new MainActivityHandler(this);
    private final Set<OnActionClickListener> mOnActionClickListeners = new ArraySet<>();

    private final BroadcastReceiver mBroadcastReceiver =
            new BroadcastReceiver() {
                @Override
                public void onReceive(Context context, Intent intent) {
                    switch (intent.getAction()) {
                        case Intent.ACTION_SCREEN_OFF:
                            if (DEBUG) Log.d(TAG, "Received ACTION_SCREEN_OFF");
                            // We need to stop TvView, when the screen is turned off. If not and TIS
                            // uses MediaPlayer, a device may not go to the sleep mode and audio
                            // can be heard, because MediaPlayer keeps playing media by its wake
                            // lock.
                            mScreenOffIntentReceived = true;
                            markCurrentChannelDuringScreenOff();
                            stopAll(true);
                            break;
                        case Intent.ACTION_SCREEN_ON:
                            if (DEBUG) Log.d(TAG, "Received ACTION_SCREEN_ON");
                            if (!mActivityResumed && mVisibleBehind) {
                                // ACTION_SCREEN_ON is usually called after onResume. But, if media
                                // is played under launcher with requestVisibleBehind(true),
                                // onResume will not be called. In this case, we need to resume
                                // TvView explicitly.
                                resumeTvIfNeeded();
                            }
                            break;
                        case TvInputManager.ACTION_PARENTAL_CONTROLS_ENABLED_CHANGED:
                            if (DEBUG) Log.d(TAG, "Received parental control settings change");
                            applyParentalControlSettings();
                            checkChannelLockNeeded(mTvView, null);
                            break;
                        case Intent.ACTION_TIME_CHANGED:
                            // Re-tune the current channel to prevent incorrect behavior of
                            // trick-play.
                            // See: b/37393628
                            if (mChannelTuner.getCurrentChannel() != null) {
                                tune(true);
                            }
                            break;
                        default: // fall out
                    }
                }
            };

    private final OnCurrentProgramUpdatedListener mOnCurrentProgramUpdatedListener =
            new OnCurrentProgramUpdatedListener() {
                @Override
                public void onCurrentProgramUpdated(long channelId, Program program) {
                    // Do not update channel banner by this notification
                    // when the time shifting is available.
                    if (mTimeShiftManager.isAvailable()) {
                        return;
                    }
                    Channel channel = mTvView.getCurrentChannel();
                    if (channel != null && channel.getId() == channelId) {
                        mOverlayManager.updateChannelBannerAndShowIfNeeded(
                                TvOverlayManager.UPDATE_CHANNEL_BANNER_REASON_UPDATE_INFO);
                        mMediaSessionWrapper.update(mTvView.isBlocked(), channel, program);
                    }
                }
            };

    private final ChannelTuner.Listener mChannelTunerListener =
            new ChannelTuner.Listener() {
                @Override
                public void onLoadFinished() {
                    Debug.getTimer(Debug.TAG_START_UP_TIMER)
                            .log("MainActivity.mChannelTunerListener.onLoadFinished");
                    mSetupUtils.markNewChannelsBrowsable();
                    if (mActivityResumed) {
                        resumeTvIfNeeded();
                    }
                    mOverlayManager.onBrowsableChannelsUpdated();
                }

                @Override
                public void onBrowsableChannelListChanged() {
                    mOverlayManager.onBrowsableChannelsUpdated();
                }

                @Override
                public void onCurrentChannelUnavailable(Channel channel) {
                    if (mChannelTuner.moveToAdjacentBrowsableChannel(true)) {
                        tune(true);
                    } else {
                        stopTv("onCurrentChannelUnavailable()", false);
                    }
                }

                @Override
                public void onChannelChanged(Channel previousChannel, Channel currentChannel) {}
            };

    private final Runnable mRestoreMainViewRunnable = this::restoreMainTvView;
    private ProgramGuideSearchFragment mSearchFragment;

    private final TvInputCallback mTvInputCallback =
            new TvInputCallback() {
                @Override
                public void onInputAdded(String inputId) {
                    if (mOptionalBuiltInTunerManager.isPresent()
                            && CommonPreferences.shouldShowSetupActivity(MainActivity.this)) {
                        BuiltInTunerManager builtInTunerManager =
                                mOptionalBuiltInTunerManager.get();
                        String tunerInputId = builtInTunerManager.getEmbeddedTunerInputId();
                        if (tunerInputId.equals(inputId)) {
                            Intent intent =
                                    builtInTunerManager
                                            .getTunerInputController()
                                            .createSetupIntent(MainActivity.this);
                            startActivity(intent);
                            CommonPreferences.setShouldShowSetupActivity(MainActivity.this, false);
                            mSetupUtils.markAsKnownInput(tunerInputId);
                        }
                    }
                }
            };

    private void applyParentalControlSettings() {
        boolean parentalControlEnabled =
                mTvInputManagerHelper.getParentalControlSettings().isParentalControlsEnabled();
        mTvView.onParentalControlChanged(parentalControlEnabled);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            ChannelPreviewUpdater.getInstance(this).updatePreviewDataForChannelsImmediately();
        }
    }

    @Override
    public MySingletons singletons() {
        return mMySingletons;
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        AndroidInjection.inject(this);
        mAccessibilityManager =
                (AccessibilityManager) getSystemService(Context.ACCESSIBILITY_SERVICE);
        DurationTimer startUpDebugTimer = Debug.getTimer(Debug.TAG_START_UP_TIMER);
        if (!startUpDebugTimer.isStarted()
                || startUpDebugTimer.getDuration() > START_UP_TIMER_RESET_THRESHOLD_MS) {
            // TvApplication can start by other reason before MainActivty is launched.
            // In this case, we restart the timer.
            startUpDebugTimer.start();
        }
        startUpDebugTimer.log("MainActivity.onCreate");
        if (DEBUG) {
            Log.d(TAG, "onCreate()");
        }
        Starter.start(this);
        super.onCreate(savedInstanceState);
        if (!mTvInputManagerHelper.hasTvInputManager()) {
            Log.wtf(TAG, "Stopping because device does not have a TvInputManager");
            finishAndRemoveTask();
            return;
        }
        mAccountHelper.init();

        TvSingletons tvApplication = (TvSingletons) getApplication();
        // In API 23, TvContract.isChannelUriForPassthroughInput is hidden.
        boolean isPassthroughInput =
                TvContract.isChannelUriForPassthroughInput(getIntent().getData());
        boolean tuneToPassthroughInput =
                Intent.ACTION_VIEW.equals(getIntent().getAction()) && isPassthroughInput;
        boolean channelLoadedAndNoChannelAvailable =
                mChannelDataManager.isDbLoadFinished()
                        && mChannelDataManager.getChannelCount() <= 0;
        if ((OnboardingUtils.isFirstRunWithCurrentVersion(this)
                        || channelLoadedAndNoChannelAvailable)
                && !tuneToPassthroughInput
                && !CommonUtils.isRunningInTest()) {
            startOnboardingActivity();
            return;
        }
        setContentView(R.layout.activity_tv);
        mTvView = findViewById(R.id.main_tunable_tv_view);
        mTvView.initialize(mProgramDataManager, mTvInputManagerHelper, mLegacyFlags);
        mTvView.setOnUnhandledInputEventListener(
                new OnUnhandledInputEventListener() {
                    @Override
                    public boolean onUnhandledInputEvent(InputEvent event) {
                        if (isKeyEventBlocked()) {
                            return true;
                        }
                        if (event instanceof KeyEvent) {
                            KeyEvent keyEvent = (KeyEvent) event;
                            if (keyEvent.getAction() == KeyEvent.ACTION_DOWN
                                    && keyEvent.isLongPress()) {
                                if (onKeyLongPress(keyEvent.getKeyCode(), keyEvent)) {
                                    return true;
                                }
                            }
                            if (keyEvent.getAction() == KeyEvent.ACTION_UP) {
                                return onKeyUp(keyEvent.getKeyCode(), keyEvent);
                            } else if (keyEvent.getAction() == KeyEvent.ACTION_DOWN) {
                                return onKeyDown(keyEvent.getKeyCode(), keyEvent);
                            }
                        }
                        return false;
                    }
                });
        mTvView.setBlockedInfoOnClickListener(v -> showPinDialogFragment());
        long channelId = Utils.getLastWatchedChannelId(this);
        String inputId = Utils.getLastWatchedTunerInputId(this);
        if (!isPassthroughInput
                && inputId != null
                && !mStartupFlags.warmupInputidBlacklist().getElementList().contains(inputId)
                && channelId != Channel.INVALID_ID) {
            mTvView.warmUpInput(inputId, TvContract.buildChannelUri(channelId));
        }

        tvApplication.getMainActivityWrapper().onMainActivityCreated(this);
        if (BuildConfig.ENG && DeveloperPreferences.ALLOW_STRICT_MODE.get(this)) {
            Toast.makeText(this, "Using Strict Mode for eng builds", Toast.LENGTH_SHORT).show();
        }
        mTracker = tvApplication.getTracker();
        if (mOptionalBuiltInTunerManager.isPresent()) {
            mTvInputManagerHelper.addCallback(mTvInputCallback);
        }
        mProgramDataManager.addOnCurrentProgramUpdatedListener(
                Channel.INVALID_ID, mOnCurrentProgramUpdatedListener);
        mProgramDataManager.setPrefetchEnabled(true);
        mChannelTuner = new ChannelTuner(mChannelDataManager, mTvInputManagerHelper);
        mChannelTuner.addListener(mChannelTunerListener);
        mChannelTuner.start();
        mMemoryManageables.add(mProgramDataManager);
        mMemoryManageables.add(ImageCache.getInstance());
        mMemoryManageables.add(TvContentRatingCache.getInstance());
        if (CommonFeatures.DVR.isEnabled(this)) {
            mDvrManager = tvApplication.getDvrManager();
        }
        mTimeShiftManager =
                new TimeShiftManager(
                        this,
                        mTvView,
                        mProgramDataManager,
                        mTracker,
                        new OnCurrentProgramUpdatedListener() {
                            @Override
                            public void onCurrentProgramUpdated(long channelId, Program program) {
                                mMediaSessionWrapper.update(
                                        mTvView.isBlocked(), getCurrentChannel(), program);
                                switch (mTimeShiftManager.getLastActionId()) {
                                    case TimeShiftManager.TIME_SHIFT_ACTION_ID_REWIND:
                                    case TimeShiftManager.TIME_SHIFT_ACTION_ID_FAST_FORWARD:
                                    case TimeShiftManager.TIME_SHIFT_ACTION_ID_JUMP_TO_PREVIOUS:
                                    case TimeShiftManager.TIME_SHIFT_ACTION_ID_JUMP_TO_NEXT:
                                        mOverlayManager.updateChannelBannerAndShowIfNeeded(
                                                TvOverlayManager
                                                        .UPDATE_CHANNEL_BANNER_REASON_FORCE_SHOW);
                                        break;
                                    case TimeShiftManager.TIME_SHIFT_ACTION_ID_PAUSE:
                                    case TimeShiftManager.TIME_SHIFT_ACTION_ID_PLAY:
                                    default:
                                        mOverlayManager.updateChannelBannerAndShowIfNeeded(
                                                TvOverlayManager
                                                        .UPDATE_CHANNEL_BANNER_REASON_UPDATE_INFO);
                                        break;
                                }
                            }
                        });

        DisplayManager displayManager = (DisplayManager) getSystemService(Context.DISPLAY_SERVICE);
        Display display = displayManager.getDisplay(Display.DEFAULT_DISPLAY);
        mDefaultRefreshRate = display.getRefreshRate();

        if (!PermissionUtils.hasAccessWatchedHistory(this)) {
            WatchedHistoryManager watchedHistoryManager =
                    new WatchedHistoryManager(getApplicationContext());
            watchedHistoryManager.start();
            mTvView.setWatchedHistoryManager(watchedHistoryManager);
        }
        mTvViewUiManager =
                new TvViewUiManager(
                        this, mTvView, findViewById(android.R.id.content), mTvOptionsManager);

        mContentView = findViewById(android.R.id.content);
        ViewGroup sceneContainer = findViewById(R.id.scene_container);
        ChannelBannerView channelBannerView =
                (ChannelBannerView)
                        getLayoutInflater().inflate(R.layout.channel_banner, sceneContainer, false);
        KeypadChannelSwitchView keypadChannelSwitchView =
                (KeypadChannelSwitchView)
                        getLayoutInflater()
                                .inflate(R.layout.keypad_channel_switch, sceneContainer, false);
        InputBannerView inputBannerView =
                (InputBannerView)
                        getLayoutInflater().inflate(R.layout.input_banner, sceneContainer, false);
        SelectInputView selectInputView =
                (SelectInputView)
                        getLayoutInflater().inflate(R.layout.select_input, sceneContainer, false);
        selectInputView.setOnInputSelectedCallback(
                new OnInputSelectedCallback() {
                    @Override
                    public void onTunerInputSelected() {
                        Channel currentChannel = mChannelTuner.getCurrentChannel();
                        if (currentChannel != null && !currentChannel.isPassthrough()) {
                            hideOverlays();
                        } else {
                            tuneToLastWatchedChannelForTunerInput();
                        }
                    }

                    @Override
                    public void onPassthroughInputSelected(@NonNull TvInputInfo input) {
                        Channel currentChannel = mChannelTuner.getCurrentChannel();
                        String currentInputId =
                                currentChannel == null ? null : currentChannel.getInputId();
                        if (TextUtils.equals(input.getId(), currentInputId)) {
                            hideOverlays();
                        } else {
                            tuneToChannel(ChannelImpl.createPassthroughChannel(input.getId()));
                        }
                    }

                    private void hideOverlays() {
                        getOverlayManager()
                                .hideOverlays(
                                        TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_DIALOG
                                                | TvOverlayManager
                                                        .FLAG_HIDE_OVERLAYS_KEEP_SIDE_PANELS
                                                | TvOverlayManager
                                                        .FLAG_HIDE_OVERLAYS_KEEP_PROGRAM_GUIDE
                                                | TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_MENU
                                                | TvOverlayManager
                                                        .FLAG_HIDE_OVERLAYS_KEEP_FRAGMENT);
                    }
                });
        mSearchFragment = new ProgramGuideSearchFragment();
        mOverlayManager =
                mOverlayFactory.create(
                        this,
                        mChannelTuner,
                        mTvView,
                        mTvOptionsManager,
                        keypadChannelSwitchView,
                        channelBannerView,
                        inputBannerView,
                        selectInputView,
                        sceneContainer,
                        mSearchFragment);
        mAccessibilityManager.addAccessibilityStateChangeListener(mOverlayManager);

        mAudioManagerHelper = new AudioManagerHelper(this, mTvView);
        mAudioCapabilitiesReceiver = new AudioCapabilitiesReceiver(this, null);
        mAudioCapabilitiesReceiver.register();
        Intent nowPlayingIntent = new Intent(this, MainActivity.class);
        PendingIntent pendingIntent =
                PendingIntent.getActivity(this, REQUEST_CODE_NOW_PLAYING, nowPlayingIntent, 0);
        mMediaSessionWrapper = new MediaSessionWrapper(this, pendingIntent);

        mTvViewUiManager.restoreDisplayMode(false);
        if (!handleIntent(getIntent())) {
            finish();
            return;
        }

        if (CommonFeatures.DVR.isEnabled(this)
                && TvFeatures.SHOW_UPCOMING_CONFLICT_DIALOG.isEnabled(this)) {
            mDvrConflictChecker = new ConflictChecker(this);
        }
        initForTest();
        Debug.getTimer(Debug.TAG_START_UP_TIMER).log("MainActivity.onCreate end");
    }

    private void startOnboardingActivity() {
        startActivity(OnboardingActivity.buildIntent(this, getIntent()));
        finish();
    }

    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        float density = getResources().getDisplayMetrics().density;
        mTvViewUiManager.onConfigurationChanged(
                (int) (newConfig.screenWidthDp * density),
                (int) (newConfig.screenHeightDp * density));
    }

    @Override
    public void onRequestPermissionsResult(
            int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        if (requestCode == PERMISSIONS_REQUEST_READ_TV_LISTINGS) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // Start reload of dependent data
                mChannelDataManager.reload();
                mProgramDataManager.reload();

                // Restart TV app.
                Intent intent = getIntent();
                finish();
                startActivity(intent);
            } else {
                Toast.makeText(
                                this,
                                R.string.msg_read_tv_listing_permission_denied,
                                Toast.LENGTH_LONG)
                        .show();
                finish();
            }
        }
    }

    @BlockScreenType
    private int getDesiredBlockScreenType() {
        if (!mActivityResumed) {
            return TunableTvView.BLOCK_SCREEN_TYPE_NO_UI;
        }
        if (isUnderShrunkenTvView()) {
            return TunableTvView.BLOCK_SCREEN_TYPE_SHRUNKEN_TV_VIEW;
        }
        if (mOverlayManager.needHideTextOnMainView()) {
            return TunableTvView.BLOCK_SCREEN_TYPE_NO_UI;
        }
        SafeDismissDialogFragment currentDialog = mOverlayManager.getCurrentDialog();
        if (currentDialog != null) {
            // If PIN dialog is shown for unblocking the channel lock or content ratings lock,
            // keeping the unlocking message is more natural instead of changing it.
            if (currentDialog instanceof PinDialogFragment) {
                int type = ((PinDialogFragment) currentDialog).getType();
                if (type == PinDialogFragment.PIN_DIALOG_TYPE_UNLOCK_CHANNEL
                        || type == PinDialogFragment.PIN_DIALOG_TYPE_UNLOCK_PROGRAM) {
                    return TunableTvView.BLOCK_SCREEN_TYPE_NORMAL;
                }
            }
            return TunableTvView.BLOCK_SCREEN_TYPE_NO_UI;
        }
        if (mOverlayManager.isSetupFragmentActive()
                || mOverlayManager.isNewSourcesFragmentActive()) {
            return TunableTvView.BLOCK_SCREEN_TYPE_NO_UI;
        }
        return TunableTvView.BLOCK_SCREEN_TYPE_NORMAL;
    }

    @Override
    protected void onNewIntent(Intent intent) {
        if (DEBUG) {
            Log.d(TAG, "onNewIntent(): " + intent);
        }
        if (mOverlayManager == null) {
            // It's called before onCreate. The intent will be handled at onCreate. b/30725058
            return;
        }
        mOverlayManager.getSideFragmentManager().hideAll(false);
        if (!handleIntent(intent) && !mActivityStarted) {
            // If the activity is stopped and not destroyed, finish the activity.
            // Otherwise, just ignore the intent.
            finish();
        }
    }

    @Override
    protected void onStart() {
        if (DEBUG) {
            Log.d(TAG, "onStart()");
        }
        super.onStart();
        mScreenOffIntentReceived = false;
        mActivityStarted = true;
        mTracker.sendMainStart();
        mMainDurationTimer.start();

        applyParentalControlSettings();
        registerReceiver(mBroadcastReceiver, SYSTEM_INTENT_FILTER);

        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
            Intent notificationIntent = new Intent(this, NotificationService.class);
            notificationIntent.setAction(NotificationService.ACTION_SHOW_RECOMMENDATION);
            startService(notificationIntent);
        }
        if (mOptionalBuiltInTunerManager.isPresent()) {
            mOptionalBuiltInTunerManager
                    .get()
                    .getTunerInputController()
                    .executeNetworkTunerDiscoveryAsyncTask(this);
        }
        mEpgFetcher.fetchImmediatelyIfNeeded();
    }

    @Override
    protected void onResume() {
        Debug.getTimer(Debug.TAG_START_UP_TIMER).log("MainActivity.onResume start");
        if (DEBUG) Log.d(TAG, "onResume()");
        super.onResume();
        mIsInPIPMode = false;
        if (!PermissionUtils.hasAccessAllEpg(this)
                && checkSelfPermission(PERMISSION_READ_TV_LISTINGS)
                        != PackageManager.PERMISSION_GRANTED) {
            requestPermissions(
                    new String[] {PERMISSION_READ_TV_LISTINGS},
                    PERMISSIONS_REQUEST_READ_TV_LISTINGS);
        }
        mTracker.sendScreenView(SCREEN_NAME);

        SystemProperties.updateSystemProperties();
        mNeedShowBackKeyGuide = true;
        mActivityResumed = true;
        mShowNewSourcesFragment = true;
        mOtherActivityLaunched = false;
        mAudioManagerHelper.requestAudioFocus();

        if (mTvView.isPlaying()) {
            // Every time onResume() is called the activity will be assumed to not have requested
            // visible behind.
            requestVisibleBehind(true);
        }
        Set<String> failedScheduledRecordingInfoSet =
                Utils.getFailedScheduledRecordingInfoSet(getApplicationContext());
        if (Utils.hasRecordingFailedReason(
                        getApplicationContext(), TvInputManager.RECORDING_ERROR_INSUFFICIENT_SPACE)
                && !failedScheduledRecordingInfoSet.isEmpty()) {
            runAfterAttachedToWindow(
                    () ->
                            DvrUiHelper.showDvrInsufficientSpaceErrorDialog(
                                    MainActivity.this, failedScheduledRecordingInfoSet));
        }

        if (mChannelTuner.areAllChannelsLoaded()) {
            mSetupUtils.markNewChannelsBrowsable();
            resumeTvIfNeeded();
        }
        mOverlayManager.showMenuWithTimeShiftPauseIfNeeded();

        // NOTE: The following codes are related to pop up an overlay UI after resume. When
        // the following code is changed, please modify willShowOverlayUiWhenResume() accordingly.
        if (mInputToSetUp != null) {
            startSetupActivity(mInputToSetUp, false);
            mInputToSetUp = null;
        } else if (mShowProgramGuide) {
            mShowProgramGuide = false;
            // This will delay the start of the animation until after the Live Channel app is
            // shown. Without this the animation is completed before it is actually visible on
            // the screen.
            mHandler.post(() -> mOverlayManager.showProgramGuide());
        } else if (mShowSelectInputView) {
            mShowSelectInputView = false;
            // mShowSelectInputView is true when the activity is started/resumed because the
            // TV_INPUT button was pressed in a different app.  This will delay the start of
            // the animation until after the Live Channel app is shown. Without this the
            // animation is completed before it is actually visible on the screen.
            mHandler.post(() -> mOverlayManager.showSelectInputView());
        }
        if (mDvrConflictChecker != null) {
            mDvrConflictChecker.start();
        }
        if (CommonFeatures.ENABLE_TV_SERVICE.isEnabled(this) && isAudioOnlyInput()) {
            // TODO(b/110969180): figure out when to call AudioOnlyTvServiceUtil.stopAudioOnlyInput
            AudioOnlyTvServiceUtil.startAudioOnlyInput(this, mLastInputIdFromIntent);
        }
        Debug.getTimer(Debug.TAG_START_UP_TIMER).log("MainActivity.onResume end");
    }

    @Override
    protected void onPause() {
        if (DEBUG) Log.d(TAG, "onPause()");
        if (mDvrConflictChecker != null) {
            mDvrConflictChecker.stop();
        }
        finishChannelChangeIfNeeded();
        mActivityResumed = false;
        mOverlayManager.hideOverlays(TvOverlayManager.FLAG_HIDE_OVERLAYS_DEFAULT);
        mTvView.setBlockScreenType(TunableTvView.BLOCK_SCREEN_TYPE_NO_UI);
        mBackKeyPressed = false;
        mShowLockedChannelsTemporarily = false;
        mShouldTuneToTunerChannel = false;
        if (!mVisibleBehind) {
            if (mIsInPIPMode) {
                mTracker.sendScreenView(SCREEN_PIP);
            } else {
                mTracker.sendScreenView("");
                mAudioManagerHelper.abandonAudioFocus();
                mMediaSessionWrapper.setPlaybackState(false);
            }
        } else {
            mTracker.sendScreenView(SCREEN_BEHIND_NAME);
        }
        super.onPause();
    }

    /** Returns true if {@link #onResume} is called and {@link #onPause} is not called yet. */
    public boolean isActivityResumed() {
        return mActivityResumed;
    }

    /** Returns true if {@link #onStart} is called and {@link #onStop} is not called yet. */
    public boolean isActivityStarted() {
        return mActivityStarted;
    }

    @Override
    public boolean requestVisibleBehind(boolean enable) {
        boolean state = super.requestVisibleBehind(enable);
        mVisibleBehind = state;
        return state;
    }

    @Override
    public void onPinChecked(boolean checked, int type, String rating) {
        if (checked) {
            switch (type) {
                case PinDialogFragment.PIN_DIALOG_TYPE_UNLOCK_CHANNEL:
                    blockOrUnblockScreen(mTvView, false);
                    mIsCurrentChannelUnblockedByUser = true;
                    break;
                case PinDialogFragment.PIN_DIALOG_TYPE_UNLOCK_PROGRAM:
                    TvContentRating unblockedRating = TvContentRating.unflattenFromString(rating);
                    mLastAllowedRatingForCurrentChannel = unblockedRating;
                    mTvView.unblockContent(unblockedRating);
                    break;
                case PinDialogFragment.PIN_DIALOG_TYPE_ENTER_PIN:
                    mOverlayManager
                            .getSideFragmentManager()
                            .show(new ParentalControlsFragment(), false);
                    // fall through.
                case PinDialogFragment.PIN_DIALOG_TYPE_NEW_PIN:
                    mOverlayManager.getSideFragmentManager().showSidePanel(true);
                    break;
                default: // fall out
            }
        } else if (type == PinDialogFragment.PIN_DIALOG_TYPE_ENTER_PIN) {
            mOverlayManager.getSideFragmentManager().hideAll(false);
        }
    }

    private void resumeTvIfNeeded() {
        if (DEBUG) Log.d(TAG, "resumeTvIfNeeded()");
        if (!mTvView.isPlaying()
                || mInitChannelUri != null
                || (mShouldTuneToTunerChannel && mChannelTuner.isCurrentChannelPassthrough())) {
            if (TvContract.isChannelUriForPassthroughInput(mInitChannelUri)) {
                // The target input may not be ready yet, especially, just after screen on.
                String inputId = mInitChannelUri.getPathSegments().get(1);
                TvInputInfo input = mTvInputManagerHelper.getTvInputInfo(inputId);
                if (input == null) {
                    input = mTvInputManagerHelper.getTvInputInfo(mParentInputIdWhenScreenOff);
                    if (input == null) {
                        SoftPreconditions.checkState(false, TAG, "Input disappear.");
                        finish();
                    } else {
                        mInitChannelUri =
                                TvContract.buildChannelUriForPassthroughInput(input.getId());
                    }
                }
            }
            mParentInputIdWhenScreenOff = null;
            startTv(mInitChannelUri);
            mInitChannelUri = null;
        }
        // Make sure TV app has the main TV view to handle the case that TvView is used in other
        // application.
        restoreMainTvView();
        mTvView.setBlockScreenType(getDesiredBlockScreenType());
    }

    private void startTv(Uri channelUri) {
        if (DEBUG) Log.d(TAG, "startTv Uri=" + channelUri);
        if ((channelUri == null || !TvContract.isChannelUriForPassthroughInput(channelUri))
                && mChannelTuner.isCurrentChannelPassthrough()) {
            // For passthrough TV input, channelUri is always given. If TV app is launched
            // by TV app icon in a launcher, channelUri is null. So if passthrough TV input
            // is playing, we stop the passthrough TV input.
            stopTv();
        }
        SoftPreconditions.checkState(
                TvContract.isChannelUriForPassthroughInput(channelUri)
                        || mChannelTuner.areAllChannelsLoaded(),
                TAG,
                "startTV assumes that ChannelDataManager is already loaded.");
        if (mTvView.isPlaying()) {
            // TV has already started.
            if (channelUri == null || channelUri.equals(mChannelTuner.getCurrentChannelUri())) {
                // Simply adjust the volume without tune.
                mAudioManagerHelper.setVolumeByAudioFocusStatus();
                return;
            }
            stopTv();
        }
        if (mChannelTuner.getCurrentChannel() != null) {
            Log.w(TAG, "The current channel should be reset before");
            mChannelTuner.resetCurrentChannel();
        }
        if (channelUri == null) {
            // If any initial channel id is not given, remember the last channel the user watched.
            long channelId = Utils.getLastWatchedChannelId(this);
            if (channelId != Channel.INVALID_ID) {
                channelUri = TvContract.buildChannelUri(channelId);
            }
        }

        if (channelUri == null) {
            mChannelTuner.moveToChannel(mChannelTuner.findNearestBrowsableChannel(0));
        } else {
            if (TvContract.isChannelUriForPassthroughInput(channelUri)) {
                ChannelImpl channel = ChannelImpl.createPassthroughChannel(channelUri);
                mChannelTuner.moveToChannel(channel);
            } else {
                long channelId = ContentUris.parseId(channelUri);
                Channel channel = mChannelDataManager.getChannel(channelId);
                if (channel == null || !mChannelTuner.moveToChannel(channel)) {
                    mChannelTuner.moveToChannel(mChannelTuner.findNearestBrowsableChannel(0));
                    Log.w(
                            TAG,
                            "The requested channel (id="
                                    + channelId
                                    + ") doesn't exist. "
                                    + "The first channel will be tuned to.");
                }
            }
        }

        mTvView.start();
        mAudioManagerHelper.setVolumeByAudioFocusStatus();
        tune(true);
    }

    @Override
    protected void onStop() {
        if (DEBUG) Log.d(TAG, "onStop()");
        if (mScreenOffIntentReceived) {
            mScreenOffIntentReceived = false;
        } else {
            PowerManager powerManager = (PowerManager) getSystemService(Context.POWER_SERVICE);
            if (!powerManager.isInteractive()) {
                // We added to check isInteractive as well as SCREEN_OFF intent, because
                // calling timing of the intent SCREEN_OFF is not consistent. b/25953633.
                // If we verify that checking isInteractive is enough, we can remove the logic
                // for SCREEN_OFF intent.
                markCurrentChannelDuringScreenOff();
            }
        }
        if (mChannelTuner.isCurrentChannelPassthrough()) {
            mInitChannelUri = mChannelTuner.getCurrentChannelUri();
        }
        mActivityStarted = false;
        stopAll(false);
        unregisterReceiver(mBroadcastReceiver);
        mTracker.sendMainStop(mMainDurationTimer.reset());
        super.onStop();
    }

    /** Handles screen off to keep the current channel for next screen on. */
    private void markCurrentChannelDuringScreenOff() {
        mInitChannelUri = mChannelTuner.getCurrentChannelUri();
        if (mChannelTuner.isCurrentChannelPassthrough()) {
            // When ACTION_SCREEN_OFF is invoked, some CEC devices may be already
            // removed. So we need to get the input info from ChannelTuner instead of
            // TvInputManagerHelper.
            TvInputInfo input = mChannelTuner.getCurrentInputInfo();
            mParentInputIdWhenScreenOff = input.getParentId();
            if (DEBUG) Log.d(TAG, "Parent input: " + mParentInputIdWhenScreenOff);
        }
    }

    private void stopAll(boolean keepVisibleBehind) {
        mOverlayManager.hideOverlays(TvOverlayManager.FLAG_HIDE_OVERLAYS_WITHOUT_ANIMATION);
        stopTv("stopAll()", keepVisibleBehind);
    }

    public TvInputManagerHelper getTvInputManagerHelper() {
        return mTvInputManagerHelper;
    }

    /**
     * Starts setup activity for the given input {@code input}.
     *
     * @param calledByPopup If true, startSetupActivity is invoked from the setup fragment.
     */
    public void startSetupActivity(TvInputInfo input, boolean calledByPopup) {
        Intent intent = CommonUtils.createSetupIntent(input);
        if (intent == null) {
            Toast.makeText(this, R.string.msg_no_setup_activity, Toast.LENGTH_SHORT).show();
            return;
        }
        // Even though other app can handle the intent, the setup launched by TV app
        // should go through TV app SetupPassthroughActivity.
        intent.setComponent(new ComponentName(this, SetupPassthroughActivity.class));
        try {
            // Now we know that the user intends to set up this input. Grant permission for writing
            // EPG data.
            SetupUtils.grantEpgPermission(this, input.getServiceInfo().packageName);

            mInputIdUnderSetup = input.getId();
            mIsSetupActivityCalledByPopup = calledByPopup;
            // Call requestVisibleBehind(false) before starting other activity.
            // In Activity.requestVisibleBehind(false), this activity is scheduled to be stopped
            // immediately if other activity is about to start. And this activity is scheduled to
            // to be stopped again after onPause().
            stopTv("startSetupActivity()", false);
            startActivityForResult(intent, REQUEST_CODE_START_SETUP_ACTIVITY);
        } catch (ActivityNotFoundException e) {
            mInputIdUnderSetup = null;
            Toast.makeText(
                            this,
                            getString(
                                    R.string.msg_unable_to_start_setup_activity,
                                    input.loadLabel(this)),
                            Toast.LENGTH_SHORT)
                    .show();
            return;
        }
        if (calledByPopup) {
            mOverlayManager.hideOverlays(
                    TvOverlayManager.FLAG_HIDE_OVERLAYS_WITHOUT_ANIMATION
                            | TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_FRAGMENT);
        } else {
            mOverlayManager.hideOverlays(
                    TvOverlayManager.FLAG_HIDE_OVERLAYS_WITHOUT_ANIMATION
                            | TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_SIDE_PANEL_HISTORY);
        }
    }

    public boolean hasCaptioningSettingsActivity() {
        return Utils.isIntentAvailable(this, new Intent(Settings.ACTION_CAPTIONING_SETTINGS));
    }

    public void startSystemCaptioningSettingsActivity() {
        Intent intent = new Intent(Settings.ACTION_CAPTIONING_SETTINGS);
        try {
            startActivitySafe(intent);
        } catch (ActivityNotFoundException e) {
            Toast.makeText(
                            this,
                            getString(R.string.msg_unable_to_start_system_captioning_settings),
                            Toast.LENGTH_SHORT)
                    .show();
        }
    }

    public ChannelDataManager getChannelDataManager() {
        return mChannelDataManager;
    }

    public ProgramDataManager getProgramDataManager() {
        return mProgramDataManager;
    }

    public TvOptionsManager getTvOptionsManager() {
        return mTvOptionsManager;
    }

    public TvViewUiManager getTvViewUiManager() {
        return mTvViewUiManager;
    }

    public TimeShiftManager getTimeShiftManager() {
        return mTimeShiftManager;
    }

    /** Returns the instance of {@link TvOverlayManager}. */
    public TvOverlayManager getOverlayManager() {
        return mOverlayManager;
    }

    /** Returns the {@link ConflictChecker}. */
    @Nullable
    public ConflictChecker getDvrConflictChecker() {
        return mDvrConflictChecker;
    }

    public Channel getCurrentChannel() {
        return mChannelTuner.getCurrentChannel();
    }

    public long getCurrentChannelId() {
        return mChannelTuner.getCurrentChannelId();
    }

    /**
     * Returns the current program which the user is watching right now.
     *
     * <p>It might be a live program. If the time shifting is available, it can be a past program,
     * too.
     */
    public Program getCurrentProgram() {
        if (!isChannelChangeKeyDownReceived() && mTimeShiftManager.isAvailable()) {
            // We shouldn't get current program from TimeShiftManager during channel tunning
            return mTimeShiftManager.getCurrentProgram();
        }
        return mProgramDataManager.getCurrentProgram(getCurrentChannelId());
    }

    /**
     * Returns the current playing time in milliseconds.
     *
     * <p>If the time shifting is available, the time is the playing position of the program,
     * otherwise, the system current time.
     */
    public long getCurrentPlayingPosition() {
        if (mTimeShiftManager.isAvailable()) {
            return mTimeShiftManager.getCurrentPositionMs();
        }
        return System.currentTimeMillis();
    }

    private Channel getBrowsableChannel() {
        Channel curChannel = mChannelTuner.getCurrentChannel();
        if (curChannel != null && curChannel.isBrowsable()) {
            return curChannel;
        } else {
            return mChannelTuner.getAdjacentBrowsableChannel(true);
        }
    }

    /**
     * Call {@link Activity#startActivity} in a safe way.
     *
     * @see LauncherActivity
     */
    public void startActivitySafe(Intent intent) {
        LauncherActivity.startActivitySafe(this, intent);
    }

    /** Show settings fragment. */
    public void showSettingsFragment() {
        if (!mChannelTuner.areAllChannelsLoaded()) {
            // Show ChannelSourcesFragment only if all the channels are loaded.
            return;
        }
        mOverlayManager.getSideFragmentManager().show(new SettingsFragment());
    }

    public void showMerchantCollection() {
        Intent onlineStoreIntent = OnboardingUtils.createOnlineStoreIntent(mUiFlags);
        if (onlineStoreIntent != null) {
            startActivitySafe(onlineStoreIntent);
        } else {
            Log.w(
                    TAG,
                    "Unable to show merchant collection, more channels url is not valid. url is "
                            + mUiFlags.moreChannelsUrl());
        }
    }

    /**
     * It is called when shrunken TvView is desired, such as EditChannelFragment and
     * ChannelsLockedFragment.
     */
    public void startShrunkenTvView(
            boolean showLockedChannelsTemporarily, boolean willMainViewBeTunerInput) {
        mChannelBeforeShrunkenTvView = mTvView.getCurrentChannel();
        mWasChannelUnblockedBeforeShrunkenByUser = mIsCurrentChannelUnblockedByUser;
        mAllowedRatingBeforeShrunken = mLastAllowedRatingForCurrentChannel;
        mTvViewUiManager.startShrunkenTvView();

        if (showLockedChannelsTemporarily) {
            mShowLockedChannelsTemporarily = true;
            checkChannelLockNeeded(mTvView, null);
        }

        mTvView.setBlockScreenType(getDesiredBlockScreenType());
    }

    /**
     * It is called when shrunken TvView is no longer desired, such as EditChannelFragment and
     * ChannelsLockedFragment.
     */
    public void endShrunkenTvView() {
        mTvViewUiManager.endShrunkenTvView();
        mIsCompletingShrunkenTvView = true;

        Channel returnChannel = mChannelBeforeShrunkenTvView;
        if (returnChannel == null
                || (!returnChannel.isPassthrough() && !returnChannel.isBrowsable())) {
            // Try to tune to the next best channel instead.
            returnChannel = getBrowsableChannel();
        }
        mShowLockedChannelsTemporarily = false;

        // The current channel is mTvView.getCurrentChannel() and need to tune to the returnChannel.
        if (!Objects.equals(mTvView.getCurrentChannel(), returnChannel)) {
            final Channel channel = returnChannel;
            Runnable tuneAction =
                    () -> {
                        tuneToChannel(channel);
                        if (mChannelBeforeShrunkenTvView == null
                                || !mChannelBeforeShrunkenTvView.equals(channel)) {
                            Utils.setLastWatchedChannel(MainActivity.this, channel);
                        }
                        mIsCompletingShrunkenTvView = false;
                        mIsCurrentChannelUnblockedByUser = mWasChannelUnblockedBeforeShrunkenByUser;
                        mTvView.setBlockScreenType(getDesiredBlockScreenType());
                    };
            mTvViewUiManager.fadeOutTvView(tuneAction);
            // Will automatically fade-in when video becomes available.
        } else {
            checkChannelLockNeeded(mTvView, null);
            mIsCompletingShrunkenTvView = false;
            mIsCurrentChannelUnblockedByUser = mWasChannelUnblockedBeforeShrunkenByUser;
            mTvView.setBlockScreenType(getDesiredBlockScreenType());
        }
    }

    private boolean isUnderShrunkenTvView() {
        return mTvViewUiManager.isUnderShrunkenTvView() || mIsCompletingShrunkenTvView;
    }

    /**
     * Returns {@code true} if the tunable tv view is blocked by resource conflict or by parental
     * control, otherwise {@code false}.
     */
    public boolean isScreenBlockedByResourceConflictOrParentalControl() {
        return mTvView.getVideoUnavailableReason()
                        == TunableTvView.VIDEO_UNAVAILABLE_REASON_NO_RESOURCE
                || mTvView.isBlocked();
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        switch (requestCode) {
            case REQUEST_CODE_START_SETUP_ACTIVITY:
                if (resultCode == RESULT_OK) {
                    int count = mChannelDataManager.getChannelCountForInput(mInputIdUnderSetup);
                    String text;
                    if (count > 0) {
                        text =
                                getResources()
                                        .getQuantityString(
                                                R.plurals.msg_channel_added, count, count);
                    } else {
                        text = getString(R.string.msg_no_channel_added);
                    }
                    Toast.makeText(MainActivity.this, text, Toast.LENGTH_SHORT).show();
                    mInputIdUnderSetup = null;
                    if (mChannelTuner.getCurrentChannel() == null) {
                        mChannelTuner.moveToAdjacentBrowsableChannel(true);
                    }
                    if (mTunePending) {
                        tune(true);
                    }
                } else {
                    mInputIdUnderSetup = null;
                }
                if (!mIsSetupActivityCalledByPopup) {
                    mOverlayManager.getSideFragmentManager().showSidePanel(false);
                }
                break;
            case REQUEST_CODE_NOW_PLAYING:
                // nothing needs to be done.  onResume will restore everything.
                break;
            default:
                // do nothing
        }
        if (data != null) {
            String errorMessage = data.getStringExtra(LauncherActivity.ERROR_MESSAGE);
            if (!TextUtils.isEmpty(errorMessage)) {
                Toast.makeText(MainActivity.this, errorMessage, Toast.LENGTH_SHORT).show();
            }
        }
    }

    @Override
    public boolean dispatchKeyEvent(KeyEvent event) {
        if (DeveloperPreferences.LOG_KEYEVENT.get(this)) {
            Log.d(TAG, "dispatchKeyEvent(" + event + ")");
        }
        // If an activity is closed on a back key down event, back key down events with none zero
        // repeat count or a back key up event can be happened without the first back key down
        // event which should be ignored in this activity.
        if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
            if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
                mBackKeyPressed = true;
            }
            if (!mBackKeyPressed) {
                return true;
            }
            if (event.getAction() == KeyEvent.ACTION_UP) {
                mBackKeyPressed = false;
            }
        }

        // When side panel is closing, it has the focus.
        // Keep the focus, but just don't deliver the key events.
        if ((mContentView.hasFocusable() && !mOverlayManager.getSideFragmentManager().isHiding())
                || mOverlayManager.getSideFragmentManager().isActive()) {
            return super.dispatchKeyEvent(event);
        }
        if (BLACKLIST_KEYCODE_TO_TIS.contains(event.getKeyCode())
                || KeyEvent.isGamepadButton(event.getKeyCode())) {
            // If the event is in blacklisted or gamepad key, do not pass it to session.
            // Gamepad keys are blacklisted to support TV UIs and here's the detail.
            // If there's a TIS granted RECEIVE_INPUT_EVENT, TIF sends key events to TIS
            // and return immediately saying that the event is handled.
            // In this case, fallback key will be injected but with FLAG_CANCELED
            // while gamepads support DPAD_CENTER and BACK by fallback.
            // Since we don't expect that TIS want to handle gamepad buttons now,
            // blacklist gamepad buttons and wait for next fallback keys.
            // TODO: Need to consider other fallback keys (e.g. ESCAPE)
            return super.dispatchKeyEvent(event);
        }
        return dispatchKeyEventToSession(event) || super.dispatchKeyEvent(event);
    }

    /** Notifies the key input focus is changed to the TV view. */
    public void updateKeyInputFocus() {
        mHandler.post(() -> mTvView.setBlockScreenType(getDesiredBlockScreenType()));
    }

    // It should be called before onResume.
    private boolean handleIntent(Intent intent) {
        mLastInputIdFromIntent = getInputId(intent);
        // Reset the closed caption settings when the activity is 1)created or 2) restarted.
        // And do not reset while TvView is playing.
        if (!mTvView.isPlaying()) {
            mCaptionSettings = new CaptionSettings(this);
        }
        mShouldTuneToTunerChannel = intent.getBooleanExtra(Utils.EXTRA_KEY_FROM_LAUNCHER, false);
        mInitChannelUri = null;

        String extraAction = intent.getStringExtra(Utils.EXTRA_KEY_ACTION);
        if (!TextUtils.isEmpty(extraAction)) {
            if (DEBUG) Log.d(TAG, "Got an extra action: " + extraAction);
            if (Utils.EXTRA_ACTION_SHOW_TV_INPUT.equals(extraAction)) {
                String lastWatchedChannelUri = Utils.getLastWatchedChannelUri(this);
                if (lastWatchedChannelUri != null) {
                    mInitChannelUri = Uri.parse(lastWatchedChannelUri);
                }
                mShowSelectInputView = true;
            }
        }

        if (TvInputManager.ACTION_SETUP_INPUTS.equals(intent.getAction())) {
            runAfterAttachedToWindow(() -> mOverlayManager.showSetupFragment());
        } else if (Intent.ACTION_VIEW.equals(intent.getAction())) {
            Uri uri = intent.getData();
            if (Utils.isProgramsUri(uri)) {
                // When the URI points to the programs (directory, not an individual item), go to
                // the program guide. The intention here is to respond to
                // "content://android.media.tv/program", not
                // "content://android.media.tv/program/XXX".
                // Later, we might want to add handling of individual programs too.
                mShowProgramGuide = true;
                return true;
            }
            // In case the channel is given explicitly, use it.
            mInitChannelUri = uri;
            if (DEBUG) Log.d(TAG, "ACTION_VIEW with " + mInitChannelUri);
            if (Channels.CONTENT_URI.equals(mInitChannelUri)) {
                // Tune to default channel.
                mInitChannelUri = null;
                mShouldTuneToTunerChannel = true;
                return true;
            }
            if ((!Utils.isChannelUriForOneChannel(mInitChannelUri)
                    && !Utils.isChannelUriForInput(mInitChannelUri))) {
                Log.w(
                        TAG,
                        "Malformed channel uri " + mInitChannelUri + " tuning to default instead");
                mInitChannelUri = null;
                return true;
            }
            mTuneParams = intent.getExtras();
            String programUriString = intent.getStringExtra(SearchManager.EXTRA_DATA_KEY);
            Uri programUriFromIntent =
                    programUriString == null ? null : Uri.parse(programUriString);
            long channelIdFromIntent = ContentUriUtils.safeParseId(mInitChannelUri);
            if (programUriFromIntent != null && channelIdFromIntent != Channel.INVALID_ID) {
                new AsyncQueryProgramTask(
                                mDbExecutor,
                                programUriFromIntent,
                                ProgramImpl.PROJECTION,
                                null,
                                null,
                                null,
                                channelIdFromIntent)
                        .executeOnDbThread();
            }
            if (mTuneParams == null) {
                mTuneParams = new Bundle();
            }
            if (Utils.isChannelUriForTunerInput(mInitChannelUri)) {
                mTuneParams.putLong(KEY_INIT_CHANNEL_ID, channelIdFromIntent);
            } else if (TvContract.isChannelUriForPassthroughInput(mInitChannelUri)) {
                // If mInitChannelUri is for a passthrough TV input.
                String inputId = mInitChannelUri.getPathSegments().get(1);
                TvInputInfo input = mTvInputManagerHelper.getTvInputInfo(inputId);
                if (input == null) {
                    mInitChannelUri = null;
                    Toast.makeText(this, R.string.msg_no_specific_input, Toast.LENGTH_SHORT).show();
                    return false;
                } else if (!input.isPassthroughInput()) {
                    mInitChannelUri = null;
                    Toast.makeText(this, R.string.msg_not_passthrough_input, Toast.LENGTH_SHORT)
                            .show();
                    return false;
                }
            } else if (mInitChannelUri != null) {
                // Handle the URI built by TvContract.buildChannelsUriForInput().
                String inputId = mInitChannelUri.getQueryParameter("input");
                long channelId = Utils.getLastWatchedChannelIdForInput(this, inputId);
                if (channelId == Channel.INVALID_ID) {
                    String[] projection = {BaseColumns._ID};
                    long time = System.currentTimeMillis();
                    try (Cursor cursor =
                            getContentResolver().query(uri, projection, null, null, null)) {
                        if (cursor != null && cursor.moveToNext()) {
                            channelId = cursor.getLong(0);
                        }
                    }
                    Debug.getTimer(Debug.TAG_START_UP_TIMER)
                            .log(
                                    "MainActivity queries DB for "
                                            + "last channel check ("
                                            + (System.currentTimeMillis() - time)
                                            + "ms)");
                }
                if (channelId == Channel.INVALID_ID) {
                    // Couldn't find any channel probably because the input hasn't been set up.
                    // Try to set it up.
                    mInitChannelUri = null;
                    mInputToSetUp = mTvInputManagerHelper.getTvInputInfo(inputId);
                } else {
                    mInitChannelUri = TvContract.buildChannelUri(channelId);
                    mTuneParams.putLong(KEY_INIT_CHANNEL_ID, channelId);
                }
            }
        }
        return true;
    }

    private class AsyncQueryProgramTask extends AsyncDbTask.AsyncQueryTask<Program> {
        private final long mChannelIdFromIntent;

        public AsyncQueryProgramTask(
                Executor executor,
                Uri uri,
                String[] projection,
                String selection,
                String[] selectionArgs,
                String orderBy,
                long channelId) {
            super(executor, MainActivity.this, uri, projection, selection, selectionArgs, orderBy);
            mChannelIdFromIntent = channelId;
        }

        @Override
        protected Program onQuery(Cursor c) {
            Program program = null;
            if (c != null && c.moveToNext()) {
                program = ProgramImpl.fromCursor(c);
            }
            return program;
        }

        @Override
        protected void onPostExecute(Program program) {
            if (program == null || program.getStartTimeUtcMillis() <= System.currentTimeMillis()) {
                // null or current program
                return;
            }
            Channel channel = mChannelDataManager.getChannel(mChannelIdFromIntent);
            if (channel != null) {
                Intent intent = new Intent(MainActivity.this, DetailsActivity.class);
                intent.putExtra(DetailsActivity.CHANNEL_ID, mChannelIdFromIntent);
                intent.putExtra(DetailsActivity.DETAILS_VIEW_TYPE, DetailsActivity.PROGRAM_VIEW);
                intent.putExtra(DetailsActivity.PROGRAM, program.toParcelable());
                intent.putExtra(DetailsActivity.INPUT_ID, channel.getInputId());
                startActivity(intent);
            }
        }
    }

    private void stopTv() {
        stopTv(null, false);
    }

    private void stopTv(String logForCaller, boolean keepVisibleBehind) {
        if (logForCaller != null) {
            Log.i(TAG, "stopTv is called at " + logForCaller + ".");
        } else {
            if (DEBUG) Log.d(TAG, "stopTv()");
        }
        if (mTvView.isPlaying()) {
            mTvView.stop();
            if (!keepVisibleBehind) {
                requestVisibleBehind(false);
            }
            mAudioManagerHelper.abandonAudioFocus();
            mMediaSessionWrapper.setPlaybackState(false);
        }
        TvSingletons.getSingletons(this)
                .getMainActivityWrapper()
                .notifyCurrentChannelChange(this, null);
        mChannelTuner.resetCurrentChannel();
        mTunePending = false;
    }

    private void scheduleRestoreMainTvView() {
        mHandler.removeCallbacks(mRestoreMainViewRunnable);
        mHandler.postDelayed(mRestoreMainViewRunnable, TVVIEW_SET_MAIN_TIMEOUT_MS);
    }

    /** Says {@code text} when accessibility is turned on. */
    private void sendAccessibilityText(String text) {
        if (mAccessibilityManager.isEnabled()) {
            AccessibilityEvent event = AccessibilityEvent.obtain();
            event.setClassName(getClass().getName());
            event.setPackageName(getPackageName());
            event.setEventType(AccessibilityEvent.TYPE_ANNOUNCEMENT);
            event.getText().add(text);
            mAccessibilityManager.sendAccessibilityEvent(event);
        }
    }

    private void tune(boolean updateChannelBanner) {
        if (DEBUG) Log.d(TAG, "tune()");
        mTuneDurationTimer.start();

        lazyInitializeIfNeeded();

        // Prerequisites to be able to tune.
        if (mInputIdUnderSetup != null) {
            mTunePending = true;
            return;
        }
        mTunePending = false;
        if (CommonFeatures.TUNER_SIGNAL_STRENGTH.isEnabled(this)) {
            mTvView.resetChannelSignalStrength();
            mOverlayManager.updateChannelBannerAndShowIfNeeded(
                    TvOverlayManager.UPDATE_CHANNEL_BANNER_REASON_UPDATE_SIGNAL_STRENGTH);
        }
        final Channel channel = mChannelTuner.getCurrentChannel();
        SoftPreconditions.checkState(channel != null);
        if (channel == null) {
            return;
        }
        if (!mChannelTuner.isCurrentChannelPassthrough()) {
            if (mTvInputManagerHelper.getTunerTvInputSize() == 0) {
                Toast.makeText(this, R.string.msg_no_input, Toast.LENGTH_SHORT).show();
                finish();
                return;
            }

            if (mSetupUtils.isFirstTune()) {
                if (!mChannelTuner.areAllChannelsLoaded()) {
                    // tune() will be called, once all channels are loaded.
                    stopTv("tune()", false);
                    return;
                }
                if (mChannelDataManager.getChannelCount() > 0) {
                    mOverlayManager.showIntroDialog();
                } else {
                    startOnboardingActivity();
                    return;
                }
            }
            mShowNewSourcesFragment = false;
            if (mChannelTuner.getBrowsableChannelCount() == 0
                    && mChannelDataManager.getChannelCount() > 0
                    && !mOverlayManager.getSideFragmentManager().isActive()) {
                if (!mChannelTuner.areAllChannelsLoaded()) {
                    return;
                }
                if (mTvInputManagerHelper.getTunerTvInputSize() == 1) {
                    mOverlayManager
                            .getSideFragmentManager()
                            .show(new CustomizeChannelListFragment());
                } else {
                    mOverlayManager.showSetupFragment();
                }
                return;
            }
            if (!CommonUtils.isRunningInTest()
                    && mShowNewSourcesFragment
                    && mSetupUtils.hasUnrecognizedInput(mTvInputManagerHelper)) {
                // Show new channel sources fragment.
                runAfterAttachedToWindow(
                        () ->
                                mOverlayManager.runAfterOverlaysAreClosed(
                                        new Runnable() {
                                            @Override
                                            public void run() {
                                                mOverlayManager.showNewSourcesFragment();
                                            }
                                        }));
            }
            mSetupUtils.onTuned();
            if (mTuneParams != null) {
                Long initChannelId = mTuneParams.getLong(KEY_INIT_CHANNEL_ID);
                if (initChannelId == channel.getId()) {
                    mTuneParams.remove(KEY_INIT_CHANNEL_ID);
                } else {
                    mTuneParams = null;
                }
            }
        }

        mIsCurrentChannelUnblockedByUser = false;
        if (!isUnderShrunkenTvView()) {
            mLastAllowedRatingForCurrentChannel = null;
        }
        // For every tune, we need to inform the tuned channel or input to a user,
        // if Talkback is turned on.
        sendAccessibilityText(
                mChannelTuner.isCurrentChannelPassthrough()
                        ? Utils.loadLabel(
                                this, mTvInputManagerHelper.getTvInputInfo(channel.getInputId()))
                        : channel.getDisplayText());

        boolean success = mTvView.tuneTo(channel, mTuneParams, mOnTuneListener);
        mOnTuneListener.onTune(channel, isUnderShrunkenTvView());

        mTuneParams = null;
        if (!success) {
            Toast.makeText(this, R.string.msg_tune_failed, Toast.LENGTH_SHORT).show();
            return;
        }

        // Explicitly make the TV view main to make the selected input an HDMI-CEC active source.
        mTvView.setMain();
        scheduleRestoreMainTvView();
        if (!isUnderShrunkenTvView()) {
            if (!channel.isPassthrough()) {
                addToRecentChannels(channel.getId());
            }
            Utils.setLastWatchedChannel(this, channel);
            TvSingletons.getSingletons(this)
                    .getMainActivityWrapper()
                    .notifyCurrentChannelChange(this, channel);
        }
        // We have to provide channel here instead of using TvView's channel, because TvView's
        // channel might be null when there's tuner conflict. In that case, TvView will resets
        // its current channel onConnectionFailed().
        checkChannelLockNeeded(mTvView, channel);
        if (updateChannelBanner) {
            mOverlayManager.updateChannelBannerAndShowIfNeeded(
                    TvOverlayManager.UPDATE_CHANNEL_BANNER_REASON_TUNE);
        }
        if (mActivityResumed) {
            // requestVisibleBehind should be called after onResume() is called. But, when
            // launcher is over the TV app and the screen is turned off and on, tune() can
            // be called during the pause state by mBroadcastReceiver (Intent.ACTION_SCREEN_ON).
            requestVisibleBehind(true);
        }
        mMediaSessionWrapper.update(mTvView.isBlocked(), getCurrentChannel(), getCurrentProgram());
    }

    // Runs the runnable after the activity is attached to window to show the fragment transition
    // animation.
    // The runnable runs asynchronously to show the animation a little better even when system is
    // busy at the moment it is called.
    // If the activity is paused shortly, runnable may not be called because all the fragments
    // should be closed when the activity is paused.
    private void runAfterAttachedToWindow(final Runnable runnable) {
        final Runnable runOnlyIfActivityIsResumed =
                () -> {
                    if (mActivityResumed) {
                        runnable.run();
                    }
                };
        if (mContentView.isAttachedToWindow()) {
            mHandler.post(runOnlyIfActivityIsResumed);
        } else {
            mContentView
                    .getViewTreeObserver()
                    .addOnWindowAttachListener(
                            new ViewTreeObserver.OnWindowAttachListener() {
                                @Override
                                public void onWindowAttached() {
                                    mContentView
                                            .getViewTreeObserver()
                                            .removeOnWindowAttachListener(this);
                                    mHandler.post(runOnlyIfActivityIsResumed);
                                }

                                @Override
                                public void onWindowDetached() {}
                            });
        }
    }

    boolean isNowPlayingProgram(Channel channel, Program program) {
        return program == null
                ? (channel != null
                        && getCurrentProgram() == null
                        && channel.equals(getCurrentChannel()))
                : program.equals(getCurrentProgram());
    }

    private void addToRecentChannels(long channelId) {
        if (!mRecentChannels.remove(channelId)) {
            if (mRecentChannels.size() >= MAX_RECENT_CHANNELS) {
                mRecentChannels.removeLast();
            }
        }
        mRecentChannels.addFirst(channelId);
        mOverlayManager.getMenu().onRecentChannelsChanged();
    }

    /** Returns the recently tuned channels. */
    public ArrayDeque<Long> getRecentChannels() {
        return mRecentChannels;
    }

    private void checkChannelLockNeeded(TunableTvView tvView, Channel currentChannel) {
        if (currentChannel == null) {
            currentChannel = tvView.getCurrentChannel();
        }
        if (tvView.isPlaying() && currentChannel != null) {
            if (getParentalControlSettings().isParentalControlsEnabled()
                    && currentChannel.isLocked()
                    && !mShowLockedChannelsTemporarily
                    && !(isUnderShrunkenTvView()
                            && currentChannel.equals(mChannelBeforeShrunkenTvView)
                            && mWasChannelUnblockedBeforeShrunkenByUser)) {
                if (DEBUG) Log.d(TAG, "Channel " + currentChannel.getId() + " is locked");
                blockOrUnblockScreen(tvView, true);
            } else {
                blockOrUnblockScreen(tvView, false);
            }
        }
    }

    private void blockOrUnblockScreen(TunableTvView tvView, boolean blockOrUnblock) {
        tvView.blockOrUnblockScreen(blockOrUnblock);
        if (tvView == mTvView) {
            mOverlayManager.updateChannelBannerAndShowIfNeeded(
                    TvOverlayManager.UPDATE_CHANNEL_BANNER_REASON_LOCK_OR_UNLOCK);
            mMediaSessionWrapper.update(blockOrUnblock, getCurrentChannel(), getCurrentProgram());
        }
    }

    /** Hide the overlays when tuning to a channel from the menu (e.g. Channels). */
    public void hideOverlaysForTune() {
        mOverlayManager.hideOverlays(TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_SCENE);
    }

    public boolean needToKeepSetupScreenWhenHidingOverlay() {
        return mInputIdUnderSetup != null && mIsSetupActivityCalledByPopup;
    }

    // For now, this only takes care of 24fps.
    private void applyDisplayRefreshRate(float videoFrameRate) {
        boolean is24Fps = Math.abs(videoFrameRate - FRAME_RATE_FOR_FILM) < FRAME_RATE_EPSILON;
        if (mIsFilmModeSet && !is24Fps) {
            setPreferredRefreshRate(mDefaultRefreshRate);
            mIsFilmModeSet = false;
        } else if (!mIsFilmModeSet && is24Fps) {
            DisplayManager displayManager =
                    (DisplayManager) getSystemService(Context.DISPLAY_SERVICE);
            Display display = displayManager.getDisplay(Display.DEFAULT_DISPLAY);

            float[] refreshRates = display.getSupportedRefreshRates();
            for (float refreshRate : refreshRates) {
                // Be conservative and set only when the display refresh rate supports 24fps.
                if (Math.abs(videoFrameRate - refreshRate) < REFRESH_RATE_EPSILON) {
                    setPreferredRefreshRate(refreshRate);
                    mIsFilmModeSet = true;
                    return;
                }
            }
        }
    }

    private void setPreferredRefreshRate(float refreshRate) {
        Window window = getWindow();
        WindowManager.LayoutParams layoutParams = window.getAttributes();
        layoutParams.preferredRefreshRate = refreshRate;
        window.setAttributes(layoutParams);
    }

    @VisibleForTesting
    protected void applyMultiAudio(String trackId) {
        List<TvTrackInfo> tracks = getTracks(TvTrackInfo.TYPE_AUDIO);
        if (tracks == null) {
            mTvOptionsManager.onMultiAudioChanged(null);
            return;
        }

        TvTrackInfo bestTrack = null;
        if (trackId != null) {
            for (TvTrackInfo track : tracks) {
                if (trackId.equals(track.getId())) {
                    bestTrack = track;
                    break;
                }
            }
        }
        if (bestTrack == null) {
            String id = TvSettings.getMultiAudioId(this);
            String language = TvSettings.getMultiAudioLanguage(this);
            int channelCount = TvSettings.getMultiAudioChannelCount(this);
            bestTrack = TvTrackInfoUtils.getBestTrackInfo(tracks, id, language, channelCount);
        }
        if (bestTrack != null) {
            String selectedTrack = getSelectedTrack(TvTrackInfo.TYPE_AUDIO);
            if (!bestTrack.getId().equals(selectedTrack)) {
                selectTrack(TvTrackInfo.TYPE_AUDIO, bestTrack, UNDEFINED_TRACK_INDEX);
            } else {
                mTvOptionsManager.onMultiAudioChanged(
                        TvTrackInfoUtils.getMultiAudioString(this, bestTrack, false));
            }
            return;
        }
        mTvOptionsManager.onMultiAudioChanged(null);
    }

    private void applyClosedCaption() {
        List<TvTrackInfo> tracks = getTracks(TvTrackInfo.TYPE_SUBTITLE);
        if (tracks == null) {
            mTvOptionsManager.onClosedCaptionsChanged(null, UNDEFINED_TRACK_INDEX);
            return;
        }

        boolean enabled = mCaptionSettings.isEnabled();
        mTvView.setClosedCaptionEnabled(enabled);

        String selectedTrackId = getSelectedTrack(TvTrackInfo.TYPE_SUBTITLE);
        if (enabled) {
            String language = mCaptionSettings.getLanguage();
            String trackId = mCaptionSettings.getTrackId();
            List<String> preferredLanguages = mCaptionSettings.getSystemPreferenceLanguageList();
            int bestTrackIndex =
                    findBestCaptionTrackIndex(tracks, language, preferredLanguages, trackId);
            if (bestTrackIndex != UNDEFINED_TRACK_INDEX) {
                selectCaptionTrack(selectedTrackId, tracks.get(bestTrackIndex), bestTrackIndex);
                return;
            }
        }
        deselectCaptionTrack(selectedTrackId);
    }

    public void showProgramGuideSearchFragment() {
        getFragmentManager()
                .beginTransaction()
                .replace(R.id.fragment_container, mSearchFragment)
                .addToBackStack(null)
                .commit();
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        // Do not save instance state because restoring instance state when TV app died
        // unexpectedly can cause some problems like initializing fragments duplicately and
        // accessing resource before it is initialized.
    }

    @Override
    protected void onDestroy() {
        if (DEBUG) Log.d(TAG, "onDestroy()");
        Debug.getTimer(Debug.TAG_START_UP_TIMER).reset();
        SideFragment.releaseRecycledViewPool();
        ViewCache.getInstance().clear();
        if (mTvView != null) {
            mTvView.release();
        }
        if (mChannelTuner != null) {
            mChannelTuner.removeListener(mChannelTunerListener);
            mChannelTuner.stop();
        }
        TvApplication application = ((TvApplication) getApplication());
        if (mProgramDataManager != null) {
            mProgramDataManager.removeOnCurrentProgramUpdatedListener(
                    Channel.INVALID_ID, mOnCurrentProgramUpdatedListener);
            if (application.getMainActivityWrapper().isCurrent(this)) {
                mProgramDataManager.setPrefetchEnabled(false);
            }
        }
        if (mOverlayManager != null) {
            mAccessibilityManager.removeAccessibilityStateChangeListener(mOverlayManager);
            mOverlayManager.release();
        }
        mMemoryManageables.clear();
        if (mMediaSessionWrapper != null) {
            mMediaSessionWrapper.release();
        }
        if (mAudioCapabilitiesReceiver != null) {
            mAudioCapabilitiesReceiver.unregister();
        }
        mHandler.removeCallbacksAndMessages(null);
        application.getMainActivityWrapper().onMainActivityDestroyed(this);
        if (mTvInputManagerHelper != null) {
            mTvInputManagerHelper.clearTvInputLabels();
            if (mOptionalBuiltInTunerManager.isPresent()) {
                mTvInputManagerHelper.removeCallback(mTvInputCallback);
            }
        }
        super.onDestroy();
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (DeveloperPreferences.LOG_KEYEVENT.get(this)) {
            Log.d(TAG, "onKeyDown(" + keyCode + ", " + event + ")");
        }
        switch (mOverlayManager.onKeyDown(keyCode, event)) {
            case KEY_EVENT_HANDLER_RESULT_DISPATCH_TO_OVERLAY:
                return super.onKeyDown(keyCode, event);
            case KEY_EVENT_HANDLER_RESULT_HANDLED:
                return true;
            case KEY_EVENT_HANDLER_RESULT_NOT_HANDLED:
                return false;
            case KEY_EVENT_HANDLER_RESULT_PASSTHROUGH:
            default:
                // fall through
        }
        if (mSearchFragment.isVisible()) {
            return super.onKeyDown(keyCode, event);
        }
        if (!mChannelTuner.areAllChannelsLoaded()) {
            return false;
        }
        if (!mChannelTuner.isCurrentChannelPassthrough()) {
            switch (keyCode) {
                case KeyEvent.KEYCODE_CHANNEL_UP:
                case KeyEvent.KEYCODE_DPAD_UP:
                    if (event.getRepeatCount() == 0
                            && mChannelTuner.getBrowsableChannelCount() > 0) {

                        channelUpPressed();
                    }
                    return true;
                case KeyEvent.KEYCODE_CHANNEL_DOWN:
                case KeyEvent.KEYCODE_DPAD_DOWN:
                    if (event.getRepeatCount() == 0
                            && mChannelTuner.getBrowsableChannelCount() > 0) {
                        channelDownPressed();
                    }
                    return true;
                default: // fall out
            }
        }
        return super.onKeyDown(keyCode, event);
    }

    @Override
    public void channelDown() {
        channelDownPressed();
        finishChannelChangeIfNeeded();
    }

    private void channelDownPressed() {
        // message sending should be done before moving channel, because we use the
        // existence of message to decide if users are switching channel.
        mHandler.sendMessageDelayed(
                mHandler.obtainMessage(MSG_CHANNEL_DOWN_PRESSED, System.currentTimeMillis()),
                CHANNEL_CHANGE_INITIAL_DELAY_MILLIS);
        moveToAdjacentChannel(false, false);
        mTracker.sendChannelDown();
    }

    @Override
    public void channelUp() {
        channelUpPressed();
        finishChannelChangeIfNeeded();
    }

    private void channelUpPressed() {
        // message sending should be done before moving channel, because we use the
        // existence of message to decide if users are switching channel.
        mHandler.sendMessageDelayed(
                mHandler.obtainMessage(MSG_CHANNEL_UP_PRESSED, System.currentTimeMillis()),
                CHANNEL_CHANGE_INITIAL_DELAY_MILLIS);
        moveToAdjacentChannel(true, false);
        mTracker.sendChannelUp();
    }

    @Override
    public boolean onKeyUp(int keyCode, KeyEvent event) {
        /*
         * The following keyboard keys map to these remote keys or "debug actions"
         *  - --------
         *  A KEYCODE_MEDIA_AUDIO_TRACK
         *  D debug: show debug options
         *  E updateChannelBannerAndShowIfNeeded
         *  G debug: refresh cloud epg
         *  I KEYCODE_TV_INPUT
         *  O debug: show display mode option
         *  S KEYCODE_CAPTIONS: select subtitle
         *  W debug: toggle screen size
         *  V KEYCODE_MEDIA_RECORD debug: record the current channel for 30 sec
         */
        if (DeveloperPreferences.LOG_KEYEVENT.get(this)) {
            Log.d(TAG, "onKeyUp(" + keyCode + ", " + event + ")");
        }
        // If we are in the middle of channel change, finish it before showing overlays.
        finishChannelChangeIfNeeded();

        if (event.getKeyCode() == KeyEvent.KEYCODE_SEARCH) {
            // Prevent MainActivity from being closed by onVisibleBehindCanceled()
            mOtherActivityLaunched = true;
            return false;
        }
        switch (mOverlayManager.onKeyUp(keyCode, event)) {
            case KEY_EVENT_HANDLER_RESULT_DISPATCH_TO_OVERLAY:
                return super.onKeyUp(keyCode, event);
            case KEY_EVENT_HANDLER_RESULT_HANDLED:
                return true;
            case KEY_EVENT_HANDLER_RESULT_NOT_HANDLED:
                return false;
            case KEY_EVENT_HANDLER_RESULT_PASSTHROUGH:
            default:
                // fall through
        }
        if (mSearchFragment.isVisible()) {
            if (keyCode == KeyEvent.KEYCODE_BACK) {
                getFragmentManager().popBackStack();
                return true;
            }
            return super.onKeyUp(keyCode, event);
        }
        if (keyCode == KeyEvent.KEYCODE_BACK) {
            // When the event is from onUnhandledInputEvent, onBackPressed is not automatically
            // called. Therefore, we need to explicitly call onBackPressed().
            onBackPressed();
            return true;
        }

        if (!mChannelTuner.areAllChannelsLoaded()) {
            // Now channel map is under loading.
        } else if (mChannelTuner.getBrowsableChannelCount() == 0) {
            switch (keyCode) {
                case KeyEvent.KEYCODE_CHANNEL_UP:
                case KeyEvent.KEYCODE_DPAD_UP:
                case KeyEvent.KEYCODE_CHANNEL_DOWN:
                case KeyEvent.KEYCODE_DPAD_DOWN:
                case KeyEvent.KEYCODE_NUMPAD_ENTER:
                case KeyEvent.KEYCODE_DPAD_CENTER:
                case KeyEvent.KEYCODE_E:
                case KeyEvent.KEYCODE_MENU:
                    showSettingsFragment();
                    return true;
                default: // fall out
            }
        } else {
            if (KeypadChannelSwitchView.isChannelNumberKey(keyCode)) {
                mOverlayManager.showKeypadChannelSwitch(keyCode);
                return true;
            }
            switch (keyCode) {
                case KeyEvent.KEYCODE_DPAD_RIGHT:
                    if (!mTvView.isVideoOrAudioAvailable()
                            && mTvView.getVideoUnavailableReason()
                                    == TunableTvView.VIDEO_UNAVAILABLE_REASON_NO_RESOURCE) {
                        DvrUiHelper.startSchedulesActivityForTuneConflict(
                                this, mChannelTuner.getCurrentChannel());
                        return true;
                    }
                    showPinDialogFragment();
                    return true;
                case KeyEvent.KEYCODE_WINDOW:
                    enterPictureInPictureMode();
                    return true;
                case KeyEvent.KEYCODE_ENTER:
                case KeyEvent.KEYCODE_NUMPAD_ENTER:
                case KeyEvent.KEYCODE_E:
                case KeyEvent.KEYCODE_DPAD_CENTER:
                case KeyEvent.KEYCODE_MENU:
                    if (event.isCanceled()) {
                        // Ignore canceled key.
                        // Note that if there's a TIS granted RECEIVE_INPUT_EVENT,
                        // fallback keys not blacklisted will have FLAG_CANCELED.
                        // See dispatchKeyEvent() for detail.
                        return true;
                    }
                    if (keyCode != KeyEvent.KEYCODE_MENU) {
                        mOverlayManager.updateChannelBannerAndShowIfNeeded(
                                TvOverlayManager.UPDATE_CHANNEL_BANNER_REASON_FORCE_SHOW);
                    }
                    if (keyCode != KeyEvent.KEYCODE_E) {
                        mOverlayManager.showMenu(Menu.REASON_NONE);
                    }
                    return true;
                case KeyEvent.KEYCODE_CHANNEL_UP:
                case KeyEvent.KEYCODE_DPAD_UP:
                case KeyEvent.KEYCODE_CHANNEL_DOWN:
                case KeyEvent.KEYCODE_DPAD_DOWN:
                    // Channel change is already done in the head of this method.
                    return true;
                case KeyEvent.KEYCODE_S:
                    if (!DeveloperPreferences.USE_DEBUG_KEYS.get(this)) {
                        break;
                    }
                    // fall through.
                case KeyEvent.KEYCODE_CAPTIONS:
                    mOverlayManager.getSideFragmentManager().show(new ClosedCaptionFragment());
                    return true;
                case KeyEvent.KEYCODE_A:
                    if (!DeveloperPreferences.USE_DEBUG_KEYS.get(this)) {
                        break;
                    }
                    // fall through.
                case KeyEvent.KEYCODE_MEDIA_AUDIO_TRACK:
                    mOverlayManager.getSideFragmentManager().show(new MultiAudioFragment());
                    return true;
                case KeyEvent.KEYCODE_INFO:
                    mOverlayManager.showBanner();
                    return true;
                case KeyEvent.KEYCODE_MEDIA_RECORD:
                case KeyEvent.KEYCODE_V:
                    Channel currentChannel = getCurrentChannel();
                    if (currentChannel != null && mDvrManager != null) {
                        boolean isRecording =
                                mDvrManager.getCurrentRecording(currentChannel.getId()) != null;
                        if (!isRecording) {
                            if (!mDvrManager.isChannelRecordable(currentChannel)) {
                                Toast.makeText(
                                                this,
                                                R.string.dvr_msg_cannot_record_program,
                                                Toast.LENGTH_SHORT)
                                        .show();
                            } else {
                                Program program =
                                        mProgramDataManager.getCurrentProgram(
                                                currentChannel.getId());
                                DvrUiHelper.checkStorageStatusAndShowErrorMessage(
                                        this,
                                        currentChannel.getInputId(),
                                        () ->
                                                DvrUiHelper.requestRecordingCurrentProgram(
                                                        MainActivity.this,
                                                        currentChannel,
                                                        program,
                                                        false));
                            }
                        } else {
                            DvrUiHelper.showStopRecordingDialog(
                                    this,
                                    currentChannel.getId(),
                                    DvrStopRecordingFragment.REASON_USER_STOP,
                                    new HalfSizedDialogFragment.OnActionClickListener() {
                                        @Override
                                        public void onActionClick(long actionId) {
                                            if (actionId == DvrStopRecordingFragment.ACTION_STOP) {
                                                ScheduledRecording currentRecording =
                                                        mDvrManager.getCurrentRecording(
                                                                currentChannel.getId());
                                                if (currentRecording != null) {
                                                    mDvrManager.stopRecording(currentRecording);
                                                }
                                            }
                                        }
                                    });
                        }
                    }
                    return true;
                default: // fall out
            }
        }
        if (keyCode == KeyEvent.KEYCODE_WINDOW) {
            // Consumes the PIP button to prevent entering PIP mode
            // in case that TV isn't showing properly (e.g. no browsable channel)
            return true;
        }
        if (DeveloperPreferences.USE_DEBUG_KEYS.get(this) || BuildConfig.ENG) {
            switch (keyCode) {
                case KeyEvent.KEYCODE_W:
                    mDebugNonFullSizeScreen = !mDebugNonFullSizeScreen;
                    if (mDebugNonFullSizeScreen) {
                        FrameLayout.LayoutParams params =
                                (FrameLayout.LayoutParams) mTvView.getLayoutParams();
                        params.width = 960;
                        params.height = 540;
                        params.gravity = Gravity.START;
                        mTvView.setTvViewLayoutParams(params);
                    } else {
                        FrameLayout.LayoutParams params =
                                (FrameLayout.LayoutParams) mTvView.getLayoutParams();
                        params.width = ViewGroup.LayoutParams.MATCH_PARENT;
                        params.height = ViewGroup.LayoutParams.MATCH_PARENT;
                        params.gravity = Gravity.CENTER;
                        mTvView.setTvViewLayoutParams(params);
                    }
                    return true;
                case KeyEvent.KEYCODE_CTRL_LEFT:
                case KeyEvent.KEYCODE_CTRL_RIGHT:
                    mUseKeycodeBlacklist = !mUseKeycodeBlacklist;
                    return true;
                case KeyEvent.KEYCODE_O:
                    mOverlayManager.getSideFragmentManager().show(new DisplayModeFragment());
                    return true;
                case KeyEvent.KEYCODE_D:
                    mOverlayManager.getSideFragmentManager().show(new DeveloperOptionFragment());
                    return true;
                default: // fall out
            }
        }
        return super.onKeyUp(keyCode, event);
    }

    private void showPinDialogFragment() {
        if (!PermissionUtils.hasModifyParentalControls(this)) {
            return;
        }
        PinDialogFragment dialog = null;
        if (mTvView.isScreenBlocked()) {
            dialog = PinDialogFragment.create(PinDialogFragment.PIN_DIALOG_TYPE_UNLOCK_CHANNEL);
        } else if (mTvView.isContentBlocked()) {
            dialog =
                    PinDialogFragment.create(
                            PinDialogFragment.PIN_DIALOG_TYPE_UNLOCK_PROGRAM,
                            mTvView.getBlockedContentRating().flattenToString());
        }
        if (dialog != null) {
            mOverlayManager.showDialogFragment(PinDialogFragment.DIALOG_TAG, dialog, false);
        }
    }

    @Override
    public boolean onKeyLongPress(int keyCode, KeyEvent event) {
        if (DeveloperPreferences.LOG_KEYEVENT.get(this)) Log.d(TAG, "onKeyLongPress(" + event);
        if (USE_BACK_KEY_LONG_PRESS) {
            // Treat the BACK key long press as the normal press since we changed the behavior in
            // onBackPressed().
            if (keyCode == KeyEvent.KEYCODE_BACK) {
                // It takes long time for TV app to finish, so stop TV first.
                stopAll(false);
                super.onBackPressed();
                return true;
            }
        }
        return false;
    }

    @Override
    public void onUserInteraction() {
        super.onUserInteraction();
        if (mOverlayManager != null) {
            mOverlayManager.onUserInteraction();
        }
    }

    @Override
    public void enterPictureInPictureMode() {
        // We need to hide overlay first, before moving the activity to PIP. If not, UI will
        // be shown during PIP stack resizing, because UI and its animation is stuck during
        // PIP resizing.
        mIsInPIPMode = true;
        if (mOverlayManager.isOverlayOpened()) {
            mOverlayManager.hideOverlays(TvOverlayManager.FLAG_HIDE_OVERLAYS_WITHOUT_ANIMATION);
            mHandler.post(MainActivity.super::enterPictureInPictureMode);
        } else {
            MainActivity.super.enterPictureInPictureMode();
        }
    }

    @Override
    public void onWindowFocusChanged(boolean hasFocus) {
        if (!hasFocus) {
            finishChannelChangeIfNeeded();
        }
    }

    /**
     * Returns {@code true} if one of the channel changing keys are pressed and not released yet.
     */
    public boolean isChannelChangeKeyDownReceived() {
        return mHandler.hasMessages(MSG_CHANNEL_UP_PRESSED)
                || mHandler.hasMessages(MSG_CHANNEL_DOWN_PRESSED);
    }

    private void finishChannelChangeIfNeeded() {
        if (!isChannelChangeKeyDownReceived()) {
            return;
        }
        mHandler.removeMessages(MSG_CHANNEL_UP_PRESSED);
        mHandler.removeMessages(MSG_CHANNEL_DOWN_PRESSED);
        if (mChannelTuner.getBrowsableChannelCount() > 0) {
            if (!mTvView.isPlaying()) {
                // We expect that mTvView is already played. But, it is sometimes not.
                // TODO: we figure out the reason when mTvView is not played.
                Log.w(TAG, "TV view isn't played in finishChannelChangeIfNeeded");
            }
            tuneToChannel(mChannelTuner.getCurrentChannel());
        } else {
            showSettingsFragment();
        }
    }

    private boolean dispatchKeyEventToSession(final KeyEvent event) {
        if (DeveloperPreferences.LOG_KEYEVENT.get(this)) {
            Log.d(TAG, "dispatchKeyEventToSession(" + event + ")");
        }
        boolean handled = false;
        if (mTvView != null) {
            handled = mTvView.dispatchKeyEvent(event);
        }
        if (isKeyEventBlocked()) {
            if ((event.getKeyCode() == KeyEvent.KEYCODE_BACK
                            || event.getKeyCode() == KeyEvent.KEYCODE_BUTTON_B)
                    && mNeedShowBackKeyGuide) {
                // KeyEvent.KEYCODE_BUTTON_B is also used like the back button.
                Toast.makeText(this, R.string.msg_back_key_guide, Toast.LENGTH_SHORT).show();
                mNeedShowBackKeyGuide = false;
            }
            return true;
        }
        return handled;
    }

    private boolean isKeyEventBlocked() {
        // If the current channel is a passthrough channel, we don't handle the key events in TV
        // activity. Instead, the key event will be handled by the passthrough TV input.
        return mChannelTuner.isCurrentChannelPassthrough();
    }

    private void tuneToLastWatchedChannelForTunerInput() {
        if (!mChannelTuner.isCurrentChannelPassthrough()) {
            return;
        }
        stopTv();
        startTv(null);
    }

    public void tuneToChannel(Channel channel) {
        if (channel == null) {
            if (mTvView.isPlaying()) {
                mTvView.reset();
            }
        } else {
            if (!mTvView.isPlaying()) {
                startTv(channel.getUri());
            } else if (channel.equals(mTvView.getCurrentChannel())) {
                mOverlayManager.updateChannelBannerAndShowIfNeeded(
                        TvOverlayManager.UPDATE_CHANNEL_BANNER_REASON_TUNE);
            } else if (channel.equals(mChannelTuner.getCurrentChannel())) {
                // Channel banner is already updated in moveToAdjacentChannel
                tune(false);
            } else if (mChannelTuner.moveToChannel(channel)) {
                // Channel banner would be updated inside of tune.
                tune(true);
            } else {
                showSettingsFragment();
            }
        }
    }

    /**
     * This method just moves the channel in the channel map and updates the channel banner, but
     * doesn't actually tune to the channel. The caller of this method should call {@link #tune} in
     * the end.
     *
     * @param channelUp {@code true} for channel up, and {@code false} for channel down.
     * @param fastTuning {@code true} if fast tuning is requested.
     */
    private void moveToAdjacentChannel(boolean channelUp, boolean fastTuning) {
        if (mChannelTuner.moveToAdjacentBrowsableChannel(channelUp)) {
            mOverlayManager.updateChannelBannerAndShowIfNeeded(
                    fastTuning
                            ? TvOverlayManager.UPDATE_CHANNEL_BANNER_REASON_TUNE_FAST
                            : TvOverlayManager.UPDATE_CHANNEL_BANNER_REASON_TUNE);
        }
    }

    /** Set the main TV view which holds HDMI-CEC active source based on the sound mode */
    private void restoreMainTvView() {
        mTvView.setMain();
    }

    @Override
    public void onVisibleBehindCanceled() {
        stopTv("onVisibleBehindCanceled()", false);
        mTracker.sendScreenView("");
        mAudioManagerHelper.abandonAudioFocus();
        mMediaSessionWrapper.setPlaybackState(false);
        mVisibleBehind = false;
        if (!mOtherActivityLaunched && Build.VERSION.SDK_INT == Build.VERSION_CODES.M) {
            // Workaround: in M, onStop is not called, even though it should be called after
            // onVisibleBehindCanceled is called. As a workaround, we call finish().
            finish();
        }
        super.onVisibleBehindCanceled();
    }

    @Override
    public void startActivityForResult(Intent intent, int requestCode) {
        mOtherActivityLaunched = true;
        if (intent.getCategories() == null
                || !intent.getCategories().contains(Intent.CATEGORY_HOME)) {
            // Workaround b/30150267
            requestVisibleBehind(false);
        }
        super.startActivityForResult(intent, requestCode);
    }

    public List<TvTrackInfo> getTracks(int type) {
        return mTvView.getTracks(type);
    }

    public String getSelectedTrack(int type) {
        return mTvView.getSelectedTrack(type);
    }

    @VisibleForTesting
    static int findBestCaptionTrackIndex(
            List<TvTrackInfo> tracks,
            String selectedLanguage,
            List<String> preferredLanguages,
            String selectedTrackId) {
        int alternativeTrackIndex = UNDEFINED_TRACK_INDEX;
        // Priority of selected alternative track, where -1 being the highest priority.
        int alternativeTrackPriority = preferredLanguages.size();
        for (int i = 0; i < tracks.size(); i++) {
            TvTrackInfo track = tracks.get(i);
            if (Utils.isEqualLanguage(track.getLanguage(), selectedLanguage)) {
                if (track.getId().equals(selectedTrackId)) {
                    return i;
                } else if (alternativeTrackPriority != HIGHEST_PRIORITY) {
                    alternativeTrackIndex = i;
                    alternativeTrackPriority = HIGHEST_PRIORITY;
                }
            } else {
                // Select alternative track in order of preference
                // 1. User language captions
                // 2. System language captions
                // 3. Other captions
                int index = UNDEFINED_TRACK_INDEX;
                for (int j = 0; j < preferredLanguages.size(); j++) {
                    if (Utils.isEqualLanguage(track.getLanguage(), preferredLanguages.get(j))) {
                        index = j;
                        break;
                    }
                }
                if (index != UNDEFINED_TRACK_INDEX && index < alternativeTrackPriority) {
                    alternativeTrackIndex = i;
                    alternativeTrackPriority = index;
                } else if (alternativeTrackIndex == UNDEFINED_TRACK_INDEX) {
                    alternativeTrackIndex = i;
                }
            }
        }
        return alternativeTrackIndex;
    }

    private void selectTrack(int type, TvTrackInfo track, int trackIndex) {
        mTvView.selectTrack(type, track == null ? null : track.getId());
        if (type == TvTrackInfo.TYPE_AUDIO) {
            mTvOptionsManager.onMultiAudioChanged(
                    track == null
                            ? null
                            : TvTrackInfoUtils.getMultiAudioString(this, track, false));
        } else if (type == TvTrackInfo.TYPE_SUBTITLE) {
            mTvOptionsManager.onClosedCaptionsChanged(track, trackIndex);
        }
    }

    private void selectCaptionTrack(String selectedTrackId, TvTrackInfo track, int trackIndex) {
        if (!track.getId().equals(selectedTrackId)) {
            selectTrack(TvTrackInfo.TYPE_SUBTITLE, track, trackIndex);
        } else {
            // Already selected. Update the option string only.
            mTvOptionsManager.onClosedCaptionsChanged(track, trackIndex);
        }
        if (DEBUG) {
            Log.d(
                    TAG,
                    "Subtitle Track Selected {id="
                            + track.getId()
                            + ", language="
                            + track.getLanguage()
                            + "}");
        }
    }

    private void deselectCaptionTrack(String selectedTrackId) {
        if (selectedTrackId != null) {
            selectTrack(TvTrackInfo.TYPE_SUBTITLE, null, UNDEFINED_TRACK_INDEX);
            if (DEBUG) Log.d(TAG, "Subtitle Track Unselected");
        } else {
            mTvOptionsManager.onClosedCaptionsChanged(null, UNDEFINED_TRACK_INDEX);
        }
    }

    public void selectAudioTrack(String trackId) {
        saveMultiAudioSetting(trackId);
        applyMultiAudio(trackId);
    }

    private void saveMultiAudioSetting(String trackId) {
        List<TvTrackInfo> tracks = getTracks(TvTrackInfo.TYPE_AUDIO);
        if (tracks != null) {
            for (TvTrackInfo track : tracks) {
                if (track.getId().equals(trackId)) {
                    TvSettings.setMultiAudioId(this, track.getId());
                    TvSettings.setMultiAudioLanguage(this, track.getLanguage());
                    TvSettings.setMultiAudioChannelCount(this, track.getAudioChannelCount());
                    return;
                }
            }
        }
        TvSettings.setMultiAudioId(this, null);
        TvSettings.setMultiAudioLanguage(this, null);
        TvSettings.setMultiAudioChannelCount(this, 0);
    }

    public void selectSubtitleTrack(int option, String trackId) {
        saveClosedCaptionSetting(option, trackId);
        applyClosedCaption();
    }

    public void selectSubtitleLanguage(int option, String language, String trackId) {
        mCaptionSettings.setEnableOption(option);
        mCaptionSettings.setLanguage(language);
        mCaptionSettings.setTrackId(trackId);
        applyClosedCaption();
    }

    private void saveClosedCaptionSetting(int option, String trackId) {
        mCaptionSettings.setEnableOption(option);
        if (option == CaptionSettings.OPTION_ON) {
            List<TvTrackInfo> tracks = getTracks(TvTrackInfo.TYPE_SUBTITLE);
            if (tracks != null) {
                for (TvTrackInfo track : tracks) {
                    if (track.getId().equals(trackId)) {
                        mCaptionSettings.setLanguage(track.getLanguage());
                        mCaptionSettings.setTrackId(trackId);
                        return;
                    }
                }
            }
        }
    }

    private void updateAvailabilityToast() {
        if (mTvView.isVideoAvailable()
                || !Objects.equals(
                        mTvView.getCurrentChannel(), mChannelTuner.getCurrentChannel())) {
            return;
        }

        switch (mTvView.getVideoUnavailableReason()) {
            case TunableTvView.VIDEO_UNAVAILABLE_REASON_NOT_TUNED:
            case TunableTvView.VIDEO_UNAVAILABLE_REASON_NO_RESOURCE:
            case TvInputManager.VIDEO_UNAVAILABLE_REASON_TUNING:
            case TvInputManager.VIDEO_UNAVAILABLE_REASON_BUFFERING:
            case TvInputManager.VIDEO_UNAVAILABLE_REASON_AUDIO_ONLY:
            case TvInputManager.VIDEO_UNAVAILABLE_REASON_WEAK_SIGNAL:
                return;
            case CommonConstants.VIDEO_UNAVAILABLE_REASON_NOT_CONNECTED:
                Toast.makeText(
                                this,
                                R.string.msg_channel_unavailable_not_connected,
                                Toast.LENGTH_SHORT)
                        .show();
                break;
            case TvInputManager.VIDEO_UNAVAILABLE_REASON_UNKNOWN:
            default:
                Toast.makeText(this, R.string.msg_channel_unavailable_unknown, Toast.LENGTH_SHORT)
                        .show();
                break;
        }
    }

    /** Returns {@code true} if some overlay UI will be shown when the activity is resumed. */
    public boolean willShowOverlayUiWhenResume() {
        return mInputToSetUp != null || mShowProgramGuide || mShowSelectInputView;
    }

    /** Returns the current parental control settings. */
    public ParentalControlSettings getParentalControlSettings() {
        return mTvInputManagerHelper.getParentalControlSettings();
    }

    /** Returns a ContentRatingsManager instance. */
    public ContentRatingsManager getContentRatingsManager() {
        return mTvInputManagerHelper.getContentRatingsManager();
    }

    /** Returns the current captioning settings. */
    public CaptionSettings getCaptionSettings() {
        return mCaptionSettings;
    }

    /** Adds the {@link OnActionClickListener}. */
    public void addOnActionClickListener(OnActionClickListener listener) {
        mOnActionClickListeners.add(listener);
    }

    /** Removes the {@link OnActionClickListener}. */
    public void removeOnActionClickListener(OnActionClickListener listener) {
        mOnActionClickListeners.remove(listener);
    }

    @Override
    public boolean onActionClick(String category, int actionId, Bundle params) {
        // There should be only one action listener per an action.
        for (OnActionClickListener l : mOnActionClickListeners) {
            if (l.onActionClick(category, actionId, params)) {
                return true;
            }
        }
        return false;
    }

    // Initialize TV app for test. The setup process should be finished before the Live TV app is
    // started. We only enable all the channels here.
    private void initForTest() {
        if (!CommonUtils.isRunningInTest()) {
            return;
        }

        // Only try to set the channels browseable if we are a system app.
        if (SYSTEM_APP_FEATURE.isEnabled(getApplicationContext())) {
            Utils.enableAllChannels(this);
        }
    }

    // Lazy initialization
    private void lazyInitializeIfNeeded() {
        // Already initialized.
        if (mLazyInitialized) {
            return;
        }
        mLazyInitialized = true;
        // Running initialization.
        mHandler.postDelayed(
                () -> {
                    if (mActivityStarted) {
                        initAnimations();
                        initSideFragments();
                        initMenuItemViews();
                    }
                },
                LAZY_INITIALIZATION_DELAY);
    }

    private void initAnimations() {
        mTvViewUiManager.initAnimatorIfNeeded();
        mOverlayManager.initAnimatorIfNeeded();
    }

    private void initSideFragments() {
        SideFragment.preloadItemViews(this);
    }

    private void initMenuItemViews() {
        mOverlayManager.getMenu().preloadItemViews();
    }

    private boolean isAudioOnlyInput() {
        if (mLastInputIdFromIntent == null) {
            return false;
        }
        TvInputInfoCompat inputInfo =
                mTvInputManagerHelper.getTvInputInfoCompat(mLastInputIdFromIntent);
        return inputInfo != null && inputInfo.isAudioOnly();
    }

    @Nullable
    private String getInputId(Intent intent) {
        Uri uri = intent.getData();
        return TvContract.isChannelUriForPassthroughInput(uri)
                ? uri.getPathSegments().get(1)
                : null;
    }

    @Override
    public void onTrimMemory(int level) {
        super.onTrimMemory(level);
        for (MemoryManageable memoryManageable : mMemoryManageables) {
            memoryManageable.performTrimMemory(level);
        }
    }

    @Override
    public AndroidInjector<Object> androidInjector() {
        return mAndroidInjector;
    }

    private static class MainActivityHandler extends WeakHandler<MainActivity> {
        MainActivityHandler(MainActivity mainActivity) {
            super(mainActivity);
        }

        @Override
        protected void handleMessage(Message msg, @NonNull MainActivity mainActivity) {
            switch (msg.what) {
                case MSG_CHANNEL_DOWN_PRESSED:
                    long startTime = (Long) msg.obj;
                    // message re-sending should be done before moving channel, because we use the
                    // existence of message to decide if users are switching channel.
                    sendMessageDelayed(Message.obtain(msg), getDelay(startTime));
                    mainActivity.moveToAdjacentChannel(false, true);
                    break;
                case MSG_CHANNEL_UP_PRESSED:
                    startTime = (Long) msg.obj;
                    // message re-sending should be done before moving channel, because we use the
                    // existence of message to decide if users are switching channel.
                    sendMessageDelayed(Message.obtain(msg), getDelay(startTime));
                    mainActivity.moveToAdjacentChannel(true, true);
                    break;
                default: // fall out
            }
        }

        private long getDelay(long startTime) {
            if (System.currentTimeMillis() - startTime > CHANNEL_CHANGE_NORMAL_SPEED_DURATION_MS) {
                return CHANNEL_CHANGE_DELAY_MS_IN_MAX_SPEED;
            }
            return CHANNEL_CHANGE_DELAY_MS_IN_NORMAL_SPEED;
        }
    }

    /** {@link OnTuneListener} implementation */
    @VisibleForTesting
    protected class MyOnTuneListener implements OnTuneListener {
        boolean mUnlockAllowedRatingBeforeShrunken = true;
        boolean mWasUnderShrunkenTvView;
        Channel mChannel;

        private void onTune(Channel channel, boolean wasUnderShrunkenTvView) {
            Debug.getTimer(Debug.TAG_START_UP_TIMER).log("MainActivity.MyOnTuneListener.onTune");
            mChannel = channel;
            mWasUnderShrunkenTvView = wasUnderShrunkenTvView;
            // Fetch complete projection of tuned channel.
            mProgramDataManager.onChannelTuned(channel.getId());
        }

        @Override
        public void onUnexpectedStop(Channel channel) {
            stopTv();
            startTv(null);
        }

        @Override
        public void onTuneFailed(Channel channel) {
            Log.w(TAG, "onTuneFailed(" + channel + ")");
            if (mTvView.isFadedOut()) {
                mTvView.removeFadeEffect();
            }
            Toast.makeText(
                            MainActivity.this,
                            R.string.msg_channel_unavailable_unknown,
                            Toast.LENGTH_SHORT)
                    .show();
        }

        @Override
        public void onStreamInfoChanged(StreamInfo info, boolean allowAutoSelectionOfTrack) {
            if (info.isVideoAvailable() && mTuneDurationTimer.isRunning()) {
                mTracker.sendChannelTuneTime(info.getCurrentChannel(), mTuneDurationTimer.reset());
            }
            if (info.isVideoOrAudioAvailable() && mChannel.equals(getCurrentChannel())) {
                mOverlayManager.updateChannelBannerAndShowIfNeeded(
                        TvOverlayManager.UPDATE_CHANNEL_BANNER_REASON_UPDATE_STREAM_INFO);
            }
            applyDisplayRefreshRate(info.getVideoFrameRate());
            mTvViewUiManager.updateTvAspectRatio();
            applyMultiAudio(
                    allowAutoSelectionOfTrack ? null : getSelectedTrack(TvTrackInfo.TYPE_AUDIO));
            applyClosedCaption();
            mOverlayManager.getMenu().onStreamInfoChanged();
            if (mTvView.isVideoAvailable()) {
                mTvViewUiManager.fadeInTvView();
            }
            if (!mTvView.isContentBlocked() && !mTvView.isScreenBlocked()) {
                updateAvailabilityToast();
            }
            mHandler.removeCallbacks(mRestoreMainViewRunnable);
            restoreMainTvView();
        }

        @Override
        public void onChannelRetuned(Uri channel) {
            if (channel == null) {
                return;
            }
            Channel currentChannel =
                    mChannelDataManager.getChannel(ContentUriUtils.safeParseId(channel));
            if (currentChannel == null) {
                Log.e(
                        TAG,
                        "onChannelRetuned is called but can't find a channel with the URI "
                                + channel);
                return;
            }
            /* Begin_AOSP_Comment_Out
            if (PLUTO_TV_PACKAGE_NAME.equals(currentChannel.getPackageName())) {
                // Do nothing for the Pluto TV input because it misuses this API. b/22720711.
                return;
            }
            End_AOSP_Comment_Out */
            if (isChannelChangeKeyDownReceived()) {
                // Ignore this message if the user is changing the channel.
                return;
            }
            mChannelTuner.setCurrentChannel(currentChannel);
            mTvView.setCurrentChannel(currentChannel);
            mOverlayManager.updateChannelBannerAndShowIfNeeded(
                    TvOverlayManager.UPDATE_CHANNEL_BANNER_REASON_TUNE);
        }

        @Override
        public void onContentBlocked() {
            Debug.getTimer(Debug.TAG_START_UP_TIMER)
                    .log("MainActivity.MyOnTuneListener.onContentBlocked removes timer");
            Debug.removeTimer(Debug.TAG_START_UP_TIMER);
            mTuneDurationTimer.reset();
            TvContentRating rating = mTvView.getBlockedContentRating();
            // When tuneTo was called while TV view was shrunken, if the channel id is the same
            // with the channel watched before shrunken, we allow the rating which was allowed
            // before.
            if (mWasUnderShrunkenTvView
                    && mUnlockAllowedRatingBeforeShrunken
                    && Objects.equals(mChannelBeforeShrunkenTvView, mChannel)
                    && rating.equals(mAllowedRatingBeforeShrunken)) {
                mUnlockAllowedRatingBeforeShrunken = isUnderShrunkenTvView();
                mTvView.unblockContent(rating);
            }
            mOverlayManager.setBlockingContentRating(rating);
            mTvViewUiManager.fadeInTvView();
            mMediaSessionWrapper.update(true, getCurrentChannel(), getCurrentProgram());
        }

        @Override
        public void onContentAllowed() {
            if (!isUnderShrunkenTvView()) {
                mUnlockAllowedRatingBeforeShrunken = false;
            }
            mOverlayManager.setBlockingContentRating(null);
            mMediaSessionWrapper.update(false, getCurrentChannel(), getCurrentProgram());
        }

        @Override
        public void onChannelSignalStrength() {
            if (CommonFeatures.TUNER_SIGNAL_STRENGTH.isEnabled(getApplicationContext())) {
                mOverlayManager.updateChannelBannerAndShowIfNeeded(
                        TvOverlayManager.UPDATE_CHANNEL_BANNER_REASON_UPDATE_SIGNAL_STRENGTH);
            }
        }
    }

    private class MySingletonsImpl implements MySingletons {

        @Override
        public Provider<Channel> getCurrentChannelProvider() {
            return MainActivity.this::getCurrentChannel;
        }

        @Override
        public Provider<Program> getCurrentProgramProvider() {
            return MainActivity.this::getCurrentProgram;
        }

        @Override
        public Provider<TvOverlayManager> getOverlayManagerProvider() {
            return MainActivity.this::getOverlayManager;
        }

        @Override
        public TvInputManagerHelper getTvInputManagerHelperSingleton() {
            return getTvInputManagerHelper();
        }

        @Override
        public Provider<Long> getCurrentPlayingPositionProvider() {
            return MainActivity.this::getCurrentPlayingPosition;
        }

        @Override
        public DvrManager getDvrManagerSingleton() {
            return TvSingletons.getSingletons(getApplicationContext()).getDvrManager();
        }
    }

    /** Exports {@link MainActivity} for Dagger codegen to create the appropriate injector. */
    @dagger.Module
    public abstract static class Module {
        @ContributesAndroidInjector
        abstract MainActivity contributesMainActivityActivityInjector();

        @ContributesAndroidInjector
        abstract DeveloperOptionFragment contributesDeveloperOptionFragment();

        @ContributesAndroidInjector
        abstract RatingsFragment contributesRatingsFragment();

        @ContributesAndroidInjector
        abstract ProgramItemView contributesProgramItemView();

        @ContributesAndroidInjector
        abstract DvrAlreadyRecordedFragment contributesDvrAlreadyRecordedFragment();

        @ContributesAndroidInjector
        abstract DvrAlreadyScheduledFragment contributesDvrAlreadyScheduledFragment();

        @ContributesAndroidInjector
        abstract DvrScheduleFragment contributesDvrScheduleFragment();
    }
}