diff --git a/core/java/android/hardware/hdmi/HdmiControlManager.java b/core/java/android/hardware/hdmi/HdmiControlManager.java
index a7734f5446076..a98b31ad6a5e2 100644
--- a/core/java/android/hardware/hdmi/HdmiControlManager.java
+++ b/core/java/android/hardware/hdmi/HdmiControlManager.java
@@ -55,6 +55,10 @@ public final class HdmiControlManager {
@Nullable private final IHdmiControlService mService;
+ private static final int INVALID_PHYSICAL_ADDRESS = 0xFFFF;
+
+ private int mPhysicalAddress = INVALID_PHYSICAL_ADDRESS;
+
/**
* Broadcast Action: Display OSD message.
* Send when the service has a message to display on screen for events
@@ -505,13 +509,40 @@ public final class HdmiControlManager {
* @hide
*/
public int getPhysicalAddress() {
+ if (mPhysicalAddress != INVALID_PHYSICAL_ADDRESS) {
+ return mPhysicalAddress;
+ }
try {
- return mService.getPhysicalAddress();
+ mPhysicalAddress = mService.getPhysicalAddress();
+ return mPhysicalAddress;
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
+ /**
+ * Check if the target device is connected to the current device. The
+ * API also returns true if the current device is the target.
+ *
+ * @param targetDevice {@link HdmiDeviceInfo} of the target device.
+ * @return true if {@code device} is directly or indirectly connected to the
+ *
+ * TODO(b/110094868): unhide for Q
+ * @hide
+ */
+ public boolean isTargetDeviceConnected(HdmiDeviceInfo targetDevice) {
+ mPhysicalAddress = getPhysicalAddress();
+ if (mPhysicalAddress == INVALID_PHYSICAL_ADDRESS) {
+ return false;
+ }
+ int targetPhysicalAddress = targetDevice.getPhysicalAddress();
+ if (targetPhysicalAddress == INVALID_PHYSICAL_ADDRESS) {
+ return false;
+ }
+ return HdmiUtils.getLocalPortFromPhysicalAddress(targetPhysicalAddress, mPhysicalAddress)
+ != HdmiUtils.TARGET_NOT_UNDER_LOCAL_DEVICE;
+ }
+
/**
* Listener used to get hotplug event from HDMI port.
*/
diff --git a/core/java/android/hardware/hdmi/HdmiUtils.java b/core/java/android/hardware/hdmi/HdmiUtils.java
new file mode 100644
index 0000000000000..308173816f13d
--- /dev/null
+++ b/core/java/android/hardware/hdmi/HdmiUtils.java
@@ -0,0 +1,81 @@
+/*
+ * 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.hardware.hdmi;
+
+/**
+ * Various utilities to handle HDMI CEC messages.
+ *
+ * TODO(b/110094868): unhide for Q
+ * @hide
+ */
+public class HdmiUtils {
+
+ /**
+ * Return value of {@link #getLocalPortFromPhysicalAddress(int, int)}
+ */
+ static final int TARGET_NOT_UNDER_LOCAL_DEVICE = -1;
+ static final int TARGET_SAME_PHYSICAL_ADDRESS = 0;
+
+ private HdmiUtils() { /* cannot be instantiated */ }
+
+ /**
+ * Method to parse target physical address to the port number on the current device.
+ *
+ *
This check assumes target address is valid.
+ *
+ * @param targetPhysicalAddress is the physical address of the target device
+ * @param myPhysicalAddress is the physical address of the current device
+ * @return
+ * If the target device is under the current device, return the port number of current device
+ * that the target device is connected to. This also applies to the devices that are indirectly
+ * connected to the current device.
+ *
+ *
If the target device has the same physical address as the current device, return
+ * {@link #TARGET_SAME_PHYSICAL_ADDRESS}.
+ *
+ *
If the target device is not under the current device, return
+ * {@link #TARGET_NOT_UNDER_LOCAL_DEVICE}.
+ */
+ public static int getLocalPortFromPhysicalAddress(
+ int targetPhysicalAddress, int myPhysicalAddress) {
+ if (myPhysicalAddress == targetPhysicalAddress) {
+ return TARGET_SAME_PHYSICAL_ADDRESS;
+ }
+
+ int mask = 0xF000;
+ int finalMask = 0xF000;
+ int maskedAddress = myPhysicalAddress;
+
+ while (maskedAddress != 0) {
+ maskedAddress = myPhysicalAddress & mask;
+ finalMask |= mask;
+ mask >>= 4;
+ }
+
+ int portAddress = targetPhysicalAddress & finalMask;
+ if ((portAddress & (finalMask << 4)) != myPhysicalAddress) {
+ return TARGET_NOT_UNDER_LOCAL_DEVICE;
+ }
+
+ mask <<= 4;
+ int port = portAddress & mask;
+ while ((port >> 4) != 0) {
+ port >>= 4;
+ }
+ return port;
+ }
+}
diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
index 73e90d6ee6283..757c03e132e6c 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -7731,6 +7731,23 @@ public final class Settings {
*/
public static final String TV_INPUT_CUSTOM_LABELS = "tv_input_custom_labels";
+ /**
+ * Whether TV app uses non-system inputs.
+ *
+ *
+ * The value is boolean (1 or 0), where 1 means non-system TV inputs are allowed,
+ * and 0 means non-system TV inputs are not allowed.
+ *
+ *
+ * Devices such as sound bars may have changed the system property allow_third_party_inputs
+ * to false so the TV Application only uses HDMI and other built in inputs. This setting
+ * allows user to override the default and have the TV Application use third party TV inputs
+ * available on play store.
+ *
+ * @hide
+ */
+ public static final String TV_APP_USES_NON_SYSTEM_INPUTS = "tv_app_uses_non_system_inputs";
+
/**
* Whether automatic routing of system audio to USB audio peripheral is disabled.
* The value is boolean (1 or 0), where 1 means automatic routing is disabled,
diff --git a/core/tests/coretests/src/android/hardware/hdmi/HdmiUtilsTest.java b/core/tests/coretests/src/android/hardware/hdmi/HdmiUtilsTest.java
new file mode 100644
index 0000000000000..16be0b0a27c16
--- /dev/null
+++ b/core/tests/coretests/src/android/hardware/hdmi/HdmiUtilsTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2018 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.hardware.hdmi;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.support.test.filters.SmallTest;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@SmallTest
+@RunWith(JUnit4.class)
+/** Tests for {@link HdmiUtils} class. */
+public class HdmiUtilsTest {
+
+ @Test
+ public void pathToPort_isMe() {
+ int targetPhysicalAddress = 0x1000;
+ int myPhysicalAddress = 0x1000;
+ assertThat(HdmiUtils.getLocalPortFromPhysicalAddress(
+ targetPhysicalAddress, myPhysicalAddress)).isEqualTo(
+ HdmiUtils.TARGET_SAME_PHYSICAL_ADDRESS);
+ }
+
+ @Test
+ public void pathToPort_isDirectlyBelow() {
+ int targetPhysicalAddress = 0x1100;
+ int myPhysicalAddress = 0x1000;
+ assertThat(HdmiUtils.getLocalPortFromPhysicalAddress(
+ targetPhysicalAddress, myPhysicalAddress)).isEqualTo(1);
+ }
+
+ @Test
+ public void pathToPort_isBelow() {
+ int targetPhysicalAddress = 0x1110;
+ int myPhysicalAddress = 0x1000;
+ assertThat(HdmiUtils.getLocalPortFromPhysicalAddress(
+ targetPhysicalAddress, myPhysicalAddress)).isEqualTo(1);
+ }
+
+ @Test
+ public void pathToPort_neitherMeNorBelow() {
+ int targetPhysicalAddress = 0x3000;
+ int myPhysicalAddress = 0x2000;
+ assertThat(HdmiUtils.getLocalPortFromPhysicalAddress(
+ targetPhysicalAddress, myPhysicalAddress)).isEqualTo(
+ HdmiUtils.TARGET_NOT_UNDER_LOCAL_DEVICE);
+
+ targetPhysicalAddress = 0x2200;
+ myPhysicalAddress = 0x3300;
+ assertThat(HdmiUtils.getLocalPortFromPhysicalAddress(
+ targetPhysicalAddress, myPhysicalAddress)).isEqualTo(
+ HdmiUtils.TARGET_NOT_UNDER_LOCAL_DEVICE);
+
+ targetPhysicalAddress = 0x2213;
+ myPhysicalAddress = 0x2212;
+ assertThat(HdmiUtils.getLocalPortFromPhysicalAddress(
+ targetPhysicalAddress, myPhysicalAddress)).isEqualTo(
+ HdmiUtils.TARGET_NOT_UNDER_LOCAL_DEVICE);
+
+ targetPhysicalAddress = 0x2340;
+ myPhysicalAddress = 0x2310;
+ assertThat(HdmiUtils.getLocalPortFromPhysicalAddress(
+ targetPhysicalAddress, myPhysicalAddress)).isEqualTo(
+ HdmiUtils.TARGET_NOT_UNDER_LOCAL_DEVICE);
+ }
+}
diff --git a/core/tests/coretests/src/android/provider/SettingsBackupTest.java b/core/tests/coretests/src/android/provider/SettingsBackupTest.java
index 13e548b2e6887..93af0130d74c1 100644
--- a/core/tests/coretests/src/android/provider/SettingsBackupTest.java
+++ b/core/tests/coretests/src/android/provider/SettingsBackupTest.java
@@ -668,6 +668,7 @@ public class SettingsBackupTest {
Settings.Secure.SMS_DEFAULT_APPLICATION,
Settings.Secure.SPELL_CHECKER_ENABLED, // Intentionally removed in Q
Settings.Secure.TRUST_AGENTS_INITIALIZED,
+ Settings.Secure.TV_APP_USES_NON_SYSTEM_INPUTS,
Settings.Secure.TV_INPUT_CUSTOM_LABELS,
Settings.Secure.TV_INPUT_HIDDEN_INPUTS,
Settings.Secure.TV_USER_SETUP_COMPLETE,
diff --git a/services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java b/services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java
index eb4e662b2c825..414f6bbfb9955 100755
--- a/services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java
+++ b/services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java
@@ -56,11 +56,6 @@ abstract class HdmiCecLocalDevice {
// Within the timer, a received will start "Press and Hold" behavior.
// When it expires, we can assume is received.
private static final int FOLLOWER_SAFETY_TIMEOUT = 550;
- /**
- * Return value of {@link #getLocalPortFromPhysicalAddress(int)}
- */
- private static final int TARGET_NOT_UNDER_LOCAL_DEVICE = -1;
- private static final int TARGET_SAME_PHYSICAL_ADDRESS = 0;
protected final HdmiControlService mService;
protected final int mDeviceType;
@@ -1061,47 +1056,6 @@ abstract class HdmiCecLocalDevice {
pw.println(String.format("mActiveRoutingPath: 0x%04x", mActiveRoutingPath));
}
- /**
- * Method to parse target physical address to the port number on the current device.
- *
- * This check assumes target address is valid.
- * @param targetPhysicalAddress is the physical address of the target device
- * @return
- * If the target device is under the current device, return the port number of current device
- * that the target device is connected to.
- *
- *
If the target device has the same physical address as the current device, return
- * {@link #TARGET_SAME_PHYSICAL_ADDRESS}.
- *
- *
If the target device is not under the current device, return
- * {@link #TARGET_NOT_UNDER_LOCAL_DEVICE}.
- */
- protected int getLocalPortFromPhysicalAddress(int targetPhysicalAddress) {
- int myPhysicalAddress = mService.getPhysicalAddress();
- if (myPhysicalAddress == targetPhysicalAddress) {
- return TARGET_SAME_PHYSICAL_ADDRESS;
- }
- int finalMask = 0xF000;
- int mask;
- int port = 0;
- for (mask = 0x0F00; mask > 0x000F; mask >>= 4) {
- if ((myPhysicalAddress & mask) == 0) {
- port = mask & targetPhysicalAddress;
- break;
- } else {
- finalMask |= mask;
- }
- }
- if (finalMask != 0xFFFF && (finalMask & targetPhysicalAddress) == myPhysicalAddress) {
- while (mask != 0x000F) {
- mask >>= 4;
- port >>= 4;
- }
- return port;
- }
- return TARGET_NOT_UNDER_LOCAL_DEVICE;
- }
-
/** Calculates the physical address for {@code activePortId}.
*
*
This method assumes current device physical address is valid.
diff --git a/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystem.java b/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystem.java
index 71075f3d71ce0..63214ed651b9a 100644
--- a/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystem.java
+++ b/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystem.java
@@ -41,7 +41,15 @@ import com.android.internal.util.IndentingPrintWriter;
import com.android.server.hdmi.Constants.AudioCodec;
import com.android.server.hdmi.DeviceDiscoveryAction.DeviceDiscoveryCallback;
import com.android.server.hdmi.HdmiAnnotations.ServiceThreadOnly;
+import com.android.server.hdmi.HdmiUtils.CodecSad;
+import com.android.server.hdmi.HdmiUtils.DeviceConfig;
+import org.xmlpull.v1.XmlPullParserException;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
@@ -105,6 +113,8 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
mTvInputs.put(1, "com.droidlogic.tvinput/.services.Hdmi3InputService/HW7");
}
+ private static final String SHORT_AUDIO_DESCRIPTOR_CONFIG_PATH = "/vendor/etc/sadConfig.xml";
+
/**
* Called when a device is newly added or a new device is detected or
* an existing device is updated.
@@ -258,7 +268,7 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
mTvSystemAudioModeSupport = false;
// Record the last state of System Audio Control before going to standby
synchronized (mLock) {
- SystemProperties.set(
+ mService.writeStringSetting(
Constants.PROPERTY_LAST_SYSTEM_AUDIO_CONTROL,
mSystemAudioActivated ? "true" : "false");
}
@@ -320,7 +330,7 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
@ServiceThreadOnly
protected void setPreferredAddress(int addr) {
assertRunOnServiceThread();
- SystemProperties.set(
+ mService.writeStringSetting(
Constants.PROPERTY_PREFERRED_ADDRESS_AUDIO_SYSTEM, String.valueOf(addr));
}
@@ -459,7 +469,7 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
protected boolean handleRequestArcInitiate(HdmiCecMessage message) {
assertRunOnServiceThread();
removeAction(ArcInitiationActionFromAvr.class);
- if (!SystemProperties.getBoolean(Constants.PROPERTY_ARC_SUPPORT, true)) {
+ if (!mService.readBooleanSetting(Constants.PROPERTY_ARC_SUPPORT, true)) {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_UNRECOGNIZED_OPCODE);
} else if (!isDirectConnectToTv()) {
HdmiLogger.debug("AVR device is not directly connected with TV");
@@ -498,13 +508,35 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_NOT_IN_CORRECT_MODE);
return true;
}
- AudioDeviceInfo deviceInfo = getSystemAudioDeviceInfo();
- if (deviceInfo == null) {
- mService.maySendFeatureAbortCommand(message, Constants.ABORT_UNABLE_TO_DETERMINE);
- return true;
+
+ List config = null;
+ File file = new File(SHORT_AUDIO_DESCRIPTOR_CONFIG_PATH);
+ if (file.exists()) {
+ try {
+ InputStream in = new FileInputStream(file);
+ config = HdmiUtils.ShortAudioDescriptorXmlParser.parse(in);
+ in.close();
+ } catch (IOException e) {
+ Slog.e(TAG, "Error reading file: " + file, e);
+ } catch (XmlPullParserException e) {
+ Slog.e(TAG, "Unable to parse file: " + file, e);
+ }
}
+
@AudioCodec int[] audioFormatCodes = parseAudioFormatCodes(message.getParams());
- byte[] sadBytes = getSupportedShortAudioDescriptors(deviceInfo, audioFormatCodes);
+ byte[] sadBytes;
+ if (config != null && config.size() > 0) {
+ sadBytes = getSupportedShortAudioDescriptorsFromConfig(config, audioFormatCodes);
+ } else {
+ AudioDeviceInfo deviceInfo = getSystemAudioDeviceInfo();
+ if (deviceInfo == null) {
+ mService.maySendFeatureAbortCommand(message, Constants.ABORT_UNABLE_TO_DETERMINE);
+ return true;
+ }
+
+ sadBytes = getSupportedShortAudioDescriptors(deviceInfo, audioFormatCodes);
+ }
+
if (sadBytes.length == 0) {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_INVALID_OPERAND);
} else {
@@ -531,6 +563,42 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
}
}
}
+ return getShortAudioDescriptorBytes(sads);
+ }
+
+ private byte[] getSupportedShortAudioDescriptorsFromConfig(
+ List deviceConfig, @AudioCodec int[] audioFormatCodes) {
+ DeviceConfig deviceConfigToUse = null;
+ for (DeviceConfig device : deviceConfig) {
+ // TODO(amyjojo) use PROPERTY_SYSTEM_AUDIO_MODE_AUDIO_PORT to get the audio device name
+ if (device.name.equals("VX_AUDIO_DEVICE_IN_HDMI_ARC")) {
+ deviceConfigToUse = device;
+ break;
+ }
+ }
+ if (deviceConfigToUse == null) {
+ // TODO(amyjojo) use PROPERTY_SYSTEM_AUDIO_MODE_AUDIO_PORT to get the audio device name
+ Slog.w(TAG, "sadConfig.xml does not have required device info for "
+ + "VX_AUDIO_DEVICE_IN_HDMI_ARC");
+ return new byte[0];
+ }
+ HashMap map = new HashMap<>();
+ ArrayList sads = new ArrayList<>(audioFormatCodes.length);
+ for (CodecSad codecSad : deviceConfigToUse.supportedCodecs) {
+ map.put(codecSad.audioCodec, codecSad.sad);
+ }
+ for (int i = 0; i < audioFormatCodes.length; i++) {
+ if (map.containsKey(audioFormatCodes[i])) {
+ byte[] sad = map.get(audioFormatCodes[i]);
+ if (sad != null && sad.length == 3) {
+ sads.add(sad);
+ }
+ }
+ }
+ return getShortAudioDescriptorBytes(sads);
+ }
+
+ private byte[] getShortAudioDescriptorBytes(ArrayList sads) {
// Short Audio Descriptors are always 3 bytes long.
byte[] bytes = new byte[sads.size() * 3];
int index = 0;
@@ -761,7 +829,7 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
boolean currentMuteStatus =
mService.getAudioManager().isStreamMute(AudioManager.STREAM_MUSIC);
if (currentMuteStatus == newSystemAudioMode) {
- if (SystemProperties.getBoolean(
+ if (mService.readBooleanSetting(
Constants.PROPERTY_SYSTEM_AUDIO_MODE_MUTING_ENABLE, true)
|| newSystemAudioMode) {
mService.getAudioManager()
diff --git a/services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java b/services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java
index 32288de15a002..7a0c279061228 100644
--- a/services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java
+++ b/services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java
@@ -100,7 +100,7 @@ public class HdmiCecLocalDevicePlayback extends HdmiCecLocalDeviceSource {
@ServiceThreadOnly
protected void setPreferredAddress(int addr) {
assertRunOnServiceThread();
- SystemProperties.set(Constants.PROPERTY_PREFERRED_ADDRESS_PLAYBACK,
+ mService.writeStringSetting(Constants.PROPERTY_PREFERRED_ADDRESS_PLAYBACK,
String.valueOf(addr));
}
diff --git a/services/core/java/com/android/server/hdmi/HdmiControlService.java b/services/core/java/com/android/server/hdmi/HdmiControlService.java
index 486faf3e9fa5b..46219d5cbe8ad 100644
--- a/services/core/java/com/android/server/hdmi/HdmiControlService.java
+++ b/services/core/java/com/android/server/hdmi/HdmiControlService.java
@@ -646,6 +646,7 @@ public class HdmiControlService extends SystemService {
return enabled ? ENABLED : DISABLED;
}
+ @VisibleForTesting
boolean readBooleanSetting(String key, boolean defVal) {
ContentResolver cr = getContext().getContentResolver();
return Global.getInt(cr, key, toInt(defVal)) == ENABLED;
@@ -656,6 +657,11 @@ public class HdmiControlService extends SystemService {
Global.putInt(cr, key, toInt(value));
}
+ void writeStringSetting(String key, String value) {
+ ContentResolver cr = getContext().getContentResolver();
+ Global.putString(cr, key, value);
+ }
+
private void initializeCec(int initiatedBy) {
mAddressAllocated = false;
mCecController.setOption(OptionKey.SYSTEM_CEC_CONTROL, true);
diff --git a/services/core/java/com/android/server/hdmi/HdmiUtils.java b/services/core/java/com/android/server/hdmi/HdmiUtils.java
index 11e557c024ce9..e44f1d1522ec1 100644
--- a/services/core/java/com/android/server/hdmi/HdmiUtils.java
+++ b/services/core/java/com/android/server/hdmi/HdmiUtils.java
@@ -16,23 +16,35 @@
package com.android.server.hdmi;
+import android.annotation.Nullable;
import android.hardware.hdmi.HdmiDeviceInfo;
import android.util.Slog;
import android.util.SparseArray;
+import android.util.Xml;
+import com.android.internal.util.HexDump;
import com.android.internal.util.IndentingPrintWriter;
+import com.android.server.hdmi.Constants.AudioCodec;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+import java.io.IOException;
+import java.io.InputStream;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
-
+import java.util.Objects;
/**
* Various utilities to handle HDMI CEC messages.
*/
final class HdmiUtils {
+ private static final String TAG = "HdmiUtils";
+
private static final int[] ADDRESS_TO_TYPE = {
HdmiDeviceInfo.DEVICE_TV, // ADDR_TV
HdmiDeviceInfo.DEVICE_RECORDER, // ADDR_RECORDER_1
@@ -69,6 +81,12 @@ final class HdmiUtils {
"Secondary_TV",
};
+ /**
+ * Return value of {@link #getLocalPortFromPhysicalAddress(int, int)}
+ */
+ static final int TARGET_NOT_UNDER_LOCAL_DEVICE = -1;
+ static final int TARGET_SAME_PHYSICAL_ADDRESS = 0;
+
private HdmiUtils() { /* cannot be instantiated */ }
/**
@@ -392,6 +410,203 @@ final class HdmiUtils {
pw.decreaseIndent();
}
+ /**
+ * Method to parse target physical address to the port number on the current device.
+ *
+ * This check assumes target address is valid.
+ *
+ * @param targetPhysicalAddress is the physical address of the target device
+ * @param myPhysicalAddress is the physical address of the current device
+ * @return
+ * If the target device is under the current device, return the port number of current device
+ * that the target device is connected to. This also applies to the devices that are indirectly
+ * connected to the current device.
+ *
+ *
If the target device has the same physical address as the current device, return
+ * {@link #TARGET_SAME_PHYSICAL_ADDRESS}.
+ *
+ *
If the target device is not under the current device, return
+ * {@link #TARGET_NOT_UNDER_LOCAL_DEVICE}.
+ */
+ public static int getLocalPortFromPhysicalAddress(
+ int targetPhysicalAddress, int myPhysicalAddress) {
+ if (myPhysicalAddress == targetPhysicalAddress) {
+ return TARGET_SAME_PHYSICAL_ADDRESS;
+ }
+
+ int mask = 0xF000;
+ int finalMask = 0xF000;
+ int maskedAddress = myPhysicalAddress;
+
+ while (maskedAddress != 0) {
+ maskedAddress = myPhysicalAddress & mask;
+ finalMask |= mask;
+ mask >>= 4;
+ }
+
+ int portAddress = targetPhysicalAddress & finalMask;
+ if ((portAddress & (finalMask << 4)) != myPhysicalAddress) {
+ return TARGET_NOT_UNDER_LOCAL_DEVICE;
+ }
+
+ mask <<= 4;
+ int port = portAddress & mask;
+ while ((port >> 4) != 0) {
+ port >>= 4;
+ }
+ return port;
+ }
+
+ public static class ShortAudioDescriptorXmlParser {
+ // We don't use namespaces
+ private static final String NS = null;
+
+ // return a list of devices config
+ public static List parse(InputStream in)
+ throws XmlPullParserException, IOException {
+ XmlPullParser parser = Xml.newPullParser();
+ parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, false);
+ parser.setInput(in, null);
+ parser.nextTag();
+ return readDevices(parser);
+ }
+
+ private static void skip(XmlPullParser parser) throws XmlPullParserException, IOException {
+ if (parser.getEventType() != XmlPullParser.START_TAG) {
+ throw new IllegalStateException();
+ }
+ int depth = 1;
+ while (depth != 0) {
+ switch (parser.next()) {
+ case XmlPullParser.END_TAG:
+ depth--;
+ break;
+ case XmlPullParser.START_TAG:
+ depth++;
+ break;
+ }
+ }
+ }
+
+ private static List readDevices(XmlPullParser parser)
+ throws XmlPullParserException, IOException {
+ List devices = new ArrayList<>();
+
+ parser.require(XmlPullParser.START_TAG, NS, "config");
+ while (parser.next() != XmlPullParser.END_TAG) {
+ if (parser.getEventType() != XmlPullParser.START_TAG) {
+ continue;
+ }
+ String name = parser.getName();
+ // Starts by looking for the device tag
+ if (name.equals("device")) {
+ String deviceType = parser.getAttributeValue(null, "type");
+ DeviceConfig config = null;
+ if (deviceType != null) {
+ config = readDeviceConfig(parser, deviceType);
+ }
+ if (config != null) {
+ devices.add(config);
+ }
+ } else {
+ skip(parser);
+ }
+ }
+ return devices;
+ }
+
+ // Processes device tags in the config.
+ @Nullable
+ private static DeviceConfig readDeviceConfig(XmlPullParser parser, String deviceType)
+ throws XmlPullParserException, IOException {
+ List codecSads = new ArrayList<>();
+ int format;
+ byte[] descriptor;
+
+ parser.require(XmlPullParser.START_TAG, NS, "device");
+ while (parser.next() != XmlPullParser.END_TAG) {
+ if (parser.getEventType() != XmlPullParser.START_TAG) {
+ continue;
+ }
+ String tagName = parser.getName();
+
+ // Starts by looking for the supportedFormat tag
+ if (tagName.equals("supportedFormat")) {
+ String codecAttriValue = parser.getAttributeValue(null, "format");
+ String sadAttriValue = parser.getAttributeValue(null, "descriptor");
+ format = (codecAttriValue) == null
+ ? Constants.AUDIO_CODEC_NONE : formatNameToNum(codecAttriValue);
+ descriptor = readSad(sadAttriValue);
+ if (format != Constants.AUDIO_CODEC_NONE && descriptor != null) {
+ codecSads.add(new CodecSad(format, descriptor));
+ }
+ parser.nextTag();
+ parser.require(XmlPullParser.END_TAG, NS, "supportedFormat");
+ } else {
+ skip(parser);
+ }
+ }
+ if (codecSads.size() == 0) {
+ return null;
+ }
+ return new DeviceConfig(deviceType, codecSads);
+ }
+
+ // Processes sad attribute in the supportedFormat.
+ @Nullable
+ private static byte[] readSad(String sad) {
+ if (sad == null || sad.length() == 0) {
+ return null;
+ }
+ byte[] sadBytes = HexDump.hexStringToByteArray(sad);
+ if (sadBytes.length != 3) {
+ Slog.w(TAG, "SAD byte array length is not 3. Length = " + sadBytes.length);
+ return null;
+ }
+ return sadBytes;
+ }
+
+ @AudioCodec
+ private static int formatNameToNum(String codecAttriValue) {
+ switch (codecAttriValue) {
+ case "AUDIO_FORMAT_NONE":
+ return Constants.AUDIO_CODEC_NONE;
+ case "AUDIO_FORMAT_LPCM":
+ return Constants.AUDIO_CODEC_LPCM;
+ case "AUDIO_FORMAT_DD":
+ return Constants.AUDIO_CODEC_DD;
+ case "AUDIO_FORMAT_MPEG1":
+ return Constants.AUDIO_CODEC_MPEG1;
+ case "AUDIO_FORMAT_MP3":
+ return Constants.AUDIO_CODEC_MP3;
+ case "AUDIO_FORMAT_MPEG2":
+ return Constants.AUDIO_CODEC_MPEG2;
+ case "AUDIO_FORMAT_AAC":
+ return Constants.AUDIO_CODEC_AAC;
+ case "AUDIO_FORMAT_DTS":
+ return Constants.AUDIO_CODEC_DTS;
+ case "AUDIO_FORMAT_ATRAC":
+ return Constants.AUDIO_CODEC_ATRAC;
+ case "AUDIO_FORMAT_ONEBITAUDIO":
+ return Constants.AUDIO_CODEC_ONEBITAUDIO;
+ case "AUDIO_FORMAT_DDP":
+ return Constants.AUDIO_CODEC_DDP;
+ case "AUDIO_FORMAT_DTSHD":
+ return Constants.AUDIO_CODEC_DTSHD;
+ case "AUDIO_FORMAT_TRUEHD":
+ return Constants.AUDIO_CODEC_TRUEHD;
+ case "AUDIO_FORMAT_DST":
+ return Constants.AUDIO_CODEC_DST;
+ case "AUDIO_FORMAT_WMAPRO":
+ return Constants.AUDIO_CODEC_WMAPRO;
+ case "AUDIO_FORMAT_MAX":
+ return Constants.AUDIO_CODEC_MAX;
+ default:
+ return Constants.AUDIO_CODEC_NONE;
+ }
+ }
+ }
+
// Device configuration of its supported Codecs and their Short Audio Descriptors.
public static class DeviceConfig {
/** Name of the device. Should be {@link Constants.AudioDevice}. **/
@@ -399,10 +614,27 @@ final class HdmiUtils {
/** List of a {@link CodecSad}. **/
public final List supportedCodecs;
- private DeviceConfig(String name, List supportedCodecs) {
+ public DeviceConfig(String name, List supportedCodecs) {
this.name = name;
this.supportedCodecs = supportedCodecs;
}
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof DeviceConfig) {
+ DeviceConfig that = (DeviceConfig) obj;
+ return that.name.equals(this.name)
+ && that.supportedCodecs.equals(this.supportedCodecs);
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(
+ name,
+ supportedCodecs.hashCode());
+ }
}
// Short Audio Descriptor of a specific Codec
@@ -419,5 +651,27 @@ final class HdmiUtils {
this.audioCodec = audioCodec;
this.sad = sad;
}
+
+ public CodecSad(int audioCodec, String sad) {
+ this.audioCodec = audioCodec;
+ this.sad = HexDump.hexStringToByteArray(sad);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof CodecSad) {
+ CodecSad that = (CodecSad) obj;
+ return that.audioCodec == this.audioCodec
+ && Arrays.equals(that.sad, this.sad);
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(
+ audioCodec,
+ Arrays.hashCode(sad));
+ }
}
}
diff --git a/services/tests/servicestests/src/com/android/server/hdmi/ArcInitiationActionFromAvrTest.java b/services/tests/servicestests/src/com/android/server/hdmi/ArcInitiationActionFromAvrTest.java
index 8b0e8abf069d2..eb9b98ec65f72 100644
--- a/services/tests/servicestests/src/com/android/server/hdmi/ArcInitiationActionFromAvrTest.java
+++ b/services/tests/servicestests/src/com/android/server/hdmi/ArcInitiationActionFromAvrTest.java
@@ -30,6 +30,7 @@ import androidx.test.InstrumentationRegistry;
import androidx.test.filters.SmallTest;
import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -147,6 +148,7 @@ public class ArcInitiationActionFromAvrTest {
mTestLooper.dispatchAll();
}
+ @Ignore("b/120845532")
@Test
public void arcInitiation_requestActiveSource() {
mSendCecCommandSuccess = true;
diff --git a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecControllerTest.java b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecControllerTest.java
index 93a09dc3ff044..5d8131f35eb74 100644
--- a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecControllerTest.java
+++ b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecControllerTest.java
@@ -40,7 +40,6 @@ import androidx.test.filters.SmallTest;
import com.android.server.hdmi.HdmiCecController.AllocateAddressCallback;
import org.junit.Before;
-import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -142,7 +141,6 @@ public class HdmiCecControllerTest {
assertEquals(ADDR_UNREGISTERED, mLogicalAddress);
}
- @Ignore("b/110413065 Support multiple device types 4 and 5.")
@Test
public void testAllocatLogicalAddress_PlaybackPreferredNotOccupied() {
mHdmiCecController.allocateLogicalAddress(DEVICE_PLAYBACK, ADDR_PLAYBACK_1, mCallback);
@@ -158,7 +156,6 @@ public class HdmiCecControllerTest {
assertEquals(ADDR_PLAYBACK_2, mLogicalAddress);
}
- @Ignore("b/110413065 Support multiple device types 4 and 5.")
@Test
public void testAllocatLogicalAddress_PlaybackNoPreferredNotOcuppied() {
mHdmiCecController.allocateLogicalAddress(DEVICE_PLAYBACK, ADDR_UNREGISTERED, mCallback);
diff --git a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystemTest.java b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystemTest.java
index 3b51a2a70f831..3a6cdc2ad7c9f 100644
--- a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystemTest.java
+++ b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystemTest.java
@@ -21,6 +21,7 @@ import static android.hardware.hdmi.HdmiControlManager.DEVICE_EVENT_UPDATE_DEVIC
import static com.android.server.hdmi.Constants.ADDR_AUDIO_SYSTEM;
import static com.android.server.hdmi.Constants.ADDR_BROADCAST;
import static com.android.server.hdmi.Constants.ADDR_PLAYBACK_1;
+import static com.android.server.hdmi.Constants.ADDR_PLAYBACK_2;
import static com.android.server.hdmi.Constants.ADDR_TUNER_1;
import static com.android.server.hdmi.Constants.ADDR_TV;
import static com.android.server.hdmi.HdmiControlService.INITIATED_BY_ENABLE_CEC;
@@ -29,9 +30,9 @@ import static com.android.server.hdmi.HdmiControlService.STANDBY_SCREEN_OFF;
import static com.google.common.truth.Truth.assertThat;
import android.hardware.hdmi.HdmiDeviceInfo;
+import android.hardware.hdmi.HdmiPortInfo;
import android.media.AudioManager;
import android.os.Looper;
-import android.os.SystemProperties;
import android.os.test.TestLooper;
import androidx.test.InstrumentationRegistry;
@@ -46,7 +47,6 @@ import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import java.util.ArrayList;
-
@SmallTest
@RunWith(JUnit4.class)
/** Tests for {@link HdmiCecLocalDeviceAudioSystem} class. */
@@ -67,9 +67,15 @@ public class HdmiCecLocalDeviceAudioSystemTest {
private int mMusicVolume;
private int mMusicMaxVolume;
private boolean mMusicMute;
- private int mAvrPhysicalAddress;
+ private static final int SELF_PHYSICAL_ADDRESS = 0x2000;
+ private static final int HDMI_1_PHYSICAL_ADDRESS = 0x2100;
+ private static final int HDMI_2_PHYSICAL_ADDRESS = 0x2200;
+ private static final int HDMI_3_PHYSICAL_ADDRESS = 0x2300;
private int mInvokeDeviceEventState;
private HdmiDeviceInfo mDeviceInfo;
+ private boolean mMutingEnabled;
+ private boolean mArcSupport;
+ private HdmiPortInfo[] mHdmiPortInfo;
@Before
public void setUp() {
@@ -141,9 +147,20 @@ public class HdmiCecLocalDeviceAudioSystemTest {
}
@Override
- int pathToPortId(int path) {
- // port id is not useful for the test right now
- return 1;
+ void writeStringSetting(String key, String value) {
+ // do nothing
+ }
+
+ @Override
+ boolean readBooleanSetting(String key, boolean defVal) {
+ switch (key) {
+ case Constants.PROPERTY_SYSTEM_AUDIO_MODE_MUTING_ENABLE:
+ return mMutingEnabled;
+ case Constants.PROPERTY_ARC_SUPPORT:
+ return mArcSupport;
+ default:
+ return defVal;
+ }
}
};
@@ -154,11 +171,17 @@ public class HdmiCecLocalDeviceAudioSystemTest {
void setIsActiveSource(boolean on) {
mIsActiveSource = on;
}
+
+ @Override
+ protected int getPreferredAddress() {
+ return ADDR_PLAYBACK_1;
+ }
};
mHdmiCecLocalDeviceAudioSystem.init();
mHdmiCecLocalDevicePlayback.init();
mHdmiControlService.setIoLooper(mMyLooper);
mNativeWrapper = new FakeNativeWrapper();
+ mNativeWrapper.setPhysicalAddress(SELF_PHYSICAL_ADDRESS);
mHdmiCecController =
HdmiCecController.createWithNativeWrapper(mHdmiControlService, mNativeWrapper);
mHdmiControlService.setCecController(mHdmiCecController);
@@ -166,15 +189,28 @@ public class HdmiCecLocalDeviceAudioSystemTest {
mHdmiControlService.setMessageValidator(new HdmiCecMessageValidator(mHdmiControlService));
mLocalDevices.add(mHdmiCecLocalDeviceAudioSystem);
mLocalDevices.add(mHdmiCecLocalDevicePlayback);
+ mHdmiCecLocalDeviceAudioSystem.setRoutingControlFeatureEnables(true);
+ mHdmiPortInfo = new HdmiPortInfo[4];
+ mHdmiPortInfo[0] =
+ new HdmiPortInfo(
+ 0, HdmiPortInfo.PORT_INPUT, SELF_PHYSICAL_ADDRESS, true, false, false);
+ mHdmiPortInfo[1] =
+ new HdmiPortInfo(
+ 2, HdmiPortInfo.PORT_INPUT, HDMI_1_PHYSICAL_ADDRESS, true, false, false);
+ mHdmiPortInfo[2] =
+ new HdmiPortInfo(
+ 1, HdmiPortInfo.PORT_INPUT, HDMI_2_PHYSICAL_ADDRESS, true, false, false);
+ mHdmiPortInfo[3] =
+ new HdmiPortInfo(
+ 4, HdmiPortInfo.PORT_INPUT, HDMI_3_PHYSICAL_ADDRESS, true, false, false);
+ mNativeWrapper.setPortInfo(mHdmiPortInfo);
mHdmiControlService.initPortInfo();
// No TV device interacts with AVR so system audio control won't be turned on here
mHdmiControlService.allocateLogicalAddress(mLocalDevices, INITIATED_BY_ENABLE_CEC);
mTestLooper.dispatchAll();
mNativeWrapper.clearResultMessages();
- mAvrPhysicalAddress = 0x2000;
- mNativeWrapper.setPhysicalAddress(mAvrPhysicalAddress);
- SystemProperties.set(Constants.PROPERTY_ARC_SUPPORT, "true");
- SystemProperties.set(Constants.PROPERTY_SYSTEM_AUDIO_MODE_MUTING_ENABLE, "true");
+ mMutingEnabled = true;
+ mArcSupport = true;
mInvokeDeviceEventState = 0;
mDeviceInfo = null;
}
@@ -244,6 +280,8 @@ public class HdmiCecLocalDeviceAudioSystemTest {
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
}
+ // Testing device has sadConfig.xml
+ @Ignore("b/120845532")
@Test
public void handleRequestShortAudioDescriptor_noAudioDeviceInfo() throws Exception {
HdmiCecMessage expectedMessage =
@@ -413,51 +451,6 @@ public class HdmiCecLocalDeviceAudioSystemTest {
assertThat(mNativeWrapper.getResultMessages()).contains(expectedMessage);
}
- @Test
- public void pathToPort_isMe() throws Exception {
- int targetPhysicalAddress = 0x1000;
- mNativeWrapper.setPhysicalAddress(0x1000);
- assertThat(mHdmiCecLocalDeviceAudioSystem
- .getLocalPortFromPhysicalAddress(targetPhysicalAddress))
- .isEqualTo(0);
- }
-
- @Test
- public void pathToPort_isBelow() throws Exception {
- int targetPhysicalAddress = 0x1100;
- mNativeWrapper.setPhysicalAddress(0x1000);
- assertThat(mHdmiCecLocalDeviceAudioSystem
- .getLocalPortFromPhysicalAddress(targetPhysicalAddress))
- .isEqualTo(1);
- }
-
- @Test
- public void pathToPort_neitherMeNorBelow() throws Exception {
- int targetPhysicalAddress = 0x3000;
- mNativeWrapper.setPhysicalAddress(0x2000);
- assertThat(mHdmiCecLocalDeviceAudioSystem
- .getLocalPortFromPhysicalAddress(targetPhysicalAddress))
- .isEqualTo(-1);
-
- targetPhysicalAddress = 0x2200;
- mNativeWrapper.setPhysicalAddress(0x3300);
- assertThat(mHdmiCecLocalDeviceAudioSystem
- .getLocalPortFromPhysicalAddress(targetPhysicalAddress))
- .isEqualTo(-1);
-
- targetPhysicalAddress = 0x2213;
- mNativeWrapper.setPhysicalAddress(0x2212);
- assertThat(mHdmiCecLocalDeviceAudioSystem
- .getLocalPortFromPhysicalAddress(targetPhysicalAddress))
- .isEqualTo(-1);
-
- targetPhysicalAddress = 0x2340;
- mNativeWrapper.setPhysicalAddress(0x2310);
- assertThat(mHdmiCecLocalDeviceAudioSystem
- .getLocalPortFromPhysicalAddress(targetPhysicalAddress))
- .isEqualTo(-1);
- }
-
@Test
public void handleRequestArcInitiate_isNotDirectConnectedToTv() throws Exception {
HdmiCecMessage message =
@@ -530,7 +523,7 @@ public class HdmiCecLocalDeviceAudioSystemTest {
ADDR_TV,
Constants.MESSAGE_REQUEST_ARC_INITIATION,
Constants.ABORT_UNRECOGNIZED_OPCODE);
- SystemProperties.set(Constants.PROPERTY_ARC_SUPPORT, "false");
+ mArcSupport = false;
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcInitiate(message)).isTrue();
mTestLooper.dispatchAll();
@@ -541,7 +534,7 @@ public class HdmiCecLocalDeviceAudioSystemTest {
HdmiCecMessage message =
HdmiCecMessageBuilder.buildSystemAudioModeRequest(
ADDR_TUNER_1, ADDR_AUDIO_SYSTEM,
- mAvrPhysicalAddress, true);
+ SELF_PHYSICAL_ADDRESS, true);
HdmiCecMessage expectedMessage =
HdmiCecMessageBuilder.buildFeatureAbortCommand(
ADDR_AUDIO_SYSTEM,
@@ -559,7 +552,7 @@ public class HdmiCecLocalDeviceAudioSystemTest {
HdmiCecMessage message =
HdmiCecMessageBuilder.buildSystemAudioModeRequest(
ADDR_TUNER_1, ADDR_AUDIO_SYSTEM,
- mAvrPhysicalAddress, true);
+ SELF_PHYSICAL_ADDRESS, true);
HdmiCecMessage expectedMessage =
HdmiCecMessageBuilder.buildSetSystemAudioMode(
ADDR_AUDIO_SYSTEM, Constants.ADDR_BROADCAST, true);
@@ -585,15 +578,14 @@ public class HdmiCecLocalDeviceAudioSystemTest {
.isEqualTo(expectedActiveSource);
}
- @Ignore("b/110413065 Support multiple device types 4 and 5.")
@Test
public void handleRoutingChange_currentActivePortIsHome() {
HdmiCecMessage message =
- HdmiCecMessageBuilder.buildRoutingChange(ADDR_TV, 0x3000, mAvrPhysicalAddress);
+ HdmiCecMessageBuilder.buildRoutingChange(ADDR_TV, 0x3000, SELF_PHYSICAL_ADDRESS);
HdmiCecMessage expectedMessage =
- HdmiCecMessageBuilder.buildActiveSource(ADDR_PLAYBACK_1, mAvrPhysicalAddress);
- ActiveSource expectedActiveSource = ActiveSource.of(ADDR_PLAYBACK_1, mAvrPhysicalAddress);
+ HdmiCecMessageBuilder.buildActiveSource(ADDR_PLAYBACK_1, SELF_PHYSICAL_ADDRESS);
+ ActiveSource expectedActiveSource = ActiveSource.of(ADDR_PLAYBACK_1, SELF_PHYSICAL_ADDRESS);
int expectedLocalActivePort = Constants.CEC_SWITCH_HOME;
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRoutingChange(message)).isTrue();
@@ -608,17 +600,18 @@ public class HdmiCecLocalDeviceAudioSystemTest {
@Test
public void handleRoutingInformation_currentActivePortIsHDMI1() {
HdmiCecMessage message =
- HdmiCecMessageBuilder.buildRoutingInformation(ADDR_TV, 0x2000);
- mHdmiCecLocalDeviceAudioSystem.setRoutingPort(Constants.CEC_SWITCH_HDMI1);
+ HdmiCecMessageBuilder.buildRoutingInformation(ADDR_TV, SELF_PHYSICAL_ADDRESS);
+ mHdmiCecLocalDeviceAudioSystem.setRoutingPort(mHdmiPortInfo[1].getId());
HdmiCecMessage expectedMessage =
- HdmiCecMessageBuilder.buildRoutingInformation(ADDR_AUDIO_SYSTEM, 0x2100);
+ HdmiCecMessageBuilder.buildRoutingInformation(
+ ADDR_AUDIO_SYSTEM, HDMI_1_PHYSICAL_ADDRESS);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRoutingInformation(message)).isTrue();
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
}
- @Ignore("b/110413065 Support multiple device types 4 and 5.")
+ @Ignore("b/120845532")
@Test
public void handleRoutingChange_homeIsActive_playbackSendActiveSource() {
HdmiCecMessage message =
@@ -667,7 +660,7 @@ public class HdmiCecLocalDeviceAudioSystemTest {
mHdmiCecLocalDeviceAudioSystem.addDeviceInfo(oldDevice);
HdmiDeviceInfo differentDevice = new HdmiDeviceInfo(
- ADDR_PLAYBACK_1, 0x2100, 4, HdmiDeviceInfo.DEVICE_PLAYBACK,
+ ADDR_PLAYBACK_1, 0x2300, 4, HdmiDeviceInfo.DEVICE_PLAYBACK,
Constants.UNKNOWN_VENDOR_ID, HdmiUtils.getDefaultDeviceName(ADDR_PLAYBACK_1));
mHdmiCecLocalDeviceAudioSystem.updateCecDevice(differentDevice);
@@ -686,14 +679,13 @@ public class HdmiCecLocalDeviceAudioSystemTest {
mHdmiCecLocalDeviceAudioSystem.addDeviceInfo(oldDevice);
HdmiDeviceInfo differentDevice = new HdmiDeviceInfo(
- ADDR_PLAYBACK_1, 0x2200, 1, HdmiDeviceInfo.DEVICE_PLAYBACK,
- Constants.UNKNOWN_VENDOR_ID, HdmiUtils.getDefaultDeviceName(ADDR_PLAYBACK_1));
+ ADDR_PLAYBACK_2, 0x2200, 1, HdmiDeviceInfo.DEVICE_PLAYBACK,
+ Constants.UNKNOWN_VENDOR_ID, HdmiUtils.getDefaultDeviceName(ADDR_PLAYBACK_2));
HdmiCecMessage reportPhysicalAddress = HdmiCecMessageBuilder
.buildReportPhysicalAddressCommand(
- ADDR_PLAYBACK_1, 0x2200, HdmiDeviceInfo.DEVICE_PLAYBACK);
+ ADDR_PLAYBACK_2, 0x2200, HdmiDeviceInfo.DEVICE_PLAYBACK);
mHdmiCecLocalDeviceAudioSystem.handleReportPhysicalAddress(reportPhysicalAddress);
- mHdmiCecLocalDeviceAudioSystem.addDeviceInfo(oldDevice);
mTestLooper.dispatchAll();
assertThat(mDeviceInfo).isEqualTo(differentDevice);
assertThat(mHdmiCecLocalDeviceAudioSystem
diff --git a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDevicePlaybackTest.java b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDevicePlaybackTest.java
index 792c617b99ea3..feae4eed7eb12 100644
--- a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDevicePlaybackTest.java
+++ b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDevicePlaybackTest.java
@@ -81,7 +81,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mNativeWrapper.setPhysicalAddress(mPlaybackPhysicalAddress);
}
- @Ignore
+ // Playback device does not handle routing control related feature right now
+ @Ignore("b/120845532")
@Test
public void handleSetStreamPath_underCurrentDevice() {
assertThat(mHdmiCecLocalDevicePlayback.getLocalActivePath()).isEqualTo(0);
diff --git a/services/tests/servicestests/src/com/android/server/hdmi/HdmiControlServiceTest.java b/services/tests/servicestests/src/com/android/server/hdmi/HdmiControlServiceTest.java
index 67ce13fdef726..1f660742122d5 100644
--- a/services/tests/servicestests/src/com/android/server/hdmi/HdmiControlServiceTest.java
+++ b/services/tests/servicestests/src/com/android/server/hdmi/HdmiControlServiceTest.java
@@ -179,6 +179,7 @@ public class HdmiControlServiceTest {
@Test
public void pathToPort_pathExists_weAreNonTv() {
mNativeWrapper.setPhysicalAddress(0x2000);
+ mHdmiControlService.initPortInfo();
assertThat(mHdmiControlService.pathToPortId(0x2120)).isEqualTo(1);
assertThat(mHdmiControlService.pathToPortId(0x2234)).isEqualTo(2);
}
@@ -186,6 +187,7 @@ public class HdmiControlServiceTest {
@Test
public void pathToPort_pathExists_weAreTv() {
mNativeWrapper.setPhysicalAddress(0x0000);
+ mHdmiControlService.initPortInfo();
assertThat(mHdmiControlService.pathToPortId(0x2120)).isEqualTo(3);
assertThat(mHdmiControlService.pathToPortId(0x3234)).isEqualTo(4);
}
@@ -193,6 +195,7 @@ public class HdmiControlServiceTest {
@Test
public void pathToPort_pathInvalid() {
mNativeWrapper.setPhysicalAddress(0x2000);
+ mHdmiControlService.initPortInfo();
assertThat(mHdmiControlService.pathToPortId(0x1000)).isEqualTo(Constants.INVALID_PORT_ID);
}
}
diff --git a/services/tests/servicestests/src/com/android/server/hdmi/HdmiUtilsTest.java b/services/tests/servicestests/src/com/android/server/hdmi/HdmiUtilsTest.java
new file mode 100644
index 0000000000000..985c6476d7671
--- /dev/null
+++ b/services/tests/servicestests/src/com/android/server/hdmi/HdmiUtilsTest.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2018 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.server.hdmi;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.util.Slog;
+
+import androidx.test.filters.SmallTest;
+
+import com.android.server.hdmi.HdmiUtils.CodecSad;
+import com.android.server.hdmi.HdmiUtils.DeviceConfig;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.xmlpull.v1.XmlPullParserException;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+@SmallTest
+@RunWith(JUnit4.class)
+/** Tests for {@link HdmiUtils} class. */
+public class HdmiUtilsTest {
+
+ private static final String TAG = "HdmiUtilsTest";
+
+ private final String mExampleXML =
+ ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + "";
+
+ @Test
+ public void pathToPort_isMe() {
+ int targetPhysicalAddress = 0x1000;
+ int myPhysicalAddress = 0x1000;
+ assertThat(HdmiUtils.getLocalPortFromPhysicalAddress(
+ targetPhysicalAddress, myPhysicalAddress)).isEqualTo(
+ HdmiUtils.TARGET_SAME_PHYSICAL_ADDRESS);
+ }
+
+ @Test
+ public void pathToPort_isDirectlyBelow() {
+ int targetPhysicalAddress = 0x1100;
+ int myPhysicalAddress = 0x1000;
+ assertThat(HdmiUtils.getLocalPortFromPhysicalAddress(
+ targetPhysicalAddress, myPhysicalAddress)).isEqualTo(1);
+ }
+
+ @Test
+ public void pathToPort_isBelow() {
+ int targetPhysicalAddress = 0x1110;
+ int myPhysicalAddress = 0x1000;
+ assertThat(HdmiUtils.getLocalPortFromPhysicalAddress(
+ targetPhysicalAddress, myPhysicalAddress)).isEqualTo(1);
+ }
+
+ @Test
+ public void pathToPort_neitherMeNorBelow() {
+ int targetPhysicalAddress = 0x3000;
+ int myPhysicalAddress = 0x2000;
+ assertThat(HdmiUtils.getLocalPortFromPhysicalAddress(
+ targetPhysicalAddress, myPhysicalAddress)).isEqualTo(
+ HdmiUtils.TARGET_NOT_UNDER_LOCAL_DEVICE);
+
+ targetPhysicalAddress = 0x2200;
+ myPhysicalAddress = 0x3300;
+ assertThat(HdmiUtils.getLocalPortFromPhysicalAddress(
+ targetPhysicalAddress, myPhysicalAddress)).isEqualTo(
+ HdmiUtils.TARGET_NOT_UNDER_LOCAL_DEVICE);
+
+ targetPhysicalAddress = 0x2213;
+ myPhysicalAddress = 0x2212;
+ assertThat(HdmiUtils.getLocalPortFromPhysicalAddress(
+ targetPhysicalAddress, myPhysicalAddress)).isEqualTo(
+ HdmiUtils.TARGET_NOT_UNDER_LOCAL_DEVICE);
+
+ targetPhysicalAddress = 0x2340;
+ myPhysicalAddress = 0x2310;
+ assertThat(HdmiUtils.getLocalPortFromPhysicalAddress(
+ targetPhysicalAddress, myPhysicalAddress)).isEqualTo(
+ HdmiUtils.TARGET_NOT_UNDER_LOCAL_DEVICE);
+ }
+
+ @Test
+ public void parseSampleXML() {
+ List config = new ArrayList<>();
+ try {
+ config = HdmiUtils.ShortAudioDescriptorXmlParser.parse(
+ new ByteArrayInputStream(mExampleXML.getBytes(StandardCharsets.UTF_8)));
+ } catch (IOException e) {
+ Slog.e(TAG, e.getMessage(), e);
+ } catch (XmlPullParserException e) {
+ Slog.e(TAG, e.getMessage(), e);
+ }
+
+ CodecSad expectedCodec1 = new CodecSad(Constants.AUDIO_CODEC_LPCM, "011a03");
+ CodecSad expectedCodec2 = new CodecSad(Constants.AUDIO_CODEC_DD, "0d0506");
+ CodecSad expectedCodec3 = new CodecSad(Constants.AUDIO_CODEC_LPCM, "010203");
+ CodecSad expectedCodec4 = new CodecSad(Constants.AUDIO_CODEC_DD, "040506");
+
+ List expectedList1 = new ArrayList<>();
+ expectedList1.add(expectedCodec1);
+ expectedList1.add(expectedCodec2);
+
+ List expectedList2 = new ArrayList<>();
+ expectedList2.add(expectedCodec3);
+ expectedList2.add(expectedCodec4);
+
+ DeviceConfig expectedDevice1 = new DeviceConfig(
+ "VX_AUDIO_DEVICE_IN_HDMI_ARC", expectedList1);
+ DeviceConfig expectedDevice2 = new DeviceConfig(
+ "AUDIO_DEVICE_IN_SPDIF", expectedList2);
+
+ List expectedConfig = new ArrayList<>();
+ expectedConfig.add(expectedDevice1);
+ expectedConfig.add(expectedDevice2);
+
+ assertThat(config).isEqualTo(expectedConfig);
+ }
+}
diff --git a/services/tests/servicestests/src/com/android/server/hdmi/SystemAudioInitiationActionFromAvrTest.java b/services/tests/servicestests/src/com/android/server/hdmi/SystemAudioInitiationActionFromAvrTest.java
index bd297eecf25ca..440a49ab81fc0 100644
--- a/services/tests/servicestests/src/com/android/server/hdmi/SystemAudioInitiationActionFromAvrTest.java
+++ b/services/tests/servicestests/src/com/android/server/hdmi/SystemAudioInitiationActionFromAvrTest.java
@@ -31,6 +31,7 @@ import androidx.test.InstrumentationRegistry;
import androidx.test.filters.SmallTest;
import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -150,6 +151,11 @@ public class SystemAudioInitiationActionFromAvrTest {
int sourceAddress, int physicalAddress) {
mBroadcastActiveSource = true;
}
+
+ @Override
+ int pathToPortId(int path) {
+ return -1;
+ }
};
mHdmiCecLocalDeviceAudioSystem =
new HdmiCecLocalDeviceAudioSystem(hdmiControlService) {
@@ -270,6 +276,7 @@ public class SystemAudioInitiationActionFromAvrTest {
assertTrue(mHdmiCecLocalDeviceAudioSystem.isSystemAudioActivated());
}
+ @Ignore("b/120845532")
@Test
public void testIsPlaybackDevice_cannotReceiveActiveSource() {
resetTestVariables();
@@ -282,10 +289,10 @@ public class SystemAudioInitiationActionFromAvrTest {
mTestLooper.dispatchAll();
assertThat(mMsgRequestActiveSourceCount).isEqualTo(1);
- assertThat(mMsgSetSystemAudioModeCount).isEqualTo(1);
- assertThat(mQueryTvSystemAudioModeSupportCount).isEqualTo(1);
- assertThat(mHdmiCecLocalDeviceAudioSystem.isSystemAudioActivated()).isTrue();
assertThat(mBroadcastActiveSource).isTrue();
+ assertThat(mQueryTvSystemAudioModeSupportCount).isEqualTo(1);
+ assertThat(mMsgSetSystemAudioModeCount).isEqualTo(1);
+ assertThat(mHdmiCecLocalDeviceAudioSystem.isSystemAudioActivated()).isTrue();
}
private void resetTestVariables() {