Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Revert "Revert "Implement initial statsd atoms for HDMI-CEC"""

Browse Source
This commit is contained in:
TreeHugger Robot
2020-09-21 08:47:22 +00:00
committed by Android (Google) Code Review
parent 21f3ca4aca d6001d4127
commit c0030f4c41
13 changed files with 285 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

192
services/core/java/com/android/server/hdmi/HdmiCecAtomWriter.java Normal file
View File

@@ -0,0 +1,192 @@
/*
* Copyright (C) 2020 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 android.stats.hdmi.HdmiStatsEnums;
import com.android.internal.util.FrameworkStatsLog;
class HdmiCecAtomWriter {
private static final int FEATURE_ABORT_OPCODE_UNKNOWN = 0x100;
private static final int ERROR_CODE_UNKNOWN = -1;
/**
* Writes a HdmiCecMessageReported atom representing an HDMI CEC message.
* Should only be directly used for sent messages; for received messages,
* use the overloaded version with the errorCode argument omitted.
*
* @param message The HDMI CEC message
* @param direction Whether the message is incoming, outgoing, or neither
* @param errorCode The error code from the final attempt to send the message
*/
public void messageReported(HdmiCecMessage message, int direction, int errorCode) {
MessageReportedGenericArgs genericArgs = createMessageReportedGenericArgs(
message, direction, errorCode);
MessageReportedSpecialArgs specialArgs = createMessageReportedSpecialArgs(message);
messageReportedBase(genericArgs, specialArgs);
}
/**
* Version of messageReported for received messages, where no error code is present.
*
* @param message The HDMI CEC message
* @param direction Whether the message is incoming, outgoing, or neither
*/
public void messageReported(HdmiCecMessage message, int direction) {
messageReported(message, direction, ERROR_CODE_UNKNOWN);
}
/**
* Constructs the generic arguments for logging a HDMI CEC message.
*
* @param message The HDMI CEC message
* @param direction Whether the message is incoming, outgoing, or neither
* @param errorCode The error code of the message if it's outgoing;
* otherwise, ERROR_CODE_UNKNOWN
*/
private MessageReportedGenericArgs createMessageReportedGenericArgs(
HdmiCecMessage message, int direction, int errorCode) {
int sendMessageResult = errorCode == ERROR_CODE_UNKNOWN
? HdmiStatsEnums.SEND_MESSAGE_RESULT_UNKNOWN
: errorCode + 10;
return new MessageReportedGenericArgs(direction, message.getSource(),
message.getDestination(), message.getOpcode(), sendMessageResult);
}
/**
* Constructs the special arguments for logging an HDMI CEC message.
*
* @param message The HDMI CEC message to log
* @return An object containing the special arguments for the message
*/
private MessageReportedSpecialArgs createMessageReportedSpecialArgs(HdmiCecMessage message) {
// Special arguments depend on message opcode
switch (message.getOpcode()) {
case Constants.MESSAGE_USER_CONTROL_PRESSED:
return createUserControlPressedSpecialArgs(message);
case Constants.MESSAGE_FEATURE_ABORT:
return createFeatureAbortSpecialArgs(message);
default:
return new MessageReportedSpecialArgs();
}
}
/**
* Constructs the special arguments for a <User Control Pressed> message.
*
* @param message The HDMI CEC message to log
*/
private MessageReportedSpecialArgs createUserControlPressedSpecialArgs(
HdmiCecMessage message) {
MessageReportedSpecialArgs specialArgs = new MessageReportedSpecialArgs();
int keycode = message.getParams()[0];
if (keycode >= 0x1E && keycode <= 0x29) {
specialArgs.mUserControlPressedCommand = HdmiStatsEnums.NUMBER;
} else {
specialArgs.mUserControlPressedCommand = keycode + 0x100;
}
return specialArgs;
}
/**
* Constructs method for constructing the special arguments for a <Feature Abort> message.
*
* @param message The HDMI CEC message to log
*/
private MessageReportedSpecialArgs createFeatureAbortSpecialArgs(HdmiCecMessage message) {
MessageReportedSpecialArgs specialArgs = new MessageReportedSpecialArgs();
specialArgs.mFeatureAbortOpcode = message.getParams()[0] & 0xFF; // Unsigned byte
specialArgs.mFeatureAbortReason = message.getParams()[1] + 10;
return specialArgs;
}
/**
* Writes a HdmiCecMessageReported atom.
*
* @param genericArgs Generic arguments; shared by all HdmiCecMessageReported atoms
* @param specialArgs Special arguments; depends on the opcode of the message
*/
private void messageReportedBase(MessageReportedGenericArgs genericArgs,
MessageReportedSpecialArgs specialArgs) {
FrameworkStatsLog.write(
FrameworkStatsLog.HDMI_CEC_MESSAGE_REPORTED,
0, // Placeholder field
genericArgs.mDirection,
genericArgs.mInitiatorLogicalAddress,
genericArgs.mDestinationLogicalAddress,
genericArgs.mOpcode,
genericArgs.mSendMessageResult,
specialArgs.mUserControlPressedCommand,
specialArgs.mFeatureAbortOpcode,
specialArgs.mFeatureAbortReason);
}
/**
* Writes a HdmiCecActiveSourceChanged atom representing a change in the active source.
*
* @param logicalAddress The Logical Address of the new active source
* @param physicalAddress The Physical Address of the new active source
* @param relationshipToActiveSource The relationship between this device and the active source
*/
public void activeSourceChanged(int logicalAddress, int physicalAddress,
@Constants.PathRelationship int relationshipToActiveSource) {
FrameworkStatsLog.write(
FrameworkStatsLog.HDMI_CEC_ACTIVE_SOURCE_CHANGED,
logicalAddress,
physicalAddress,
relationshipToActiveSource
);
}
/**
* Contains the required arguments for creating any HdmiCecMessageReported atom
*/
private class MessageReportedGenericArgs {
final int mDirection;
final int mInitiatorLogicalAddress;
final int mDestinationLogicalAddress;
final int mOpcode;
final int mSendMessageResult;
MessageReportedGenericArgs(int direction, int initiatorLogicalAddress,
int destinationLogicalAddress, int opcode, int sendMessageResult) {
this.mDirection = direction;
this.mInitiatorLogicalAddress = initiatorLogicalAddress;
this.mDestinationLogicalAddress = destinationLogicalAddress;
this.mOpcode = opcode;
this.mSendMessageResult = sendMessageResult;
}
}
/**
* Contains the opcode-dependent arguments for creating a HdmiCecMessageReported atom. Each
* field is initialized to a null-like value by default. Therefore, a freshly constructed
* instance of this object represents a HDMI CEC message whose type does not require any
* additional arguments.
*/
private class MessageReportedSpecialArgs {
int mUserControlPressedCommand = HdmiStatsEnums.USER_CONTROL_PRESSED_COMMAND_UNKNOWN;
int mFeatureAbortOpcode = FEATURE_ABORT_OPCODE_UNKNOWN;
int mFeatureAbortReason = HdmiStatsEnums.FEATURE_ABORT_REASON_UNKNOWN;
}
}

71
services/core/java/com/android/server/hdmi/HdmiCecController.java
View File

@@ -28,9 +28,11 @@ import android.os.Handler;
import android.os.IHwBinder;
import android.os.Looper;
import android.os.RemoteException;
import android.stats.hdmi.HdmiStatsEnums;
import android.util.Slog;
import android.util.SparseArray;
import com.android.internal.util.FrameworkStatsLog;
import com.android.internal.util.IndentingPrintWriter;
import com.android.server.hdmi.HdmiAnnotations.IoThreadOnly;
import com.android.server.hdmi.HdmiAnnotations.ServiceThreadOnly;
@@ -123,10 +125,14 @@ final class HdmiCecController {
private final NativeWrapper mNativeWrapperImpl;
private final HdmiCecAtomWriter mHdmiCecAtomWriter;
// Private constructor. Use HdmiCecController.create().
private HdmiCecController(HdmiControlService service, NativeWrapper nativeWrapper) {
private HdmiCecController(
HdmiControlService service, NativeWrapper nativeWrapper, HdmiCecAtomWriter atomWriter) {
mService = service;
mNativeWrapperImpl = nativeWrapper;
mHdmiCecAtomWriter = atomWriter;
}
/**
@@ -134,21 +140,22 @@ final class HdmiCecController {
* inner device or has no device it will return {@code null}.
*
* <p>Declared as package-private, accessed by {@link HdmiControlService} only.
* @param service {@link HdmiControlService} instance used to create internal handler
* and to pass callback for incoming message or event.
* @param service {@link HdmiControlService} instance used to create internal handler
* and to pass callback for incoming message or event.
* @param atomWriter {@link HdmiCecAtomWriter} instance for writing atoms for metrics.
* @return {@link HdmiCecController} if device is initialized successfully. Otherwise,
* returns {@code null}.
*/
static HdmiCecController create(HdmiControlService service) {
return createWithNativeWrapper(service, new NativeWrapperImpl());
static HdmiCecController create(HdmiControlService service, HdmiCecAtomWriter atomWriter) {
return createWithNativeWrapper(service, new NativeWrapperImpl(), atomWriter);
}
/**
* A factory method with injection of native methods for testing.
*/
static HdmiCecController createWithNativeWrapper(
HdmiControlService service, NativeWrapper nativeWrapper) {
HdmiCecController controller = new HdmiCecController(service, nativeWrapper);
HdmiControlService service, NativeWrapper nativeWrapper, HdmiCecAtomWriter atomWriter) {
HdmiCecController controller = new HdmiCecController(service, nativeWrapper, atomWriter);
String nativePtr = nativeWrapper.nativeInit();
if (nativePtr == null) {
HdmiLogger.warning("Couldn't get tv.cec service.");
@@ -619,7 +626,7 @@ final class HdmiCecController {
public void run() {
HdmiLogger.debug("[S]:" + cecMessage);
byte[] body = buildBody(cecMessage.getOpcode(), cecMessage.getParams());
int i = 0;
int retransmissionCount = 0;
int errorCode = SendMessageResult.SUCCESS;
do {
errorCode = mNativeWrapperImpl.nativeSendCecCommand(
@@ -627,20 +634,25 @@ final class HdmiCecController {
if (errorCode == SendMessageResult.SUCCESS) {
break;
}
} while (i++ < HdmiConfig.RETRANSMISSION_COUNT);
} while (retransmissionCount++ < HdmiConfig.RETRANSMISSION_COUNT);
final int finalError = errorCode;
if (finalError != SendMessageResult.SUCCESS) {
Slog.w(TAG, "Failed to send " + cecMessage + " with errorCode=" + finalError);
}
if (callback != null) {
runOnServiceThread(new Runnable() {
@Override
public void run() {
runOnServiceThread(new Runnable() {
@Override
public void run() {
mHdmiCecAtomWriter.messageReported(
cecMessage,
FrameworkStatsLog.HDMI_CEC_MESSAGE_REPORTED__DIRECTION__OUTGOING,
finalError
);
if (callback != null) {
callback.onSendCompleted(finalError);
}
});
}
}
});
}
});
}
@@ -654,9 +666,38 @@ final class HdmiCecController {
HdmiCecMessage command = HdmiCecMessageBuilder.of(srcAddress, dstAddress, body);
HdmiLogger.debug("[R]:" + command);
addCecMessageToHistory(true /* isReceived */, command);
mHdmiCecAtomWriter.messageReported(command,
incomingMessageDirection(srcAddress, dstAddress));
onReceiveCommand(command);
}
/**
* Computes the direction of an incoming message, as implied by the source and
* destination addresses. This will usually return INCOMING; if not, it can indicate a bug.
*/
private int incomingMessageDirection(int srcAddress, int dstAddress) {
boolean sourceIsLocal = false;
boolean destinationIsLocal = false;
for (HdmiCecLocalDevice localDevice : getLocalDeviceList()) {
int logicalAddress = localDevice.getDeviceInfo().getLogicalAddress();
if (logicalAddress == srcAddress) {
sourceIsLocal = true;
}
if (logicalAddress == dstAddress) {
destinationIsLocal = true;
}
}
if (!sourceIsLocal && destinationIsLocal) {
return HdmiStatsEnums.INCOMING;
} else if (sourceIsLocal && destinationIsLocal) {
return HdmiStatsEnums.TO_SELF;
}
return HdmiStatsEnums.MESSAGE_DIRECTION_OTHER;
}
/**
* Called when a hotplug event issues.
*/

15
services/core/java/com/android/server/hdmi/HdmiControlService.java
View File

@@ -397,6 +397,10 @@ public class HdmiControlService extends SystemService {
// Set to true if the logical address allocation is completed.
private boolean mAddressAllocated = false;
// Object that handles logging statsd atoms.
// Use getAtomWriter() instead of accessing directly, to allow dependency injection for testing.
private HdmiCecAtomWriter mAtomWriter = new HdmiCecAtomWriter();
// Buffer for processing the incoming cec messages while allocating logical addresses.
private final class CecMessageBuffer {
private List<HdmiCecMessage> mBuffer = new ArrayList<>();
@@ -509,7 +513,7 @@ public class HdmiControlService extends SystemService {
mMhlInputChangeEnabled = readBooleanSetting(Global.MHL_INPUT_SWITCHING_ENABLED, true);
if (mCecController == null) {
mCecController = HdmiCecController.create(this);
mCecController = HdmiCecController.create(this, getAtomWriter());
}
if (mCecController != null) {
if (mHdmiControlEnabled) {
@@ -3233,6 +3237,10 @@ public class HdmiControlService extends SystemService {
mActiveSource.logicalAddress = logicalAddress;
mActiveSource.physicalAddress = physicalAddress;
}
getAtomWriter().activeSourceChanged(logicalAddress, physicalAddress,
HdmiUtils.pathRelationship(getPhysicalAddress(), physicalAddress));
// If the current device is a source device, check if the current Active Source matches
// the local device info. Set mIsActiveSource of the local device accordingly.
for (HdmiCecLocalDevice device : getAllLocalDevices()) {
@@ -3363,6 +3371,11 @@ public class HdmiControlService extends SystemService {
}
}
@VisibleForTesting
HdmiCecAtomWriter getAtomWriter() {
return mAtomWriter;
}
boolean isMhlInputChangeEnabled() {
synchronized (mLock) {
return mMhlInputChangeEnabled;

2
services/tests/servicestests/src/com/android/server/hdmi/ActiveSourceActionTest.java
View File

@@ -110,7 +110,7 @@ public class ActiveSourceActionTest {
mHdmiControlService.setIoLooper(looper);
mNativeWrapper = new FakeNativeWrapper();
HdmiCecController hdmiCecController = HdmiCecController.createWithNativeWrapper(
this.mHdmiControlService, mNativeWrapper);
this.mHdmiControlService, mNativeWrapper, mHdmiControlService.getAtomWriter());
mHdmiControlService.setCecController(hdmiCecController);
mHdmiControlService.setHdmiMhlController(HdmiMhlControllerStub.create(mHdmiControlService));
mHdmiControlService.setMessageValidator(new HdmiCecMessageValidator(mHdmiControlService));

4
services/tests/servicestests/src/com/android/server/hdmi/ArcInitiationActionFromAvrTest.java
View File

@@ -120,8 +120,8 @@ public class ArcInitiationActionFromAvrTest {
Looper looper = mTestLooper.getLooper();
mHdmiControlService.setIoLooper(looper);
mNativeWrapper = new FakeNativeWrapper();
mHdmiCecController =
HdmiCecController.createWithNativeWrapper(this.mHdmiControlService, mNativeWrapper);
mHdmiCecController = HdmiCecController.createWithNativeWrapper(
this.mHdmiControlService, mNativeWrapper, mHdmiControlService.getAtomWriter());
mHdmiControlService.setCecController(mHdmiCecController);
mHdmiControlService.setHdmiMhlController(HdmiMhlControllerStub.create(mHdmiControlService));
mHdmiControlService.setMessageValidator(new HdmiCecMessageValidator(mHdmiControlService));

4
services/tests/servicestests/src/com/android/server/hdmi/ArcTerminationActionFromAvrTest.java
View File

@@ -114,8 +114,8 @@ public class ArcTerminationActionFromAvrTest {
Looper looper = mTestLooper.getLooper();
mHdmiControlService.setIoLooper(looper);
mNativeWrapper = new FakeNativeWrapper();
mHdmiCecController =
HdmiCecController.createWithNativeWrapper(this.mHdmiControlService, mNativeWrapper);
mHdmiCecController = HdmiCecController.createWithNativeWrapper(
this.mHdmiControlService, mNativeWrapper, mHdmiControlService.getAtomWriter());
mHdmiControlService.setCecController(mHdmiCecController);
mHdmiControlService.setHdmiMhlController(HdmiMhlControllerStub.create(mHdmiControlService));
mHdmiControlService.setMessageValidator(new HdmiCecMessageValidator(mHdmiControlService));

4
services/tests/servicestests/src/com/android/server/hdmi/HdmiCecControllerTest.java
View File

@@ -89,8 +89,8 @@ public class HdmiCecControllerTest {
mMyLooper = mTestLooper.getLooper();
mHdmiControlService = new MyHdmiControlService(InstrumentationRegistry.getTargetContext());
mNativeWrapper = new FakeNativeWrapper();
mHdmiCecController =
HdmiCecController.createWithNativeWrapper(mHdmiControlService, mNativeWrapper);
mHdmiCecController = HdmiCecController.createWithNativeWrapper(
mHdmiControlService, mNativeWrapper, mHdmiControlService.getAtomWriter());
}
/** Tests for {@link HdmiCecController#allocateLogicalAddress} */

4
services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystemTest.java
View File

@@ -188,8 +188,8 @@ public class HdmiCecLocalDeviceAudioSystemTest {
mHdmiControlService.setIoLooper(mMyLooper);
mNativeWrapper = new FakeNativeWrapper();
mNativeWrapper.setPhysicalAddress(SELF_PHYSICAL_ADDRESS);
mHdmiCecController =
HdmiCecController.createWithNativeWrapper(mHdmiControlService, mNativeWrapper);
mHdmiCecController = HdmiCecController.createWithNativeWrapper(
mHdmiControlService, mNativeWrapper, mHdmiControlService.getAtomWriter());
mHdmiControlService.setCecController(mHdmiCecController);
mHdmiControlService.setHdmiMhlController(HdmiMhlControllerStub.create(mHdmiControlService));
mHdmiControlService.setMessageValidator(new HdmiCecMessageValidator(mHdmiControlService));

4
services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDevicePlaybackTest.java
View File

@@ -119,8 +119,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mHdmiCecLocalDevicePlayback.init();
mHdmiControlService.setIoLooper(mMyLooper);
mNativeWrapper = new FakeNativeWrapper();
mHdmiCecController =
HdmiCecController.createWithNativeWrapper(mHdmiControlService, mNativeWrapper);
mHdmiCecController = HdmiCecController.createWithNativeWrapper(
mHdmiControlService, mNativeWrapper, mHdmiControlService.getAtomWriter());
mHdmiControlService.setCecController(mHdmiCecController);
mHdmiControlService.setHdmiMhlController(HdmiMhlControllerStub.create(mHdmiControlService));
mHdmiControlService.setMessageValidator(new HdmiCecMessageValidator(mHdmiControlService));

5
services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceTest.java
View File

@@ -117,9 +117,8 @@ public class HdmiCecLocalDeviceTest {
}
};
mHdmiControlService.setIoLooper(mTestLooper.getLooper());
mHdmiCecController =
HdmiCecController.createWithNativeWrapper(
mHdmiControlService, new FakeNativeWrapper());
mHdmiCecController = HdmiCecController.createWithNativeWrapper(
mHdmiControlService, new FakeNativeWrapper(), mHdmiControlService.getAtomWriter());
mHdmiControlService.setCecController(mHdmiCecController);
mHdmiLocalDevice = new MyHdmiCecLocalDevice(mHdmiControlService, DEVICE_TV);
mMessageValidator =

4
services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceTvTest.java
View File

@@ -97,8 +97,8 @@ public class HdmiCecLocalDeviceTvTest {
mHdmiCecLocalDeviceTv.init();
mHdmiControlService.setIoLooper(mMyLooper);
mNativeWrapper = new FakeNativeWrapper();
mHdmiCecController =
HdmiCecController.createWithNativeWrapper(mHdmiControlService, mNativeWrapper);
mHdmiCecController = HdmiCecController.createWithNativeWrapper(
mHdmiControlService, mNativeWrapper, mHdmiControlService.getAtomWriter());
mHdmiControlService.setCecController(mHdmiCecController);
mHdmiControlService.setHdmiMhlController(HdmiMhlControllerStub.create(mHdmiControlService));
mHdmiControlService.setMessageValidator(new HdmiCecMessageValidator(mHdmiControlService));

12
services/tests/servicestests/src/com/android/server/hdmi/HdmiControlServiceBinderAPITest.java
View File

@@ -15,28 +15,28 @@
*/
package com.android.server.hdmi;
import static android.os.SystemClock.sleep;
import static com.android.server.hdmi.HdmiControlService.INITIATED_BY_ENABLE_CEC;
import static com.google.common.truth.Truth.assertThat;
import static junit.framework.Assert.assertEquals;
import android.hardware.hdmi.HdmiControlManager;
import android.hardware.hdmi.HdmiPortInfo;
import android.hardware.hdmi.IHdmiControlCallback;
import android.os.Looper;
import android.os.SystemProperties;
import android.os.test.TestLooper;
import android.util.Slog;
import androidx.test.InstrumentationRegistry;
import androidx.test.filters.SmallTest;
import java.util.ArrayList;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import java.util.ArrayList;
/**
* Tests for {@link HdmiControlServiceBinderAPITest} class.
*/
@@ -158,8 +158,8 @@ public class HdmiControlServiceBinderAPITest {
mHdmiControlService.setIoLooper(mMyLooper);
mNativeWrapper = new FakeNativeWrapper();
mHdmiCecController =
HdmiCecController.createWithNativeWrapper(mHdmiControlService, mNativeWrapper);
mHdmiCecController = HdmiCecController.createWithNativeWrapper(
mHdmiControlService, mNativeWrapper, mHdmiControlService.getAtomWriter());
mHdmiControlService.setCecController(mHdmiCecController);
mHdmiControlService.setHdmiMhlController(HdmiMhlControllerStub.create(mHdmiControlService));
mHdmiControlService.setMessageValidator(new HdmiCecMessageValidator(mHdmiControlService));

4
services/tests/servicestests/src/com/android/server/hdmi/HdmiControlServiceTest.java
View File

@@ -158,8 +158,8 @@ public class HdmiControlServiceTest {
mHdmiControlService.setIoLooper(mMyLooper);
mNativeWrapper = new FakeNativeWrapper();
mHdmiCecController =
HdmiCecController.createWithNativeWrapper(mHdmiControlService, mNativeWrapper);
mHdmiCecController = HdmiCecController.createWithNativeWrapper(
mHdmiControlService, mNativeWrapper, mHdmiControlService.getAtomWriter());
mHdmiControlService.setCecController(mHdmiCecController);
mHdmiControlService.setHdmiMhlController(HdmiMhlControllerStub.create(mHdmiControlService));
mHdmiControlService.setMessageValidator(new HdmiCecMessageValidator(mHdmiControlService));