Java tutorial
/* * 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.ui; import android.app.Fragment; import android.app.FragmentManager; import android.app.FragmentManager.OnBackStackChangedListener; import android.content.Intent; import android.media.tv.TvInputInfo; import android.os.Build; import android.os.Bundle; import android.os.Handler; import android.os.Message; import android.support.annotation.IntDef; import android.support.annotation.NonNull; import android.support.annotation.Nullable; import android.support.annotation.UiThread; import android.support.v4.os.BuildCompat; import android.util.Log; import android.view.Gravity; import android.view.KeyEvent; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import android.widget.Space; import com.android.tv.ApplicationSingletons; import com.android.tv.ChannelTuner; import com.android.tv.MainActivity; import com.android.tv.MainActivity.KeyHandlerResultType; import com.android.tv.R; import com.android.tv.TimeShiftManager; import com.android.tv.TvApplication; import com.android.tv.analytics.Tracker; import com.android.tv.common.WeakHandler; import com.android.tv.common.feature.CommonFeatures; import com.android.tv.common.ui.setup.OnActionClickListener; import com.android.tv.common.ui.setup.SetupFragment; import com.android.tv.common.ui.setup.SetupMultiPaneFragment; import com.android.tv.data.ChannelDataManager; import com.android.tv.dialog.FullscreenDialogFragment; import com.android.tv.dialog.PinDialogFragment; import com.android.tv.dialog.RecentlyWatchedDialogFragment; import com.android.tv.dialog.SafeDismissDialogFragment; import com.android.tv.dvr.DvrDataManager; import com.android.tv.dvr.ui.DvrActivity; import com.android.tv.dvr.ui.HalfSizedDialogFragment; import com.android.tv.guide.ProgramGuide; import com.android.tv.menu.Menu; import com.android.tv.menu.Menu.MenuShowReason; import com.android.tv.menu.MenuRowFactory; import com.android.tv.menu.MenuView; import com.android.tv.onboarding.NewSourcesFragment; import com.android.tv.onboarding.SetupSourcesFragment; import com.android.tv.onboarding.SetupSourcesFragment.InputSetupRunnable; import com.android.tv.search.ProgramGuideSearchFragment; import com.android.tv.ui.TvTransitionManager.SceneType; import com.android.tv.ui.sidepanel.SettingsFragment; import com.android.tv.ui.sidepanel.SideFragmentManager; import com.android.tv.ui.sidepanel.parentalcontrols.RatingsFragment; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; /** * A class responsible for the life cycle and event handling of the pop-ups over TV view. */ // TODO: Put TvTransitionManager into this class. @UiThread public class TvOverlayManager { private static final String TAG = "TvOverlayManager"; private static final boolean DEBUG = false; public static final String INTRO_TRACKER_LABEL = "Intro dialog"; @Retention(RetentionPolicy.SOURCE) @IntDef(flag = true, value = { FLAG_HIDE_OVERLAYS_DEFAULT, FLAG_HIDE_OVERLAYS_WITHOUT_ANIMATION, FLAG_HIDE_OVERLAYS_KEEP_SCENE, FLAG_HIDE_OVERLAYS_KEEP_DIALOG, FLAG_HIDE_OVERLAYS_KEEP_SIDE_PANELS, FLAG_HIDE_OVERLAYS_KEEP_SIDE_PANEL_HISTORY, FLAG_HIDE_OVERLAYS_KEEP_PROGRAM_GUIDE, FLAG_HIDE_OVERLAYS_KEEP_MENU, FLAG_HIDE_OVERLAYS_KEEP_FRAGMENT }) public @interface HideOverlayFlag { } // FLAG_HIDE_OVERLAYs must be bitwise exclusive. public static final int FLAG_HIDE_OVERLAYS_DEFAULT = 0b000000000; public static final int FLAG_HIDE_OVERLAYS_WITHOUT_ANIMATION = 0b000000010; public static final int FLAG_HIDE_OVERLAYS_KEEP_SCENE = 0b000000100; public static final int FLAG_HIDE_OVERLAYS_KEEP_DIALOG = 0b000001000; public static final int FLAG_HIDE_OVERLAYS_KEEP_SIDE_PANELS = 0b000010000; public static final int FLAG_HIDE_OVERLAYS_KEEP_SIDE_PANEL_HISTORY = 0b000100000; public static final int FLAG_HIDE_OVERLAYS_KEEP_PROGRAM_GUIDE = 0b001000000; public static final int FLAG_HIDE_OVERLAYS_KEEP_MENU = 0b010000000; public static final int FLAG_HIDE_OVERLAYS_KEEP_FRAGMENT = 0b100000000; public static final int MSG_OVERLAY_CLOSED = 1000; @Retention(RetentionPolicy.SOURCE) @IntDef(flag = true, value = { OVERLAY_TYPE_NONE, OVERLAY_TYPE_MENU, OVERLAY_TYPE_SIDE_FRAGMENT, OVERLAY_TYPE_DIALOG, OVERLAY_TYPE_GUIDE, OVERLAY_TYPE_SCENE_CHANNEL_BANNER, OVERLAY_TYPE_SCENE_INPUT_BANNER, OVERLAY_TYPE_SCENE_KEYPAD_CHANNEL_SWITCH, OVERLAY_TYPE_SCENE_SELECT_INPUT, OVERLAY_TYPE_FRAGMENT }) private @interface TvOverlayType { } // OVERLAY_TYPEs must be bitwise exclusive. private static final int OVERLAY_TYPE_NONE = 0b000000000; private static final int OVERLAY_TYPE_MENU = 0b000000001; private static final int OVERLAY_TYPE_SIDE_FRAGMENT = 0b000000010; private static final int OVERLAY_TYPE_DIALOG = 0b000000100; private static final int OVERLAY_TYPE_GUIDE = 0b000001000; private static final int OVERLAY_TYPE_SCENE_CHANNEL_BANNER = 0b000010000; private static final int OVERLAY_TYPE_SCENE_INPUT_BANNER = 0b000100000; private static final int OVERLAY_TYPE_SCENE_KEYPAD_CHANNEL_SWITCH = 0b001000000; private static final int OVERLAY_TYPE_SCENE_SELECT_INPUT = 0b010000000; private static final int OVERLAY_TYPE_FRAGMENT = 0b100000000; private static final Set<String> AVAILABLE_DIALOG_TAGS = new HashSet<>(); static { AVAILABLE_DIALOG_TAGS.add(RecentlyWatchedDialogFragment.DIALOG_TAG); AVAILABLE_DIALOG_TAGS.add(PinDialogFragment.DIALOG_TAG); AVAILABLE_DIALOG_TAGS.add(FullscreenDialogFragment.DIALOG_TAG); AVAILABLE_DIALOG_TAGS.add(SettingsFragment.LicenseActionItem.DIALOG_TAG); AVAILABLE_DIALOG_TAGS.add(RatingsFragment.AttributionItem.DIALOG_TAG); AVAILABLE_DIALOG_TAGS.add(HalfSizedDialogFragment.DIALOG_TAG); } private final MainActivity mMainActivity; private final ChannelTuner mChannelTuner; private final TvTransitionManager mTransitionManager; private final ChannelDataManager mChannelDataManager; private final Menu mMenu; private final SideFragmentManager mSideFragmentManager; private final ProgramGuide mProgramGuide; private final KeypadChannelSwitchView mKeypadChannelSwitchView; private final SelectInputView mSelectInputView; private final ProgramGuideSearchFragment mSearchFragment; private final Tracker mTracker; private SafeDismissDialogFragment mCurrentDialog; private final SetupSourcesFragment mSetupFragment; private boolean mSetupFragmentActive; private final NewSourcesFragment mNewSourcesFragment; private boolean mNewSourcesFragmentActive; private final Handler mHandler = new TvOverlayHandler(this); private @TvOverlayType int mOpenedOverlays; private final List<Runnable> mPendingActions = new ArrayList<>(); public TvOverlayManager(MainActivity mainActivity, ChannelTuner channelTuner, KeypadChannelSwitchView keypadChannelSwitchView, ChannelBannerView channelBannerView, InputBannerView inputBannerView, SelectInputView selectInputView, ViewGroup sceneContainer, ProgramGuideSearchFragment searchFragment) { mMainActivity = mainActivity; mChannelTuner = channelTuner; ApplicationSingletons singletons = TvApplication.getSingletons(mainActivity); mChannelDataManager = singletons.getChannelDataManager(); mKeypadChannelSwitchView = keypadChannelSwitchView; mSelectInputView = selectInputView; mSearchFragment = searchFragment; mTracker = singletons.getTracker(); mTransitionManager = new TvTransitionManager(mainActivity, sceneContainer, channelBannerView, inputBannerView, mKeypadChannelSwitchView, selectInputView); mTransitionManager.setListener(new TvTransitionManager.Listener() { @Override public void onSceneChanged(int fromScene, int toScene) { // Call notifyOverlayOpened first so that the listener can know that a new scene // will be opened when the notifyOverlayClosed is called. if (toScene != TvTransitionManager.SCENE_TYPE_EMPTY) { onOverlayOpened(convertSceneToOverlayType(toScene)); } if (fromScene != TvTransitionManager.SCENE_TYPE_EMPTY) { onOverlayClosed(convertSceneToOverlayType(fromScene)); } } }); // Menu MenuView menuView = (MenuView) mainActivity.findViewById(R.id.menu); mMenu = new Menu(mainActivity, menuView, new MenuRowFactory(mainActivity), new Menu.OnMenuVisibilityChangeListener() { @Override public void onMenuVisibilityChange(boolean visible) { if (visible) { onOverlayOpened(OVERLAY_TYPE_MENU); } else { onOverlayClosed(OVERLAY_TYPE_MENU); } } }); // Side Fragment mSideFragmentManager = new SideFragmentManager(mainActivity, new Runnable() { @Override public void run() { onOverlayOpened(OVERLAY_TYPE_SIDE_FRAGMENT); hideOverlays(FLAG_HIDE_OVERLAYS_KEEP_SIDE_PANELS); } }, new Runnable() { @Override public void run() { mMainActivity.showChannelBannerIfHiddenBySideFragment(); onOverlayClosed(OVERLAY_TYPE_SIDE_FRAGMENT); } }); // Program Guide Runnable preShowRunnable = new Runnable() { @Override public void run() { onOverlayOpened(OVERLAY_TYPE_GUIDE); } }; Runnable postHideRunnable = new Runnable() { @Override public void run() { onOverlayClosed(OVERLAY_TYPE_GUIDE); } }; DvrDataManager dvrDataManager = CommonFeatures.DVR.isEnabled(mainActivity) && BuildCompat.isAtLeastN() ? singletons.getDvrDataManager() : null; mProgramGuide = new ProgramGuide(mainActivity, channelTuner, singletons.getTvInputManagerHelper(), mChannelDataManager, singletons.getProgramDataManager(), dvrDataManager, singletons.getTracker(), preShowRunnable, postHideRunnable); mSetupFragment = new SetupSourcesFragment(); mSetupFragment.setOnActionClickListener(new OnActionClickListener() { @Override public void onActionClick(String category, int id) { switch (id) { case SetupMultiPaneFragment.ACTION_DONE: closeSetupFragment(true); break; case SetupSourcesFragment.ACTION_PLAY_STORE: mMainActivity.showMerchantCollection(); break; } } }); mSetupFragment.setInputSetupRunnable(new InputSetupRunnable() { @Override public void runInputSetup(TvInputInfo input) { mMainActivity.startSetupActivity(input, true); } }); mNewSourcesFragment = new NewSourcesFragment(); mNewSourcesFragment.setOnActionClickListener(new OnActionClickListener() { @Override public void onActionClick(String category, int id) { switch (id) { case NewSourcesFragment.ACTION_SETUP: closeNewSourcesFragment(false); showSetupFragment(); break; case NewSourcesFragment.ACTION_SKIP: // Don't remove the fragment because new fragment will be replaced with // this fragment. closeNewSourcesFragment(true); break; } } }); } /** * A method to release all the allocated resources or unregister listeners. * This is called from {@link MainActivity#onDestroy}. */ public void release() { mMenu.release(); mHandler.removeCallbacksAndMessages(null); } /** * Returns the instance of {@link Menu}. */ public Menu getMenu() { return mMenu; } /** * Returns the instance of {@link SideFragmentManager}. */ public SideFragmentManager getSideFragmentManager() { return mSideFragmentManager; } /** * Returns the currently opened dialog. */ public SafeDismissDialogFragment getCurrentDialog() { return mCurrentDialog; } /** * Checks whether the setup fragment is active or not. */ public boolean isSetupFragmentActive() { return mSetupFragmentActive; } /** * Checks whether the new sources fragment is active or not. */ public boolean isNewSourcesFragmentActive() { return mNewSourcesFragmentActive; } /** * Returns the instance of {@link ProgramGuide}. */ public ProgramGuide getProgramGuide() { return mProgramGuide; } /** * Shows the main menu. */ public void showMenu(@MenuShowReason int reason) { if (mChannelTuner != null && mChannelTuner.areAllChannelsLoaded()) { mMenu.show(reason); } } /** * Shows the play controller of the menu if the playback is paused. */ public boolean showMenuWithTimeShiftPauseIfNeeded() { if (mMainActivity.getTimeShiftManager().isPaused()) { showMenu(Menu.REASON_PLAY_CONTROLS_PAUSE); return true; } return false; } /** * Shows the given dialog. */ public void showDialogFragment(String tag, SafeDismissDialogFragment dialog, boolean keepSidePanelHistory) { showDialogFragment(tag, dialog, keepSidePanelHistory, false); } public void showDialogFragment(String tag, SafeDismissDialogFragment dialog, boolean keepSidePanelHistory, boolean keepProgramGuide) { int flags = FLAG_HIDE_OVERLAYS_KEEP_DIALOG; if (keepSidePanelHistory) { flags |= FLAG_HIDE_OVERLAYS_KEEP_SIDE_PANEL_HISTORY; } if (keepProgramGuide) { flags |= FLAG_HIDE_OVERLAYS_KEEP_PROGRAM_GUIDE; } hideOverlays(flags); // A tag for dialog must be added to AVAILABLE_DIALOG_TAGS to make it launchable from TV. if (!AVAILABLE_DIALOG_TAGS.contains(tag)) { return; } Fragment old = mMainActivity.getFragmentManager().findFragmentByTag(tag); // Do not show the dialog if the same kind of dialog is already opened. if (old != null) { return; } mCurrentDialog = dialog; dialog.show(mMainActivity.getFragmentManager(), tag); // Calling this from SafeDismissDialogFragment.onCreated() might be late // because it takes time for onCreated to be called // and next key events can be handled by MainActivity, not Dialog. onOverlayOpened(OVERLAY_TYPE_DIALOG); } private void runAfterSideFragmentsAreClosed(final Runnable runnable) { final FragmentManager manager = mMainActivity.getFragmentManager(); if (mSideFragmentManager.isSidePanelVisible()) { manager.addOnBackStackChangedListener(new OnBackStackChangedListener() { @Override public void onBackStackChanged() { if (manager.getBackStackEntryCount() == 0) { manager.removeOnBackStackChangedListener(this); runnable.run(); } } }); } else { runnable.run(); } } private void showFragment(final Fragment fragment) { hideOverlays(FLAG_HIDE_OVERLAYS_KEEP_FRAGMENT); onOverlayOpened(OVERLAY_TYPE_FRAGMENT); runAfterSideFragmentsAreClosed(new Runnable() { @Override public void run() { mMainActivity.getFragmentManager().beginTransaction().replace(R.id.fragment_container, fragment) .commit(); } }); } private void closeFragment(Fragment fragmentToRemove) { onOverlayClosed(OVERLAY_TYPE_FRAGMENT); if (fragmentToRemove != null) { if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) { // In L, NPE happens if there is no next fragment when removing or hiding a fragment // which has an exit transition. b/22631964 // A workaround is just replacing with a dummy fragment. mMainActivity.getFragmentManager().beginTransaction() .replace(R.id.fragment_container, new DummyFragment()).commit(); } else { mMainActivity.getFragmentManager().beginTransaction().remove(fragmentToRemove).commit(); } } } /** * Shows setup dialog. */ public void showSetupFragment() { if (DEBUG) Log.d(TAG, "showSetupFragment"); mSetupFragmentActive = true; mSetupFragment.enableFragmentTransition( SetupFragment.FRAGMENT_ENTER_TRANSITION | SetupFragment.FRAGMENT_EXIT_TRANSITION | SetupFragment.FRAGMENT_RETURN_TRANSITION | SetupFragment.FRAGMENT_REENTER_TRANSITION); mSetupFragment.setFragmentTransition(SetupFragment.FRAGMENT_EXIT_TRANSITION, Gravity.END); showFragment(mSetupFragment); } // Set removeFragment to false only when the new fragment is going to be shown. private void closeSetupFragment(boolean removeFragment) { if (DEBUG) Log.d(TAG, "closeSetupFragment"); if (!mSetupFragmentActive) { return; } mSetupFragmentActive = false; closeFragment(removeFragment ? mSetupFragment : null); if (mChannelDataManager.getChannelCount() == 0) { mMainActivity.finish(); } } /** * Shows new sources dialog. */ public void showNewSourcesFragment() { if (DEBUG) Log.d(TAG, "showNewSourcesFragment"); mNewSourcesFragmentActive = true; showFragment(mNewSourcesFragment); } // Set removeFragment to false only when the new fragment is going to be shown. private void closeNewSourcesFragment(boolean removeFragment) { if (DEBUG) Log.d(TAG, "closeNewSourcesFragment"); mNewSourcesFragmentActive = false; closeFragment(removeFragment ? mNewSourcesFragment : null); } /** * Shows DVR manager. */ public void showDvrManager() { Intent intent = new Intent(mMainActivity, DvrActivity.class); mMainActivity.startActivity(intent); } /** * Shows intro dialog. */ public void showIntroDialog() { if (DEBUG) Log.d(TAG, "showIntroDialog"); showDialogFragment(FullscreenDialogFragment.DIALOG_TAG, FullscreenDialogFragment.newInstance(R.layout.intro_dialog, INTRO_TRACKER_LABEL), false); } /** * Shows recently watched dialog. */ public void showRecentlyWatchedDialog() { showDialogFragment(RecentlyWatchedDialogFragment.DIALOG_TAG, new RecentlyWatchedDialogFragment(), false); } /** * Shows banner view. */ public void showBanner() { mTransitionManager.goToChannelBannerScene(); } public void showKeypadChannelSwitch() { hideOverlays(TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_SCENE | TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_SIDE_PANELS | TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_DIALOG | TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_FRAGMENT); mTransitionManager.goToKeypadChannelSwitchScene(); } /** * Shows select input view. */ public void showSelectInputView() { hideOverlays(TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_SCENE); mTransitionManager.goToSelectInputScene(); } /** * Initializes animators if animators are not initialized yet. */ public void initAnimatorIfNeeded() { mTransitionManager.initIfNeeded(); } /** * It is called when a SafeDismissDialogFragment is destroyed. */ public void onDialogDestroyed() { mCurrentDialog = null; onOverlayClosed(OVERLAY_TYPE_DIALOG); } /** * Shows the program guide. */ public void showProgramGuide() { mProgramGuide.show(new Runnable() { @Override public void run() { hideOverlays(TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_PROGRAM_GUIDE); } }); } /** * Hides all the opened overlays according to the flags. */ // TODO: Add test for this method. public void hideOverlays(@HideOverlayFlag int flags) { if (mMainActivity.needToKeepSetupScreenWhenHidingOverlay()) { flags |= FLAG_HIDE_OVERLAYS_KEEP_FRAGMENT; } if ((flags & FLAG_HIDE_OVERLAYS_KEEP_DIALOG) != 0) { // Keeps the dialog. } else { if (mCurrentDialog != null) { if (mCurrentDialog instanceof PinDialogFragment) { // The result listener of PinDialogFragment could call MenuView when // the dialog is dismissed. In order not to call it, set the result listener // to null. ((PinDialogFragment) mCurrentDialog).setResultListener(null); } mCurrentDialog.dismiss(); } mCurrentDialog = null; } boolean withAnimation = (flags & FLAG_HIDE_OVERLAYS_WITHOUT_ANIMATION) == 0; if ((flags & FLAG_HIDE_OVERLAYS_KEEP_FRAGMENT) == 0) { if (mSetupFragmentActive) { if (!withAnimation) { mSetupFragment.setReturnTransition(null); mSetupFragment.setExitTransition(null); } closeSetupFragment(true); } else if (mNewSourcesFragmentActive) { closeNewSourcesFragment(true); } } if ((flags & FLAG_HIDE_OVERLAYS_KEEP_MENU) != 0) { // Keeps the menu. } else { mMenu.hide(withAnimation); } if ((flags & FLAG_HIDE_OVERLAYS_KEEP_SCENE) != 0) { // Keeps the current scene. } else { mTransitionManager.goToEmptyScene(withAnimation); } if ((flags & FLAG_HIDE_OVERLAYS_KEEP_SIDE_PANELS) != 0) { // Keeps side panels. } else if (mSideFragmentManager.isSidePanelVisible()) { if ((flags & FLAG_HIDE_OVERLAYS_KEEP_SIDE_PANEL_HISTORY) != 0) { mSideFragmentManager.hideSidePanel(withAnimation); } else { mSideFragmentManager.hideAll(withAnimation); } } if ((flags & FLAG_HIDE_OVERLAYS_KEEP_PROGRAM_GUIDE) != 0) { // Keep the program guide. } else { mProgramGuide.hide(); } } /** * Returns true, if a main view needs to hide informational text. Specifically, when overlay * UIs except banner is shown, the informational text needs to be hidden for clean UI. */ public boolean needHideTextOnMainView() { return mSideFragmentManager.isActive() || getMenu().isActive() || mTransitionManager.isKeypadChannelSwitchActive() || mTransitionManager.isSelectInputActive() || mSetupFragmentActive || mNewSourcesFragmentActive; } @TvOverlayType private int convertSceneToOverlayType(@SceneType int sceneType) { switch (sceneType) { case TvTransitionManager.SCENE_TYPE_CHANNEL_BANNER: return OVERLAY_TYPE_SCENE_CHANNEL_BANNER; case TvTransitionManager.SCENE_TYPE_INPUT_BANNER: return OVERLAY_TYPE_SCENE_INPUT_BANNER; case TvTransitionManager.SCENE_TYPE_KEYPAD_CHANNEL_SWITCH: return OVERLAY_TYPE_SCENE_KEYPAD_CHANNEL_SWITCH; case TvTransitionManager.SCENE_TYPE_SELECT_INPUT: return OVERLAY_TYPE_SCENE_SELECT_INPUT; case TvTransitionManager.SCENE_TYPE_EMPTY: default: return OVERLAY_TYPE_NONE; } } @UiThread private void onOverlayOpened(@TvOverlayType int overlayType) { if (DEBUG) Log.d(TAG, "Overlay opened: 0b" + Integer.toBinaryString(overlayType)); mOpenedOverlays |= overlayType; if (DEBUG) Log.d(TAG, "Opened overlays: 0b" + Integer.toBinaryString(mOpenedOverlays)); mHandler.removeMessages(MSG_OVERLAY_CLOSED); mMainActivity.updateKeyInputFocus(); } @UiThread private void onOverlayClosed(@TvOverlayType int overlayType) { if (DEBUG) Log.d(TAG, "Overlay closed: 0b" + Integer.toBinaryString(overlayType)); mOpenedOverlays &= ~overlayType; if (DEBUG) Log.d(TAG, "Opened overlays: 0b" + Integer.toBinaryString(mOpenedOverlays)); mHandler.removeMessages(MSG_OVERLAY_CLOSED); mMainActivity.updateKeyInputFocus(); // Show the main menu again if there are no pop-ups or banners only. // The main menu should not be shown when the activity is in paused state. boolean menuAboutToShow = false; if (canExecuteCloseAction()) { menuAboutToShow = mMainActivity.getTimeShiftManager().isPaused(); mHandler.sendEmptyMessage(MSG_OVERLAY_CLOSED); } // Don't set screen name to main if the overlay closing is a banner // or if a non banner overlay is still open // or if we just opened the menu if (overlayType != OVERLAY_TYPE_SCENE_CHANNEL_BANNER && overlayType != OVERLAY_TYPE_SCENE_INPUT_BANNER && isOnlyBannerOrNoneOpened() && !menuAboutToShow) { mTracker.sendScreenView(MainActivity.SCREEN_NAME); } } private boolean canExecuteCloseAction() { return mMainActivity.isActivityResumed() && isOnlyBannerOrNoneOpened(); } private boolean isOnlyBannerOrNoneOpened() { return (mOpenedOverlays & ~OVERLAY_TYPE_SCENE_CHANNEL_BANNER & ~OVERLAY_TYPE_SCENE_INPUT_BANNER) == 0; } /** * Runs a given {@code action} after all the overlays are closed. */ @UiThread public void runAfterOverlaysAreClosed(Runnable action) { if (canExecuteCloseAction()) { action.run(); } else { mPendingActions.add(action); } } /** * Handles the onUserInteraction event of the {@link MainActivity}. */ public void onUserInteraction() { if (mSideFragmentManager.isActive()) { mSideFragmentManager.scheduleHideAll(); } else if (mMenu.isActive()) { mMenu.scheduleHide(); } else if (mProgramGuide.isActive()) { mProgramGuide.scheduleHide(); } } /** * Handles the onKeyDown event of the {@link MainActivity}. */ @KeyHandlerResultType public int onKeyDown(int keyCode, KeyEvent event) { if (mCurrentDialog != null) { // Consumes the keys while a Dialog is creating. return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } // Handle media key here because it is related to the menu. if (isMediaStartKey(keyCode)) { // Consumes the keys which may trigger system's default music player. return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } if (mMenu.isActive() || mSideFragmentManager.isActive() || mProgramGuide.isActive() || mSetupFragmentActive || mNewSourcesFragmentActive) { return MainActivity.KEY_EVENT_HANDLER_RESULT_DISPATCH_TO_OVERLAY; } if (mTransitionManager.isKeypadChannelSwitchActive()) { return mKeypadChannelSwitchView.onKeyDown(keyCode, event) ? MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED : MainActivity.KEY_EVENT_HANDLER_RESULT_NOT_HANDLED; } if (mTransitionManager.isSelectInputActive()) { return mSelectInputView.onKeyDown(keyCode, event) ? MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED : MainActivity.KEY_EVENT_HANDLER_RESULT_NOT_HANDLED; } return MainActivity.KEY_EVENT_HANDLER_RESULT_PASSTHROUGH; } /** * Handles the onKeyUp event of the {@link MainActivity}. */ @KeyHandlerResultType public int onKeyUp(int keyCode, KeyEvent event) { // Handle media key here because it is related to the menu. if (isMediaStartKey(keyCode)) { // The media key should not be passed up to the system in any cases. if (mCurrentDialog != null || mProgramGuide.isActive() || mSideFragmentManager.isActive() || mSearchFragment.isVisible() || mTransitionManager.isKeypadChannelSwitchActive() || mTransitionManager.isSelectInputActive() || mSetupFragmentActive || mNewSourcesFragmentActive) { // Do not handle media key when any pop-ups which can handle keys are active. return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } TimeShiftManager timeShiftManager = mMainActivity.getTimeShiftManager(); if (!timeShiftManager.isAvailable()) { return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } switch (keyCode) { case KeyEvent.KEYCODE_MEDIA_PLAY: timeShiftManager.play(); showMenu(Menu.REASON_PLAY_CONTROLS_PLAY); break; case KeyEvent.KEYCODE_MEDIA_PAUSE: timeShiftManager.pause(); showMenu(Menu.REASON_PLAY_CONTROLS_PAUSE); break; case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE: timeShiftManager.togglePlayPause(); showMenu(Menu.REASON_PLAY_CONTROLS_PLAY_PAUSE); break; case KeyEvent.KEYCODE_MEDIA_REWIND: timeShiftManager.rewind(); showMenu(Menu.REASON_PLAY_CONTROLS_REWIND); break; case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD: timeShiftManager.fastForward(); showMenu(Menu.REASON_PLAY_CONTROLS_FAST_FORWARD); break; case KeyEvent.KEYCODE_MEDIA_PREVIOUS: timeShiftManager.jumpToPrevious(); showMenu(Menu.REASON_PLAY_CONTROLS_JUMP_TO_PREVIOUS); break; case KeyEvent.KEYCODE_MEDIA_NEXT: timeShiftManager.jumpToNext(); showMenu(Menu.REASON_PLAY_CONTROLS_JUMP_TO_NEXT); break; default: // Does nothing. break; } return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } if (keyCode == KeyEvent.KEYCODE_I || keyCode == KeyEvent.KEYCODE_TV_INPUT) { if (mTransitionManager.isSelectInputActive()) { mSelectInputView.onKeyUp(keyCode, event); } else { showSelectInputView(); } return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } if (mCurrentDialog != null) { // Consumes the keys while a Dialog is showing. // This can be happen while a Dialog isn't created yet. return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } if (mProgramGuide.isActive()) { if (keyCode == KeyEvent.KEYCODE_BACK) { mProgramGuide.onBackPressed(); return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } return MainActivity.KEY_EVENT_HANDLER_RESULT_DISPATCH_TO_OVERLAY; } if (mSideFragmentManager.isActive()) { if (keyCode == KeyEvent.KEYCODE_BACK || mSideFragmentManager.isHideKeyForCurrentPanel(keyCode)) { mSideFragmentManager.popSideFragment(); return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } return MainActivity.KEY_EVENT_HANDLER_RESULT_DISPATCH_TO_OVERLAY; } if (mMenu.isActive() || mTransitionManager.isSceneActive()) { if (keyCode == KeyEvent.KEYCODE_BACK) { TimeShiftManager timeShiftManager = mMainActivity.getTimeShiftManager(); if (timeShiftManager.isPaused()) { timeShiftManager.play(); } hideOverlays(TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_SIDE_PANELS | TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_DIALOG | TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_FRAGMENT); return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } if (mMenu.isActive()) { if (KeypadChannelSwitchView.isChannelNumberKey(keyCode)) { mMainActivity.showKeypadChannelSwitchView(keyCode); return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } return MainActivity.KEY_EVENT_HANDLER_RESULT_DISPATCH_TO_OVERLAY; } } if (mTransitionManager.isKeypadChannelSwitchActive()) { if (keyCode == KeyEvent.KEYCODE_BACK) { mTransitionManager.goToEmptyScene(true); return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } return mKeypadChannelSwitchView.onKeyUp(keyCode, event) ? MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED : MainActivity.KEY_EVENT_HANDLER_RESULT_NOT_HANDLED; } if (mTransitionManager.isSelectInputActive()) { if (keyCode == KeyEvent.KEYCODE_BACK) { mTransitionManager.goToEmptyScene(true); return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } return mSelectInputView.onKeyUp(keyCode, event) ? MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED : MainActivity.KEY_EVENT_HANDLER_RESULT_NOT_HANDLED; } if (mSetupFragmentActive) { if (keyCode == KeyEvent.KEYCODE_BACK) { closeSetupFragment(true); return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } return MainActivity.KEY_EVENT_HANDLER_RESULT_DISPATCH_TO_OVERLAY; } if (mNewSourcesFragmentActive) { if (keyCode == KeyEvent.KEYCODE_BACK) { closeNewSourcesFragment(true); return MainActivity.KEY_EVENT_HANDLER_RESULT_HANDLED; } return MainActivity.KEY_EVENT_HANDLER_RESULT_DISPATCH_TO_OVERLAY; } return MainActivity.KEY_EVENT_HANDLER_RESULT_PASSTHROUGH; } /** * Checks whether the given {@code keyCode} can start the system's music app or not. */ private static boolean isMediaStartKey(int keyCode) { switch (keyCode) { case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE: case KeyEvent.KEYCODE_MEDIA_PLAY: case KeyEvent.KEYCODE_MEDIA_PAUSE: case KeyEvent.KEYCODE_MEDIA_NEXT: case KeyEvent.KEYCODE_MEDIA_PREVIOUS: case KeyEvent.KEYCODE_MEDIA_REWIND: case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD: return true; } return false; } private static class TvOverlayHandler extends WeakHandler<TvOverlayManager> { public TvOverlayHandler(TvOverlayManager ref) { super(ref); } @Override public void handleMessage(Message msg, @NonNull TvOverlayManager tvOverlayManager) { switch (msg.what) { case MSG_OVERLAY_CLOSED: if (!tvOverlayManager.canExecuteCloseAction()) { return; } if (tvOverlayManager.showMenuWithTimeShiftPauseIfNeeded()) { return; } if (!tvOverlayManager.mPendingActions.isEmpty()) { Runnable action = tvOverlayManager.mPendingActions.get(0); tvOverlayManager.mPendingActions.remove(action); action.run(); } break; } } } /** * Dummny class for the workaround of b/22631964. See {@link #closeFragment}. */ public static class DummyFragment extends Fragment { @Override public @Nullable View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { final View v = new Space(inflater.getContext()); v.setVisibility(View.GONE); return v; } } }