| /* |
| * Copyright (C) 2022 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.interactive; |
| |
| import static com.android.tv.util.CaptionSettings.OPTION_OFF; |
| import static com.android.tv.util.CaptionSettings.OPTION_ON; |
| |
| import android.annotation.TargetApi; |
| import android.graphics.Rect; |
| import android.media.tv.TvTrackInfo; |
| import android.media.tv.interactive.TvInteractiveAppManager; |
| import android.media.tv.AitInfo; |
| import android.media.tv.interactive.TvInteractiveAppService; |
| import android.media.tv.interactive.TvInteractiveAppServiceInfo; |
| import android.media.tv.interactive.TvInteractiveAppView; |
| import android.net.Uri; |
| import android.os.Build; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.support.annotation.NonNull; |
| import android.util.Log; |
| import android.view.InputEvent; |
| import android.view.KeyEvent; |
| import android.view.View; |
| import android.view.ViewGroup; |
| |
| import com.android.tv.MainActivity; |
| import com.android.tv.R; |
| import com.android.tv.common.SoftPreconditions; |
| import com.android.tv.common.util.ContentUriUtils; |
| import com.android.tv.data.api.Channel; |
| import com.android.tv.dialog.InteractiveAppDialogFragment; |
| import com.android.tv.features.TvFeatures; |
| import com.android.tv.ui.TunableTvView; |
| import com.android.tv.util.TvSettings; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.concurrent.ExecutorService; |
| import java.util.concurrent.Executors; |
| |
| @TargetApi(Build.VERSION_CODES.TIRAMISU) |
| public class IAppManager { |
| private static final String TAG = "IAppManager"; |
| private static final boolean DEBUG = false; |
| |
| private final MainActivity mMainActivity; |
| private final TvInteractiveAppManager mTvIAppManager; |
| private final TvInteractiveAppView mTvIAppView; |
| private final TunableTvView mTvView; |
| private final Handler mHandler; |
| private AitInfo mCurrentAitInfo; |
| private AitInfo mHeldAitInfo; // AIT info that has been held pending dialog confirmation |
| private boolean mTvAppDialogShown = false; |
| |
| public IAppManager(@NonNull MainActivity parentActivity, @NonNull TunableTvView tvView, |
| @NonNull Handler handler) { |
| SoftPreconditions.checkFeatureEnabled(parentActivity, TvFeatures.HAS_TIAF, TAG); |
| |
| mMainActivity = parentActivity; |
| mTvView = tvView; |
| mHandler = handler; |
| mTvIAppManager = mMainActivity.getSystemService(TvInteractiveAppManager.class); |
| mTvIAppView = mMainActivity.findViewById(R.id.tv_app_view); |
| if (mTvIAppManager == null || mTvIAppView == null) { |
| Log.e(TAG, "Could not find interactive app view or manager"); |
| return; |
| } |
| |
| ExecutorService executor = Executors.newSingleThreadExecutor(); |
| mTvIAppManager.registerCallback( |
| executor, |
| new MyInteractiveAppManagerCallback() |
| ); |
| mTvIAppView.setCallback( |
| executor, |
| new MyInteractiveAppViewCallback() |
| ); |
| mTvIAppView.setOnUnhandledInputEventListener(executor, |
| inputEvent -> { |
| if (mMainActivity.isKeyEventBlocked()) { |
| return true; |
| } |
| if (inputEvent instanceof KeyEvent) { |
| KeyEvent keyEvent = (KeyEvent) inputEvent; |
| if (keyEvent.getAction() == KeyEvent.ACTION_DOWN |
| && keyEvent.isLongPress()) { |
| if (mMainActivity.onKeyLongPress(keyEvent.getKeyCode(), keyEvent)) { |
| return true; |
| } |
| } |
| if (keyEvent.getAction() == KeyEvent.ACTION_UP) { |
| return mMainActivity.onKeyUp(keyEvent.getKeyCode(), keyEvent); |
| } else if (keyEvent.getAction() == KeyEvent.ACTION_DOWN) { |
| return mMainActivity.onKeyDown(keyEvent.getKeyCode(), keyEvent); |
| } |
| } |
| return false; |
| }); |
| } |
| |
| public void stop() { |
| mTvIAppView.stopInteractiveApp(); |
| mTvIAppView.reset(); |
| mCurrentAitInfo = null; |
| } |
| |
| /* |
| * Update current info based on ait info that was held when the dialog was shown. |
| */ |
| public void processHeldAitInfo() { |
| if (mHeldAitInfo != null) { |
| onAitInfoUpdated(mHeldAitInfo); |
| } |
| } |
| |
| public boolean dispatchKeyEvent(KeyEvent event) { |
| if (mTvIAppView != null && mTvIAppView.getVisibility() == View.VISIBLE |
| && mTvIAppView.dispatchKeyEvent(event)){ |
| return true; |
| } |
| return false; |
| } |
| |
| public void onAitInfoUpdated(AitInfo aitInfo) { |
| if (mTvIAppManager == null || aitInfo == null) { |
| return; |
| } |
| if (mCurrentAitInfo != null && mCurrentAitInfo.getType() == aitInfo.getType()) { |
| if (DEBUG) { |
| Log.d(TAG, "Ignoring AIT update: Same type as current"); |
| } |
| return; |
| } |
| |
| List<TvInteractiveAppServiceInfo> tvIAppInfoList = |
| mTvIAppManager.getTvInteractiveAppServiceList(); |
| if (tvIAppInfoList.isEmpty()) { |
| if (DEBUG) { |
| Log.d(TAG, "Ignoring AIT update: No interactive app services registered"); |
| } |
| return; |
| } |
| |
| // App Type ID numbers allocated by DVB Services |
| int type = -1; |
| switch (aitInfo.getType()) { |
| case 0x0010: // HBBTV |
| type = TvInteractiveAppServiceInfo.INTERACTIVE_APP_TYPE_HBBTV; |
| break; |
| case 0x0006: // DCAP-J: DCAP Java applications |
| case 0x0007: // DCAP-X: DCAP XHTML applications |
| type = TvInteractiveAppServiceInfo.INTERACTIVE_APP_TYPE_ATSC; |
| break; |
| case 0x0001: // Ginga-J |
| case 0x0009: // Ginga-NCL |
| case 0x000b: // Ginga-HTML5 |
| type = TvInteractiveAppServiceInfo.INTERACTIVE_APP_TYPE_GINGA; |
| break; |
| default: |
| Log.e(TAG, "AIT info contained unknown type: " + aitInfo.getType()); |
| return; |
| } |
| |
| if (TvSettings.isTvIAppOn(mMainActivity.getApplicationContext())) { |
| mTvAppDialogShown = false; |
| for (TvInteractiveAppServiceInfo info : tvIAppInfoList) { |
| if ((info.getSupportedTypes() & type) > 0) { |
| mCurrentAitInfo = aitInfo; |
| if (mTvIAppView != null) { |
| mTvIAppView.setVisibility(View.VISIBLE); |
| mTvIAppView.prepareInteractiveApp(info.getId(), type); |
| } |
| break; |
| } |
| } |
| } else if (!mTvAppDialogShown) { |
| if (DEBUG) { |
| Log.d(TAG, "TV IApp is not enabled"); |
| } |
| |
| for (TvInteractiveAppServiceInfo info : tvIAppInfoList) { |
| if ((info.getSupportedTypes() & type) > 0) { |
| mMainActivity.getOverlayManager().showDialogFragment( |
| InteractiveAppDialogFragment.DIALOG_TAG, |
| InteractiveAppDialogFragment.create(info.getServiceInfo().packageName), |
| false); |
| mHeldAitInfo = aitInfo; |
| mTvAppDialogShown = true; |
| break; |
| } |
| } |
| } |
| } |
| |
| private class MyInteractiveAppManagerCallback extends |
| TvInteractiveAppManager.TvInteractiveAppCallback { |
| @Override |
| public void onInteractiveAppServiceAdded(String iAppServiceId) {} |
| |
| @Override |
| public void onInteractiveAppServiceRemoved(String iAppServiceId) {} |
| |
| @Override |
| public void onInteractiveAppServiceUpdated(String iAppServiceId) {} |
| |
| @Override |
| public void onTvInteractiveAppServiceStateChanged(String iAppServiceId, int type, int state, |
| int err) { |
| if (state == TvInteractiveAppManager.SERVICE_STATE_READY && mTvIAppView != null) { |
| mTvIAppView.startInteractiveApp(); |
| mTvIAppView.setTvView(mTvView.getTvView()); |
| if (mTvView.getTvView() != null) { |
| mTvView.getTvView().setInteractiveAppNotificationEnabled(true); |
| } |
| } |
| } |
| } |
| |
| private class MyInteractiveAppViewCallback extends |
| TvInteractiveAppView.TvInteractiveAppCallback { |
| @Override |
| public void onPlaybackCommandRequest(String iAppServiceId, String cmdType, |
| Bundle parameters) { |
| if (mTvView == null || cmdType == null) { |
| return; |
| } |
| switch (cmdType) { |
| case TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_TUNE: |
| if (parameters == null) { |
| return; |
| } |
| String uriString = parameters.getString( |
| TvInteractiveAppService.COMMAND_PARAMETER_KEY_CHANNEL_URI); |
| if (uriString != null) { |
| Uri channelUri = Uri.parse(uriString); |
| Channel channel = mMainActivity.getChannelDataManager().getChannel( |
| ContentUriUtils.safeParseId(channelUri)); |
| if (channel != null) { |
| mHandler.post(() -> mMainActivity.tuneToChannel(channel)); |
| } |
| } |
| break; |
| case TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_SELECT_TRACK: |
| if (mTvView != null && parameters != null) { |
| int trackType = parameters.getInt( |
| TvInteractiveAppService.COMMAND_PARAMETER_KEY_TRACK_TYPE, |
| -1); |
| String trackId = parameters.getString( |
| TvInteractiveAppService.COMMAND_PARAMETER_KEY_TRACK_ID, |
| null); |
| switch (trackType) { |
| case TvTrackInfo.TYPE_AUDIO: |
| // When trackId is null, deselects current audio track. |
| mHandler.post(() -> mMainActivity.selectAudioTrack(trackId)); |
| break; |
| case TvTrackInfo.TYPE_SUBTITLE: |
| // When trackId is null, turns off captions. |
| mHandler.post(() -> mMainActivity.selectSubtitleTrack( |
| trackId == null ? OPTION_OFF : OPTION_ON, trackId)); |
| break; |
| } |
| } |
| break; |
| case TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_SET_STREAM_VOLUME: |
| if (parameters == null) { |
| return; |
| } |
| float volume = parameters.getFloat( |
| TvInteractiveAppService.COMMAND_PARAMETER_KEY_VOLUME, -1); |
| if (volume >= 0.0 && volume <= 1.0) { |
| mHandler.post(() -> mTvView.setStreamVolume(volume)); |
| } |
| break; |
| case TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_TUNE_NEXT: |
| mHandler.post(mMainActivity::channelUp); |
| break; |
| case TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_TUNE_PREV: |
| mHandler.post(mMainActivity::channelDown); |
| break; |
| case TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_STOP: |
| int mode = 1; // TvInteractiveAppService.COMMAND_PARAMETER_VALUE_STOP_MODE_BLANK |
| if (parameters != null) { |
| mode = parameters.getInt( |
| /* TvInteractiveAppService.COMMAND_PARAMETER_KEY_STOP_MODE */ |
| "command_stop_mode", |
| /*TvInteractiveAppService.COMMAND_PARAMETER_VALUE_STOP_MODE_BLANK*/ |
| 1); |
| } |
| mHandler.post(mMainActivity::stopTv); |
| break; |
| default: |
| Log.e(TAG, "PlaybackCommandRequest had unknown cmdType:" |
| + cmdType); |
| break; |
| } |
| } |
| |
| @Override |
| public void onStateChanged(String iAppServiceId, int state, int err) { |
| } |
| |
| @Override |
| public void onBiInteractiveAppCreated(String iAppServiceId, Uri biIAppUri, |
| String biIAppId) {} |
| |
| @Override |
| public void onTeletextAppStateChanged(String iAppServiceId, int state) {} |
| |
| @Override |
| public void onSetVideoBounds(String iAppServiceId, Rect rect) { |
| if (mTvView != null) { |
| ViewGroup.MarginLayoutParams layoutParams = mTvView.getTvViewLayoutParams(); |
| layoutParams.setMargins(rect.left, rect.top, rect.right, rect.bottom); |
| mTvView.setTvViewLayoutParams(layoutParams); |
| } |
| } |
| |
| @Override |
| @TargetApi(34) |
| public void onRequestCurrentVideoBounds(@NonNull String iAppServiceId) { |
| mHandler.post( |
| () -> { |
| if (DEBUG) { |
| Log.d(TAG, "onRequestCurrentVideoBounds service ID = " |
| + iAppServiceId); |
| } |
| Rect bounds = new Rect(mTvView.getLeft(), mTvView.getTop(), |
| mTvView.getRight(), mTvView.getBottom()); |
| mTvIAppView.sendCurrentVideoBounds(bounds); |
| }); |
| } |
| |
| @Override |
| public void onRequestCurrentChannelUri(String iAppServiceId) { |
| if (mTvIAppView == null) { |
| return; |
| } |
| Channel currentChannel = mMainActivity.getCurrentChannel(); |
| Uri currentUri = (currentChannel == null) |
| ? null |
| : currentChannel.getUri(); |
| mTvIAppView.sendCurrentChannelUri(currentUri); |
| } |
| |
| @Override |
| public void onRequestCurrentChannelLcn(String iAppServiceId) { |
| if (mTvIAppView == null) { |
| return; |
| } |
| Channel currentChannel = mMainActivity.getCurrentChannel(); |
| if (currentChannel == null || currentChannel.getDisplayNumber() == null) { |
| return; |
| } |
| // Expected format is major channel number, delimiter, minor channel number |
| String displayNumber = currentChannel.getDisplayNumber(); |
| String format = "[0-9]+" + Channel.CHANNEL_NUMBER_DELIMITER + "[0-9]+"; |
| if (!displayNumber.matches(format)) { |
| return; |
| } |
| // Major channel number is returned |
| String[] numbers = displayNumber.split( |
| String.valueOf(Channel.CHANNEL_NUMBER_DELIMITER)); |
| mTvIAppView.sendCurrentChannelLcn(Integer.parseInt(numbers[0])); |
| } |
| |
| @Override |
| public void onRequestStreamVolume(String iAppServiceId) { |
| if (mTvIAppView == null || mTvView == null) { |
| return; |
| } |
| mTvIAppView.sendStreamVolume(mTvView.getStreamVolume()); |
| } |
| |
| @Override |
| public void onRequestTrackInfoList(String iAppServiceId) { |
| if (mTvIAppView == null || mTvView == null) { |
| return; |
| } |
| List<TvTrackInfo> allTracks = new ArrayList<>(); |
| int[] trackTypes = new int[] {TvTrackInfo.TYPE_AUDIO, |
| TvTrackInfo.TYPE_VIDEO, TvTrackInfo.TYPE_SUBTITLE}; |
| |
| for (int trackType : trackTypes) { |
| List<TvTrackInfo> currentTracks = mTvView.getTracks(trackType); |
| if (currentTracks == null) { |
| continue; |
| } |
| for (TvTrackInfo track : currentTracks) { |
| if (track != null) { |
| allTracks.add(track); |
| } |
| } |
| } |
| mTvIAppView.sendTrackInfoList(allTracks); |
| } |
| |
| @Override |
| public void onRequestCurrentTvInputId(String iAppServiceId) { |
| if (mTvIAppView == null) { |
| return; |
| } |
| Channel currentChannel = mMainActivity.getCurrentChannel(); |
| String currentInputId = (currentChannel == null) |
| ? null |
| : currentChannel.getInputId(); |
| mTvIAppView.sendCurrentTvInputId(currentInputId); |
| } |
| |
| @Override |
| public void onRequestSigning(String iAppServiceId, String signingId, String algorithm, |
| String alias, byte[] data) {} |
| } |
| } |
