1
2
3
4
5
6
7
8
9
10
//framework/base/services/java/com/android/server/SystemServer.java
private void startOtherServices() {
...
    if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_HDMI_CEC)) {
        traceBeginAndSlog("StartHdmiControlService");
        mSystemServiceManager.startService(HdmiControlService.class);
        traceEnd();
    }
...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
//frameworks/base/services/core/java/com/android/server/hdmi/HdmiControlService.java
//mLocalDevices是Integer列表
private final List<Integer> mLocalDevices;
//Handler用于在service线程运行,因为使用了默认的Looper。
private final Handler mHandler = new Handler();
...
public HdmiControlService(Context context) {
    super(context);
    //这里可以看出，当设置了"ro.hdmi.device_type"时，mLocalDevices就会根据属性
    //生成对应类型的LocalDevice
    mLocalDevices = getIntList(SystemProperties.get(Constants.PROPERTY_DEVICE_TYPE));
    //mSettingsObserver是为了后续创建ContentObserver监听数据库的变化做准备
    mSettingsObserver = new SettingsObserver(mHandler);
}

@Override
public void onStart() {
    //启动Io线程
    if (mIoLooper == null) {
        mIoThread.start();
        //后续将mIoLooper传到HdmiCecController的handler中，使得消息在mIoThread线程中处理。
        mIoLooper = mIoThread.getLooper();
    }
    mPowerStatus = HdmiControlManager.POWER_STATUS_TRANSIENT_TO_ON;
    mProhibitMode = false;
    //数据库hdmi_control_enabled用于控制Hdmi控制是否使能
    mHdmiControlEnabled = readBooleanSetting(Global.HDMI_CONTROL_ENABLED, true);
    ...
    //新建CecController,初始化Native层
    if (mCecController == null) {
        mCecController = dHdmiCecController.create(this);
    }
    if (mCecController != null) {
        if (mHdmiControlEnabled) {
            /*
            仅有mHdmiControlEnabled打开时，初始化Cec.
            注意到初始化还会传入初始化原因，包括:
            1. static final int INITIATED_BY_ENABLE_CEC = 0;
            2. static final int INITIATED_BY_BOOT_UP = 1;
            3. static final int INITIATED_BY_SCREEN_ON = 2;
            4. static final int INITIATED_BY_WAKE_UP_MESSAGE = 3;
            5. static final int INITIATED_BY_HOTPLUG = 4;
            */
            initializeCec(INITIATED_BY_BOOT_UP);
        } else {
            //假如mHdmiControlEnabled关闭时，向底层发送ENABLE_CEC设置为false
            mCecController.setOption(OptionKey.ENABLE_CEC, false);
        }
    } else {
        Slog.i(TAG, "Device does not support HDMI-CEC.");
        return;
    }
    ...
    initPortInfo();
    if (mMessageValidator == null) {
        mMessageValidator = new HdmiCecMessageValidator(this);
    }
    //创建Binder服务，用以和HdmiControlService进行交互
    publishBinderService(Context.HDMI_CONTROL_SERVICE, new BinderService());
    //注册广播接收器，用以监听如关屏，开屏，关机，配置改变的广播
    if (mCecController != null) {
        // Register broadcast receiver for power state change.
        IntentFilter filter = new IntentFilter();
        filter.addAction(Intent.ACTION_SCREEN_OFF);
        filter.addAction(Intent.ACTION_SCREEN_ON);
        filter.addAction(Intent.ACTION_SHUTDOWN);
        filter.addAction(Intent.ACTION_CONFIGURATION_CHANGED);
        getContext().registerReceiver(mHdmiControlBroadcastReceiver, filter);
        /*
         注册ContentObserver用以监听数据库的变化,包括:
            Global.HDMI_CONTROL_ENABLED,
            Global.HDMI_CONTROL_AUTO_WAKEUP_ENABLED,
            Global.HDMI_CONTROL_AUTO_DEVICE_OFF_ENABLED,
            Global.HDMI_SYSTEM_AUDIO_CONTROL_ENABLED,
            Global.MHL_INPUT_SWITCHING_ENABLED,
            Global.MHL_POWER_CHARGE_ENABLED,
            Global.HDMI_CEC_SWITCH_ENABLED,
            Global.DEVICE_NAME
        */
        registerContentObserver();
    }
    ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//frameworks/base/services/core/java/com/android/server/hdmi/HdmiCecController.java
static HdmiCecController create(HdmiControlService service) {
    //新建wrapper类，用于方便调用HdmiCecController的native接口
    return createWithNativeWrapper(service, new NativeWrapperImpl());
}

static HdmiCecController createWithNativeWrapper(
    HdmiControlService service, NativeWrapper nativeWrapper) {
        //这里才新建HdmiCecController
        HdmiCecController controller = new HdmiCecController(service, nativeWrapper);
        //nativeInit返回的是Native层HdmiCecController的对象的地址。
        long nativePtr = nativeWrapper
            .nativeInit(controller, service.getServiceLooper().getQueue());
        if (nativePtr == 0L) {
            controller = null;
            return null;
        }
        //HdmiCecController初始化
        controller.init(nativePtr);
        return controller;
}

private void init(long nativePtr) {
    //将IoLooper设置到新建mIoHandler中，得以将处理流程放在Io线程中。
    mIoHandler = new Handler(mService.getIoLooper());
    //将服务流程Looper放到新建mControlHandler中
    mControlHandler = new Handler(mService.getServiceLooper());
    mNativePtr = nativePtr;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
//frameworks/base/services/core/java/com/android/server/hdmi/HdmiControlService.java
private class HdmiControlBroadcastReceiver extends BroadcastReceiver {
@ServiceThreadOnly
@Override
public void onReceive(Context context, Intent intent) {
    //确定该流程是在Service线程进行的。
    assertRunOnServiceThread();
    boolean isReboot = SystemProperties.get(SHUTDOWN_ACTION_PROPERTY).contains("1");
    switch (intent.getAction()) {
        case Intent.ACTION_SCREEN_OFF:
            //关屏前，检查mPowerStatus是否为POWER_STATUS_ON状态或者POWER_STATUS_TRANSIENT_TO_ON状态
            //且当前不是重启状态
            if (isPowerOnOrTransient() && !isReboot) {
                //调用onStandby,传参STANDBY_SCREEN_OFF
                onStandby(STANDBY_SCREEN_OFF);
            }
            break;
            ...
        case Intent.ACTION_SHUTDOWN:
            if (isPowerOnOrTransient() && !isReboot) {
                //调用onStandby,传参STANDBY_SHUTDOWN
                onStandby(STANDBY_SHUTDOWN);
            }
            break;
    }
}

@ServiceThreadOnly
@VisibleForTesting
protected void onStandby(final int standbyAction) {
    assertRunOnServiceThread();
    mPowerStatus = HdmiControlManager.POWER_STATUS_TRANSIENT_TO_STANDBY;
    //假如客户端设置了VendorCommandListener,在调用onStandby时会通知到客户端,
    //并告知原因为CONTROL_STATE_CHANGED_REASON_STANDBY
    invokeVendorCommandListenersOnControlStateChanged(false,
            HdmiControlManager.CONTROL_STATE_CHANGED_REASON_STANDBY);
    //获取LocalDevices，此处为Playback设备。
    final List<HdmiCecLocalDevice> devices = getAllLocalDevices();
    //假如还没收到sink端的消息，且设备设备的canGoToStandby还没有准备好进入休眠模式
    if (!isStandbyMessageReceived() && !canGoToStandby()) {
        //设置全局变量mPowerStatus为POWER_STATUS_STANDBY。
        mPowerStatus = HdmiControlManager.POWER_STATUS_STANDBY;
        for (HdmiCecLocalDevice device : devices) {
            //调用Playback设备的onStandby方法
            device.onStandby(mStandbyMessageReceived, standbyAction);
        }
        return;
    }
    //假设已经收到休眠消息　或者已经能够进入休眠状态了，此时再调用onStandBy，会调用disableDevices,
    //其实质是调用PlayBackdevice的disableDevice.并新建了一个callback,等待disable完成后，调用onCleared设置环境
    disableDevices(new PendingActionClearedCallback() {
        @Override
        public void onCleared(HdmiCecLocalDevice device) {
            Slog.v(TAG, "On standby-action cleared:" + device.mDeviceType);
            devices.remove(device);
            if (devices.isEmpty()) {
                onStandbyCompleted(standbyAction);
            }
        }
    });
}

private void disableDevices(PendingActionClearedCallback callback) {
    if (mCecController != null) {
        for (HdmiCecLocalDevice device : mCecController.getLocalDeviceList()) {
            device.disableDevice(mStandbyMessageReceived, callback);
        }
    }
    ....
｝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//frameworks/base/services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java
@Override
    @ServiceThreadOnly
    protected void onStandby(boolean initiatedByCec, int standbyAction) {
        assertRunOnServiceThread();
        if (!mService.isControlEnabled() || initiatedByCec || !mAutoTvOff) {
            return;
        }
        switch (standbyAction) {
            case HdmiControlService.STANDBY_SCREEN_OFF:
                //source端为localDevice,所以为mAddress.dest为ADDR_TV，电视的地址
                mService.sendCecCommand(
                        HdmiCecMessageBuilder.buildStandby(mAddress, Constants.ADDR_TV));
                break;
            case HdmiControlService.STANDBY_SHUTDOWN:
                //source端为localDevice,所以为mAddress.dest为ADDR_BROADCAST，广播的地址
                mService.sendCecCommand(
                        HdmiCecMessageBuilder.buildStandby(mAddress, Constants.ADDR_BROADCAST));
                break;
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//frameworks/base/services/core/java/com/android/server/hdmi/HdmiCecMessageBuilder.java
public static HdmiCecMessage buildStandby(int src, int dest) {
    return buildCommand(src, dest, Constants.MESSAGE_STANDBY);
}

private static HdmiCecMessage buildCommand(int src, int dest, int opcode) {
    //原来是返回了一新的HdmiCecMessage对象，并设置了opcode,src端以及dest端。
    return new HdmiCecMessage(src, dest, opcode, HdmiCecMessage.EMPTY_PARAM);
}

public HdmiCecMessage(int source, int destination, int opcode, byte[] params) {
    mSource = source;
    mDestination = destination;
    mOpcode = opcode & 0xFF;
    mParams = Arrays.copyOf(params, params.length);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//frameworks/base/services/core/java/com/android/server/hdmi/HdmiControlService.java
@ServiceThreadOnly
   void sendCecCommand(HdmiCecMessage command, @Nullable SendMessageCallback callback) {
       assertRunOnServiceThread();
       //MessageValidator会检查command命令是否有效，分别从source，dest等进行分析。
       if (mMessageValidator.isValid(command) == HdmiCecMessageValidator.OK) {
           //有效的命令将允许通过HdmiCecController发送下去
           mCecController.sendCommand(command, callback);
       } else {
           HdmiLogger.error("Invalid message type:" + command);
           if (callback != null) {
               callback.onSendCompleted(SendMessageResult.FAIL);
           }
       }
   }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
//frameworks/base/services/core/java/com/android/server/hdmi/HdmiCecController.java
@ServiceThreadOnly
void sendCommand(final HdmiCecMessage cecMessage,
        final HdmiControlService.SendMessageCallback callback) {
    assertRunOnServiceThread();
    //生成一个MessageHistoryRecord对象，加入到ArrayBlockingQueue中进行管理。
    addMessageToHistory(false /* isReceived */, cecMessage);
    //想运行到IoThread？只需要定义一个Runnable对象并post到IoThread中即可。
    runOnIoThread(new Runnable() {
        @Override
        public void run() {
            HdmiLogger.debug("[S]:" + cecMessage);
            //传的是二进制数byte
            byte[] body = buildBody(cecMessage.getOpcode(), cecMessage.getParams());
            int i = 0;
            int errorCode = SendMessageResult.SUCCESS;
            do {
                //核心是通过NativeWrapperImpl将消息发送到Native层。
                errorCode = mNativeWrapperImpl.nativeSendCecCommand(mNativePtr,
                    cecMessage.getSource(), cecMessage.getDestination(), body);
                if (errorCode == SendMessageResult.SUCCESS) {
                    break;
                }
                //将会在限定次数内进行尝试
            } while (i++ < HdmiConfig.RETRANSMISSION_COUNT);

            final int finalError = errorCode;
            if (finalError != SendMessageResult.SUCCESS) {
                Slog.w(TAG, "Failed to send " + cecMessage + " with errorCode=" + finalError);
            }
            //假如回调不为空，将会在Service线程里运行回调方法，告诉调用方已经发送完成了。
            if (callback != null) {
                runOnServiceThread(new Runnable() {
                    @Override
                    public void run() {
                        callback.onSendCompleted(finalError);
                    }
                });
            }
        }
    });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
    //frameworks/base/services/core/java/com/android/server/hdmi/HdmiCecController.java
    @ServiceThreadOnly
    private void handleIncomingCecCommand(int srcAddress, int dstAddress, byte[] body) {
        assertRunOnServiceThread();
        HdmiCecMessage command = HdmiCecMessageBuilder.of(srcAddress, dstAddress, body);
        HdmiLogger.debug("[R]:" + command);
        //生成一个新的MessageHistoryRecord对象加入到历史中(ArrayBlockingQueue)
        addMessageToHistory(true /* isReceived */, command);
        //调用onReceiveCommand
        onReceiveCommand(command);
    }
    
    @ServiceThreadOnly
    private void onReceiveCommand(HdmiCecMessage message) {
        assertRunOnServiceThread();
        //调用HdmiControlService的handleCecCommand处理消息
        if (isAcceptableAddress(message.getDestination()) && mService.handleCecCommand(message)) {
            return;
        }
        // Not handled message, so we will reply it with <Feature Abort>.
        maySendFeatureAbortCommand(message, Constants.ABORT_UNRECOGNIZED_OPCODE);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//frameworks/base/services/core/java/com/android/server/hdmi/HdmiControlService.java
@ServiceThreadOnly
    boolean handleCecCommand(HdmiCecMessage message) {
        assertRunOnServiceThread();
        int errorCode = mMessageValidator.isValid(message);
        if (errorCode != HdmiCecMessageValidator.OK) {
            // We'll not response on the messages with the invalid source or destination
            // or with parameter length shorter than specified in the standard.
            if (errorCode == HdmiCecMessageValidator.ERROR_PARAMETER) {
                maySendFeatureAbortCommand(message, Constants.ABORT_INVALID_OPERAND);
            }
            return true;
        }
        //传到localDevice中处理
        if (dispatchMessageToLocalDevice(message)) {
            return true;
        }

        return (!mAddressAllocated) ? mCecMessageBuffer.bufferMessage(message) : false;
    }
    
    @ServiceThreadOnly
    private boolean dispatchMessageToLocalDevice(HdmiCecMessage message) {
        assertRunOnServiceThread();
        for (HdmiCecLocalDevice device : mCecController.getLocalDeviceList()) {
            if (device.dispatchMessage(message)
                    && message.getDestination() != Constants.ADDR_BROADCAST) {
                return true;
            }
        }

        if (message.getDestination() != Constants.ADDR_BROADCAST) {
            HdmiLogger.warning("Unhandled cec command:" + message);
        }
        return false;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
//frameworks/base/services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java
    @ServiceThreadOnly
    boolean dispatchMessage(HdmiCecMessage message) {
        assertRunOnServiceThread();
        int dest = message.getDestination();
        if (dest != mAddress && dest != Constants.ADDR_BROADCAST) {
            return false;
        }
        mCecMessageCache.cacheMessage(message);
        return onMessage(message);
    }

    @ServiceThreadOnly
    protected final boolean onMessage(HdmiCecMessage message) {
        assertRunOnServiceThread();
        if (dispatchMessageToAction(message)) {
            return true;
        }
        switch (message.getOpcode()) {
            ...
            case Constants.MESSAGE_STANDBY:
                //调用handleStandby
                return handleStandby(message);
            ...
            default:
                return false;
        }
    }
    
    @ServiceThreadOnly
    protected boolean handleStandby(HdmiCecMessage message) {
        assertRunOnServiceThread();
        // Seq #12
        if (mService.isControlEnabled()
                && !mService.isProhibitMode()
                && mService.isPowerOnOrTransient()) {
            //调用服务的standby方法
            mService.standby();
            return true;
        }
        return false;
    }

    //frameworks/base/services/core/java/com/android/server/hdmi/HdmiControlService.java
    @ServiceThreadOnly
    void standby() {
        assertRunOnServiceThread();
        if (!canGoToStandby()) {
            return;
        }
        mStandbyMessageReceived = true;
        //最终到PowerManager的goToSleep进入休眠
        mPowerManager.goToSleep(SystemClock.uptimeMillis(), PowerManager.GO_TO_SLEEP_REASON_HDMI, 0);
        // PowerManger will send the broadcast Intent.ACTION_SCREEN_OFF and after this gets
        // the intent, the sequence will continue at onStandby().
    }