Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 47927f75 authored by Jinsuk Kim's avatar Jinsuk Kim Committed by Jungshik Jang
Browse files

DO NOT MERGE: CEC Initialization per device type 

CEC initialization may vary from device type to type. Changed logical address
map to HdmiCecLocalDevice map to handle it. These per-type classes for local
device will be extended also to take care of incoming CEC commands that should
require different action based on device type.

Change-Id: Ia59a464607b14e942fcf83e63aa1d6310ca6a575
parent 404d7041

services/core/java/com/android/server/hdmi/HdmiCecController.java

+42 −53
Original line number Diff line number Diff line
@@ -21,7 +21,6 @@ import android.hardware.hdmi.HdmiCecDeviceInfo; 
import android.hardware.hdmi.HdmiCecMessage;

import android.os.Handler;

import android.util.SparseArray;

import android.util.SparseIntArray;



import libcore.util.EmptyArray;
@@ -75,14 +74,12 @@ final class HdmiCecController { 
    // used as key of container.

    private final SparseArray<HdmiCecDeviceInfo> mDeviceInfos =

            new SparseArray<HdmiCecDeviceInfo>();

    // Set-like container for all local devices' logical address.

    // Key and value are same.

    private final SparseIntArray mLocalAddresses = new SparseIntArray();



    // Stores the local CEC devices in the system.

    private final ArrayList<HdmiCecLocalDevice> mLocalDevices = new ArrayList<>();



    // Private constructor.  Use HdmiCecController.create().

    private HdmiCecController() {

        // TODO: Consider restoring the local device addresses from persistent storage

        //       to allocate the same addresses again if possible.

    }



    /**
@@ -96,53 +93,41 @@ final class HdmiCecController { 
     *         returns {@code null}.

     */

    static HdmiCecController create(HdmiControlService service) {

        HdmiCecController handler = new HdmiCecController();

        long nativePtr = nativeInit(handler);

        HdmiCecController controller = new HdmiCecController();

        long nativePtr = nativeInit(controller);

        if (nativePtr == 0L) {

            handler = null;

            controller = null;

            return null;

        }



        handler.init(service, nativePtr);

        return handler;

        controller.init(service, nativePtr);

        return controller;

    }



    /**

     * Initialize {@link #mLocalAddresses} by allocating logical addresses for each hosted type.

     *

     * @param deviceTypes local device types

     */

    void initializeLocalDevices(int[] deviceTypes) {

        for (int deviceType : deviceTypes) {

            int preferred = getPreferredAddress(deviceType);

            allocateLogicalAddress(deviceType, preferred, new AllocateLogicalAddressCallback() {

                @Override

                public void onAllocated(int deviceType, int logicalAddress) {

                    addLogicalAddress(logicalAddress);

                }

            });

        }

    private void init(HdmiControlService service, long nativePtr) {

        mService = service;

        mIoHandler = new Handler(service.getServiceLooper());

        mControlHandler = new Handler(service.getServiceLooper());

        mNativePtr = nativePtr;

    }



    /**

     * Get the preferred address for a given type.

     * Perform initialization for each hosted device.

     *

     * @param deviceType logical device type to get the address for

     * @return preferred address; {@link HdmiCec#ADDR_UNREGISTERED} if not available.

     * @param deviceTypes array of device types

     */

    private int getPreferredAddress(int deviceType) {

        // Uses the data restored from persistent memory at boot up if they are available.

        // Otherwise we return UNREGISTERED indicating there is no preferred address.

        // Note that for address SPECIFIC_USE(14), HdmiCec.getTypeFromAddress() returns DEVICE_TV,

        // meaning that we do not support device type video processor yet.

        for (int i = 0; i < mLocalAddresses.size(); ++i) {

            int address = mLocalAddresses.keyAt(i);

            int type = HdmiCec.getTypeFromAddress(address);

            if (type == deviceType) {

                return address;

    void initializeLocalDevices(int[] deviceTypes) {

        for (int type : deviceTypes) {

            HdmiCecLocalDevice device = HdmiCecLocalDevice.create(this, type);

            if (device == null) {

                continue;

            }

            // TODO: Consider restoring the local device addresses from persistent storage

            //       to allocate the same addresses again if possible.

            device.setPreferredAddress(HdmiCec.ADDR_UNREGISTERED);

            mLocalDevices.add(device);

            device.init();

        }

        return HdmiCec.ADDR_UNREGISTERED;

    }



    /**
@@ -310,7 +295,6 @@ final class HdmiCecController { 
     */

    int addLogicalAddress(int newLogicalAddress) {

        if (HdmiCec.isValidAddress(newLogicalAddress)) {

            mLocalAddresses.put(newLogicalAddress, newLogicalAddress);

            return nativeAddLogicalAddress(mNativePtr, newLogicalAddress);

        } else {

            return -1;
@@ -325,7 +309,9 @@ final class HdmiCecController { 
    void clearLogicalAddress() {

        // TODO: consider to backup logical address so that new logical address

        // allocation can use it as preferred address.

        mLocalAddresses.clear();

        for (HdmiCecLocalDevice device : mLocalDevices) {

            device.clearAddress();

        }

        nativeClearLogicalAddress(mNativePtr);

    }
@@ -367,18 +353,17 @@ final class HdmiCecController { 
        mControlHandler.post(runnable);

    }



    private void init(HdmiControlService service, long nativePtr) {

        mService = service;

        mIoHandler = new Handler(service.getServiceLooper());

        mControlHandler = new Handler(service.getServiceLooper());

        mNativePtr = nativePtr;

    }



    private boolean isAcceptableAddress(int address) {

        // Can access command targeting devices available in local device or

        // broadcast command.

        return address == HdmiCec.ADDR_BROADCAST

                || mLocalAddresses.indexOfKey(address) < 0;

        // Can access command targeting devices available in local device or broadcast command.

        if (address == HdmiCec.ADDR_BROADCAST) {

            return true;

        }

        for (HdmiCecLocalDevice device : mLocalDevices) {

            if (device.isAddressOf(address)) {

                return true;

            }

        }

        return false;

    }



    private void onReceiveCommand(HdmiCecMessage message) {
@@ -397,6 +382,10 @@ final class HdmiCecController { 
        sendCommand(cecMessage, null);

    }



    void sendCommand(HdmiCecMessage cecMessage) {

        sendCommand(cecMessage, null);

    }



    void sendCommand(final HdmiCecMessage cecMessage,

            final HdmiControlService.SendMessageCallback callback) {

        runOnIoThread(new Runnable() {

services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java

0 → 100644
+78 −0
Original line number Diff line number Diff line 
/*

 * 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 com.android.server.hdmi;



import com.android.server.hdmi.HdmiCecController.AllocateLogicalAddressCallback;



import android.hardware.hdmi.HdmiCec;



/**

 * Class that models a logical CEC device hosted in this system. Handles initialization,

 * CEC commands that call for actions customized per device type.

 */

abstract class HdmiCecLocalDevice {



    protected final HdmiCecController mController;

    protected final int mDeviceType;

    protected int mAddress;

    protected int mPreferredAddress;



    protected HdmiCecLocalDevice(HdmiCecController controller, int deviceType) {

        mController = controller;

        mDeviceType = deviceType;

        mAddress = HdmiCec.ADDR_UNREGISTERED;

    }



    // Factory method that returns HdmiCecLocalDevice of corresponding type.

    static HdmiCecLocalDevice create(HdmiCecController controller, int deviceType) {

        switch (deviceType) {

        case HdmiCec.DEVICE_TV:

            return new HdmiCecLocalDeviceTv(controller);

        case HdmiCec.DEVICE_PLAYBACK:

            return new HdmiCecLocalDevicePlayback(controller);

        default:

            return null;

        }

    }



    abstract void init();



    protected void allocateAddress(int type) {

        mController.allocateLogicalAddress(type, mPreferredAddress,

                new AllocateLogicalAddressCallback() {

            @Override

            public void onAllocated(int deviceType, int logicalAddress) {

                mAddress = mPreferredAddress = logicalAddress;

                mController.addLogicalAddress(logicalAddress);

            }

        });

    }



    // Returns true if the logical address is same as the argument.

    boolean isAddressOf(int addr) {

        return addr == mAddress;

    }



    // Resets the logical address to unregistered(15), meaning the logical device is invalid.

    void clearAddress() {

        mAddress = HdmiCec.ADDR_UNREGISTERED;

    }



    void setPreferredAddress(int addr) {

        mPreferredAddress = addr;

    }

}

services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java

0 → 100644
+36 −0
Original line number Diff line number Diff line 
/*

 * 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 com.android.server.hdmi;



import android.hardware.hdmi.HdmiCec;



/**

 * Represent a logical device of type Playback residing in Android system.

 */

final class HdmiCecLocalDevicePlayback extends HdmiCecLocalDevice {



    HdmiCecLocalDevicePlayback(HdmiCecController controller) {

        super(controller, HdmiCec.DEVICE_PLAYBACK);

    }



    @Override

    void init() {

        allocateAddress(mDeviceType);

        mController.sendCommand(HdmiCecMessageBuilder.buildReportPhysicalAddressCommand(

                mAddress, mController.getPhysicalAddress(), mDeviceType));

    }

}

services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceTv.java

0 → 100644
+43 −0
Original line number Diff line number Diff line 
/*

 * 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 com.android.server.hdmi;



import android.hardware.hdmi.HdmiCec;



/**

 * Represent a logical device of type TV residing in Android system.

 */

final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {



    HdmiCecLocalDeviceTv(HdmiCecController controller) {

        super(controller, HdmiCec.DEVICE_TV);

    }



    @Override

    void init() {

        allocateAddress(mDeviceType);



        // TODO: vendor-specific initialization here.



        mController.sendCommand(HdmiCecMessageBuilder.buildReportPhysicalAddressCommand(

                mAddress, mController.getPhysicalAddress(), mDeviceType));

        mController.sendCommand(HdmiCecMessageBuilder.buildDeviceVendorIdCommand(

                mAddress, mController.getVendorId()));



        // TODO: Start routing control action, device discovery action.

    }

}