/*
|
* 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.android.server.hdmi.Constants.ALWAYS_SYSTEM_AUDIO_CONTROL_ON_POWER_ON;
|
import static com.android.server.hdmi.Constants.PROPERTY_SYSTEM_AUDIO_CONTROL_ON_POWER_ON;
|
import static com.android.server.hdmi.Constants.USE_LAST_STATE_SYSTEM_AUDIO_CONTROL_ON_POWER_ON;
|
|
import android.annotation.Nullable;
|
import android.content.ActivityNotFoundException;
|
import android.content.Intent;
|
import android.hardware.hdmi.HdmiControlManager;
|
import android.hardware.hdmi.HdmiDeviceInfo;
|
import android.hardware.hdmi.HdmiPortInfo;
|
import android.hardware.hdmi.IHdmiControlCallback;
|
import android.media.AudioDeviceInfo;
|
import android.media.AudioFormat;
|
import android.media.AudioManager;
|
import android.media.AudioSystem;
|
import android.media.tv.TvContract;
|
import android.media.tv.TvInputInfo;
|
import android.media.tv.TvInputManager.TvInputCallback;
|
import android.os.SystemProperties;
|
import android.provider.Settings.Global;
|
import android.util.Slog;
|
import android.util.SparseArray;
|
|
import com.android.internal.annotations.GuardedBy;
|
import com.android.internal.annotations.VisibleForTesting;
|
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;
|
import java.util.Collections;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.stream.Collectors;
|
|
|
/**
|
* Represent a logical device of type {@link HdmiDeviceInfo#DEVICE_AUDIO_SYSTEM} residing in Android
|
* system.
|
*/
|
public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
|
|
private static final String TAG = "HdmiCecLocalDeviceAudioSystem";
|
|
// Whether the System Audio Control feature is enabled or not. True by default.
|
@GuardedBy("mLock")
|
private boolean mSystemAudioControlFeatureEnabled;
|
|
/**
|
* Indicates if the TV that the current device is connected to supports System Audio Mode or not
|
*
|
* <p>If the current device has no information on this, keep mTvSystemAudioModeSupport null
|
*
|
* <p>The boolean will be reset to null every time when the current device goes to standby
|
* or loses its physical address.
|
*/
|
private Boolean mTvSystemAudioModeSupport = null;
|
|
// Whether ARC is available or not. "true" means that ARC is established between TV and
|
// AVR as audio receiver.
|
@ServiceThreadOnly private boolean mArcEstablished = false;
|
|
// If the current device uses TvInput for ARC. We assume all other inputs also use TvInput
|
// when ARC is using TvInput.
|
private boolean mArcIntentUsed = SystemProperties
|
.get(Constants.PROPERTY_SYSTEM_AUDIO_DEVICE_ARC_PORT, "0").contains("tvinput");
|
|
// Keeps the mapping (HDMI port ID to TV input URI) to keep track of the TV inputs ready to
|
// accept input switching request from HDMI devices.
|
@GuardedBy("mLock")
|
private final HashMap<Integer, String> mPortIdToTvInputs = new HashMap<>();
|
|
// A map from TV input id to HDMI device info.
|
@GuardedBy("mLock")
|
private final HashMap<String, HdmiDeviceInfo> mTvInputsToDeviceInfo = new HashMap<>();
|
|
// Copy of mDeviceInfos to guarantee thread-safety.
|
@GuardedBy("mLock")
|
private List<HdmiDeviceInfo> mSafeAllDeviceInfos = Collections.emptyList();
|
|
// Map-like container of all cec devices.
|
// device id is used as key of container.
|
private final SparseArray<HdmiDeviceInfo> mDeviceInfos = new SparseArray<>();
|
|
protected HdmiCecLocalDeviceAudioSystem(HdmiControlService service) {
|
super(service, HdmiDeviceInfo.DEVICE_AUDIO_SYSTEM);
|
mRoutingControlFeatureEnabled =
|
mService.readBooleanSetting(Global.HDMI_CEC_SWITCH_ENABLED, false);
|
mSystemAudioControlFeatureEnabled =
|
mService.readBooleanSetting(Global.HDMI_SYSTEM_AUDIO_CONTROL_ENABLED, true);
|
}
|
|
private static final String SHORT_AUDIO_DESCRIPTOR_CONFIG_PATH = "/vendor/etc/sadConfig.xml";
|
|
private final TvInputCallback mTvInputCallback = new TvInputCallback() {
|
@Override
|
public void onInputAdded(String inputId) {
|
addOrUpdateTvInput(inputId);
|
}
|
|
@Override
|
public void onInputRemoved(String inputId) {
|
removeTvInput(inputId);
|
}
|
|
@Override
|
public void onInputUpdated(String inputId) {
|
addOrUpdateTvInput(inputId);
|
}
|
};
|
|
@ServiceThreadOnly
|
private void addOrUpdateTvInput(String inputId) {
|
assertRunOnServiceThread();
|
synchronized (mLock) {
|
TvInputInfo tvInfo = mService.getTvInputManager().getTvInputInfo(inputId);
|
if (tvInfo == null) {
|
return;
|
}
|
HdmiDeviceInfo info = tvInfo.getHdmiDeviceInfo();
|
if (info == null) {
|
return;
|
}
|
mPortIdToTvInputs.put(info.getPortId(), inputId);
|
mTvInputsToDeviceInfo.put(inputId, info);
|
}
|
}
|
|
@ServiceThreadOnly
|
private void removeTvInput(String inputId) {
|
assertRunOnServiceThread();
|
synchronized (mLock) {
|
if (mTvInputsToDeviceInfo.get(inputId) == null) {
|
return;
|
}
|
int portId = mTvInputsToDeviceInfo.get(inputId).getPortId();
|
mPortIdToTvInputs.remove(portId);
|
mTvInputsToDeviceInfo.remove(inputId);
|
}
|
}
|
|
/**
|
* Called when a device is newly added or a new device is detected or
|
* an existing device is updated.
|
*
|
* @param info device info of a new device.
|
*/
|
@ServiceThreadOnly
|
final void addCecDevice(HdmiDeviceInfo info) {
|
assertRunOnServiceThread();
|
HdmiDeviceInfo old = addDeviceInfo(info);
|
if (info.getPhysicalAddress() == mService.getPhysicalAddress()) {
|
// The addition of the device itself should not be notified.
|
// Note that different logical address could still be the same local device.
|
return;
|
}
|
if (old == null) {
|
invokeDeviceEventListener(info, HdmiControlManager.DEVICE_EVENT_ADD_DEVICE);
|
} else if (!old.equals(info)) {
|
invokeDeviceEventListener(old, HdmiControlManager.DEVICE_EVENT_REMOVE_DEVICE);
|
invokeDeviceEventListener(info, HdmiControlManager.DEVICE_EVENT_ADD_DEVICE);
|
}
|
}
|
|
/**
|
* Called when a device is removed or removal of device is detected.
|
*
|
* @param address a logical address of a device to be removed
|
*/
|
@ServiceThreadOnly
|
final void removeCecDevice(int address) {
|
assertRunOnServiceThread();
|
HdmiDeviceInfo info = removeDeviceInfo(HdmiDeviceInfo.idForCecDevice(address));
|
|
mCecMessageCache.flushMessagesFrom(address);
|
invokeDeviceEventListener(info, HdmiControlManager.DEVICE_EVENT_REMOVE_DEVICE);
|
}
|
|
/**
|
* Called when a device is updated.
|
*
|
* @param info device info of the updating device.
|
*/
|
@ServiceThreadOnly
|
final void updateCecDevice(HdmiDeviceInfo info) {
|
assertRunOnServiceThread();
|
HdmiDeviceInfo old = addDeviceInfo(info);
|
|
if (old == null) {
|
invokeDeviceEventListener(info, HdmiControlManager.DEVICE_EVENT_ADD_DEVICE);
|
} else if (!old.equals(info)) {
|
invokeDeviceEventListener(info, HdmiControlManager.DEVICE_EVENT_UPDATE_DEVICE);
|
}
|
}
|
|
/**
|
* Add a new {@link HdmiDeviceInfo}. It returns old device info which has the same
|
* logical address as new device info's.
|
*
|
* @param deviceInfo a new {@link HdmiDeviceInfo} to be added.
|
* @return {@code null} if it is new device. Otherwise, returns old {@HdmiDeviceInfo}
|
* that has the same logical address as new one has.
|
*/
|
@ServiceThreadOnly
|
@VisibleForTesting
|
protected HdmiDeviceInfo addDeviceInfo(HdmiDeviceInfo deviceInfo) {
|
assertRunOnServiceThread();
|
HdmiDeviceInfo oldDeviceInfo = getCecDeviceInfo(deviceInfo.getLogicalAddress());
|
if (oldDeviceInfo != null) {
|
removeDeviceInfo(deviceInfo.getId());
|
}
|
mDeviceInfos.append(deviceInfo.getId(), deviceInfo);
|
updateSafeDeviceInfoList();
|
return oldDeviceInfo;
|
}
|
|
/**
|
* Remove a device info corresponding to the given {@code logicalAddress}.
|
* It returns removed {@link HdmiDeviceInfo} if exists.
|
*
|
* @param id id of device to be removed
|
* @return removed {@link HdmiDeviceInfo} it exists. Otherwise, returns {@code null}
|
*/
|
@ServiceThreadOnly
|
private HdmiDeviceInfo removeDeviceInfo(int id) {
|
assertRunOnServiceThread();
|
HdmiDeviceInfo deviceInfo = mDeviceInfos.get(id);
|
if (deviceInfo != null) {
|
mDeviceInfos.remove(id);
|
}
|
updateSafeDeviceInfoList();
|
return deviceInfo;
|
}
|
|
/**
|
* Return a {@link HdmiDeviceInfo} corresponding to the given {@code logicalAddress}.
|
*
|
* @param logicalAddress logical address of the device to be retrieved
|
* @return {@link HdmiDeviceInfo} matched with the given {@code logicalAddress}.
|
* Returns null if no logical address matched
|
*/
|
@ServiceThreadOnly
|
HdmiDeviceInfo getCecDeviceInfo(int logicalAddress) {
|
assertRunOnServiceThread();
|
return mDeviceInfos.get(HdmiDeviceInfo.idForCecDevice(logicalAddress));
|
}
|
|
@ServiceThreadOnly
|
private void updateSafeDeviceInfoList() {
|
assertRunOnServiceThread();
|
List<HdmiDeviceInfo> copiedDevices = HdmiUtils.sparseArrayToList(mDeviceInfos);
|
synchronized (mLock) {
|
mSafeAllDeviceInfos = copiedDevices;
|
}
|
}
|
|
@GuardedBy("mLock")
|
List<HdmiDeviceInfo> getSafeCecDevicesLocked() {
|
ArrayList<HdmiDeviceInfo> infoList = new ArrayList<>();
|
for (HdmiDeviceInfo info : mSafeAllDeviceInfos) {
|
infoList.add(info);
|
}
|
return infoList;
|
}
|
|
private void invokeDeviceEventListener(HdmiDeviceInfo info, int status) {
|
mService.invokeDeviceEventListeners(info, status);
|
}
|
|
@Override
|
@ServiceThreadOnly
|
void onHotplug(int portId, boolean connected) {
|
assertRunOnServiceThread();
|
if (connected) {
|
mService.wakeUp();
|
}
|
if (mService.getPortInfo(portId).getType() == HdmiPortInfo.PORT_OUTPUT) {
|
mCecMessageCache.flushAll();
|
} else if (!connected && mPortIdToTvInputs.get(portId) != null) {
|
String tvInputId = mPortIdToTvInputs.get(portId);
|
HdmiDeviceInfo info = mTvInputsToDeviceInfo.get(tvInputId);
|
if (info == null) {
|
return;
|
}
|
// Update with TIF on the device removal. TIF callback will update
|
// mPortIdToTvInputs and mPortIdToTvInputs.
|
removeCecDevice(info.getLogicalAddress());
|
}
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected void disableDevice(boolean initiatedByCec, PendingActionClearedCallback callback) {
|
super.disableDevice(initiatedByCec, callback);
|
assertRunOnServiceThread();
|
mService.unregisterTvInputCallback(mTvInputCallback);
|
// TODO(b/129088603): check disableDevice and onStandby behaviors per spec
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected void onStandby(boolean initiatedByCec, int standbyAction) {
|
assertRunOnServiceThread();
|
mTvSystemAudioModeSupport = null;
|
// Record the last state of System Audio Control before going to standby
|
synchronized (mLock) {
|
mService.writeStringSystemProperty(
|
Constants.PROPERTY_LAST_SYSTEM_AUDIO_CONTROL,
|
isSystemAudioActivated() ? "true" : "false");
|
}
|
terminateSystemAudioMode();
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected void onAddressAllocated(int logicalAddress, int reason) {
|
assertRunOnServiceThread();
|
if (reason == mService.INITIATED_BY_ENABLE_CEC) {
|
mService.setAndBroadcastActiveSource(mService.getPhysicalAddress(),
|
getDeviceInfo().getDeviceType(), Constants.ADDR_BROADCAST);
|
}
|
mService.sendCecCommand(
|
HdmiCecMessageBuilder.buildReportPhysicalAddressCommand(
|
mAddress, mService.getPhysicalAddress(), mDeviceType));
|
mService.sendCecCommand(
|
HdmiCecMessageBuilder.buildDeviceVendorIdCommand(mAddress, mService.getVendorId()));
|
mService.registerTvInputCallback(mTvInputCallback);
|
int systemAudioControlOnPowerOnProp =
|
SystemProperties.getInt(
|
PROPERTY_SYSTEM_AUDIO_CONTROL_ON_POWER_ON,
|
ALWAYS_SYSTEM_AUDIO_CONTROL_ON_POWER_ON);
|
boolean lastSystemAudioControlStatus =
|
SystemProperties.getBoolean(Constants.PROPERTY_LAST_SYSTEM_AUDIO_CONTROL, true);
|
systemAudioControlOnPowerOn(systemAudioControlOnPowerOnProp, lastSystemAudioControlStatus);
|
clearDeviceInfoList();
|
launchDeviceDiscovery();
|
startQueuedActions();
|
}
|
|
@Override
|
protected int findKeyReceiverAddress() {
|
if (getActiveSource().isValid()) {
|
return getActiveSource().logicalAddress;
|
}
|
return Constants.ADDR_INVALID;
|
}
|
|
@VisibleForTesting
|
protected void systemAudioControlOnPowerOn(
|
int systemAudioOnPowerOnProp, boolean lastSystemAudioControlStatus) {
|
if ((systemAudioOnPowerOnProp == ALWAYS_SYSTEM_AUDIO_CONTROL_ON_POWER_ON)
|
|| ((systemAudioOnPowerOnProp == USE_LAST_STATE_SYSTEM_AUDIO_CONTROL_ON_POWER_ON)
|
&& lastSystemAudioControlStatus && isSystemAudioControlFeatureEnabled())) {
|
addAndStartAction(new SystemAudioInitiationActionFromAvr(this));
|
}
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected int getPreferredAddress() {
|
assertRunOnServiceThread();
|
return SystemProperties.getInt(
|
Constants.PROPERTY_PREFERRED_ADDRESS_AUDIO_SYSTEM, Constants.ADDR_UNREGISTERED);
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected void setPreferredAddress(int addr) {
|
assertRunOnServiceThread();
|
mService.writeStringSystemProperty(
|
Constants.PROPERTY_PREFERRED_ADDRESS_AUDIO_SYSTEM, String.valueOf(addr));
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected boolean handleReportPhysicalAddress(HdmiCecMessage message) {
|
assertRunOnServiceThread();
|
int path = HdmiUtils.twoBytesToInt(message.getParams());
|
int address = message.getSource();
|
int type = message.getParams()[2];
|
|
// Ignore if [Device Discovery Action] is going on.
|
if (hasAction(DeviceDiscoveryAction.class)) {
|
Slog.i(TAG, "Ignored while Device Discovery Action is in progress: " + message);
|
return true;
|
}
|
|
// Update the device info with TIF, note that the same device info could have added in
|
// device discovery and we do not want to override it with default OSD name. Therefore we
|
// need the following check to skip redundant device info updating.
|
HdmiDeviceInfo oldDevice = getCecDeviceInfo(address);
|
if (oldDevice == null || oldDevice.getPhysicalAddress() != path) {
|
addCecDevice(new HdmiDeviceInfo(
|
address, path, mService.pathToPortId(path), type,
|
Constants.UNKNOWN_VENDOR_ID, HdmiUtils.getDefaultDeviceName(address)));
|
// if we are adding a new device info, send out a give osd name command
|
// to update the name of the device in TIF
|
mService.sendCecCommand(
|
HdmiCecMessageBuilder.buildGiveOsdNameCommand(mAddress, address));
|
return true;
|
}
|
|
Slog.w(TAG, "Device info exists. Not updating on Physical Address.");
|
return true;
|
}
|
|
@Override
|
protected boolean handleReportPowerStatus(HdmiCecMessage command) {
|
int newStatus = command.getParams()[0] & 0xFF;
|
updateDevicePowerStatus(command.getSource(), newStatus);
|
return true;
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected boolean handleSetOsdName(HdmiCecMessage message) {
|
int source = message.getSource();
|
String osdName;
|
HdmiDeviceInfo deviceInfo = getCecDeviceInfo(source);
|
// If the device is not in device list, ignore it.
|
if (deviceInfo == null) {
|
Slog.i(TAG, "No source device info for <Set Osd Name>." + message);
|
return true;
|
}
|
try {
|
osdName = new String(message.getParams(), "US-ASCII");
|
} catch (UnsupportedEncodingException e) {
|
Slog.e(TAG, "Invalid <Set Osd Name> request:" + message, e);
|
return true;
|
}
|
|
if (deviceInfo.getDisplayName().equals(osdName)) {
|
Slog.d(TAG, "Ignore incoming <Set Osd Name> having same osd name:" + message);
|
return true;
|
}
|
|
Slog.d(TAG, "Updating device OSD name from "
|
+ deviceInfo.getDisplayName()
|
+ " to " + osdName);
|
updateCecDevice(new HdmiDeviceInfo(deviceInfo.getLogicalAddress(),
|
deviceInfo.getPhysicalAddress(), deviceInfo.getPortId(),
|
deviceInfo.getDeviceType(), deviceInfo.getVendorId(), osdName));
|
return true;
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected boolean handleInitiateArc(HdmiCecMessage message) {
|
assertRunOnServiceThread();
|
// TODO(amyjojo): implement initiate arc handler
|
HdmiLogger.debug(TAG + "Stub handleInitiateArc");
|
return true;
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected boolean handleReportArcInitiate(HdmiCecMessage message) {
|
assertRunOnServiceThread();
|
// TODO(amyjojo): implement report arc initiate handler
|
HdmiLogger.debug(TAG + "Stub handleReportArcInitiate");
|
return true;
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected boolean handleReportArcTermination(HdmiCecMessage message) {
|
assertRunOnServiceThread();
|
// TODO(amyjojo): implement report arc terminate handler
|
HdmiLogger.debug(TAG + "Stub handleReportArcTermination");
|
return true;
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected boolean handleGiveAudioStatus(HdmiCecMessage message) {
|
assertRunOnServiceThread();
|
if (isSystemAudioControlFeatureEnabled()) {
|
reportAudioStatus(message.getSource());
|
} else {
|
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
|
}
|
return true;
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected boolean handleGiveSystemAudioModeStatus(HdmiCecMessage message) {
|
assertRunOnServiceThread();
|
// If the audio system is initiating the system audio mode on and TV asks the sam status at
|
// the same time, respond with true. Since we know TV supports sam in this situation.
|
// If the query comes from STB, we should respond with the current sam status and the STB
|
// should listen to the <Set System Audio Mode> broadcasting.
|
boolean isSystemAudioModeOnOrTurningOn = isSystemAudioActivated();
|
if (!isSystemAudioModeOnOrTurningOn
|
&& message.getSource() == Constants.ADDR_TV
|
&& hasAction(SystemAudioInitiationActionFromAvr.class)) {
|
isSystemAudioModeOnOrTurningOn = true;
|
}
|
mService.sendCecCommand(
|
HdmiCecMessageBuilder.buildReportSystemAudioMode(
|
mAddress, message.getSource(), isSystemAudioModeOnOrTurningOn));
|
return true;
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected boolean handleRequestArcInitiate(HdmiCecMessage message) {
|
assertRunOnServiceThread();
|
removeAction(ArcInitiationActionFromAvr.class);
|
if (!mService.readBooleanSystemProperty(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");
|
mService.maySendFeatureAbortCommand(message, Constants.ABORT_NOT_IN_CORRECT_MODE);
|
} else {
|
addAndStartAction(new ArcInitiationActionFromAvr(this));
|
}
|
return true;
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected boolean handleRequestArcTermination(HdmiCecMessage message) {
|
assertRunOnServiceThread();
|
if (!SystemProperties.getBoolean(Constants.PROPERTY_ARC_SUPPORT, true)) {
|
mService.maySendFeatureAbortCommand(message, Constants.ABORT_UNRECOGNIZED_OPCODE);
|
} else if (!isArcEnabled()) {
|
HdmiLogger.debug("ARC is not established between TV and AVR device");
|
mService.maySendFeatureAbortCommand(message, Constants.ABORT_NOT_IN_CORRECT_MODE);
|
} else {
|
removeAction(ArcTerminationActionFromAvr.class);
|
addAndStartAction(new ArcTerminationActionFromAvr(this));
|
}
|
return true;
|
}
|
|
@ServiceThreadOnly
|
protected boolean handleRequestShortAudioDescriptor(HdmiCecMessage message) {
|
assertRunOnServiceThread();
|
HdmiLogger.debug(TAG + "Stub handleRequestShortAudioDescriptor");
|
if (!isSystemAudioControlFeatureEnabled()) {
|
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
|
return true;
|
}
|
if (!isSystemAudioActivated()) {
|
mService.maySendFeatureAbortCommand(message, Constants.ABORT_NOT_IN_CORRECT_MODE);
|
return true;
|
}
|
|
List<DeviceConfig> 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;
|
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 {
|
mService.sendCecCommand(
|
HdmiCecMessageBuilder.buildReportShortAudioDescriptor(
|
mAddress, message.getSource(), sadBytes));
|
}
|
return true;
|
}
|
|
private byte[] getSupportedShortAudioDescriptors(
|
AudioDeviceInfo deviceInfo, @AudioCodec int[] audioFormatCodes) {
|
ArrayList<byte[]> sads = new ArrayList<>(audioFormatCodes.length);
|
for (@AudioCodec int audioFormatCode : audioFormatCodes) {
|
byte[] sad = getSupportedShortAudioDescriptor(deviceInfo, audioFormatCode);
|
if (sad != null) {
|
if (sad.length == 3) {
|
|
sads.add(sad);
|
} else {
|
HdmiLogger.warning(
|
"Dropping Short Audio Descriptor with length %d for requested codec %x",
|
sad.length, audioFormatCode);
|
}
|
}
|
}
|
return getShortAudioDescriptorBytes(sads);
|
}
|
|
private byte[] getSupportedShortAudioDescriptorsFromConfig(
|
List<DeviceConfig> 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<Integer, byte[]> map = new HashMap<>();
|
ArrayList<byte[]> 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<byte[]> sads) {
|
// Short Audio Descriptors are always 3 bytes long.
|
byte[] bytes = new byte[sads.size() * 3];
|
int index = 0;
|
for (byte[] sad : sads) {
|
System.arraycopy(sad, 0, bytes, index, 3);
|
index += 3;
|
}
|
return bytes;
|
}
|
|
/**
|
* Returns a 3 byte short audio descriptor as described in CEC 1.4 table 29 or null if the
|
* audioFormatCode is not supported.
|
*/
|
@Nullable
|
private byte[] getSupportedShortAudioDescriptor(
|
AudioDeviceInfo deviceInfo, @AudioCodec int audioFormatCode) {
|
switch (audioFormatCode) {
|
case Constants.AUDIO_CODEC_NONE: {
|
return null;
|
}
|
case Constants.AUDIO_CODEC_LPCM: {
|
return getLpcmShortAudioDescriptor(deviceInfo);
|
}
|
// TODO(b/80297701): implement the rest of the codecs
|
case Constants.AUDIO_CODEC_DD:
|
case Constants.AUDIO_CODEC_MPEG1:
|
case Constants.AUDIO_CODEC_MP3:
|
case Constants.AUDIO_CODEC_MPEG2:
|
case Constants.AUDIO_CODEC_AAC:
|
case Constants.AUDIO_CODEC_DTS:
|
case Constants.AUDIO_CODEC_ATRAC:
|
case Constants.AUDIO_CODEC_ONEBITAUDIO:
|
case Constants.AUDIO_CODEC_DDP:
|
case Constants.AUDIO_CODEC_DTSHD:
|
case Constants.AUDIO_CODEC_TRUEHD:
|
case Constants.AUDIO_CODEC_DST:
|
case Constants.AUDIO_CODEC_WMAPRO:
|
default: {
|
return null;
|
}
|
}
|
}
|
|
@Nullable
|
private byte[] getLpcmShortAudioDescriptor(AudioDeviceInfo deviceInfo) {
|
// TODO(b/80297701): implement
|
return null;
|
}
|
|
@Nullable
|
private AudioDeviceInfo getSystemAudioDeviceInfo() {
|
AudioManager audioManager = mService.getContext().getSystemService(AudioManager.class);
|
if (audioManager == null) {
|
HdmiLogger.error(
|
"Error getting system audio device because AudioManager not available.");
|
return null;
|
}
|
AudioDeviceInfo[] devices = audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS);
|
HdmiLogger.debug("Found %d audio input devices", devices.length);
|
for (AudioDeviceInfo device : devices) {
|
HdmiLogger.debug("%s at port %s", device.getProductName(), device.getPort());
|
HdmiLogger.debug("Supported encodings are %s",
|
Arrays.stream(device.getEncodings()).mapToObj(
|
AudioFormat::toLogFriendlyEncoding
|
).collect(Collectors.joining(", ")));
|
// TODO(b/80297701) use the actual device type that system audio mode is connected to.
|
if (device.getType() == AudioDeviceInfo.TYPE_HDMI_ARC) {
|
return device;
|
}
|
}
|
return null;
|
}
|
|
@AudioCodec
|
private int[] parseAudioFormatCodes(byte[] params) {
|
@AudioCodec int[] audioFormatCodes = new int[params.length];
|
for (int i = 0; i < params.length; i++) {
|
byte val = params[i];
|
audioFormatCodes[i] =
|
val >= 1 && val <= Constants.AUDIO_CODEC_MAX ? val : Constants.AUDIO_CODEC_NONE;
|
}
|
return audioFormatCodes;
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected boolean handleSystemAudioModeRequest(HdmiCecMessage message) {
|
assertRunOnServiceThread();
|
boolean systemAudioStatusOn = message.getParams().length != 0;
|
// Check if the request comes from a non-TV device.
|
// Need to check if TV supports System Audio Control
|
// if non-TV device tries to turn on the feature
|
if (message.getSource() != Constants.ADDR_TV) {
|
if (systemAudioStatusOn) {
|
handleSystemAudioModeOnFromNonTvDevice(message);
|
return true;
|
}
|
} else {
|
// If TV request the feature on
|
// cache TV supporting System Audio Control
|
// until Audio System loses its physical address.
|
setTvSystemAudioModeSupport(true);
|
}
|
// If TV or Audio System does not support the feature,
|
// will send abort command.
|
if (!checkSupportAndSetSystemAudioMode(systemAudioStatusOn)) {
|
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
|
return true;
|
}
|
|
mService.sendCecCommand(
|
HdmiCecMessageBuilder.buildSetSystemAudioMode(
|
mAddress, Constants.ADDR_BROADCAST, systemAudioStatusOn));
|
return true;
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected boolean handleSetSystemAudioMode(HdmiCecMessage message) {
|
assertRunOnServiceThread();
|
if (!checkSupportAndSetSystemAudioMode(
|
HdmiUtils.parseCommandParamSystemAudioStatus(message))) {
|
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
|
}
|
return true;
|
}
|
|
@Override
|
@ServiceThreadOnly
|
protected boolean handleSystemAudioModeStatus(HdmiCecMessage message) {
|
assertRunOnServiceThread();
|
if (!checkSupportAndSetSystemAudioMode(
|
HdmiUtils.parseCommandParamSystemAudioStatus(message))) {
|
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
|
}
|
return true;
|
}
|
|
@ServiceThreadOnly
|
void setArcStatus(boolean enabled) {
|
// TODO(shubang): add tests
|
assertRunOnServiceThread();
|
|
HdmiLogger.debug("Set Arc Status[old:%b new:%b]", mArcEstablished, enabled);
|
// 1. Enable/disable ARC circuit.
|
enableAudioReturnChannel(enabled);
|
// 2. Notify arc status to audio service.
|
notifyArcStatusToAudioService(enabled);
|
// 3. Update arc status;
|
mArcEstablished = enabled;
|
}
|
|
/** Switch hardware ARC circuit in the system. */
|
@ServiceThreadOnly
|
private void enableAudioReturnChannel(boolean enabled) {
|
assertRunOnServiceThread();
|
mService.enableAudioReturnChannel(
|
SystemProperties.getInt(Constants.PROPERTY_SYSTEM_AUDIO_DEVICE_ARC_PORT, 0),
|
enabled);
|
}
|
|
private void notifyArcStatusToAudioService(boolean enabled) {
|
// Note that we don't set any name to ARC.
|
mService.getAudioManager()
|
.setWiredDeviceConnectionState(AudioSystem.DEVICE_IN_HDMI, enabled ? 1 : 0, "", "");
|
}
|
|
void reportAudioStatus(int source) {
|
assertRunOnServiceThread();
|
|
int volume = mService.getAudioManager().getStreamVolume(AudioManager.STREAM_MUSIC);
|
boolean mute = mService.getAudioManager().isStreamMute(AudioManager.STREAM_MUSIC);
|
int maxVolume = mService.getAudioManager().getStreamMaxVolume(AudioManager.STREAM_MUSIC);
|
int minVolume = mService.getAudioManager().getStreamMinVolume(AudioManager.STREAM_MUSIC);
|
int scaledVolume = VolumeControlAction.scaleToCecVolume(volume, maxVolume);
|
HdmiLogger.debug("Reporting volume %d (%d-%d) as CEC volume %d", volume,
|
minVolume, maxVolume, scaledVolume);
|
|
mService.sendCecCommand(
|
HdmiCecMessageBuilder.buildReportAudioStatus(
|
mAddress, source, scaledVolume, mute));
|
}
|
|
/**
|
* Method to check if device support System Audio Control. If so, wake up device if necessary.
|
*
|
* <p> then call {@link #setSystemAudioMode(boolean)} to turn on or off System Audio Mode
|
* @param newSystemAudioMode turning feature on or off. True is on. False is off.
|
* @return true or false.
|
*
|
* <p>False when device does not support the feature. Otherwise returns true.
|
*/
|
protected boolean checkSupportAndSetSystemAudioMode(boolean newSystemAudioMode) {
|
if (!isSystemAudioControlFeatureEnabled()) {
|
HdmiLogger.debug(
|
"Cannot turn "
|
+ (newSystemAudioMode ? "on" : "off")
|
+ "system audio mode "
|
+ "because the System Audio Control feature is disabled.");
|
return false;
|
}
|
HdmiLogger.debug(
|
"System Audio Mode change[old:%b new:%b]",
|
isSystemAudioActivated(), newSystemAudioMode);
|
// Wake up device if System Audio Control is turned on
|
if (newSystemAudioMode) {
|
mService.wakeUp();
|
}
|
setSystemAudioMode(newSystemAudioMode);
|
return true;
|
}
|
|
/**
|
* Real work to turn on or off System Audio Mode.
|
*
|
* Use {@link #checkSupportAndSetSystemAudioMode(boolean)}
|
* if trying to turn on or off the feature.
|
*/
|
private void setSystemAudioMode(boolean newSystemAudioMode) {
|
int targetPhysicalAddress = getActiveSource().physicalAddress;
|
int port = mService.pathToPortId(targetPhysicalAddress);
|
if (newSystemAudioMode && port >= 0) {
|
switchToAudioInput();
|
}
|
// Mute device when feature is turned off and unmute device when feature is turned on.
|
// PROPERTY_SYSTEM_AUDIO_MODE_MUTING_ENABLE is false when device never needs to be muted.
|
boolean currentMuteStatus =
|
mService.getAudioManager().isStreamMute(AudioManager.STREAM_MUSIC);
|
if (currentMuteStatus == newSystemAudioMode) {
|
if (mService.readBooleanSystemProperty(
|
Constants.PROPERTY_SYSTEM_AUDIO_MODE_MUTING_ENABLE, true)
|
|| newSystemAudioMode) {
|
mService.getAudioManager()
|
.adjustStreamVolume(
|
AudioManager.STREAM_MUSIC,
|
newSystemAudioMode
|
? AudioManager.ADJUST_UNMUTE
|
: AudioManager.ADJUST_MUTE,
|
0);
|
}
|
}
|
updateAudioManagerForSystemAudio(newSystemAudioMode);
|
synchronized (mLock) {
|
if (isSystemAudioActivated() != newSystemAudioMode) {
|
mService.setSystemAudioActivated(newSystemAudioMode);
|
mService.announceSystemAudioModeChange(newSystemAudioMode);
|
}
|
}
|
// Init arc whenever System Audio Mode is on
|
// Terminate arc when System Audio Mode is off
|
// Since some TVs don't request ARC on with System Audio Mode on request
|
if (SystemProperties.getBoolean(Constants.PROPERTY_ARC_SUPPORT, true)
|
&& isDirectConnectToTv()) {
|
if (newSystemAudioMode && !isArcEnabled()) {
|
removeAction(ArcInitiationActionFromAvr.class);
|
addAndStartAction(new ArcInitiationActionFromAvr(this));
|
} else if (!newSystemAudioMode && isArcEnabled()) {
|
removeAction(ArcTerminationActionFromAvr.class);
|
addAndStartAction(new ArcTerminationActionFromAvr(this));
|
}
|
}
|
}
|
|
protected void switchToAudioInput() {
|
// TODO(b/111396634): switch input according to PROPERTY_SYSTEM_AUDIO_MODE_AUDIO_PORT
|
}
|
|
protected boolean isDirectConnectToTv() {
|
int myPhysicalAddress = mService.getPhysicalAddress();
|
return (myPhysicalAddress & Constants.ROUTING_PATH_TOP_MASK) == myPhysicalAddress;
|
}
|
|
private void updateAudioManagerForSystemAudio(boolean on) {
|
int device = mService.getAudioManager().setHdmiSystemAudioSupported(on);
|
HdmiLogger.debug("[A]UpdateSystemAudio mode[on=%b] output=[%X]", on, device);
|
}
|
|
void onSystemAduioControlFeatureSupportChanged(boolean enabled) {
|
setSystemAudioControlFeatureEnabled(enabled);
|
if (enabled) {
|
addAndStartAction(new SystemAudioInitiationActionFromAvr(this));
|
}
|
}
|
|
@ServiceThreadOnly
|
void setSystemAudioControlFeatureEnabled(boolean enabled) {
|
assertRunOnServiceThread();
|
synchronized (mLock) {
|
mSystemAudioControlFeatureEnabled = enabled;
|
}
|
}
|
|
@ServiceThreadOnly
|
void setRoutingControlFeatureEnables(boolean enabled) {
|
assertRunOnServiceThread();
|
synchronized (mLock) {
|
mRoutingControlFeatureEnabled = enabled;
|
}
|
}
|
|
@ServiceThreadOnly
|
void doManualPortSwitching(int portId, IHdmiControlCallback callback) {
|
assertRunOnServiceThread();
|
if (!mService.isValidPortId(portId)) {
|
invokeCallback(callback, HdmiControlManager.RESULT_TARGET_NOT_AVAILABLE);
|
return;
|
}
|
if (portId == getLocalActivePort()) {
|
invokeCallback(callback, HdmiControlManager.RESULT_SUCCESS);
|
return;
|
}
|
if (!mService.isControlEnabled()) {
|
setRoutingPort(portId);
|
setLocalActivePort(portId);
|
invokeCallback(callback, HdmiControlManager.RESULT_INCORRECT_MODE);
|
return;
|
}
|
int oldPath = getRoutingPort() != Constants.CEC_SWITCH_HOME
|
? mService.portIdToPath(getRoutingPort())
|
: getDeviceInfo().getPhysicalAddress();
|
int newPath = mService.portIdToPath(portId);
|
if (oldPath == newPath) {
|
return;
|
}
|
setRoutingPort(portId);
|
setLocalActivePort(portId);
|
HdmiCecMessage routingChange =
|
HdmiCecMessageBuilder.buildRoutingChange(mAddress, oldPath, newPath);
|
mService.sendCecCommand(routingChange);
|
}
|
|
boolean isSystemAudioControlFeatureEnabled() {
|
synchronized (mLock) {
|
return mSystemAudioControlFeatureEnabled;
|
}
|
}
|
|
protected boolean isSystemAudioActivated() {
|
return mService.isSystemAudioActivated();
|
}
|
|
protected void terminateSystemAudioMode() {
|
// remove pending initiation actions
|
removeAction(SystemAudioInitiationActionFromAvr.class);
|
if (!isSystemAudioActivated()) {
|
return;
|
}
|
|
if (checkSupportAndSetSystemAudioMode(false)) {
|
// send <Set System Audio Mode> [“Off”]
|
mService.sendCecCommand(
|
HdmiCecMessageBuilder.buildSetSystemAudioMode(
|
mAddress, Constants.ADDR_BROADCAST, false));
|
}
|
}
|
|
/** Reports if System Audio Mode is supported by the connected TV */
|
interface TvSystemAudioModeSupportedCallback {
|
|
/** {@code supported} is true if the TV is connected and supports System Audio Mode. */
|
void onResult(boolean supported);
|
}
|
|
/**
|
* Queries the connected TV to detect if System Audio Mode is supported by the TV.
|
*
|
* <p>This query may take up to 2 seconds to complete.
|
*
|
* <p>The result of the query may be cached until Audio device type is put in standby or loses
|
* its physical address.
|
*/
|
void queryTvSystemAudioModeSupport(TvSystemAudioModeSupportedCallback callback) {
|
if (mTvSystemAudioModeSupport == null) {
|
addAndStartAction(new DetectTvSystemAudioModeSupportAction(this, callback));
|
} else {
|
callback.onResult(mTvSystemAudioModeSupport);
|
}
|
}
|
|
/**
|
* Handler of System Audio Mode Request on from non TV device
|
*/
|
void handleSystemAudioModeOnFromNonTvDevice(HdmiCecMessage message) {
|
if (!isSystemAudioControlFeatureEnabled()) {
|
HdmiLogger.debug(
|
"Cannot turn on" + "system audio mode "
|
+ "because the System Audio Control feature is disabled.");
|
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
|
return;
|
}
|
// Wake up device
|
mService.wakeUp();
|
// If Audio device is the active source or is on the active path,
|
// enable system audio mode without querying TV's support on sam.
|
// This is per HDMI spec 1.4b CEC 13.15.4.2.
|
if (mService.pathToPortId(getActiveSource().physicalAddress)
|
!= Constants.INVALID_PORT_ID) {
|
setSystemAudioMode(true);
|
mService.sendCecCommand(
|
HdmiCecMessageBuilder.buildSetSystemAudioMode(
|
mAddress, Constants.ADDR_BROADCAST, true));
|
return;
|
}
|
// Check if TV supports System Audio Control.
|
// Handle broadcasting setSystemAudioMode on or aborting message on callback.
|
queryTvSystemAudioModeSupport(new TvSystemAudioModeSupportedCallback() {
|
public void onResult(boolean supported) {
|
if (supported) {
|
setSystemAudioMode(true);
|
mService.sendCecCommand(
|
HdmiCecMessageBuilder.buildSetSystemAudioMode(
|
mAddress, Constants.ADDR_BROADCAST, true));
|
} else {
|
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
|
}
|
}
|
});
|
}
|
|
void setTvSystemAudioModeSupport(boolean supported) {
|
mTvSystemAudioModeSupport = supported;
|
}
|
|
@VisibleForTesting
|
protected boolean isArcEnabled() {
|
synchronized (mLock) {
|
return mArcEstablished;
|
}
|
}
|
|
@Override
|
protected void switchInputOnReceivingNewActivePath(int physicalAddress) {
|
int port = mService.pathToPortId(physicalAddress);
|
if (isSystemAudioActivated() && port < 0) {
|
// If system audio mode is on and the new active source is not under the current device,
|
// Will switch to ARC input.
|
// TODO(b/115637145): handle system aduio without ARC
|
routeToInputFromPortId(Constants.CEC_SWITCH_ARC);
|
} else if (mIsSwitchDevice && port >= 0) {
|
// If current device is a switch and the new active source is under it,
|
// will switch to the corresponding active path.
|
routeToInputFromPortId(port);
|
}
|
}
|
|
protected void routeToInputFromPortId(int portId) {
|
if (!isRoutingControlFeatureEnabled()) {
|
HdmiLogger.debug("Routing Control Feature is not enabled.");
|
return;
|
}
|
if (mArcIntentUsed) {
|
routeToTvInputFromPortId(portId);
|
} else {
|
// TODO(): implement input switching for devices not using TvInput.
|
}
|
}
|
|
protected void routeToTvInputFromPortId(int portId) {
|
if (portId < 0 || portId >= Constants.CEC_SWITCH_PORT_MAX) {
|
HdmiLogger.debug("Invalid port number for Tv Input switching.");
|
return;
|
}
|
// Wake up if the current device if ready to route.
|
mService.wakeUp();
|
if (portId == Constants.CEC_SWITCH_HOME && mService.isPlaybackDevice()) {
|
switchToHomeTvInput();
|
} else if (portId == Constants.CEC_SWITCH_ARC) {
|
switchToTvInput(SystemProperties.get(Constants.PROPERTY_SYSTEM_AUDIO_DEVICE_ARC_PORT));
|
setLocalActivePort(portId);
|
return;
|
} else {
|
String uri = mPortIdToTvInputs.get(portId);
|
if (uri != null) {
|
switchToTvInput(uri);
|
} else {
|
HdmiLogger.debug("Port number does not match any Tv Input.");
|
return;
|
}
|
}
|
|
setLocalActivePort(portId);
|
setRoutingPort(portId);
|
}
|
|
// For device to switch to specific TvInput with corresponding URI.
|
private void switchToTvInput(String uri) {
|
try {
|
mService.getContext().startActivity(new Intent(Intent.ACTION_VIEW,
|
TvContract.buildChannelUriForPassthroughInput(uri))
|
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
|
} catch (ActivityNotFoundException e) {
|
Slog.e(TAG, "Can't find activity to switch to " + uri, e);
|
}
|
}
|
|
// For device using TvInput to switch to Home.
|
private void switchToHomeTvInput() {
|
try {
|
Intent activityIntent = new Intent(Intent.ACTION_MAIN)
|
.addCategory(Intent.CATEGORY_HOME)
|
.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP
|
| Intent.FLAG_ACTIVITY_SINGLE_TOP
|
| Intent.FLAG_ACTIVITY_NEW_TASK
|
| Intent.FLAG_ACTIVITY_NO_ANIMATION);
|
mService.getContext().startActivity(activityIntent);
|
} catch (ActivityNotFoundException e) {
|
Slog.e(TAG, "Can't find activity to switch to HOME", e);
|
}
|
}
|
|
@Override
|
protected void handleRoutingChangeAndInformation(int physicalAddress, HdmiCecMessage message) {
|
int port = mService.pathToPortId(physicalAddress);
|
// Routing change or information sent from switches under the current device can be ignored.
|
if (port > 0) {
|
return;
|
}
|
// When other switches route to some other devices not under the current device,
|
// check system audio mode status and do ARC switch if needed.
|
if (port < 0 && isSystemAudioActivated()) {
|
handleRoutingChangeAndInformationForSystemAudio();
|
return;
|
}
|
// When other switches route to the current device
|
// and the current device is also a switch.
|
if (port == 0) {
|
handleRoutingChangeAndInformationForSwitch(message);
|
}
|
}
|
|
// Handle the system audio(ARC) part of the logic on receiving routing change or information.
|
private void handleRoutingChangeAndInformationForSystemAudio() {
|
// TODO(b/115637145): handle system aduio without ARC
|
routeToInputFromPortId(Constants.CEC_SWITCH_ARC);
|
}
|
|
// Handle the routing control part of the logic on receiving routing change or information.
|
private void handleRoutingChangeAndInformationForSwitch(HdmiCecMessage message) {
|
if (getRoutingPort() == Constants.CEC_SWITCH_HOME && mService.isPlaybackDevice()) {
|
routeToInputFromPortId(Constants.CEC_SWITCH_HOME);
|
mService.setAndBroadcastActiveSourceFromOneDeviceType(
|
message.getSource(), mService.getPhysicalAddress());
|
return;
|
}
|
|
int routingInformationPath = mService.portIdToPath(getRoutingPort());
|
// If current device is already the leaf of the whole HDMI system, will do nothing.
|
if (routingInformationPath == mService.getPhysicalAddress()) {
|
HdmiLogger.debug("Current device can't assign valid physical address"
|
+ "to devices under it any more. "
|
+ "It's physical address is "
|
+ routingInformationPath);
|
return;
|
}
|
// Otherwise will switch to the current active port and broadcast routing information.
|
mService.sendCecCommand(HdmiCecMessageBuilder.buildRoutingInformation(
|
mAddress, routingInformationPath));
|
routeToInputFromPortId(getRoutingPort());
|
}
|
|
protected void updateDevicePowerStatus(int logicalAddress, int newPowerStatus) {
|
HdmiDeviceInfo info = getCecDeviceInfo(logicalAddress);
|
if (info == null) {
|
Slog.w(TAG, "Can not update power status of non-existing device:" + logicalAddress);
|
return;
|
}
|
|
if (info.getDevicePowerStatus() == newPowerStatus) {
|
return;
|
}
|
|
HdmiDeviceInfo newInfo = HdmiUtils.cloneHdmiDeviceInfo(info, newPowerStatus);
|
// addDeviceInfo replaces old device info with new one if exists.
|
addDeviceInfo(newInfo);
|
|
invokeDeviceEventListener(newInfo, HdmiControlManager.DEVICE_EVENT_UPDATE_DEVICE);
|
}
|
|
@ServiceThreadOnly
|
private void launchDeviceDiscovery() {
|
assertRunOnServiceThread();
|
if (hasAction(DeviceDiscoveryAction.class)) {
|
Slog.i(TAG, "Device Discovery Action is in progress. Restarting.");
|
removeAction(DeviceDiscoveryAction.class);
|
}
|
DeviceDiscoveryAction action = new DeviceDiscoveryAction(this,
|
new DeviceDiscoveryCallback() {
|
@Override
|
public void onDeviceDiscoveryDone(List<HdmiDeviceInfo> deviceInfos) {
|
for (HdmiDeviceInfo info : deviceInfos) {
|
addCecDevice(info);
|
}
|
}
|
});
|
addAndStartAction(action);
|
}
|
|
// Clear all device info.
|
@ServiceThreadOnly
|
private void clearDeviceInfoList() {
|
assertRunOnServiceThread();
|
for (HdmiDeviceInfo info : HdmiUtils.sparseArrayToList(mDeviceInfos)) {
|
if (info.getPhysicalAddress() == mService.getPhysicalAddress()) {
|
continue;
|
}
|
invokeDeviceEventListener(info, HdmiControlManager.DEVICE_EVENT_REMOVE_DEVICE);
|
}
|
mDeviceInfos.clear();
|
updateSafeDeviceInfoList();
|
}
|
|
@Override
|
protected void dump(IndentingPrintWriter pw) {
|
pw.println("HdmiCecLocalDeviceAudioSystem:");
|
pw.increaseIndent();
|
pw.println("isRoutingFeatureEnabled " + isRoutingControlFeatureEnabled());
|
pw.println("mSystemAudioControlFeatureEnabled: " + mSystemAudioControlFeatureEnabled);
|
pw.println("mTvSystemAudioModeSupport: " + mTvSystemAudioModeSupport);
|
pw.println("mArcEstablished: " + mArcEstablished);
|
pw.println("mArcIntentUsed: " + mArcIntentUsed);
|
pw.println("mRoutingPort: " + getRoutingPort());
|
pw.println("mLocalActivePort: " + getLocalActivePort());
|
HdmiUtils.dumpMap(pw, "mPortIdToTvInputs:", mPortIdToTvInputs);
|
HdmiUtils.dumpMap(pw, "mTvInputsToDeviceInfo:", mTvInputsToDeviceInfo);
|
HdmiUtils.dumpSparseArray(pw, "mDeviceInfos:", mDeviceInfos);
|
pw.decreaseIndent();
|
super.dump(pw);
|
}
|
}
|
