| /* |
| * Copyright (C) 2014 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 android.media.tv.cts; |
| |
| import android.app.Activity; |
| import android.app.ActivityManager; |
| import android.app.ActivityManager.RunningAppProcessInfo; |
| import android.app.Instrumentation; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.pm.PackageManager; |
| import android.content.pm.ResolveInfo; |
| import android.database.Cursor; |
| import android.media.AudioDeviceInfo; |
| import android.media.AudioFormat; |
| import android.media.AudioManager; |
| import android.media.tv.cts.TvViewTest.MockCallback; |
| import android.media.tv.TunedInfo; |
| import android.media.tv.TvContentRating; |
| import android.media.tv.TvContract; |
| import android.media.tv.TvInputHardwareInfo; |
| import android.media.tv.TvInputInfo; |
| import android.media.tv.TvInputManager; |
| import android.media.tv.TvInputManager.Hardware; |
| import android.media.tv.TvInputManager.HardwareCallback; |
| import android.media.tv.TvInputManager.Session; |
| import android.media.tv.TvInputManager.SessionCallback; |
| import android.media.tv.TvInputService; |
| import android.media.tv.TvStreamConfig; |
| import android.media.tv.TvView; |
| import android.media.tv.tunerresourcemanager.TunerResourceManager; |
| import android.net.Uri; |
| import android.os.Binder; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.IBinder; |
| import android.os.Looper; |
| import android.test.ActivityInstrumentationTestCase2; |
| import android.tv.cts.R; |
| |
| import com.android.compatibility.common.util.PollingCheck; |
| |
| import androidx.test.InstrumentationRegistry; |
| |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.concurrent.Executor; |
| |
| import org.xmlpull.v1.XmlPullParserException; |
| |
| /** |
| * Test for {@link android.media.tv.TvInputManager}. |
| */ |
| public class TvInputManagerTest extends ActivityInstrumentationTestCase2<TvViewStubActivity> { |
| /** The maximum time to wait for an operation. */ |
| private static final long TIME_OUT_MS = 15000L; |
| private static final int PRIORITY_HINT_USE_CASE_TYPE_INVALID = 1000; |
| |
| private static final int DUMMY_DEVICE_ID = Integer.MAX_VALUE; |
| private static final String[] VALID_TV_INPUT_SERVICES = { |
| StubTunerTvInputService.class.getName() |
| }; |
| private static final String[] INVALID_TV_INPUT_SERVICES = { |
| NoMetadataTvInputService.class.getName(), NoPermissionTvInputService.class.getName() |
| }; |
| private static final String EXTENSION_INTERFACE_NAME_WITHOUT_PERMISSION = |
| "android.media.tv.cts.TvInputManagerTest.EXTENSION_INTERFACE_NAME_WITHOUT_PERMISSION"; |
| private static final String EXTENSION_INTERFACE_NAME_WITH_PERMISSION_GRANTED = |
| "android.media.tv.cts.TvInputManagerTest" |
| + ".EXTENSION_INTERFACE_NAME_WITH_PERMISSION_GRANTED"; |
| private static final String EXTENSION_INTERFACE_NAME_WITH_PERMISSION_UNGRANTED = |
| "android.media.tv.cts.TvInputManagerTest" |
| + ".EXTENSION_INTERFACE_NAME_WITH_PERMISSION_UNGRANTED"; |
| private static final String PERMISSION_GRANTED = |
| "android.media.tv.cts.TvInputManagerTest.PERMISSION_GRANTED"; |
| private static final String PERMISSION_UNGRANTED = |
| "android.media.tv.cts.TvInputManagerTest.PERMISSION_UNGRANTED"; |
| |
| private static final TvContentRating DUMMY_RATING = TvContentRating.createRating( |
| "com.android.tv", "US_TV", "US_TV_PG", "US_TV_D", "US_TV_L"); |
| |
| private static final String PERMISSION_ACCESS_WATCHED_PROGRAMS = |
| "com.android.providers.tv.permission.ACCESS_WATCHED_PROGRAMS"; |
| private static final String PERMISSION_WRITE_EPG_DATA = |
| "com.android.providers.tv.permission.WRITE_EPG_DATA"; |
| private static final String PERMISSION_ACCESS_TUNED_INFO = |
| "android.permission.ACCESS_TUNED_INFO"; |
| private static final String PERMISSION_TV_INPUT_HARDWARE = |
| "android.permission.TV_INPUT_HARDWARE"; |
| private static final String PERMISSION_TUNER_RESOURCE_ACCESS = |
| "android.permission.TUNER_RESOURCE_ACCESS"; |
| private static final String PERMISSION_TIS_EXTENSION_INTERFACE = |
| "android.permission.TIS_EXTENSION_INTERFACE"; |
| private static final String[] BASE_SHELL_PERMISSIONS = { |
| PERMISSION_ACCESS_WATCHED_PROGRAMS, |
| PERMISSION_WRITE_EPG_DATA, |
| PERMISSION_ACCESS_TUNED_INFO, |
| PERMISSION_TUNER_RESOURCE_ACCESS, |
| PERMISSION_TIS_EXTENSION_INTERFACE |
| }; |
| |
| private String mStubId; |
| private TvInputManager mManager; |
| private LoggingCallback mCallback = new LoggingCallback(); |
| private TvInputInfo mStubTvInputInfo; |
| private TvView mTvView; |
| private Activity mActivity; |
| private Instrumentation mInstrumentation; |
| private TvInputInfo mStubTunerTvInputInfo; |
| private final MockCallback mMockCallback = new MockCallback(); |
| |
| private static TvInputInfo getInfoForClassName(List<TvInputInfo> list, String name) { |
| for (TvInputInfo info : list) { |
| if (info.getServiceInfo().name.equals(name)) { |
| return info; |
| } |
| } |
| return null; |
| } |
| |
| private static boolean isHardwareDeviceAdded(List<TvInputHardwareInfo> list, int deviceId) { |
| if (list != null) { |
| for (TvInputHardwareInfo info : list) { |
| if (info.getDeviceId() == deviceId) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| private String prepareStubHardwareTvInputService() { |
| String[] newPermissions = Arrays.copyOf( |
| BASE_SHELL_PERMISSIONS, BASE_SHELL_PERMISSIONS.length + 1); |
| newPermissions[BASE_SHELL_PERMISSIONS.length] = PERMISSION_TV_INPUT_HARDWARE; |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .adoptShellPermissionIdentity(newPermissions); |
| |
| // Use the test api to add an HDMI hardware device |
| mManager.addHardwareDevice(DUMMY_DEVICE_ID); |
| assertTrue(isHardwareDeviceAdded(mManager.getHardwareList(), DUMMY_DEVICE_ID)); |
| |
| PackageManager pm = getActivity().getPackageManager(); |
| ComponentName component = |
| new ComponentName(getActivity(), StubHardwareTvInputService.class); |
| pm.setComponentEnabledSetting(component, PackageManager.COMPONENT_ENABLED_STATE_ENABLED, |
| PackageManager.DONT_KILL_APP); |
| new PollingCheck(TIME_OUT_MS) { |
| @Override |
| protected boolean check() { |
| return null != getInfoForClassName( |
| mManager.getTvInputList(), StubHardwareTvInputService.class.getName()); |
| } |
| }.run(); |
| |
| TvInputInfo info = getInfoForClassName( |
| mManager.getTvInputList(), StubHardwareTvInputService.class.getName()); |
| assertNotNull(info); |
| return info.getId(); |
| } |
| |
| private void cleanupStubHardwareTvInputService() { |
| // Restore the base shell permissions |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .adoptShellPermissionIdentity(BASE_SHELL_PERMISSIONS); |
| |
| PackageManager pm = getActivity().getPackageManager(); |
| ComponentName component = |
| new ComponentName(getActivity(), StubHardwareTvInputService.class); |
| pm.setComponentEnabledSetting(component, PackageManager.COMPONENT_ENABLED_STATE_DISABLED, |
| PackageManager.DONT_KILL_APP); |
| new PollingCheck(TIME_OUT_MS) { |
| @Override |
| protected boolean check() { |
| return null == getInfoForClassName( |
| mManager.getTvInputList(), StubHardwareTvInputService.class.getName()); |
| } |
| }.run(); |
| |
| mManager.removeHardwareDevice(DUMMY_DEVICE_ID); |
| } |
| |
| public TvInputManagerTest() { |
| super(TvViewStubActivity.class); |
| } |
| |
| @Override |
| public void setUp() throws Exception { |
| super.setUp(); |
| mActivity = getActivity(); |
| if (!Utils.hasTvInputFramework(mActivity)) { |
| return; |
| } |
| |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .adoptShellPermissionIdentity(BASE_SHELL_PERMISSIONS); |
| |
| mInstrumentation = getInstrumentation(); |
| mTvView = findTvViewById(R.id.tvview); |
| mManager = (TvInputManager) mActivity.getSystemService(Context.TV_INPUT_SERVICE); |
| mStubId = getInfoForClassName( |
| mManager.getTvInputList(), StubTvInputService2.class.getName()).getId(); |
| mStubTvInputInfo = getInfoForClassName( |
| mManager.getTvInputList(), StubTvInputService2.class.getName()); |
| for (TvInputInfo info : mManager.getTvInputList()) { |
| if (info.getServiceInfo().name.equals(StubTunerTvInputService.class.getName())) { |
| mStubTunerTvInputInfo = info; |
| break; |
| } |
| } |
| assertNotNull(mStubTunerTvInputInfo); |
| mTvView.setCallback(mMockCallback); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| if (!Utils.hasTvInputFramework(getActivity())) { |
| super.tearDown(); |
| return; |
| } |
| StubTunerTvInputService.deleteChannels( |
| mActivity.getContentResolver(), mStubTunerTvInputInfo); |
| StubTunerTvInputService.clearTracks(); |
| try { |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mTvView.reset(); |
| } |
| }); |
| } catch (Throwable t) { |
| throw new RuntimeException(t); |
| } |
| mInstrumentation.waitForIdleSync(); |
| |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .dropShellPermissionIdentity(); |
| super.tearDown(); |
| } |
| |
| private TvView findTvViewById(int id) { |
| return (TvView) mActivity.findViewById(id); |
| } |
| |
| private void tryTuneAllChannels() throws Throwable { |
| StubTunerTvInputService.insertChannels( |
| mActivity.getContentResolver(), mStubTunerTvInputInfo); |
| |
| Uri uri = TvContract.buildChannelsUriForInput(mStubTunerTvInputInfo.getId()); |
| String[] projection = { TvContract.Channels._ID }; |
| try (Cursor cursor = mActivity.getContentResolver().query( |
| uri, projection, null, null, null)) { |
| while (cursor != null && cursor.moveToNext()) { |
| long channelId = cursor.getLong(0); |
| Uri channelUri = TvContract.buildChannelUri(channelId); |
| mCallback.mTunedInfos = null; |
| mTvView.tune(mStubTunerTvInputInfo.getId(), channelUri); |
| mInstrumentation.waitForIdleSync(); |
| new PollingCheck(TIME_OUT_MS) { |
| @Override |
| protected boolean check() { |
| return mMockCallback.isVideoAvailable(mStubTunerTvInputInfo.getId()); |
| } |
| }.run(); |
| new PollingCheck(TIME_OUT_MS) { |
| @Override |
| protected boolean check() { |
| return mCallback.mTunedInfos != null; |
| } |
| }.run(); |
| |
| List<TunedInfo> returnedInfos = mManager.getCurrentTunedInfos(); |
| assertEquals(1, returnedInfos.size()); |
| TunedInfo returnedInfo = returnedInfos.get(0); |
| TunedInfo expectedInfo = new TunedInfo( |
| "android.tv.cts/android.media.tv.cts.StubTunerTvInputService", |
| channelUri, |
| false, |
| false, |
| false, |
| TunedInfo.APP_TYPE_SELF, |
| TunedInfo.APP_TAG_SELF); |
| assertEquals(expectedInfo, returnedInfo); |
| |
| assertEquals(expectedInfo.getAppTag(), returnedInfo.getAppTag()); |
| assertEquals(expectedInfo.getAppType(), returnedInfo.getAppType()); |
| assertEquals(expectedInfo.getChannelUri(), returnedInfo.getChannelUri()); |
| assertEquals(expectedInfo.getInputId(), returnedInfo.getInputId()); |
| assertEquals(expectedInfo.isMainSession(), returnedInfo.isMainSession()); |
| assertEquals(expectedInfo.isRecordingSession(), returnedInfo.isRecordingSession()); |
| assertEquals(expectedInfo.isVisible(), returnedInfo.isVisible()); |
| |
| assertEquals(1, mCallback.mTunedInfos.size()); |
| TunedInfo callbackInfo = mCallback.mTunedInfos.get(0); |
| assertEquals(expectedInfo, callbackInfo); |
| } |
| } |
| } |
| |
| public void testGetCurrentTunedInfos() throws Throwable { |
| if (!Utils.hasTvInputFramework(getActivity())) { |
| return; |
| } |
| mActivity.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mManager.registerCallback(mCallback, new Handler()); |
| } |
| }); |
| tryTuneAllChannels(); |
| mActivity.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mManager.unregisterCallback(mCallback); |
| } |
| }); |
| } |
| |
| public void testGetInputState() throws Exception { |
| if (!Utils.hasTvInputFramework(getActivity())) { |
| return; |
| } |
| assertEquals(mManager.getInputState(mStubId), TvInputManager.INPUT_STATE_CONNECTED); |
| } |
| |
| public void testGetTvInputInfo() throws Exception { |
| if (!Utils.hasTvInputFramework(getActivity())) { |
| return; |
| } |
| TvInputInfo expected = mManager.getTvInputInfo(mStubId); |
| TvInputInfo actual = getInfoForClassName(mManager.getTvInputList(), |
| StubTvInputService2.class.getName()); |
| assertTrue("expected=" + expected + " actual=" + actual, |
| TvInputInfoTest.compareTvInputInfos(getActivity(), expected, actual)); |
| } |
| |
| public void testGetTvInputList() throws Exception { |
| if (!Utils.hasTvInputFramework(getActivity())) { |
| return; |
| } |
| List<TvInputInfo> list = mManager.getTvInputList(); |
| for (String name : VALID_TV_INPUT_SERVICES) { |
| assertNotNull("getTvInputList() doesn't contain valid input: " + name, |
| getInfoForClassName(list, name)); |
| } |
| for (String name : INVALID_TV_INPUT_SERVICES) { |
| assertNull("getTvInputList() contains invalind input: " + name, |
| getInfoForClassName(list, name)); |
| } |
| } |
| |
| public void testIsParentalControlsEnabled() { |
| if (!Utils.hasTvInputFramework(getActivity())) { |
| return; |
| } |
| try { |
| mManager.isParentalControlsEnabled(); |
| } catch (Exception e) { |
| fail(); |
| } |
| } |
| |
| public void testIsRatingBlocked() { |
| if (!Utils.hasTvInputFramework(getActivity())) { |
| return; |
| } |
| try { |
| mManager.isRatingBlocked(DUMMY_RATING); |
| } catch (Exception e) { |
| fail(); |
| } |
| } |
| |
| public void testRegisterUnregisterCallback() { |
| if (!Utils.hasTvInputFramework(getActivity())) { |
| return; |
| } |
| getActivity().runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| mManager.registerCallback(mCallback, new Handler()); |
| mManager.unregisterCallback(mCallback); |
| } catch (Exception e) { |
| fail(); |
| } |
| } |
| }); |
| getInstrumentation().waitForIdleSync(); |
| } |
| |
| public void testInputAddedAndRemoved() { |
| if (!Utils.hasTvInputFramework(getActivity())) { |
| return; |
| } |
| getActivity().runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mManager.registerCallback(mCallback, new Handler()); |
| } |
| }); |
| getInstrumentation().waitForIdleSync(); |
| |
| // Test if onInputRemoved() is called. |
| mCallback.resetLogs(); |
| PackageManager pm = getActivity().getPackageManager(); |
| ComponentName component = new ComponentName(getActivity(), StubTvInputService2.class); |
| assertTrue(PackageManager.COMPONENT_ENABLED_STATE_DISABLED != pm.getComponentEnabledSetting( |
| component)); |
| pm.setComponentEnabledSetting(component, PackageManager.COMPONENT_ENABLED_STATE_DISABLED, |
| PackageManager.DONT_KILL_APP); |
| new PollingCheck(TIME_OUT_MS) { |
| @Override |
| protected boolean check() { |
| return mCallback.isInputRemoved(mStubId); |
| } |
| }.run(); |
| |
| // Test if onInputAdded() is called. |
| mCallback.resetLogs(); |
| assertEquals(PackageManager.COMPONENT_ENABLED_STATE_DISABLED, pm.getComponentEnabledSetting( |
| component)); |
| pm.setComponentEnabledSetting(component, PackageManager.COMPONENT_ENABLED_STATE_ENABLED, |
| PackageManager.DONT_KILL_APP); |
| new PollingCheck(TIME_OUT_MS) { |
| @Override |
| protected boolean check() { |
| return mCallback.isInputAdded(mStubId); |
| } |
| }.run(); |
| |
| getActivity().runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mManager.unregisterCallback(mCallback); |
| } |
| }); |
| getInstrumentation().waitForIdleSync(); |
| } |
| |
| public void testTvInputInfoUpdated() throws IOException, XmlPullParserException { |
| if (!Utils.hasTvInputFramework(getActivity())) { |
| return; |
| } |
| getActivity().runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mManager.registerCallback(mCallback, new Handler()); |
| } |
| }); |
| getInstrumentation().waitForIdleSync(); |
| |
| mCallback.resetLogs(); |
| TvInputInfo defaultInfo = new TvInputInfo.Builder(getActivity(), |
| new ComponentName(getActivity(), StubTunerTvInputService.class)).build(); |
| TvInputInfo updatedInfo = new TvInputInfo.Builder(getActivity(), |
| new ComponentName(getActivity(), StubTunerTvInputService.class)) |
| .setTunerCount(10).setCanRecord(true).setCanPauseRecording(false).build(); |
| |
| mManager.updateTvInputInfo(updatedInfo); |
| new PollingCheck(TIME_OUT_MS) { |
| @Override |
| protected boolean check() { |
| TvInputInfo info = mCallback.getLastUpdatedTvInputInfo(); |
| return info != null && info.getTunerCount() == 10 && info.canRecord() |
| && !info.canPauseRecording(); |
| } |
| }.run(); |
| |
| mManager.updateTvInputInfo(defaultInfo); |
| new PollingCheck(TIME_OUT_MS) { |
| @Override |
| protected boolean check() { |
| TvInputInfo info = mCallback.getLastUpdatedTvInputInfo(); |
| return info != null && info.getTunerCount() == 1 && !info.canRecord() |
| && info.canPauseRecording(); |
| } |
| }.run(); |
| |
| getActivity().runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mManager.unregisterCallback(mCallback); |
| } |
| }); |
| getInstrumentation().waitForIdleSync(); |
| } |
| |
| public void testAcquireTvInputHardware() { |
| if (!Utils.hasTvInputFramework(getActivity()) || mManager == null) { |
| return; |
| } |
| |
| String[] newPermissions = Arrays.copyOf( |
| BASE_SHELL_PERMISSIONS, BASE_SHELL_PERMISSIONS.length + 1); |
| newPermissions[BASE_SHELL_PERMISSIONS.length] = PERMISSION_TV_INPUT_HARDWARE; |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .adoptShellPermissionIdentity(newPermissions); |
| |
| // Update hardware device list |
| int deviceId = 0; |
| boolean hardwareDeviceAdded = false; |
| List<TvInputHardwareInfo> hardwareList = mManager.getHardwareList(); |
| if (hardwareList == null || hardwareList.isEmpty()) { |
| // Use the test api to add an HDMI hardware device |
| mManager.addHardwareDevice(deviceId); |
| hardwareDeviceAdded = true; |
| } else { |
| deviceId = hardwareList.get(0).getDeviceId(); |
| } |
| |
| // Acquire Hardware with a record client |
| HardwareCallback callback = new HardwareCallback() { |
| @Override |
| public void onReleased() {} |
| |
| @Override |
| public void onStreamConfigChanged(TvStreamConfig[] configs) {} |
| }; |
| CallbackExecutor executor = new CallbackExecutor(); |
| Hardware hardware = mManager.acquireTvInputHardware( |
| deviceId, mStubTvInputInfo, null /*tvInputSessionId*/, |
| TvInputService.PRIORITY_HINT_USE_CASE_TYPE_PLAYBACK, |
| executor, callback); |
| assertNotNull(hardware); |
| |
| // Acquire the same device with a LIVE client |
| Hardware hardwareAcquired = mManager.acquireTvInputHardware( |
| deviceId, mStubTvInputInfo, null /*tvInputSessionId*/, |
| TvInputService.PRIORITY_HINT_USE_CASE_TYPE_LIVE, |
| executor, callback); |
| |
| assertNotNull(hardwareAcquired); |
| |
| // Clean up |
| if (hardwareDeviceAdded) { |
| mManager.removeHardwareDevice(deviceId); |
| } |
| // Restore the base shell permissions |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .adoptShellPermissionIdentity(BASE_SHELL_PERMISSIONS); |
| } |
| |
| public void testTvInputHardwareOverrideAudioSink() { |
| if (!Utils.hasTvInputFramework(getActivity()) || mManager == null) { |
| return; |
| } |
| |
| // Update hardware device list |
| int deviceId = 0; |
| boolean hardwareDeviceAdded = false; |
| List<TvInputHardwareInfo> hardwareList = mManager.getHardwareList(); |
| if (hardwareList == null || hardwareList.isEmpty()) { |
| // Use the test api to add an HDMI hardware device |
| mManager.addHardwareDevice(deviceId); |
| hardwareDeviceAdded = true; |
| } else { |
| deviceId = hardwareList.get(0).getDeviceId(); |
| } |
| |
| // Acquire Hardware with a record client |
| HardwareCallback callback = new HardwareCallback() { |
| @Override |
| public void onReleased() { |
| } |
| |
| @Override |
| public void onStreamConfigChanged(TvStreamConfig[] configs) { |
| } |
| }; |
| CallbackExecutor executor = new CallbackExecutor(); |
| Hardware hardware = mManager.acquireTvInputHardware( |
| deviceId, mStubTvInputInfo, null /*tvInputSessionId*/, |
| TvInputService.PRIORITY_HINT_USE_CASE_TYPE_PLAYBACK, |
| executor, callback); |
| if (hardware == null) { |
| return; |
| } |
| |
| // Override audio sink |
| try { |
| AudioManager am = mActivity.getSystemService(AudioManager.class); |
| AudioDeviceInfo[] deviceInfos = am.getDevices(AudioManager.GET_DEVICES_OUTPUTS); |
| if (deviceInfos.length > 0) { |
| // test available overrideAudioSink APIs |
| hardware.overrideAudioSink(deviceInfos[0], 0, |
| AudioFormat.CHANNEL_OUT_DEFAULT, AudioFormat.ENCODING_DEFAULT); |
| hardware.overrideAudioSink(deviceInfos[0].getType(), deviceInfos[0].getAddress(), 0, |
| AudioFormat.CHANNEL_OUT_DEFAULT, AudioFormat.ENCODING_DEFAULT); |
| } |
| } catch (Exception e) { |
| fail(); |
| } finally { |
| if (hardwareDeviceAdded) { |
| mManager.removeHardwareDevice(deviceId); |
| } |
| } |
| } |
| |
| public void testGetAvailableExtensionInterfaceNames() { |
| if (!Utils.hasTvInputFramework(getActivity())) { |
| return; |
| } |
| |
| try { |
| String inputId = prepareStubHardwareTvInputService(); |
| |
| StubHardwareTvInputService.injectAvailableExtensionInterface( |
| EXTENSION_INTERFACE_NAME_WITHOUT_PERMISSION, null); |
| StubHardwareTvInputService.injectAvailableExtensionInterface( |
| EXTENSION_INTERFACE_NAME_WITH_PERMISSION_GRANTED, PERMISSION_GRANTED); |
| StubHardwareTvInputService.injectAvailableExtensionInterface( |
| EXTENSION_INTERFACE_NAME_WITH_PERMISSION_UNGRANTED, PERMISSION_UNGRANTED); |
| |
| List<String> names = mManager.getAvailableExtensionInterfaceNames(inputId); |
| assertTrue(names != null && !names.isEmpty()); |
| assertTrue(names.contains(EXTENSION_INTERFACE_NAME_WITHOUT_PERMISSION)); |
| assertTrue(names.contains(EXTENSION_INTERFACE_NAME_WITH_PERMISSION_GRANTED)); |
| assertFalse(names.contains(EXTENSION_INTERFACE_NAME_WITH_PERMISSION_UNGRANTED)); |
| |
| StubHardwareTvInputService.clearAvailableExtensionInterfaces(); |
| |
| names = mManager.getAvailableExtensionInterfaceNames(inputId); |
| assertTrue(names != null && names.isEmpty()); |
| } finally { |
| StubHardwareTvInputService.clearAvailableExtensionInterfaces(); |
| cleanupStubHardwareTvInputService(); |
| } |
| } |
| |
| public void testGetExtensionInterface() { |
| if (!Utils.hasTvInputFramework(getActivity())) { |
| return; |
| } |
| |
| try { |
| String inputId = prepareStubHardwareTvInputService(); |
| |
| StubHardwareTvInputService.injectAvailableExtensionInterface( |
| EXTENSION_INTERFACE_NAME_WITHOUT_PERMISSION, null); |
| StubHardwareTvInputService.injectAvailableExtensionInterface( |
| EXTENSION_INTERFACE_NAME_WITH_PERMISSION_GRANTED, PERMISSION_GRANTED); |
| StubHardwareTvInputService.injectAvailableExtensionInterface( |
| EXTENSION_INTERFACE_NAME_WITH_PERMISSION_UNGRANTED, PERMISSION_UNGRANTED); |
| |
| assertNotNull(mManager.getExtensionInterface(inputId, |
| EXTENSION_INTERFACE_NAME_WITHOUT_PERMISSION)); |
| assertNotNull(mManager.getExtensionInterface(inputId, |
| EXTENSION_INTERFACE_NAME_WITH_PERMISSION_GRANTED)); |
| assertNull(mManager.getExtensionInterface(inputId, |
| EXTENSION_INTERFACE_NAME_WITH_PERMISSION_UNGRANTED)); |
| } finally { |
| StubHardwareTvInputService.clearAvailableExtensionInterfaces(); |
| cleanupStubHardwareTvInputService(); |
| } |
| } |
| |
| public void testGetClientPriority() { |
| if (!Utils.hasTvInputFramework(getActivity()) || !Utils.hasTunerFeature(getActivity())) { |
| return; |
| } |
| |
| // Use the test api to get priorities in tunerResourceManagerUseCaseConfig.xml |
| TunerResourceManager trm = (TunerResourceManager) getActivity() |
| .getSystemService(Context.TV_TUNER_RESOURCE_MGR_SERVICE); |
| int fgLivePriority = trm.getConfigPriority(TvInputService.PRIORITY_HINT_USE_CASE_TYPE_LIVE, |
| true); |
| int bgLivePriority = trm.getConfigPriority(TvInputService.PRIORITY_HINT_USE_CASE_TYPE_LIVE, |
| false); |
| int fgDefaultPriority = trm.getConfigPriority(PRIORITY_HINT_USE_CASE_TYPE_INVALID, true); |
| int bgDefaultPriority = trm.getConfigPriority(PRIORITY_HINT_USE_CASE_TYPE_INVALID, false); |
| boolean isForeground = checkIsForeground(android.os.Process.myPid()); |
| |
| int priority = mManager.getClientPriority(TvInputService.PRIORITY_HINT_USE_CASE_TYPE_LIVE); |
| assertTrue(priority == (isForeground ? fgLivePriority : bgLivePriority)); |
| |
| try { |
| priority = mManager.getClientPriority( |
| PRIORITY_HINT_USE_CASE_TYPE_INVALID /* invalid use case type */); |
| } catch (IllegalArgumentException e) { |
| // pass |
| } |
| |
| Handler handler = new Handler(Looper.getMainLooper()); |
| final SessionCallback sessionCallback = new SessionCallback(); |
| mManager.createSession(mStubId, sessionCallback, handler); |
| PollingCheck.waitFor(TIME_OUT_MS, () -> sessionCallback.getSession() != null); |
| Session session = sessionCallback.getSession(); |
| String sessionId = StubTvInputService2.getSessionId(); |
| assertNotNull(sessionId); |
| |
| priority = mManager.getClientPriority( |
| TvInputService.PRIORITY_HINT_USE_CASE_TYPE_LIVE, sessionId /* valid sessionId */); |
| assertTrue(priority == (isForeground ? fgLivePriority : bgLivePriority)); |
| |
| try { |
| priority = mManager.getClientPriority( |
| PRIORITY_HINT_USE_CASE_TYPE_INVALID /* invalid use case type */, |
| sessionId /* valid sessionId */); |
| } catch (IllegalArgumentException e) { |
| // pass |
| } |
| |
| session.release(); |
| PollingCheck.waitFor(TIME_OUT_MS, () -> StubTvInputService2.getSessionId() == null); |
| |
| priority = mManager.getClientPriority( |
| TvInputService.PRIORITY_HINT_USE_CASE_TYPE_LIVE, sessionId /* invalid sessionId */); |
| assertTrue(priority == bgLivePriority); |
| |
| try { |
| priority = mManager.getClientPriority( |
| PRIORITY_HINT_USE_CASE_TYPE_INVALID /* invalid use case type */, |
| sessionId /* invalid sessionId */); |
| } catch (IllegalArgumentException e) { |
| // pass |
| } |
| } |
| |
| public void testGetClientPid() { |
| if (!Utils.hasTvInputFramework(getActivity())) { |
| return; |
| } |
| |
| Handler handler = new Handler(Looper.getMainLooper()); |
| final SessionCallback sessionCallback = new SessionCallback(); |
| mManager.createSession(mStubId, sessionCallback, handler); |
| PollingCheck.waitFor(TIME_OUT_MS, () -> sessionCallback.getSession() != null); |
| Session session = sessionCallback.getSession(); |
| String sessionId = StubTvInputService2.getSessionId(); |
| assertNotNull(sessionId); |
| |
| int pid = mManager.getClientPid(sessionId); |
| assertTrue(pid == android.os.Process.myPid()); |
| |
| session.release(); |
| PollingCheck.waitFor(TIME_OUT_MS, () -> StubTvInputService2.getSessionId() == null); |
| } |
| |
| private static class LoggingCallback extends TvInputManager.TvInputCallback { |
| private final List<String> mAddedInputs = new ArrayList<>(); |
| private final List<String> mRemovedInputs = new ArrayList<>(); |
| private TvInputInfo mLastUpdatedTvInputInfo; |
| private List<TunedInfo> mTunedInfos; |
| |
| @Override |
| public synchronized void onInputAdded(String inputId) { |
| mAddedInputs.add(inputId); |
| } |
| |
| @Override |
| public synchronized void onInputRemoved(String inputId) { |
| mRemovedInputs.add(inputId); |
| } |
| |
| @Override |
| public synchronized void onTvInputInfoUpdated(TvInputInfo info) { |
| mLastUpdatedTvInputInfo = info; |
| } |
| |
| @Override |
| public synchronized void onCurrentTunedInfosUpdated( |
| List<TunedInfo> tunedInfos) { |
| super.onCurrentTunedInfosUpdated(tunedInfos); |
| mTunedInfos = tunedInfos; |
| } |
| |
| public synchronized void resetLogs() { |
| mAddedInputs.clear(); |
| mRemovedInputs.clear(); |
| mLastUpdatedTvInputInfo = null; |
| } |
| |
| public synchronized boolean isInputAdded(String inputId) { |
| return mRemovedInputs.isEmpty() && mAddedInputs.size() == 1 && mAddedInputs.contains( |
| inputId); |
| } |
| |
| public synchronized boolean isInputRemoved(String inputId) { |
| return mAddedInputs.isEmpty() && mRemovedInputs.size() == 1 && mRemovedInputs.contains( |
| inputId); |
| } |
| |
| public synchronized TvInputInfo getLastUpdatedTvInputInfo() { |
| return mLastUpdatedTvInputInfo; |
| } |
| } |
| |
| public static class StubTvInputService2 extends StubTvInputService { |
| static String sTvInputSessionId; |
| |
| public static String getSessionId() { |
| return sTvInputSessionId; |
| } |
| |
| @Override |
| public Session onCreateSession(String inputId, String tvInputSessionId) { |
| sTvInputSessionId = tvInputSessionId; |
| return new StubSessionImpl2(this); |
| } |
| |
| public static class StubSessionImpl2 extends StubTvInputService.StubSessionImpl { |
| StubSessionImpl2(Context context) { |
| super(context); |
| } |
| |
| @Override |
| public void onRelease() { |
| sTvInputSessionId = null; |
| } |
| } |
| } |
| |
| public static class StubHardwareTvInputService extends TvInputService { |
| private static final Map<String, String> sAvailableExtensionInterfaceMap = new HashMap<>(); |
| |
| private ResolveInfo mResolveInfo = null; |
| private TvInputInfo mTvInputInfo = null; |
| |
| public static void clearAvailableExtensionInterfaces() { |
| sAvailableExtensionInterfaceMap.clear(); |
| } |
| |
| public static void injectAvailableExtensionInterface(String name, String permission) { |
| sAvailableExtensionInterfaceMap.put(name, permission); |
| } |
| |
| @Override |
| public void onCreate() { |
| mResolveInfo = getPackageManager().resolveService( |
| new Intent(SERVICE_INTERFACE).setClass(this, getClass()), |
| PackageManager.GET_SERVICES | PackageManager.GET_META_DATA); |
| } |
| |
| @Override |
| public TvInputInfo onHardwareAdded(TvInputHardwareInfo hardwareInfo) { |
| TvInputInfo info = null; |
| if (hardwareInfo.getDeviceId() == DUMMY_DEVICE_ID) { |
| info = new TvInputInfo.Builder(this, mResolveInfo) |
| .setTvInputHardwareInfo(hardwareInfo) |
| .build(); |
| mTvInputInfo = info; |
| } |
| return info; |
| } |
| |
| @Override |
| public String onHardwareRemoved(TvInputHardwareInfo hardwareInfo) { |
| String inputId = null; |
| if (hardwareInfo.getDeviceId() == DUMMY_DEVICE_ID && mTvInputInfo != null) { |
| inputId = mTvInputInfo.getId(); |
| mTvInputInfo = null; |
| } |
| return inputId; |
| } |
| |
| @Override |
| public Session onCreateSession(String inputId) { |
| return null; |
| } |
| |
| @Override |
| public List<String> getAvailableExtensionInterfaceNames() { |
| super.getAvailableExtensionInterfaceNames(); |
| return new ArrayList<>(sAvailableExtensionInterfaceMap.keySet()); |
| } |
| |
| @Override |
| public String getExtensionInterfacePermission(String name) { |
| super.getExtensionInterfacePermission(name); |
| return sAvailableExtensionInterfaceMap.get(name); |
| } |
| |
| @Override |
| public IBinder getExtensionInterface(String name) { |
| super.getExtensionInterface(name); |
| if (sAvailableExtensionInterfaceMap.containsKey(name)) { |
| return new Binder(); |
| } else { |
| return null; |
| } |
| } |
| } |
| |
| public class CallbackExecutor implements Executor { |
| @Override |
| public void execute(Runnable r) { |
| r.run(); |
| } |
| } |
| |
| private class SessionCallback extends TvInputManager.SessionCallback { |
| private TvInputManager.Session mSession; |
| |
| public TvInputManager.Session getSession() { |
| return mSession; |
| } |
| |
| @Override |
| public void onSessionCreated(TvInputManager.Session session) { |
| mSession = session; |
| } |
| } |
| |
| private boolean checkIsForeground(int pid) { |
| ActivityManager am = (ActivityManager) getActivity() |
| .getSystemService(Context.ACTIVITY_SERVICE); |
| List<RunningAppProcessInfo> appProcesses = am.getRunningAppProcesses(); |
| if (appProcesses == null) { |
| return false; |
| } |
| for (RunningAppProcessInfo appProcess : appProcesses) { |
| if (appProcess.pid == pid |
| && appProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) { |
| return true; |
| } |
| } |
| return false; |
| } |
| } |
