| /* |
| * 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.onboarding; |
| |
| import android.content.ActivityNotFoundException; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.graphics.Typeface; |
| import android.graphics.drawable.Drawable; |
| import android.media.tv.TvInputInfo; |
| import android.media.tv.TvInputManager.TvInputCallback; |
| import android.os.Bundle; |
| import android.support.annotation.NonNull; |
| import android.support.v17.leanback.widget.GuidanceStylist.Guidance; |
| import android.support.v17.leanback.widget.GuidedAction; |
| import android.support.v17.leanback.widget.GuidedActionsStylist; |
| import android.support.v17.leanback.widget.VerticalGridView; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.widget.ImageView; |
| import android.widget.TextView; |
| import android.widget.Toast; |
| |
| import com.android.tv.ApplicationSingletons; |
| import com.android.tv.Features; |
| import com.android.tv.R; |
| import com.android.tv.SetupPassthroughActivity; |
| import com.android.tv.TvApplication; |
| import com.android.tv.common.TvCommonUtils; |
| import com.android.tv.common.ui.setup.SetupGuidedStepFragment; |
| import com.android.tv.common.ui.setup.SetupMultiPaneFragment; |
| import com.android.tv.data.ChannelDataManager; |
| import com.android.tv.data.TvInputNewComparator; |
| import com.android.tv.util.SetupUtils; |
| import com.android.tv.util.TvInputManagerHelper; |
| import com.android.tv.util.Utils; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| |
| /** |
| * A fragment for channel source info/setup. |
| */ |
| public class SetupSourcesFragment extends SetupMultiPaneFragment { |
| private static final String TAG = "SetupSourcesFragment"; |
| |
| public static final String ACTION_CATEGORY = |
| "com.android.tv.onboarding.SetupSourcesFragment"; |
| public static final int ACTION_PLAY_STORE = 1; |
| |
| private static final String SETUP_TRACKER_LABEL = "Setup fragment"; |
| |
| private InputSetupRunnable mInputSetupRunnable; |
| |
| private ContentFragment mContentFragment; |
| |
| @Override |
| public View onCreateView(LayoutInflater inflater, ViewGroup container, |
| Bundle savedInstanceState) { |
| View view = super.onCreateView(inflater, container, savedInstanceState); |
| TvApplication.getSingletons(getActivity()).getTracker().sendScreenView(SETUP_TRACKER_LABEL); |
| return view; |
| } |
| |
| @Override |
| protected void onEnterTransitionEnd() { |
| if (mContentFragment != null) { |
| mContentFragment.executePendingAction(); |
| } |
| } |
| |
| @Override |
| protected SetupGuidedStepFragment onCreateContentFragment() { |
| mContentFragment = new ContentFragment(); |
| mContentFragment.setParentFragment(this); |
| Bundle arguments = new Bundle(); |
| arguments.putBoolean(SetupGuidedStepFragment.KEY_THREE_PANE, true); |
| mContentFragment.setArguments(arguments); |
| return mContentFragment; |
| } |
| |
| @Override |
| protected String getActionCategory() { |
| return ACTION_CATEGORY; |
| } |
| |
| /** |
| * Call this method to run customized input setup. |
| * |
| * @param runnable runnable to be called when the input setup is necessary. |
| */ |
| public void setInputSetupRunnable(InputSetupRunnable runnable) { |
| mInputSetupRunnable = runnable; |
| } |
| |
| /** |
| * Interface for the customized input setup. |
| */ |
| public interface InputSetupRunnable { |
| /** |
| * Called for the input setup. |
| * |
| * @param input TV input for setup. |
| */ |
| void runInputSetup(TvInputInfo input); |
| } |
| |
| public static class ContentFragment extends SetupGuidedStepFragment { |
| private static final int REQUEST_CODE_START_SETUP_ACTIVITY = 1; |
| |
| // ACTION_PLAY_STORE is defined in the outer class. |
| private static final int ACTION_DIVIDER = 2; |
| private static final int ACTION_HEADER = 3; |
| private static final int ACTION_INPUT_START = 4; |
| |
| private static final int PENDING_ACTION_NONE = 0; |
| private static final int PENDING_ACTION_INPUT_CHANGED = 1; |
| private static final int PENDING_ACTION_CHANNEL_CHANGED = 2; |
| |
| private TvInputManagerHelper mInputManager; |
| private ChannelDataManager mChannelDataManager; |
| private SetupUtils mSetupUtils; |
| private List<TvInputInfo> mInputs; |
| private int mKnownInputStartIndex; |
| private int mDoneInputStartIndex; |
| |
| private SetupSourcesFragment mParentFragment; |
| |
| private String mNewlyAddedInputId; |
| |
| private int mPendingAction = PENDING_ACTION_NONE; |
| |
| private final TvInputCallback mInputCallback = new TvInputCallback() { |
| @Override |
| public void onInputAdded(String inputId) { |
| handleInputChanged(); |
| } |
| |
| @Override |
| public void onInputRemoved(String inputId) { |
| handleInputChanged(); |
| } |
| |
| @Override |
| public void onInputUpdated(String inputId) { |
| handleInputChanged(); |
| } |
| |
| private void handleInputChanged() { |
| // The actions created while enter transition is running will not be included in the |
| // fragment transition. |
| if (mParentFragment.isEnterTransitionRunning()) { |
| mPendingAction = PENDING_ACTION_INPUT_CHANGED; |
| return; |
| } |
| buildInputs(); |
| updateActions(); |
| } |
| }; |
| |
| void setParentFragment(SetupSourcesFragment parentFragment) { |
| mParentFragment = parentFragment; |
| } |
| |
| private final ChannelDataManager.Listener mChannelDataManagerListener |
| = new ChannelDataManager.Listener() { |
| @Override |
| public void onLoadFinished() { |
| handleChannelChanged(); |
| } |
| |
| @Override |
| public void onChannelListUpdated() { |
| handleChannelChanged(); |
| } |
| |
| @Override |
| public void onChannelBrowsableChanged() { |
| handleChannelChanged(); |
| } |
| |
| private void handleChannelChanged() { |
| // The actions created while enter transition is running will not be included in the |
| // fragment transition. |
| if (mParentFragment.isEnterTransitionRunning()) { |
| if (mPendingAction != PENDING_ACTION_INPUT_CHANGED) { |
| mPendingAction = PENDING_ACTION_CHANNEL_CHANGED; |
| } |
| return; |
| } |
| updateActions(); |
| } |
| }; |
| |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| // TODO: Handle USB TV tuner differently. |
| Context context = getActivity(); |
| ApplicationSingletons app = TvApplication.getSingletons(context); |
| mInputManager = app.getTvInputManagerHelper(); |
| mChannelDataManager = app.getChannelDataManager(); |
| mSetupUtils = SetupUtils.getInstance(context); |
| buildInputs(); |
| mInputManager.addCallback(mInputCallback); |
| mChannelDataManager.addListener(mChannelDataManagerListener); |
| super.onCreate(savedInstanceState); |
| } |
| |
| @Override |
| public void onDestroy() { |
| super.onDestroy(); |
| mChannelDataManager.removeListener(mChannelDataManagerListener); |
| mInputManager.removeCallback(mInputCallback); |
| } |
| |
| @NonNull |
| @Override |
| public Guidance onCreateGuidance(Bundle savedInstanceState) { |
| String title = getString(R.string.setup_sources_text); |
| String description = getString(R.string.setup_sources_description); |
| return new Guidance(title, description, null, null); |
| } |
| |
| @Override |
| public GuidedActionsStylist onCreateActionsStylist() { |
| return new SetupSourceGuidedActionsStylist(); |
| } |
| |
| @Override |
| public void onCreateActions(@NonNull List<GuidedAction> actions, |
| Bundle savedInstanceState) { |
| createActionsInternal(actions); |
| } |
| |
| private void buildInputs() { |
| List<TvInputInfo> oldInputs = mInputs; |
| mInputs = mInputManager.getTvInputInfos(true, true); |
| // Get newly installed input ID. |
| if (oldInputs != null) { |
| List<TvInputInfo> newList = new ArrayList<>(mInputs); |
| for (TvInputInfo input : oldInputs) { |
| newList.remove(input); |
| } |
| if (newList.size() > 0 && mSetupUtils.isNewInput(newList.get(0).getId())) { |
| mNewlyAddedInputId = newList.get(0).getId(); |
| } else { |
| mNewlyAddedInputId = null; |
| } |
| } |
| Collections.sort(mInputs, new TvInputNewComparator(mSetupUtils, mInputManager)); |
| mKnownInputStartIndex = 0; |
| mDoneInputStartIndex = 0; |
| for (TvInputInfo input : mInputs) { |
| if (mSetupUtils.isNewInput(input.getId())) { |
| mSetupUtils.markAsKnownInput(input.getId()); |
| ++mKnownInputStartIndex; |
| } |
| if (!mSetupUtils.isSetupDone(input.getId())) { |
| ++mDoneInputStartIndex; |
| } |
| } |
| } |
| |
| private void updateActions() { |
| List<GuidedAction> actions = new ArrayList<>(); |
| createActionsInternal(actions); |
| setActions(actions); |
| } |
| |
| private void createActionsInternal(List<GuidedAction> actions) { |
| int newPosition = -1; |
| int position = 0; |
| if (mDoneInputStartIndex > 0) { |
| // Need a "New" category |
| actions.add(new GuidedAction.Builder(getActivity()).id(ACTION_HEADER) |
| .title(null).description(getString(R.string.setup_category_new)) |
| .focusable(false).build()); |
| } |
| for (int i = 0; i < mInputs.size(); ++i) { |
| if (i == mDoneInputStartIndex) { |
| ++position; |
| actions.add(new GuidedAction.Builder(getActivity()).id(ACTION_HEADER) |
| .title(null).description(getString(R.string.setup_category_done)) |
| .focusable(false).build()); |
| } |
| TvInputInfo input = mInputs.get(i); |
| String inputId = input.getId(); |
| String description; |
| int channelCount = mChannelDataManager.getChannelCountForInput(inputId); |
| if (mSetupUtils.isSetupDone(inputId) || channelCount > 0) { |
| if (channelCount == 0) { |
| description = getString(R.string.setup_input_no_channels); |
| } else { |
| description = getResources().getQuantityString( |
| R.plurals.setup_input_channels, channelCount, channelCount); |
| } |
| } else if (i >= mKnownInputStartIndex) { |
| description = getString(R.string.setup_input_setup_now); |
| } else { |
| description = getString(R.string.setup_input_new); |
| } |
| ++position; |
| if (input.getId().equals(mNewlyAddedInputId)) { |
| newPosition = position; |
| } |
| actions.add(new GuidedAction.Builder(getActivity()).id(ACTION_INPUT_START + i) |
| .title(input.loadLabel(getActivity()).toString()).description(description) |
| .build()); |
| } |
| if (Features.ONBOARDING_PLAY_STORE.isEnabled(getActivity())) { |
| if (mInputs.size() > 0) { |
| // Divider |
| ++position; |
| actions.add(new GuidedAction.Builder(getActivity()).id(ACTION_DIVIDER) |
| .title(null).description(null).focusable(false).build()); |
| } |
| // Play store action |
| ++position; |
| actions.add(new GuidedAction.Builder(getActivity()).id(ACTION_PLAY_STORE) |
| .title(getString(R.string.setup_play_store_action_title)) |
| .description(getString(R.string.setup_play_store_action_description)) |
| .icon(R.drawable.ic_playstore).build()); |
| } |
| if (newPosition != -1) { |
| VerticalGridView gridView = getGuidedActionsStylist().getActionsGridView(); |
| gridView.setSelectedPosition(newPosition); |
| } |
| } |
| |
| @Override |
| protected String getActionCategory() { |
| return ACTION_CATEGORY; |
| } |
| |
| @Override |
| public void onGuidedActionClicked(GuidedAction action) { |
| if (action.getId() == ACTION_PLAY_STORE) { |
| mParentFragment.onActionClick(ACTION_CATEGORY, (int) action.getId()); |
| return; |
| } |
| TvInputInfo input = mInputs.get((int) action.getId() - ACTION_INPUT_START); |
| if (mParentFragment.mInputSetupRunnable != null) { |
| mParentFragment.mInputSetupRunnable.runInputSetup(input); |
| return; |
| } |
| Intent intent = TvCommonUtils.createSetupIntent(input); |
| if (intent == null) { |
| Toast.makeText(getActivity(), R.string.msg_no_setup_activity, Toast.LENGTH_SHORT) |
| .show(); |
| return; |
| } |
| // Even though other app can handle the intent, the setup launched by Live channels |
| // should go through Live channels SetupPassthroughActivity. |
| intent.setComponent(new ComponentName(getActivity(), SetupPassthroughActivity.class)); |
| try { |
| // Now we know that the user intends to set up this input. Grant permission for |
| // writing EPG data. |
| SetupUtils.grantEpgPermission(getActivity(), input.getServiceInfo().packageName); |
| startActivityForResult(intent, REQUEST_CODE_START_SETUP_ACTIVITY); |
| } catch (ActivityNotFoundException e) { |
| Toast.makeText(getActivity(), getString(R.string.msg_unable_to_start_setup_activity, |
| input.loadLabel(getActivity())), Toast.LENGTH_SHORT).show(); |
| } |
| } |
| |
| @Override |
| public void onActivityResult(int requestCode, int resultCode, Intent data) { |
| updateActions(); |
| } |
| |
| void executePendingAction() { |
| switch (mPendingAction) { |
| case PENDING_ACTION_INPUT_CHANGED: |
| buildInputs(); |
| // Fall through |
| case PENDING_ACTION_CHANNEL_CHANGED: |
| updateActions(); |
| break; |
| } |
| mPendingAction = PENDING_ACTION_NONE; |
| } |
| |
| private class SetupSourceGuidedActionsStylist extends GuidedActionsStylist { |
| private static final int VIEW_TYPE_DIVIDER = 1; |
| |
| private static final float ALPHA_CATEGORY = 1.0f; |
| private static final float ALPHA_INPUT_DESCRIPTION = 0.5f; |
| |
| @Override |
| public int getItemViewType(GuidedAction action) { |
| if (action.getId() == ACTION_DIVIDER) { |
| return VIEW_TYPE_DIVIDER; |
| } |
| return super.getItemViewType(action); |
| } |
| |
| @Override |
| public int onProvideItemLayoutId(int viewType) { |
| if (viewType == VIEW_TYPE_DIVIDER) { |
| return R.layout.onboarding_item_divider; |
| } |
| return super.onProvideItemLayoutId(viewType); |
| } |
| |
| @Override |
| public void onBindViewHolder(ViewHolder vh, GuidedAction action) { |
| super.onBindViewHolder(vh, action); |
| TextView descriptionView = vh.getDescriptionView(); |
| if (descriptionView != null) { |
| if (action.getId() == ACTION_HEADER) { |
| descriptionView.setAlpha(ALPHA_CATEGORY); |
| descriptionView.setTextColor(Utils.getColor(getResources(), |
| R.color.setup_category)); |
| descriptionView.setTypeface(Typeface.create( |
| getString(R.string.condensed_font), 0)); |
| } else { |
| descriptionView.setAlpha(ALPHA_INPUT_DESCRIPTION); |
| descriptionView.setTextColor(Utils.getColor(getResources(), |
| R.color.common_setup_input_description)); |
| descriptionView.setTypeface(Typeface.create(getString(R.string.font), 0)); |
| } |
| } |
| // Workaround for b/26473407. |
| ImageView iconView = vh.getIconView(); |
| if (iconView != null) { |
| Drawable icon = action.getIcon(); |
| if (icon != null) { |
| // setImageDrawable resets the drawable's level unless we set the view level |
| // first. |
| iconView.setImageLevel(icon.getLevel()); |
| iconView.setImageDrawable(icon); |
| iconView.setVisibility(View.VISIBLE); |
| } else { |
| iconView.setVisibility(View.GONE); |
| } |
| } |
| } |
| } |
| } |
| } |
