diff --git a/services/core/java/com/android/server/hdmi/ActiveSourceHandler.java b/services/core/java/com/android/server/hdmi/ActiveSourceHandler.java
index dcf43a3..2c8c1c1 100644
--- a/services/core/java/com/android/server/hdmi/ActiveSourceHandler.java
+++ b/services/core/java/com/android/server/hdmi/ActiveSourceHandler.java
@@ -18,9 +18,8 @@
 
 import android.annotation.Nullable;
 import android.hardware.hdmi.IHdmiControlCallback;
-import android.hardware.hdmi.HdmiCec;
 import android.hardware.hdmi.HdmiCecDeviceInfo;
-import android.hardware.hdmi.HdmiCecMessage;
+import android.hardware.hdmi.HdmiControlManager;
 import android.os.RemoteException;
 import android.util.Slog;
 
@@ -62,7 +61,7 @@
         // Seq #17
         HdmiCecLocalDeviceTv tv = mSource;
         if (getSourcePath() == activePath && tv.getActiveSource() == getSourceAddress()) {
-            invokeCallback(HdmiCec.RESULT_SUCCESS);
+            invokeCallback(HdmiControlManager.RESULT_SUCCESS);
             return;
         }
         HdmiCecDeviceInfo device = mService.getDeviceInfo(activeAddress);
@@ -77,7 +76,7 @@
             if (currentActive != activeAddress && currentPath != activePath) {
                 tv.updateActivePortId(mService.pathToPortId(activePath));
             }
-            invokeCallback(HdmiCec.RESULT_SUCCESS);
+            invokeCallback(HdmiControlManager.RESULT_SUCCESS);
         } else {
             // TV is in a mode that should keep its current source/input from
             // being changed for its operation. Reclaim the active source
@@ -87,7 +86,7 @@
                         HdmiCecMessageBuilder.buildActiveSource(currentActive, currentPath);
                 mService.sendCecCommand(activeSource);
                 tv.updateActiveSource(currentActive, currentPath);
-                invokeCallback(HdmiCec.RESULT_SUCCESS);
+                invokeCallback(HdmiControlManager.RESULT_SUCCESS);
             } else {
                 HdmiCecMessage routingChange = HdmiCecMessageBuilder.buildRoutingChange(
                         getSourceAddress(), activePath, currentPath);
diff --git a/services/core/java/com/android/server/hdmi/Constants.java b/services/core/java/com/android/server/hdmi/Constants.java
new file mode 100644
index 0000000..4da781f
--- /dev/null
+++ b/services/core/java/com/android/server/hdmi/Constants.java
@@ -0,0 +1,200 @@
+/*
+ * 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;
+
+/**
+ * Defines constants related to HDMI-CEC protocol internal implementation.
+ * If a constant will be used in the public api, it should be located in
+ * {@link android.hardware.hdmi.HdmiCec}.
+ */
+final class Constants {
+
+    /** Logical address for TV */
+    public static final int ADDR_TV = 0;
+
+    /** Logical address for recorder 1 */
+    public static final int ADDR_RECORDER_1 = 1;
+
+    /** Logical address for recorder 2 */
+    public static final int ADDR_RECORDER_2 = 2;
+
+    /** Logical address for tuner 1 */
+    public static final int ADDR_TUNER_1 = 3;
+
+    /** Logical address for playback 1 */
+    public static final int ADDR_PLAYBACK_1 = 4;
+
+    /** Logical address for audio system */
+    public static final int ADDR_AUDIO_SYSTEM = 5;
+
+    /** Logical address for tuner 2 */
+    public static final int ADDR_TUNER_2 = 6;
+
+    /** Logical address for tuner 3 */
+    public static final int ADDR_TUNER_3 = 7;
+
+    /** Logical address for playback 2 */
+    public static final int ADDR_PLAYBACK_2 = 8;
+
+    /** Logical address for recorder 3 */
+    public static final int ADDR_RECORDER_3 = 9;
+
+    /** Logical address for tuner 4 */
+    public static final int ADDR_TUNER_4 = 10;
+
+    /** Logical address for playback 3 */
+    public static final int ADDR_PLAYBACK_3 = 11;
+
+    /** Logical address reserved for future usage */
+    public static final int ADDR_RESERVED_1 = 12;
+
+    /** Logical address reserved for future usage */
+    public static final int ADDR_RESERVED_2 = 13;
+
+    /** Logical address for TV other than the one assigned with {@link #ADDR_TV} */
+    public static final int ADDR_SPECIFIC_USE = 14;
+
+    /** Logical address for devices to which address cannot be allocated */
+    public static final int ADDR_UNREGISTERED = 15;
+
+    /** Logical address used in the destination address field for broadcast messages */
+    public static final int ADDR_BROADCAST = 15;
+
+    /** Logical address used to indicate it is not initialized or invalid. */
+    public static final int ADDR_INVALID = -1;
+
+    /** Logical address used to indicate the source comes from internal device. */
+    public static final int ADDR_INTERNAL = 0xFFFF;
+
+    static final int MESSAGE_FEATURE_ABORT = 0x00;
+    static final int MESSAGE_IMAGE_VIEW_ON = 0x04;
+    static final int MESSAGE_TUNER_STEP_INCREMENT = 0x05;
+    static final int MESSAGE_TUNER_STEP_DECREMENT = 0x06;
+    static final int MESSAGE_TUNER_DEVICE_STATUS = 0x07;
+    static final int MESSAGE_GIVE_TUNER_DEVICE_STATUS = 0x08;
+    static final int MESSAGE_RECORD_ON = 0x09;
+    static final int MESSAGE_RECORD_STATUS = 0x0A;
+    static final int MESSAGE_RECORD_OFF = 0x0B;
+    static final int MESSAGE_TEXT_VIEW_ON = 0x0D;
+    static final int MESSAGE_RECORD_TV_SCREEN = 0x0F;
+    static final int MESSAGE_GIVE_DECK_STATUS = 0x1A;
+    static final int MESSAGE_DECK_STATUS = 0x1B;
+    static final int MESSAGE_SET_MENU_LANGUAGE = 0x32;
+    static final int MESSAGE_CLEAR_ANALOG_TIMER = 0x33;
+    static final int MESSAGE_SET_ANALOG_TIMER = 0x34;
+    static final int MESSAGE_TIMER_STATUS = 0x35;
+    static final int MESSAGE_STANDBY = 0x36;
+    static final int MESSAGE_PLAY = 0x41;
+    static final int MESSAGE_DECK_CONTROL = 0x42;
+    static final int MESSAGE_TIMER_CLEARED_STATUS = 0x043;
+    static final int MESSAGE_USER_CONTROL_PRESSED = 0x44;
+    static final int MESSAGE_USER_CONTROL_RELEASED = 0x45;
+    static final int MESSAGE_GIVE_OSD_NAME = 0x46;
+    static final int MESSAGE_SET_OSD_NAME = 0x47;
+    static final int MESSAGE_SET_OSD_STRING = 0x64;
+    static final int MESSAGE_SET_TIMER_PROGRAM_TITLE = 0x67;
+    static final int MESSAGE_SYSTEM_AUDIO_MODE_REQUEST = 0x70;
+    static final int MESSAGE_GIVE_AUDIO_STATUS = 0x71;
+    static final int MESSAGE_SET_SYSTEM_AUDIO_MODE = 0x72;
+    static final int MESSAGE_REPORT_AUDIO_STATUS = 0x7A;
+    static final int MESSAGE_GIVE_SYSTEM_AUDIO_MODE_STATUS = 0x7D;
+    static final int MESSAGE_SYSTEM_AUDIO_MODE_STATUS = 0x7E;
+    static final int MESSAGE_ROUTING_CHANGE = 0x80;
+    static final int MESSAGE_ROUTING_INFORMATION = 0x81;
+    static final int MESSAGE_ACTIVE_SOURCE = 0x82;
+    static final int MESSAGE_GIVE_PHYSICAL_ADDRESS = 0x83;
+    static final int MESSAGE_REPORT_PHYSICAL_ADDRESS = 0x84;
+    static final int MESSAGE_REQUEST_ACTIVE_SOURCE = 0x85;
+    static final int MESSAGE_SET_STREAM_PATH = 0x86;
+    static final int MESSAGE_DEVICE_VENDOR_ID = 0x87;
+    static final int MESSAGE_VENDOR_COMMAND = 0x89;
+    static final int MESSAGE_VENDOR_REMOTE_BUTTON_DOWN = 0x8A;
+    static final int MESSAGE_VENDOR_REMOTE_BUTTON_UP = 0x8B;
+    static final int MESSAGE_GIVE_DEVICE_VENDOR_ID = 0x8C;
+    static final int MESSAGE_MENU_REQUEST = 0x8D;
+    static final int MESSAGE_MENU_STATUS = 0x8E;
+    static final int MESSAGE_GIVE_DEVICE_POWER_STATUS = 0x8F;
+    static final int MESSAGE_REPORT_POWER_STATUS = 0x90;
+    static final int MESSAGE_GET_MENU_LANGUAGE = 0x91;
+    static final int MESSAGE_SELECT_ANALOG_SERVICE = 0x92;
+    static final int MESSAGE_SELECT_DIGITAL_SERVICE = 0x93;
+    static final int MESSAGE_SET_DIGITAL_TIMER = 0x97;
+    static final int MESSAGE_CLEAR_DIGITAL_TIMER = 0x99;
+    static final int MESSAGE_SET_AUDIO_RATE = 0x9A;
+    static final int MESSAGE_INACTIVE_SOURCE = 0x9D;
+    static final int MESSAGE_CEC_VERSION = 0x9E;
+    static final int MESSAGE_GET_CEC_VERSION = 0x9F;
+    static final int MESSAGE_VENDOR_COMMAND_WITH_ID = 0xA0;
+    static final int MESSAGE_CLEAR_EXTERNAL_TIMER = 0xA1;
+    static final int MESSAGE_SET_EXTERNAL_TIMER = 0xA2;
+    static final int MESSAGE_INITIATE_ARC = 0xC0;
+    static final int MESSAGE_REPORT_ARC_INITIATED = 0xC1;
+    static final int MESSAGE_REPORT_ARC_TERMINATED = 0xC2;
+    static final int MESSAGE_REQUEST_ARC_INITIATION = 0xC3;
+    static final int MESSAGE_REQUEST_ARC_TERMINATION = 0xC4;
+    static final int MESSAGE_TERMINATE_ARC = 0xC5;
+    static final int MESSAGE_ABORT = 0xFF;
+
+    static final int UNKNOWN_VENDOR_ID = 0xFFFFFF;
+
+    // Constants related to operands of HDMI CEC commands.
+    // Refer to CEC Table 29 in HDMI Spec v1.4b.
+    // [Abort Reason]
+    static final int ABORT_UNRECOGNIZED_MODE = 0;
+    static final int ABORT_NOT_IN_CORRECT_MODE = 1;
+    static final int ABORT_CANNOT_PROVIDE_SOURCE = 2;
+    static final int ABORT_INVALID_OPERAND = 3;
+    static final int ABORT_REFUSED = 4;
+    static final int ABORT_UNABLE_TO_DETERMINE = 5;
+
+    // [Audio Status]
+    static final int SYSTEM_AUDIO_STATUS_OFF = 0;
+    static final int SYSTEM_AUDIO_STATUS_ON = 1;
+
+    // Bit mask used to get the routing path of the top level device.
+    // When &'d with the path 1.2.2.0 (0x1220), for instance, gives 1.0.0.0.
+    static final int ROUTING_PATH_TOP_MASK = 0xF000;
+
+    static final int INVALID_PORT_ID = -1;
+    static final int INVALID_PHYSICAL_ADDRESS = 0xFFFF;
+
+    // Send result codes.
+    static final int SEND_RESULT_SUCCESS = 0;
+    static final int SEND_RESULT_NAK = -1;
+    static final int SEND_RESULT_FAILURE = -2;
+
+    // Strategy for device polling.
+    // Should use "OR(|) operation of POLL_STRATEGY_XXX and POLL_ITERATION_XXX.
+    static final int POLL_STRATEGY_MASK = 0x3;  // first and second bit.
+    static final int POLL_STRATEGY_REMOTES_DEVICES = 0x1;
+    static final int POLL_STRATEGY_SYSTEM_AUDIO = 0x2;
+
+    static final int POLL_ITERATION_STRATEGY_MASK = 0x30000;  // first and second bit.
+    static final int POLL_ITERATION_IN_ORDER = 0x10000;
+    static final int POLL_ITERATION_REVERSE_ORDER = 0x20000;
+
+    static final int UNKNOWN_VOLUME = -1;
+
+    // IRT(Initiator Repetition Time) in millisecond as recommended in the standard.
+    // Outgoing UCP commands, when in 'Press and Hold' mode, should be this much apart
+    // from the adjacent one so as not to place unnecessarily heavy load on the CEC line.
+    // TODO: This value might need tweaking per product basis. Consider putting it
+    //       in config.xml to allow customization.
+    static final int IRT_MS = 300;
+
+    private Constants() { /* cannot be instantiated */ }
+}
diff --git a/services/core/java/com/android/server/hdmi/DeviceDiscoveryAction.java b/services/core/java/com/android/server/hdmi/DeviceDiscoveryAction.java
index 7e3eb1d..6577406 100644
--- a/services/core/java/com/android/server/hdmi/DeviceDiscoveryAction.java
+++ b/services/core/java/com/android/server/hdmi/DeviceDiscoveryAction.java
@@ -16,9 +16,7 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
 import android.hardware.hdmi.HdmiCecDeviceInfo;
-import android.hardware.hdmi.HdmiCecMessage;
 import android.util.Slog;
 
 import com.android.internal.util.Preconditions;
@@ -72,10 +70,10 @@
     private static final class DeviceInfo {
         private final int mLogicalAddress;
 
-        private int mPhysicalAddress = HdmiConstants.INVALID_PHYSICAL_ADDRESS;
-        private int mVendorId = HdmiCec.UNKNOWN_VENDOR_ID;
+        private int mPhysicalAddress = Constants.INVALID_PHYSICAL_ADDRESS;
+        private int mVendorId = Constants.UNKNOWN_VENDOR_ID;
         private String mDisplayName = "";
-        private int mDeviceType = HdmiCec.DEVICE_INACTIVE;
+        private int mDeviceType = HdmiCecDeviceInfo.DEVICE_INACTIVE;
 
         private DeviceInfo(int logicalAddress) {
             mLogicalAddress = logicalAddress;
@@ -119,8 +117,8 @@
                 allocateDevices(ackedAddress);
                 startPhysicalAddressStage();
             }
-        }, HdmiConstants.POLL_ITERATION_REVERSE_ORDER
-            | HdmiConstants.POLL_STRATEGY_REMOTES_DEVICES, DEVICE_POLLING_RETRY);
+        }, Constants.POLL_ITERATION_REVERSE_ORDER
+            | Constants.POLL_STRATEGY_REMOTES_DEVICES, DEVICE_POLLING_RETRY);
         return true;
     }
 
@@ -140,7 +138,7 @@
     }
 
     private boolean verifyValidLogicalAddress(int address) {
-        return address >= HdmiCec.ADDR_TV && address < HdmiCec.ADDR_UNREGISTERED;
+        return address >= Constants.ADDR_TV && address < Constants.ADDR_UNREGISTERED;
     }
 
     private void queryPhysicalAddress(int address) {
@@ -152,7 +150,7 @@
         mActionTimer.clearTimerMessage();
 
         // Check cache first and send request if not exist.
-        if (mayProcessMessageIfCached(address, HdmiCec.MESSAGE_REPORT_PHYSICAL_ADDRESS)) {
+        if (mayProcessMessageIfCached(address, Constants.MESSAGE_REPORT_PHYSICAL_ADDRESS)) {
             return;
         }
         sendCommand(HdmiCecMessageBuilder.buildGivePhysicalAddress(getSourceAddress(), address));
@@ -175,7 +173,7 @@
 
         mActionTimer.clearTimerMessage();
 
-        if (mayProcessMessageIfCached(address, HdmiCec.MESSAGE_SET_OSD_NAME)) {
+        if (mayProcessMessageIfCached(address, Constants.MESSAGE_SET_OSD_NAME)) {
             return;
         }
         sendCommand(HdmiCecMessageBuilder.buildGiveOsdNameCommand(getSourceAddress(), address));
@@ -199,7 +197,7 @@
 
         mActionTimer.clearTimerMessage();
 
-        if (mayProcessMessageIfCached(address, HdmiCec.MESSAGE_DEVICE_VENDOR_ID)) {
+        if (mayProcessMessageIfCached(address, Constants.MESSAGE_DEVICE_VENDOR_ID)) {
             return;
         }
         sendCommand(
@@ -220,19 +218,19 @@
     boolean processCommand(HdmiCecMessage cmd) {
         switch (mState) {
             case STATE_WAITING_FOR_PHYSICAL_ADDRESS:
-                if (cmd.getOpcode() == HdmiCec.MESSAGE_REPORT_PHYSICAL_ADDRESS) {
+                if (cmd.getOpcode() == Constants.MESSAGE_REPORT_PHYSICAL_ADDRESS) {
                     handleReportPhysicalAddress(cmd);
                     return true;
                 }
                 return false;
             case STATE_WAITING_FOR_OSD_NAME:
-                if (cmd.getOpcode() == HdmiCec.MESSAGE_SET_OSD_NAME) {
+                if (cmd.getOpcode() == Constants.MESSAGE_SET_OSD_NAME) {
                     handleSetOsdName(cmd);
                     return true;
                 }
                 return false;
             case STATE_WAITING_FOR_VENDOR_ID:
-                if (cmd.getOpcode() == HdmiCec.MESSAGE_DEVICE_VENDOR_ID) {
+                if (cmd.getOpcode() == Constants.MESSAGE_DEVICE_VENDOR_ID) {
                     handleVendorId(cmd);
                     return true;
                 }
@@ -285,7 +283,7 @@
         } catch (UnsupportedEncodingException e) {
             Slog.w(TAG, "Failed to decode display name: " + cmd.toString());
             // If failed to get display name, use the default name of device.
-            displayName = HdmiCec.getDefaultDeviceName(current.mLogicalAddress);
+            displayName = HdmiUtils.getDefaultDeviceName(current.mLogicalAddress);
         }
         current.mDisplayName = displayName;
         increaseProcessedDeviceCount();
diff --git a/services/core/java/com/android/server/hdmi/DevicePowerStatusAction.java b/services/core/java/com/android/server/hdmi/DevicePowerStatusAction.java
index 51df473..87c8d92 100644
--- a/services/core/java/com/android/server/hdmi/DevicePowerStatusAction.java
+++ b/services/core/java/com/android/server/hdmi/DevicePowerStatusAction.java
@@ -16,8 +16,6 @@
  * limitations under the License.
  */
 
-import android.hardware.hdmi.HdmiCec;
-import android.hardware.hdmi.HdmiCecMessage;
 import android.hardware.hdmi.HdmiControlManager;
 import android.hardware.hdmi.IHdmiControlCallback;
 import android.os.RemoteException;
@@ -75,7 +73,7 @@
         if (mState != STATE_WAITING_FOR_REPORT_POWER_STATUS) {
             return false;
         }
-        if (cmd.getOpcode() == HdmiCec.MESSAGE_REPORT_POWER_STATUS) {
+        if (cmd.getOpcode() == Constants.MESSAGE_REPORT_POWER_STATUS) {
             int status = cmd.getParams()[0];
             invokeCallback(status);
             finish();
@@ -91,7 +89,7 @@
         }
         if (state == STATE_WAITING_FOR_REPORT_POWER_STATUS) {
             // Got no response from TV. Report status 'unknown'.
-            invokeCallback(HdmiCec.POWER_STATUS_UNKNOWN);
+            invokeCallback(HdmiControlManager.POWER_STATUS_UNKNOWN);
             finish();
         }
     }
diff --git a/services/core/java/com/android/server/hdmi/DeviceSelectAction.java b/services/core/java/com/android/server/hdmi/DeviceSelectAction.java
index 18bba37..01a5a09 100644
--- a/services/core/java/com/android/server/hdmi/DeviceSelectAction.java
+++ b/services/core/java/com/android/server/hdmi/DeviceSelectAction.java
@@ -16,9 +16,8 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
 import android.hardware.hdmi.HdmiCecDeviceInfo;
-import android.hardware.hdmi.HdmiCecMessage;
+import android.hardware.hdmi.HdmiControlManager;
 import android.hardware.hdmi.HdmiTvClient;
 import android.hardware.hdmi.IHdmiControlCallback;
 import android.os.RemoteException;
@@ -108,12 +107,12 @@
 
         switch (mState) {
             case STATE_WAIT_FOR_REPORT_POWER_STATUS:
-                if (opcode == HdmiCec.MESSAGE_REPORT_POWER_STATUS && params.length == 1) {
+                if (opcode == Constants.MESSAGE_REPORT_POWER_STATUS && params.length == 1) {
                     return handleReportPowerStatus(params[0]);
                 }
                 return false;
             case STATE_WAIT_FOR_ACTIVE_SOURCE:
-                if (opcode == HdmiCec.MESSAGE_ACTIVE_SOURCE && params.length == 2) {
+                if (opcode == Constants.MESSAGE_ACTIVE_SOURCE && params.length == 2) {
                     int activePath = HdmiUtils.twoBytesToInt(params);
                     ActiveSourceHandler
                             .create((HdmiCecLocalDeviceTv) localDevice(), mCallback)
@@ -133,10 +132,10 @@
         //       If in 'Standby' or 'Transit to standby', remove the banner
         //       and stop this action. Otherwise, send <Set Stream Path>
         switch (powerStatus) {
-            case HdmiCec.POWER_STATUS_ON:
+            case HdmiControlManager.POWER_STATUS_ON:
                 sendSetStreamPath();
                 return true;
-            case HdmiCec.POWER_STATUS_TRANSIENT_TO_STANDBY:
+            case HdmiControlManager.POWER_STATUS_TRANSIENT_TO_STANDBY:
                 if (mPowerStatusCounter < 4) {
                     mState = STATE_WAIT_FOR_DEVICE_TO_TRANSIT_TO_STANDBY;
                     addTimer(mState, TIMEOUT_TRANSIT_TO_STANDBY_MS);
@@ -144,14 +143,14 @@
                     sendSetStreamPath();
                 }
                 return true;
-            case HdmiCec.POWER_STATUS_STANDBY:
+            case HdmiControlManager.POWER_STATUS_STANDBY:
                 if (mPowerStatusCounter == 0) {
                     turnOnDevice();
                 } else {
                     sendSetStreamPath();
                 }
                 return true;
-            case HdmiCec.POWER_STATUS_TRANSIENT_TO_ON:
+            case HdmiControlManager.POWER_STATUS_TRANSIENT_TO_ON:
                 if (mPowerStatusCounter < LOOP_COUNTER_MAX) {
                     mState = STATE_WAIT_FOR_DEVICE_POWER_ON;
                     addTimer(mState, TIMEOUT_POWER_ON_MS);
@@ -197,7 +196,7 @@
             case STATE_WAIT_FOR_ACTIVE_SOURCE:
                 // TODO: Remove the banner
                 //       Display banner "Communication failed. Please check your cable or connection"
-                invokeCallback(HdmiCec.RESULT_TIMEOUT);
+                invokeCallback(HdmiControlManager.RESULT_TIMEOUT);
                 finish();
                 break;
         }
diff --git a/services/core/java/com/android/server/hdmi/FeatureAction.java b/services/core/java/com/android/server/hdmi/FeatureAction.java
index 3595f79..f8ebed2 100644
--- a/services/core/java/com/android/server/hdmi/FeatureAction.java
+++ b/services/core/java/com/android/server/hdmi/FeatureAction.java
@@ -15,7 +15,6 @@
  */
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCecMessage;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Message;
diff --git a/services/core/java/com/android/server/hdmi/HdmiCecController.java b/services/core/java/com/android/server/hdmi/HdmiCecController.java
index 7dfea6a..c860673 100644
--- a/services/core/java/com/android/server/hdmi/HdmiCecController.java
+++ b/services/core/java/com/android/server/hdmi/HdmiCecController.java
@@ -16,8 +16,6 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
-import android.hardware.hdmi.HdmiCecMessage;
 import android.hardware.hdmi.HdmiPortInfo;
 import android.os.Handler;
 import android.os.Looper;
@@ -59,7 +57,7 @@
          *
          * @param deviceType requested device type to allocate logical address
          * @param logicalAddress allocated logical address. If it is
-         *                       {@link HdmiCec#ADDR_UNREGISTERED}, it means that
+         *                       {@link Constants.ADDR_UNREGISTERED}, it means that
          *                       it failed to allocate logical address for the given device type
          */
         void onAllocated(int deviceType, int logicalAddress);
@@ -93,7 +91,7 @@
     private final Predicate<Integer> mSystemAudioAddressPredicate = new Predicate<Integer>() {
         @Override
         public boolean apply(Integer address) {
-            return HdmiCec.getTypeFromAddress(address) == HdmiCec.ADDR_AUDIO_SYSTEM;
+            return HdmiUtils.getTypeFromAddress(address) == Constants.ADDR_AUDIO_SYSTEM;
         }
     };
 
@@ -160,7 +158,7 @@
      *
      * @param deviceType type of device to used to determine logical address
      * @param preferredAddress a logical address preferred to be allocated.
-     *                         If sets {@link HdmiCec#ADDR_UNREGISTERED}, scans
+     *                         If sets {@link Constants.ADDR_UNREGISTERED}, scans
      *                         the smallest logical address matched with the given device type.
      *                         Otherwise, scan address will start from {@code preferredAddress}
      * @param callback callback interface to report allocated logical address to caller
@@ -185,21 +183,21 @@
         int startAddress = preferredAddress;
         // If preferred address is "unregistered", start address will be the smallest
         // address matched with the given device type.
-        if (preferredAddress == HdmiCec.ADDR_UNREGISTERED) {
+        if (preferredAddress == Constants.ADDR_UNREGISTERED) {
             for (int i = 0; i < NUM_LOGICAL_ADDRESS; ++i) {
-                if (deviceType == HdmiCec.getTypeFromAddress(i)) {
+                if (deviceType == HdmiUtils.getTypeFromAddress(i)) {
                     startAddress = i;
                     break;
                 }
             }
         }
 
-        int logicalAddress = HdmiCec.ADDR_UNREGISTERED;
+        int logicalAddress = Constants.ADDR_UNREGISTERED;
         // Iterates all possible addresses which has the same device type.
         for (int i = 0; i < NUM_LOGICAL_ADDRESS; ++i) {
             int curAddress = (startAddress + i) % NUM_LOGICAL_ADDRESS;
-            if (curAddress != HdmiCec.ADDR_UNREGISTERED
-                    && deviceType == HdmiCec.getTypeFromAddress(curAddress)) {
+            if (curAddress != Constants.ADDR_UNREGISTERED
+                    && deviceType == HdmiUtils.getTypeFromAddress(curAddress)) {
                 if (!sendPollMessage(curAddress, curAddress,
                         RETRY_COUNT_FOR_LOGICAL_ADDRESS_ALLOCATION)) {
                     logicalAddress = curAddress;
@@ -255,7 +253,7 @@
     @ServiceThreadOnly
     int addLogicalAddress(int newLogicalAddress) {
         assertRunOnServiceThread();
-        if (HdmiCec.isValidAddress(newLogicalAddress)) {
+        if (HdmiUtils.isValidAddress(newLogicalAddress)) {
             return nativeAddLogicalAddress(mNativePtr, newLogicalAddress);
         } else {
             return -1;
@@ -315,13 +313,10 @@
     }
 
     /**
-     * Pass a option to CEC HAL.
+     * Set an option to CEC HAL.
      *
-     * @param flag a key of option. For more details, look at
-     *        {@link HdmiConstants#FLAG_HDMI_OPTION_WAKEUP} to
-     *        {@link HdmiConstants#FLAG_HDMI_OPTION_SYSTEM_CEC_CONTROL}.
-     * @param value a value of option. Actual value varies from flag to flag. For more
-     *        details, look at description of flags.
+     * @param flag key of option
+     * @param value value of option
      */
     @ServiceThreadOnly
     void setOption(int flag, int value) {
@@ -385,31 +380,31 @@
     }
 
     private List<Integer> pickPollCandidates(int pickStrategy) {
-        int strategy = pickStrategy & HdmiConstants.POLL_STRATEGY_MASK;
+        int strategy = pickStrategy & Constants.POLL_STRATEGY_MASK;
         Predicate<Integer> pickPredicate = null;
         switch (strategy) {
-            case HdmiConstants.POLL_STRATEGY_SYSTEM_AUDIO:
+            case Constants.POLL_STRATEGY_SYSTEM_AUDIO:
                 pickPredicate = mSystemAudioAddressPredicate;
                 break;
-            case HdmiConstants.POLL_STRATEGY_REMOTES_DEVICES:
+            case Constants.POLL_STRATEGY_REMOTES_DEVICES:
             default:  // The default is POLL_STRATEGY_REMOTES_DEVICES.
                 pickPredicate = mRemoteDeviceAddressPredicate;
                 break;
         }
 
-        int iterationStrategy = pickStrategy & HdmiConstants.POLL_ITERATION_STRATEGY_MASK;
+        int iterationStrategy = pickStrategy & Constants.POLL_ITERATION_STRATEGY_MASK;
         ArrayList<Integer> pollingCandidates = new ArrayList<>();
         switch (iterationStrategy) {
-            case HdmiConstants.POLL_ITERATION_IN_ORDER:
-                for (int i = HdmiCec.ADDR_TV; i <= HdmiCec.ADDR_SPECIFIC_USE; ++i) {
+            case Constants.POLL_ITERATION_IN_ORDER:
+                for (int i = Constants.ADDR_TV; i <= Constants.ADDR_SPECIFIC_USE; ++i) {
                     if (pickPredicate.apply(i)) {
                         pollingCandidates.add(i);
                     }
                 }
                 break;
-            case HdmiConstants.POLL_ITERATION_REVERSE_ORDER:
+            case Constants.POLL_ITERATION_REVERSE_ORDER:
             default:  // The default is reverse order.
-                for (int i = HdmiCec.ADDR_SPECIFIC_USE; i >= HdmiCec.ADDR_TV; --i) {
+                for (int i = Constants.ADDR_SPECIFIC_USE; i >= Constants.ADDR_TV; --i) {
                     if (pickPredicate.apply(i)) {
                         pollingCandidates.add(i);
                     }
@@ -465,7 +460,7 @@
             // new logical address for the device because no device uses
             // it as logical address of the device.
             if (nativeSendCecCommand(mNativePtr, sourceAddress, destinationAddress, EMPTY_BODY)
-                    == HdmiConstants.SEND_RESULT_SUCCESS) {
+                    == Constants.SEND_RESULT_SUCCESS) {
                 return true;
             }
         }
@@ -497,7 +492,7 @@
 
     private boolean isAcceptableAddress(int address) {
         // Can access command targeting devices available in local device or broadcast command.
-        if (address == HdmiCec.ADDR_BROADCAST) {
+        if (address == Constants.ADDR_BROADCAST) {
             return true;
         }
         return isAllocatedLocalDeviceAddress(address);
@@ -511,12 +506,12 @@
             return;
         }
 
-        if (message.getDestination() != HdmiCec.ADDR_BROADCAST) {
+        if (message.getDestination() != Constants.ADDR_BROADCAST) {
             int sourceAddress = message.getDestination();
             // Reply <Feature Abort> to initiator (source) for all requests.
             HdmiCecMessage cecMessage = HdmiCecMessageBuilder.buildFeatureAbortCommand(
                     sourceAddress, message.getSource(), message.getOpcode(),
-                    HdmiConstants.ABORT_REFUSED);
+                    Constants.ABORT_REFUSED);
             sendCommand(cecMessage);
         }
     }
@@ -537,7 +532,7 @@
                 byte[] body = buildBody(cecMessage.getOpcode(), cecMessage.getParams());
                 final int error = nativeSendCecCommand(mNativePtr, cecMessage.getSource(),
                         cecMessage.getDestination(), body);
-                if (error != HdmiConstants.SEND_RESULT_SUCCESS) {
+                if (error != Constants.SEND_RESULT_SUCCESS) {
                     Slog.w(TAG, "Failed to send " + cecMessage);
                 }
                 if (callback != null) {
diff --git a/services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java b/services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java
index d6d6006..e87db50 100644
--- a/services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java
+++ b/services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java
@@ -16,9 +16,7 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
 import android.hardware.hdmi.HdmiCecDeviceInfo;
-import android.hardware.hdmi.HdmiCecMessage;
 import android.os.Looper;
 import android.util.Slog;
 
@@ -63,16 +61,16 @@
     protected HdmiCecLocalDevice(HdmiControlService service, int deviceType) {
         mService = service;
         mDeviceType = deviceType;
-        mAddress = HdmiCec.ADDR_UNREGISTERED;
+        mAddress = Constants.ADDR_UNREGISTERED;
         mLock = service.getServiceLock();
     }
 
     // Factory method that returns HdmiCecLocalDevice of corresponding type.
     static HdmiCecLocalDevice create(HdmiControlService service, int deviceType) {
         switch (deviceType) {
-        case HdmiCec.DEVICE_TV:
+        case HdmiCecDeviceInfo.DEVICE_TV:
             return new HdmiCecLocalDeviceTv(service);
-        case HdmiCec.DEVICE_PLAYBACK:
+        case HdmiCecDeviceInfo.DEVICE_PLAYBACK:
             return new HdmiCecLocalDevicePlayback(service);
         default:
             return null;
@@ -82,7 +80,7 @@
     @ServiceThreadOnly
     void init() {
         assertRunOnServiceThread();
-        mPreferredAddress = HdmiCec.ADDR_UNREGISTERED;
+        mPreferredAddress = Constants.ADDR_UNREGISTERED;
         // TODO: load preferred address from permanent storage.
     }
 
@@ -101,7 +99,7 @@
     final boolean dispatchMessage(HdmiCecMessage message) {
         assertRunOnServiceThread();
         int dest = message.getDestination();
-        if (dest != mAddress && dest != HdmiCec.ADDR_BROADCAST) {
+        if (dest != mAddress && dest != Constants.ADDR_BROADCAST) {
             return false;
         }
         // Cache incoming message. Note that it caches only white-listed one.
@@ -116,47 +114,47 @@
             return true;
         }
         switch (message.getOpcode()) {
-            case HdmiCec.MESSAGE_ACTIVE_SOURCE:
+            case Constants.MESSAGE_ACTIVE_SOURCE:
                 return handleActiveSource(message);
-            case HdmiCec.MESSAGE_INACTIVE_SOURCE:
+            case Constants.MESSAGE_INACTIVE_SOURCE:
                 return handleInactiveSource(message);
-            case HdmiCec.MESSAGE_REQUEST_ACTIVE_SOURCE:
+            case Constants.MESSAGE_REQUEST_ACTIVE_SOURCE:
                 return handleRequestActiveSource(message);
-            case HdmiCec.MESSAGE_GET_MENU_LANGUAGE:
+            case Constants.MESSAGE_GET_MENU_LANGUAGE:
                 return handleGetMenuLanguage(message);
-            case HdmiCec.MESSAGE_GIVE_PHYSICAL_ADDRESS:
+            case Constants.MESSAGE_GIVE_PHYSICAL_ADDRESS:
                 return handleGivePhysicalAddress();
-            case HdmiCec.MESSAGE_GIVE_OSD_NAME:
+            case Constants.MESSAGE_GIVE_OSD_NAME:
                 return handleGiveOsdName(message);
-            case HdmiCec.MESSAGE_GIVE_DEVICE_VENDOR_ID:
+            case Constants.MESSAGE_GIVE_DEVICE_VENDOR_ID:
                 return handleGiveDeviceVendorId();
-            case HdmiCec.MESSAGE_GET_CEC_VERSION:
+            case Constants.MESSAGE_GET_CEC_VERSION:
                 return handleGetCecVersion(message);
-            case HdmiCec.MESSAGE_REPORT_PHYSICAL_ADDRESS:
+            case Constants.MESSAGE_REPORT_PHYSICAL_ADDRESS:
                 return handleReportPhysicalAddress(message);
-            case HdmiCec.MESSAGE_ROUTING_CHANGE:
+            case Constants.MESSAGE_ROUTING_CHANGE:
                 return handleRoutingChange(message);
-            case HdmiCec.MESSAGE_INITIATE_ARC:
+            case Constants.MESSAGE_INITIATE_ARC:
                 return handleInitiateArc(message);
-            case HdmiCec.MESSAGE_TERMINATE_ARC:
+            case Constants.MESSAGE_TERMINATE_ARC:
                 return handleTerminateArc(message);
-            case HdmiCec.MESSAGE_SET_SYSTEM_AUDIO_MODE:
+            case Constants.MESSAGE_SET_SYSTEM_AUDIO_MODE:
                 return handleSetSystemAudioMode(message);
-            case HdmiCec.MESSAGE_SYSTEM_AUDIO_MODE_STATUS:
+            case Constants.MESSAGE_SYSTEM_AUDIO_MODE_STATUS:
                 return handleSystemAudioModeStatus(message);
-            case HdmiCec.MESSAGE_REPORT_AUDIO_STATUS:
+            case Constants.MESSAGE_REPORT_AUDIO_STATUS:
                 return handleReportAudioStatus(message);
-            case HdmiCec.MESSAGE_STANDBY:
+            case Constants.MESSAGE_STANDBY:
                 return handleStandby(message);
-            case HdmiCec.MESSAGE_TEXT_VIEW_ON:
+            case Constants.MESSAGE_TEXT_VIEW_ON:
                 return handleTextViewOn(message);
-            case HdmiCec.MESSAGE_IMAGE_VIEW_ON:
+            case Constants.MESSAGE_IMAGE_VIEW_ON:
                 return handleImageViewOn(message);
-            case HdmiCec.MESSAGE_USER_CONTROL_PRESSED:
+            case Constants.MESSAGE_USER_CONTROL_PRESSED:
                 return handleUserControlPressed(message);
-            case HdmiCec.MESSAGE_SET_STREAM_PATH:
+            case Constants.MESSAGE_SET_STREAM_PATH:
                 return handleSetStreamPath(message);
-            case HdmiCec.MESSAGE_GIVE_DEVICE_POWER_STATUS:
+            case Constants.MESSAGE_GIVE_DEVICE_POWER_STATUS:
                 return handleGiveDevicePowerStatus(message);
             default:
                 return false;
@@ -226,8 +224,8 @@
         Slog.w(TAG, "Only TV can handle <Get Menu Language>:" + message.toString());
         mService.sendCecCommand(
                 HdmiCecMessageBuilder.buildFeatureAbortCommand(mAddress,
-                        message.getSource(), HdmiCec.MESSAGE_GET_MENU_LANGUAGE,
-                        HdmiConstants.ABORT_UNRECOGNIZED_MODE));
+                        message.getSource(), Constants.MESSAGE_GET_MENU_LANGUAGE,
+                        Constants.ABORT_UNRECOGNIZED_MODE));
         return true;
     }
 
@@ -305,7 +303,8 @@
 
     private static boolean isPowerOnOrToggleCommand(HdmiCecMessage message) {
         byte[] params = message.getParams();
-        return message.getOpcode() == HdmiCec.MESSAGE_USER_CONTROL_PRESSED && params.length == 1
+        return message.getOpcode() == Constants.MESSAGE_USER_CONTROL_PRESSED
+                && params.length == 1
                 && (params[0] == HdmiCecKeycode.CEC_KEYCODE_POWER
                         || params[0] == HdmiCecKeycode.CEC_KEYCODE_POWER_ON_FUNCTION
                         || params[0] == HdmiCecKeycode.CEC_KEYCODE_POWER_TOGGLE_FUNCTION);
@@ -313,7 +312,8 @@
 
     private static boolean isPowerOffOrToggleCommand(HdmiCecMessage message) {
         byte[] params = message.getParams();
-        return message.getOpcode() == HdmiCec.MESSAGE_USER_CONTROL_PRESSED && params.length == 1
+        return message.getOpcode() == Constants.MESSAGE_USER_CONTROL_PRESSED
+                && params.length == 1
                 && (params[0] == HdmiCecKeycode.CEC_KEYCODE_POWER
                         || params[0] == HdmiCecKeycode.CEC_KEYCODE_POWER_OFF_FUNCTION
                         || params[0] == HdmiCecKeycode.CEC_KEYCODE_POWER_TOGGLE_FUNCTION);
@@ -367,7 +367,7 @@
     @ServiceThreadOnly
     void clearAddress() {
         assertRunOnServiceThread();
-        mAddress = HdmiCec.ADDR_UNREGISTERED;
+        mAddress = Constants.ADDR_UNREGISTERED;
     }
 
     @ServiceThreadOnly
diff --git a/services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java b/services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java
index a631172..7ab2e8c 100644
--- a/services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java
+++ b/services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java
@@ -16,8 +16,8 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
-import android.hardware.hdmi.HdmiCecMessage;
+import android.hardware.hdmi.HdmiCecDeviceInfo;
+import android.hardware.hdmi.HdmiControlManager;
 import android.hardware.hdmi.IHdmiControlCallback;
 import android.os.RemoteException;
 import android.util.Slog;
@@ -33,7 +33,7 @@
     private boolean mIsActiveSource = false;
 
     HdmiCecLocalDevicePlayback(HdmiControlService service) {
-        super(service, HdmiCec.DEVICE_PLAYBACK);
+        super(service, HdmiCecDeviceInfo.DEVICE_PLAYBACK);
     }
 
     @Override
@@ -49,16 +49,17 @@
         assertRunOnServiceThread();
         if (hasAction(OneTouchPlayAction.class)) {
             Slog.w(TAG, "oneTouchPlay already in progress");
-            invokeCallback(callback, HdmiCec.RESULT_ALREADY_IN_PROGRESS);
+            invokeCallback(callback, HdmiControlManager.RESULT_ALREADY_IN_PROGRESS);
             return;
         }
 
         // TODO: Consider the case of multiple TV sets. For now we always direct the command
         //       to the primary one.
-        OneTouchPlayAction action = OneTouchPlayAction.create(this, HdmiCec.ADDR_TV, callback);
+        OneTouchPlayAction action = OneTouchPlayAction.create(this, Constants.ADDR_TV,
+                callback);
         if (action == null) {
             Slog.w(TAG, "Cannot initiate oneTouchPlay");
-            invokeCallback(callback, HdmiCec.RESULT_EXCEPTION);
+            invokeCallback(callback, HdmiControlManager.RESULT_EXCEPTION);
             return;
         }
         addAndStartAction(action);
@@ -69,14 +70,14 @@
         assertRunOnServiceThread();
         if (hasAction(DevicePowerStatusAction.class)) {
             Slog.w(TAG, "queryDisplayStatus already in progress");
-            invokeCallback(callback, HdmiCec.RESULT_ALREADY_IN_PROGRESS);
+            invokeCallback(callback, HdmiControlManager.RESULT_ALREADY_IN_PROGRESS);
             return;
         }
         DevicePowerStatusAction action = DevicePowerStatusAction.create(this,
-                HdmiCec.ADDR_TV, callback);
+                Constants.ADDR_TV, callback);
         if (action == null) {
             Slog.w(TAG, "Cannot initiate queryDisplayStatus");
-            invokeCallback(callback, HdmiCec.RESULT_EXCEPTION);
+            invokeCallback(callback, HdmiControlManager.RESULT_EXCEPTION);
             return;
         }
         addAndStartAction(action);
diff --git a/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceTv.java b/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceTv.java
index 1b88aea..45ee89f 100644
--- a/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceTv.java
+++ b/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceTv.java
@@ -16,9 +16,8 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
 import android.hardware.hdmi.HdmiCecDeviceInfo;
-import android.hardware.hdmi.HdmiCecMessage;
+import android.hardware.hdmi.HdmiControlManager;
 import android.hardware.hdmi.IHdmiControlCallback;
 import android.media.AudioSystem;
 import android.os.IBinder;
@@ -57,12 +56,12 @@
     // be able to switch to it upon receiving <Inactive Source> from currently active source.
     // This remains valid only when the active source was switched via one touch play operation
     // (either by TV or source device). Manual port switching invalidates this value to
-    // HdmiConstants.PORT_INVALID, for which case <Inactive Source> does not do anything.
+    // Constants.PORT_INVALID, for which case <Inactive Source> does not do anything.
     @GuardedBy("mLock")
     private int mPrevPortId;
 
     @GuardedBy("mLock")
-    private int mSystemAudioVolume = HdmiConstants.UNKNOWN_VOLUME;
+    private int mSystemAudioVolume = Constants.UNKNOWN_VOLUME;
 
     @GuardedBy("mLock")
     private boolean mSystemAudioMute = false;
@@ -83,8 +82,8 @@
     private boolean mAutoDeviceOff;
 
     HdmiCecLocalDeviceTv(HdmiControlService service) {
-        super(service, HdmiCec.DEVICE_TV);
-        mPrevPortId = HdmiConstants.INVALID_PORT_ID;
+        super(service, HdmiCecDeviceInfo.DEVICE_TV);
+        mPrevPortId = Constants.INVALID_PORT_ID;
         // TODO: load system audio mode and set it to mSystemAudioMode.
     }
 
@@ -111,13 +110,13 @@
     @ServiceThreadOnly
     void deviceSelect(int targetAddress, IHdmiControlCallback callback) {
         assertRunOnServiceThread();
-        if (targetAddress == HdmiCec.ADDR_INTERNAL) {
+        if (targetAddress == Constants.ADDR_INTERNAL) {
             handleSelectInternalSource(callback);
             return;
         }
         HdmiCecDeviceInfo targetDevice = getDeviceInfo(targetAddress);
         if (targetDevice == null) {
-            invokeCallback(callback, HdmiCec.RESULT_TARGET_NOT_AVAILABLE);
+            invokeCallback(callback, HdmiControlManager.RESULT_TARGET_NOT_AVAILABLE);
             return;
         }
         removeAction(DeviceSelectAction.class);
@@ -194,7 +193,7 @@
         assertRunOnServiceThread();
         // Seq #20
         if (!mService.isControlEnabled() || portId == getActivePortId()) {
-            invokeCallback(callback, HdmiCec.RESULT_INCORRECT_MODE);
+            invokeCallback(callback, HdmiControlManager.RESULT_INCORRECT_MODE);
             return;
         }
         // TODO: Make sure this call does not stem from <Active Source> message reception.
@@ -279,7 +278,7 @@
             return true;
         }
         int portId = getPrevPortId();
-        if (portId != HdmiConstants.INVALID_PORT_ID) {
+        if (portId != Constants.INVALID_PORT_ID) {
             // TODO: Do this only if TV is not showing multiview like PIP/PAP.
 
             HdmiCecDeviceInfo inactiveSource = getDeviceInfo(message.getSource());
@@ -293,7 +292,7 @@
 
             setActivePortId(portId);
             doManualPortSwitching(portId, null);
-            setPrevPortId(HdmiConstants.INVALID_PORT_ID);
+            setPrevPortId(Constants.INVALID_PORT_ID);
         }
         return true;
     }
@@ -426,7 +425,7 @@
         // For now, simply reply with <Feature Abort> and mark it consumed by returning true.
         mService.sendCecCommand(HdmiCecMessageBuilder.buildFeatureAbortCommand(
                 message.getDestination(), message.getSource(), message.getOpcode(),
-                HdmiConstants.ABORT_REFUSED));
+                Constants.ABORT_REFUSED));
         return true;
     }
 
@@ -516,7 +515,7 @@
         assertRunOnServiceThread();
         HdmiCecDeviceInfo avr = getAvrDeviceInfo();
         if (avr == null) {
-            invokeCallback(callback, HdmiCec.RESULT_SOURCE_NOT_AVAILABLE);
+            invokeCallback(callback, HdmiControlManager.RESULT_SOURCE_NOT_AVAILABLE);
             return;
         }
 
@@ -737,8 +736,8 @@
     }
 
     private boolean isMessageForSystemAudio(HdmiCecMessage message) {
-        if (message.getSource() != HdmiCec.ADDR_AUDIO_SYSTEM
-                || message.getDestination() != HdmiCec.ADDR_TV
+        if (message.getSource() != Constants.ADDR_AUDIO_SYSTEM
+                || message.getDestination() != Constants.ADDR_TV
                 || getAvrDeviceInfo() == null) {
             Slog.w(TAG, "Skip abnormal CecMessage: " + message);
             return false;
@@ -865,7 +864,7 @@
     @ServiceThreadOnly
     HdmiCecDeviceInfo getAvrDeviceInfo() {
         assertRunOnServiceThread();
-        return getDeviceInfo(HdmiCec.ADDR_AUDIO_SYSTEM);
+        return getDeviceInfo(Constants.ADDR_AUDIO_SYSTEM);
     }
 
     /**
@@ -889,7 +888,7 @@
     }
 
     HdmiCecDeviceInfo getSafeAvrDeviceInfo() {
-        return getSafeDeviceInfo(HdmiCec.ADDR_AUDIO_SYSTEM);
+        return getSafeDeviceInfo(Constants.ADDR_AUDIO_SYSTEM);
     }
 
     /**
@@ -958,7 +957,7 @@
     void launchRoutingControl(boolean routingForBootup) {
         assertRunOnServiceThread();
         // Seq #24
-        if (getActivePortId() != HdmiConstants.INVALID_PORT_ID) {
+        if (getActivePortId() != Constants.INVALID_PORT_ID) {
             if (!routingForBootup && !isProhibitMode()) {
                 removeAction(RoutingControlAction.class);
                 int newPath = mService.portIdToPath(getActivePortId());
@@ -1058,7 +1057,7 @@
         }
         if (!initiatedByCec) {
             mService.sendCecCommand(HdmiCecMessageBuilder.buildStandby(
-                    mAddress, HdmiCec.ADDR_BROADCAST));
+                    mAddress, Constants.ADDR_BROADCAST));
         }
     }
 
diff --git a/services/core/java/com/android/server/hdmi/HdmiCecMessage.java b/services/core/java/com/android/server/hdmi/HdmiCecMessage.java
new file mode 100644
index 0000000..c0ff81d
--- /dev/null
+++ b/services/core/java/com/android/server/hdmi/HdmiCecMessage.java
@@ -0,0 +1,180 @@
+/*
+ * 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.os.Parcel;
+import android.os.Parcelable;
+
+import libcore.util.EmptyArray;
+
+import java.util.Arrays;
+
+/**
+ * A class to encapsulate HDMI-CEC message used for the devices connected via
+ * HDMI cable to communicate with one another. A message is defined by its
+ * source and destination address, command (or opcode), and optional parameters.
+ */
+public final class HdmiCecMessage implements Parcelable {
+
+    public static final byte[] EMPTY_PARAM = EmptyArray.BYTE;
+
+    private static final int MAX_MESSAGE_LENGTH = 16;
+
+    private final int mSource;
+    private final int mDestination;
+
+    private final int mOpcode;
+    private final byte[] mParams;
+
+    /**
+     * Constructor.
+     */
+    public HdmiCecMessage(int source, int destination, int opcode, byte[] params) {
+        mSource = source;
+        mDestination = destination;
+        mOpcode = opcode & 0xFF;
+        mParams = Arrays.copyOf(params, params.length);
+    }
+
+    /**
+     * Return the source address field of the message. It is the logical address
+     * of the device which generated the message.
+     *
+     * @return source address
+     */
+    public int getSource() {
+        return mSource;
+    }
+
+    /**
+     * Return the destination address field of the message. It is the logical address
+     * of the device to which the message is sent.
+     *
+     * @return destination address
+     */
+    public int getDestination() {
+        return mDestination;
+    }
+
+    /**
+     * Return the opcode field of the message. It is the type of the message that
+     * tells the destination device what to do.
+     *
+     * @return opcode
+     */
+    public int getOpcode() {
+        return mOpcode;
+    }
+
+    /**
+     * Return the parameter field of the message. The contents of parameter varies
+     * from opcode to opcode, and is used together with opcode to describe
+     * the action for the destination device to take.
+     *
+     * @return parameter
+     */
+    public byte[] getParams() {
+        return mParams;
+    }
+
+    /**
+     * Describe the kinds of special objects contained in this Parcelable's
+     * marshalled representation.
+     */
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    /**
+     * Flatten this object in to a Parcel.
+     *
+     * @param dest The Parcel in which the object should be written.
+     * @param flags Additional flags about how the object should be written.
+     *        May be 0 or {@link Parcelable#PARCELABLE_WRITE_RETURN_VALUE}.
+     */
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeInt(mSource);
+        dest.writeInt(mDestination);
+        dest.writeInt(mOpcode);
+        dest.writeInt(mParams.length);
+        dest.writeByteArray(mParams);
+    }
+
+    public static final Parcelable.Creator<HdmiCecMessage> CREATOR
+            = new Parcelable.Creator<HdmiCecMessage>() {
+        /**
+         * Rebuild a HdmiCecMessage previously stored with writeToParcel().
+         * @param p HdmiCecMessage object to read the Rating from
+         * @return a new HdmiCecMessage created from the data in the parcel
+         */
+        @Override
+        public HdmiCecMessage createFromParcel(Parcel p) {
+            int source = p.readInt();
+            int destination = p.readInt();
+            int opcode = p.readInt();
+            byte[] params = new byte[p.readInt()];
+            p.readByteArray(params);
+            return new HdmiCecMessage(source, destination, opcode, params);
+        }
+        @Override
+        public HdmiCecMessage[] newArray(int size) {
+            return new HdmiCecMessage[size];
+        }
+    };
+
+    @Override
+    public String toString() {
+        StringBuffer s = new StringBuffer();
+        s.append(String.format("<%s> src: %d, dst: %d",
+                opcodeToString(mOpcode), mSource, mDestination));
+        if (mParams.length > 0) {
+            s.append(", params:");
+            for (byte data : mParams) {
+                s.append(String.format(" %02X", data));
+            }
+        }
+        return s.toString();
+    }
+
+    private static String opcodeToString(int opcode) {
+        switch (opcode) {
+            case Constants.MESSAGE_FEATURE_ABORT:
+                return "Feature Abort";
+            case Constants.MESSAGE_CEC_VERSION:
+                return "CEC Version";
+            case Constants.MESSAGE_REQUEST_ARC_INITIATION:
+                return "Request ARC Initiation";
+            case Constants.MESSAGE_REQUEST_ARC_TERMINATION:
+                return "Request ARC Termination";
+            case Constants.MESSAGE_REPORT_ARC_INITIATED:
+                return "Report ARC Initiated";
+            case Constants.MESSAGE_REPORT_ARC_TERMINATED:
+                return "Report ARC Terminated";
+            case Constants.MESSAGE_TEXT_VIEW_ON:
+                return "Text View On";
+            case Constants.MESSAGE_ACTIVE_SOURCE:
+                return "Active Source";
+            case Constants.MESSAGE_GIVE_DEVICE_POWER_STATUS:
+                return "Give Device Power Status";
+            default:
+                return String.format("Opcode: %02X", opcode);
+        }
+    }
+}
+
diff --git a/services/core/java/com/android/server/hdmi/HdmiCecMessageBuilder.java b/services/core/java/com/android/server/hdmi/HdmiCecMessageBuilder.java
index b1ea134..fe35b24 100644
--- a/services/core/java/com/android/server/hdmi/HdmiCecMessageBuilder.java
+++ b/services/core/java/com/android/server/hdmi/HdmiCecMessageBuilder.java
@@ -16,9 +16,6 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
-import android.hardware.hdmi.HdmiCecMessage;
-
 import java.io.UnsupportedEncodingException;
 import java.util.Arrays;
 
@@ -60,7 +57,7 @@
                 (byte) originalOpcode,
                 (byte) reason,
         };
-        return buildCommand(src, dest, HdmiCec.MESSAGE_FEATURE_ABORT, params);
+        return buildCommand(src, dest, Constants.MESSAGE_FEATURE_ABORT, params);
     }
 
     /**
@@ -71,7 +68,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildGivePhysicalAddress(int src, int dest) {
-        return buildCommand(src, dest, HdmiCec.MESSAGE_GIVE_PHYSICAL_ADDRESS);
+        return buildCommand(src, dest, Constants.MESSAGE_GIVE_PHYSICAL_ADDRESS);
     }
 
     /**
@@ -82,7 +79,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildGiveOsdNameCommand(int src, int dest) {
-        return buildCommand(src, dest, HdmiCec.MESSAGE_GIVE_OSD_NAME);
+        return buildCommand(src, dest, Constants.MESSAGE_GIVE_OSD_NAME);
     }
 
     /**
@@ -93,7 +90,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildGiveDeviceVendorIdCommand(int src, int dest) {
-        return buildCommand(src, dest, HdmiCec.MESSAGE_GIVE_DEVICE_VENDOR_ID);
+        return buildCommand(src, dest, Constants.MESSAGE_GIVE_DEVICE_VENDOR_ID);
     }
 
     /**
@@ -118,8 +115,8 @@
                 (byte) normalized.charAt(2),
         };
         // <Set Menu Language> is broadcast message.
-        return buildCommand(src, HdmiCec.ADDR_BROADCAST, HdmiCec.MESSAGE_SET_MENU_LANGUAGE,
-                params);
+        return buildCommand(src, Constants.ADDR_BROADCAST,
+                Constants.MESSAGE_SET_MENU_LANGUAGE, params);
     }
 
     /**
@@ -138,7 +135,7 @@
         } catch (UnsupportedEncodingException e) {
             return null;
         }
-        return buildCommand(src, dest, HdmiCec.MESSAGE_SET_OSD_NAME, params);
+        return buildCommand(src, dest, Constants.MESSAGE_SET_OSD_NAME, params);
     }
 
     /**
@@ -161,8 +158,8 @@
                 (byte) deviceType
         };
         // <Report Physical Address> is broadcast message.
-        return buildCommand(src, HdmiCec.ADDR_BROADCAST, HdmiCec.MESSAGE_REPORT_PHYSICAL_ADDRESS,
-                params);
+        return buildCommand(src, Constants.ADDR_BROADCAST,
+                Constants.MESSAGE_REPORT_PHYSICAL_ADDRESS, params);
     }
 
     /**
@@ -182,8 +179,8 @@
                 (byte) (vendorId & 0xFF)
         };
         // <Device Vendor Id> is broadcast message.
-        return buildCommand(src, HdmiCec.ADDR_BROADCAST, HdmiCec.MESSAGE_DEVICE_VENDOR_ID,
-                params);
+        return buildCommand(src, Constants.ADDR_BROADCAST,
+                Constants.MESSAGE_DEVICE_VENDOR_ID, params);
     }
 
     /**
@@ -199,7 +196,7 @@
         byte[] params = new byte[] {
                 (byte) version
         };
-        return buildCommand(src, dest, HdmiCec.MESSAGE_CEC_VERSION, params);
+        return buildCommand(src, dest, Constants.MESSAGE_CEC_VERSION, params);
     }
 
     /**
@@ -210,7 +207,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildRequestArcInitiation(int src, int dest) {
-        return buildCommand(src, dest, HdmiCec.MESSAGE_REQUEST_ARC_INITIATION);
+        return buildCommand(src, dest, Constants.MESSAGE_REQUEST_ARC_INITIATION);
     }
 
     /**
@@ -221,7 +218,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildRequestArcTermination(int src, int dest) {
-        return buildCommand(src, dest, HdmiCec.MESSAGE_REQUEST_ARC_TERMINATION);
+        return buildCommand(src, dest, Constants.MESSAGE_REQUEST_ARC_TERMINATION);
     }
 
     /**
@@ -232,7 +229,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildReportArcInitiated(int src, int dest) {
-        return buildCommand(src, dest, HdmiCec.MESSAGE_REPORT_ARC_INITIATED);
+        return buildCommand(src, dest, Constants.MESSAGE_REPORT_ARC_INITIATED);
     }
 
     /**
@@ -243,7 +240,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildReportArcTerminated(int src, int dest) {
-        return buildCommand(src, dest, HdmiCec.MESSAGE_REPORT_ARC_TERMINATED);
+        return buildCommand(src, dest, Constants.MESSAGE_REPORT_ARC_TERMINATED);
     }
 
     /**
@@ -254,7 +251,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildTextViewOn(int src, int dest) {
-        return buildCommand(src, dest, HdmiCec.MESSAGE_TEXT_VIEW_ON);
+        return buildCommand(src, dest, Constants.MESSAGE_TEXT_VIEW_ON);
     }
 
     /**
@@ -265,7 +262,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildActiveSource(int src, int physicalAddress) {
-        return buildCommand(src, HdmiCec.ADDR_BROADCAST, HdmiCec.MESSAGE_ACTIVE_SOURCE,
+        return buildCommand(src, Constants.ADDR_BROADCAST, Constants.MESSAGE_ACTIVE_SOURCE,
                 physicalAddressToParam(physicalAddress));
     }
 
@@ -277,8 +274,8 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildInactiveSource(int src, int physicalAddress) {
-        return buildCommand(src, HdmiCec.ADDR_BROADCAST, HdmiCec.MESSAGE_INACTIVE_SOURCE,
-                physicalAddressToParam(physicalAddress));
+        return buildCommand(src, Constants.ADDR_BROADCAST,
+                Constants.MESSAGE_INACTIVE_SOURCE, physicalAddressToParam(physicalAddress));
     }
 
     /**
@@ -291,8 +288,8 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildSetStreamPath(int src, int streamPath) {
-        return buildCommand(src, HdmiCec.ADDR_BROADCAST, HdmiCec.MESSAGE_SET_STREAM_PATH,
-                physicalAddressToParam(streamPath));
+        return buildCommand(src, Constants.ADDR_BROADCAST,
+                Constants.MESSAGE_SET_STREAM_PATH, physicalAddressToParam(streamPath));
     }
 
     /**
@@ -310,7 +307,8 @@
             (byte) ((oldPath >> 8) & 0xFF), (byte) (oldPath & 0xFF),
             (byte) ((newPath >> 8) & 0xFF), (byte) (newPath & 0xFF)
         };
-        return buildCommand(src, HdmiCec.ADDR_BROADCAST, HdmiCec.MESSAGE_ROUTING_CHANGE, param);
+        return buildCommand(src, Constants.ADDR_BROADCAST, Constants.MESSAGE_ROUTING_CHANGE,
+                param);
     }
 
     /**
@@ -321,7 +319,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildGiveDevicePowerStatus(int src, int dest) {
-        return buildCommand(src, dest, HdmiCec.MESSAGE_GIVE_DEVICE_POWER_STATUS);
+        return buildCommand(src, dest, Constants.MESSAGE_GIVE_DEVICE_POWER_STATUS);
     }
 
     /**
@@ -336,7 +334,7 @@
         byte[] param = new byte[] {
                 (byte) (powerStatus)
         };
-        return buildCommand(src, dest, HdmiCec.MESSAGE_REPORT_POWER_STATUS, param);
+        return buildCommand(src, dest, Constants.MESSAGE_REPORT_POWER_STATUS, param);
     }
 
     /**
@@ -351,10 +349,10 @@
     static HdmiCecMessage buildSystemAudioModeRequest(int src, int avr, int avrPhysicalAddress,
             boolean enableSystemAudio) {
         if (enableSystemAudio) {
-            return buildCommand(src, avr, HdmiCec.MESSAGE_SYSTEM_AUDIO_MODE_REQUEST,
+            return buildCommand(src, avr, Constants.MESSAGE_SYSTEM_AUDIO_MODE_REQUEST,
                     physicalAddressToParam(avrPhysicalAddress));
         } else {
-            return buildCommand(src, avr, HdmiCec.MESSAGE_SYSTEM_AUDIO_MODE_REQUEST);
+            return buildCommand(src, avr, Constants.MESSAGE_SYSTEM_AUDIO_MODE_REQUEST);
         }
     }
 
@@ -366,7 +364,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildGiveAudioStatus(int src, int dest) {
-        return buildCommand(src, dest, HdmiCec.MESSAGE_GIVE_AUDIO_STATUS);
+        return buildCommand(src, dest, Constants.MESSAGE_GIVE_AUDIO_STATUS);
     }
 
     /**
@@ -390,7 +388,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildUserControlPressed(int src, int dest, byte[] commandParam) {
-        return buildCommand(src, dest, HdmiCec.MESSAGE_USER_CONTROL_PRESSED, commandParam);
+        return buildCommand(src, dest, Constants.MESSAGE_USER_CONTROL_PRESSED, commandParam);
     }
 
     /**
@@ -401,7 +399,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildUserControlReleased(int src, int dest) {
-        return buildCommand(src, dest, HdmiCec.MESSAGE_USER_CONTROL_RELEASED);
+        return buildCommand(src, dest, Constants.MESSAGE_USER_CONTROL_RELEASED);
     }
 
     /**
@@ -412,7 +410,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     static HdmiCecMessage buildGiveSystemAudioModeStatus(int src, int dest) {
-        return buildCommand(src, dest, HdmiCec.MESSAGE_GIVE_SYSTEM_AUDIO_MODE_STATUS);
+        return buildCommand(src, dest, Constants.MESSAGE_GIVE_SYSTEM_AUDIO_MODE_STATUS);
     }
 
     /**
@@ -423,7 +421,7 @@
      * @return newly created {@link HdmiCecMessage}
      */
     public static HdmiCecMessage buildStandby(int src, int dest) {
-        return buildCommand(src, dest, HdmiCec.MESSAGE_STANDBY);
+        return buildCommand(src, dest, Constants.MESSAGE_STANDBY);
     }
 
     /***** Please ADD new buildXXX() methods above. ******/
diff --git a/services/core/java/com/android/server/hdmi/HdmiCecMessageCache.java b/services/core/java/com/android/server/hdmi/HdmiCecMessageCache.java
index abda656..fb4460f 100644
--- a/services/core/java/com/android/server/hdmi/HdmiCecMessageCache.java
+++ b/services/core/java/com/android/server/hdmi/HdmiCecMessageCache.java
@@ -16,8 +16,6 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
-import android.hardware.hdmi.HdmiCecMessage;
 import android.util.FastImmutableArraySet;
 import android.util.SparseArray;
 
@@ -29,12 +27,12 @@
  * to clean up messages come from the device.
  */
 final class HdmiCecMessageCache {
-    private static final FastImmutableArraySet<Integer> CACHEABLE_OPCODES = new FastImmutableArraySet<>(
-            new Integer[] {
-                    HdmiCec.MESSAGE_SET_OSD_NAME,
-                    HdmiCec.MESSAGE_REPORT_PHYSICAL_ADDRESS,
-                    HdmiCec.MESSAGE_DEVICE_VENDOR_ID,
-                    HdmiCec.MESSAGE_CEC_VERSION,
+    private static final FastImmutableArraySet<Integer> CACHEABLE_OPCODES =
+            new FastImmutableArraySet<>(new Integer[] {
+                    Constants.MESSAGE_SET_OSD_NAME,
+                    Constants.MESSAGE_REPORT_PHYSICAL_ADDRESS,
+                    Constants.MESSAGE_DEVICE_VENDOR_ID,
+                    Constants.MESSAGE_CEC_VERSION,
             });
 
     // It's like [Source Logical Address, [Opcode, HdmiCecMessage]].
diff --git a/services/core/java/com/android/server/hdmi/HdmiConstants.java b/services/core/java/com/android/server/hdmi/HdmiConstants.java
deleted file mode 100644
index 3f9e517..0000000
--- a/services/core/java/com/android/server/hdmi/HdmiConstants.java
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * 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;
-
-/**
- * Defines constants related to HDMI-CEC protocol internal implementation.
- * If a constant will be used in the public api, it should be located in
- * {@link android.hardware.hdmi.HdmiCec}.
- */
-final class HdmiConstants {
-
-    // Constants related to operands of HDMI CEC commands.
-    // Refer to CEC Table 29 in HDMI Spec v1.4b.
-    // [Abort Reason]
-    static final int ABORT_UNRECOGNIZED_MODE = 0;
-    static final int ABORT_NOT_IN_CORRECT_MODE = 1;
-    static final int ABORT_CANNOT_PROVIDE_SOURCE = 2;
-    static final int ABORT_INVALID_OPERAND = 3;
-    static final int ABORT_REFUSED = 4;
-    static final int ABORT_UNABLE_TO_DETERMINE = 5;
-
-    // [Audio Status]
-    static final int SYSTEM_AUDIO_STATUS_OFF = 0;
-    static final int SYSTEM_AUDIO_STATUS_ON = 1;
-
-    // Bit mask used to get the routing path of the top level device.
-    // When &'d with the path 1.2.2.0 (0x1220), for instance, gives 1.0.0.0.
-    static final int ROUTING_PATH_TOP_MASK = 0xF000;
-
-    // Flags used for setOption to CEC HAL.
-    /**
-     * When set to false, HAL does not wake up the system upon receiving
-     * <Image View On> or <Text View On>. Used when user changes the TV
-     * settings to disable the auto TV on functionality.
-     * True by default.
-     */
-    static final int FLAG_HDMI_OPTION_WAKEUP = 1;
-    /**
-     * When set to false, all the CEC commands are discarded. Used when
-     * user changes the TV settings to disable CEC functionality.
-     * True by default.
-     */
-    static final int FLAG_HDMI_OPTION_ENABLE_CEC = 2;
-    /**
-     * Setting this flag to false means Android system will stop handling
-     * CEC service and yield the control over to the microprocessor that is
-     * powered on through the standby mode. When set to true, the system
-     * will gain the control over, hence telling the microprocessor to stop
-     * handling the cec commands. This is called when system goes
-     * in and out of standby mode to notify the microprocessor that it should
-     * start/stop handling CEC commands on behalf of the system.
-     * False by default.
-     */
-    static final int FLAG_HDMI_OPTION_SYSTEM_CEC_CONTROL = 3;
-
-    static final int INVALID_PORT_ID = -1;
-    static final int INVALID_PHYSICAL_ADDRESS = 0xFFFF;
-
-    // Send result codes.
-    static final int SEND_RESULT_SUCCESS = 0;
-    static final int SEND_RESULT_NAK = -1;
-    static final int SEND_RESULT_FAILURE = -2;
-
-    // Strategy for device polling.
-    // Should use "OR(|) operation of POLL_STRATEGY_XXX and POLL_ITERATION_XXX.
-    static final int POLL_STRATEGY_MASK = 0x3;  // first and second bit.
-    static final int POLL_STRATEGY_REMOTES_DEVICES = 0x1;
-    static final int POLL_STRATEGY_SYSTEM_AUDIO = 0x2;
-
-    static final int POLL_ITERATION_STRATEGY_MASK = 0x30000;  // first and second bit.
-    static final int POLL_ITERATION_IN_ORDER = 0x10000;
-    static final int POLL_ITERATION_REVERSE_ORDER = 0x20000;
-
-    static final int UNKNOWN_VOLUME = -1;
-
-    // IRT(Initiator Repetition Time) in millisecond as recommended in the standard.
-    // Outgoing UCP commands, when in 'Press and Hold' mode, should be this much apart
-    // from the adjacent one so as not to place unnecessarily heavy load on the CEC line.
-    // TODO: This value might need tweaking per product basis. Consider putting it
-    //       in config.xml to allow customization.
-    static final int IRT_MS = 300;
-
-    private HdmiConstants() { /* cannot be instantiated */ }
-}
diff --git a/services/core/java/com/android/server/hdmi/HdmiControlService.java b/services/core/java/com/android/server/hdmi/HdmiControlService.java
index 1fdb3ec..f927cb6 100644
--- a/services/core/java/com/android/server/hdmi/HdmiControlService.java
+++ b/services/core/java/com/android/server/hdmi/HdmiControlService.java
@@ -21,11 +21,11 @@
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
-import android.hardware.hdmi.HdmiCec;
 import android.hardware.hdmi.HdmiCecDeviceInfo;
-import android.hardware.hdmi.HdmiCecMessage;
+import android.hardware.hdmi.HdmiControlManager;
 import android.hardware.hdmi.HdmiHotplugEvent;
 import android.hardware.hdmi.HdmiPortInfo;
+import android.hardware.hdmi.HdmiTvClient;
 import android.hardware.hdmi.IHdmiControlCallback;
 import android.hardware.hdmi.IHdmiControlService;
 import android.hardware.hdmi.IHdmiDeviceEventListener;
@@ -181,7 +181,7 @@
     private final PowerStateReceiver mPowerStateReceiver = new PowerStateReceiver();
 
     @ServiceThreadOnly
-    private int mPowerStatus = HdmiCec.POWER_STATUS_STANDBY;
+    private int mPowerStatus = HdmiControlManager.POWER_STATUS_STANDBY;
 
     @ServiceThreadOnly
     private boolean mStandbyMessageReceived = false;
@@ -195,11 +195,12 @@
     @Override
     public void onStart() {
         mIoThread.start();
-        mPowerStatus = HdmiCec.POWER_STATUS_TRANSIENT_TO_ON;
+        mPowerStatus = HdmiControlManager.POWER_STATUS_TRANSIENT_TO_ON;
         mCecController = HdmiCecController.create(this);
 
         if (mCecController != null) {
-            mCecController.setOption(HdmiCec.OPTION_CEC_SERVICE_CONTROL, HdmiCec.DISABLED);
+            mCecController.setOption(HdmiTvClient.OPTION_CEC_SERVICE_CONTROL,
+                    HdmiTvClient.DISABLED);
             initializeLocalDevices(mLocalDevices);
         } else {
             Slog.i(TAG, "Device does not support HDMI-CEC.");
@@ -241,7 +242,7 @@
                     localDevice.getPreferredAddress(), new AllocateAddressCallback() {
                 @Override
                 public void onAllocated(int deviceType, int logicalAddress) {
-                    if (logicalAddress == HdmiCec.ADDR_UNREGISTERED) {
+                    if (logicalAddress == Constants.ADDR_UNREGISTERED) {
                         Slog.e(TAG, "Failed to allocate address:[device_type:" + deviceType + "]");
                     } else {
                         HdmiCecDeviceInfo deviceInfo = createDeviceInfo(logicalAddress, deviceType);
@@ -254,8 +255,8 @@
 
                     // Address allocation completed for all devices. Notify each device.
                     if (deviceTypes.size() == finished.size()) {
-                        if (mPowerStatus == HdmiCec.POWER_STATUS_TRANSIENT_TO_ON) {
-                            mPowerStatus = HdmiCec.POWER_STATUS_ON;
+                        if (mPowerStatus == HdmiControlManager.POWER_STATUS_TRANSIENT_TO_ON) {
+                            mPowerStatus = HdmiControlManager.POWER_STATUS_ON;
                         }
                         notifyAddressAllocated(devices);
                     }
@@ -344,7 +345,7 @@
         HdmiPortInfo portInfo = getPortInfo(portId);
         if (portInfo == null) {
             Slog.e(TAG, "Cannot find the port info: " + portId);
-            return HdmiConstants.INVALID_PHYSICAL_ADDRESS;
+            return Constants.INVALID_PHYSICAL_ADDRESS;
         }
         return portInfo.getAddress();
     }
@@ -356,13 +357,13 @@
      * 0x1000 (1.0.0.0) which is the topmost path of the given routing path.
      */
     int pathToPortId(int path) {
-        int portAddress = path & HdmiConstants.ROUTING_PATH_TOP_MASK;
+        int portAddress = path & Constants.ROUTING_PATH_TOP_MASK;
         for (HdmiPortInfo info : mPortInfo) {
             if (portAddress == info.getAddress()) {
                 return info.getId();
             }
         }
-        return HdmiConstants.INVALID_PORT_ID;
+        return Constants.INVALID_PORT_ID;
     }
 
     /**
@@ -475,12 +476,12 @@
         assertRunOnServiceThread();
         for (HdmiCecLocalDevice device : mCecController.getLocalDeviceList()) {
             if (device.dispatchMessage(message)
-                    && message.getDestination() != HdmiCec.ADDR_BROADCAST) {
+                    && message.getDestination() != Constants.ADDR_BROADCAST) {
                 return true;
             }
         }
 
-        if (message.getDestination() != HdmiCec.ADDR_BROADCAST) {
+        if (message.getDestination() != Constants.ADDR_BROADCAST) {
             Slog.w(TAG, "Unhandled cec command:" + message);
         }
         return false;
@@ -520,11 +521,11 @@
     }
 
     private int checkPollStrategy(int pickStrategy) {
-        int strategy = pickStrategy & HdmiConstants.POLL_STRATEGY_MASK;
+        int strategy = pickStrategy & Constants.POLL_STRATEGY_MASK;
         if (strategy == 0) {
             throw new IllegalArgumentException("Invalid poll strategy:" + pickStrategy);
         }
-        int iterationStrategy = pickStrategy & HdmiConstants.POLL_ITERATION_STRATEGY_MASK;
+        int iterationStrategy = pickStrategy & Constants.POLL_ITERATION_STRATEGY_MASK;
         if (iterationStrategy == 0) {
             throw new IllegalArgumentException("Invalid iteration strategy:" + pickStrategy);
         }
@@ -632,7 +633,7 @@
                     HdmiCecLocalDeviceTv tv = tv();
                     if (tv == null) {
                         Slog.w(TAG, "Local tv device not available");
-                        invokeCallback(callback, HdmiCec.RESULT_SOURCE_NOT_AVAILABLE);
+                        invokeCallback(callback, HdmiControlManager.RESULT_SOURCE_NOT_AVAILABLE);
                         return;
                     }
                     tv.deviceSelect(logicalAddress, callback);
@@ -649,7 +650,7 @@
                     HdmiCecLocalDeviceTv tv = tv();
                     if (tv == null) {
                         Slog.w(TAG, "Local tv device not available");
-                        invokeCallback(callback, HdmiCec.RESULT_SOURCE_NOT_AVAILABLE);
+                        invokeCallback(callback, HdmiControlManager.RESULT_SOURCE_NOT_AVAILABLE);
                         return;
                     }
                     tv.doManualPortSwitching(portId, callback);
@@ -765,7 +766,7 @@
                     HdmiCecLocalDeviceTv tv = tv();
                     if (tv == null) {
                         Slog.w(TAG, "Local tv device not available");
-                        invokeCallback(callback, HdmiCec.RESULT_SOURCE_NOT_AVAILABLE);
+                        invokeCallback(callback, HdmiControlManager.RESULT_SOURCE_NOT_AVAILABLE);
                         return;
                     }
                     tv.changeSystemAudioMode(enabled, callback);
@@ -823,10 +824,10 @@
                     if (tv == null) {
                         return;
                     }
-                    int value = enabled ? HdmiCec.ENABLED : HdmiCec.DISABLED;
-                    mCecController.setOption(HdmiCec.OPTION_CEC_ENABLE, value);
+                    int value = enabled ? HdmiTvClient.ENABLED : HdmiTvClient.DISABLED;
+                    mCecController.setOption(HdmiTvClient.OPTION_CEC_ENABLE, value);
                     if (mMhlController != null) {
-                        mMhlController.setOption(HdmiCec.OPTION_MHL_ENABLE, value);
+                        mMhlController.setOption(HdmiTvClient.OPTION_MHL_ENABLE, value);
                     }
                     tv.launchRoutingControl(false);
                 }
@@ -888,15 +889,15 @@
                 return;
             }
             switch (key) {
-                case HdmiCec.OPTION_CEC_AUTO_WAKEUP:
+                case HdmiTvClient.OPTION_CEC_AUTO_WAKEUP:
                     mCecController.setOption(key, value);
                     break;
-                case HdmiCec.OPTION_CEC_AUTO_DEVICE_OFF:
+                case HdmiTvClient.OPTION_CEC_AUTO_DEVICE_OFF:
                     // No need to pass this option to HAL.
-                    tv().setAutoDeviceOff(value == HdmiCec.ENABLED);
+                    tv().setAutoDeviceOff(value == HdmiTvClient.ENABLED);
                     break;
-                case HdmiCec.OPTION_MHL_INPUT_SWITCHING:  // Fall through
-                case HdmiCec.OPTION_MHL_POWER_CHARGE:
+                case HdmiTvClient.OPTION_MHL_INPUT_SWITCHING:  // Fall through
+                case HdmiTvClient.OPTION_MHL_POWER_CHARGE:
                     if (mMhlController != null) {
                         mMhlController.setOption(key, value);
                     }
@@ -924,7 +925,7 @@
         HdmiCecLocalDevicePlayback source = playback();
         if (source == null) {
             Slog.w(TAG, "Local playback device not available");
-            invokeCallback(callback, HdmiCec.RESULT_SOURCE_NOT_AVAILABLE);
+            invokeCallback(callback, HdmiControlManager.RESULT_SOURCE_NOT_AVAILABLE);
             return;
         }
         source.oneTouchPlay(callback);
@@ -936,7 +937,7 @@
         HdmiCecLocalDevicePlayback source = playback();
         if (source == null) {
             Slog.w(TAG, "Local playback device not available");
-            invokeCallback(callback, HdmiCec.RESULT_SOURCE_NOT_AVAILABLE);
+            invokeCallback(callback, HdmiControlManager.RESULT_SOURCE_NOT_AVAILABLE);
             return;
         }
         source.queryDisplayStatus(callback);
@@ -1095,16 +1096,17 @@
     }
 
     private static boolean hasSameTopPort(int path1, int path2) {
-        return (path1 & HdmiConstants.ROUTING_PATH_TOP_MASK)
-                == (path2 & HdmiConstants.ROUTING_PATH_TOP_MASK);
+        return (path1 & Constants.ROUTING_PATH_TOP_MASK)
+                == (path2 & Constants.ROUTING_PATH_TOP_MASK);
     }
 
     private HdmiCecLocalDeviceTv tv() {
-        return (HdmiCecLocalDeviceTv) mCecController.getLocalDevice(HdmiCec.DEVICE_TV);
+        return (HdmiCecLocalDeviceTv) mCecController.getLocalDevice(HdmiCecDeviceInfo.DEVICE_TV);
     }
 
     private HdmiCecLocalDevicePlayback playback() {
-        return (HdmiCecLocalDevicePlayback) mCecController.getLocalDevice(HdmiCec.DEVICE_PLAYBACK);
+        return (HdmiCecLocalDevicePlayback)
+                mCecController.getLocalDevice(HdmiCecDeviceInfo.DEVICE_PLAYBACK);
     }
 
     AudioManager getAudioManager() {
@@ -1122,17 +1124,17 @@
     }
 
     boolean isPowerOnOrTransient() {
-        return mPowerStatus == HdmiCec.POWER_STATUS_ON
-                || mPowerStatus == HdmiCec.POWER_STATUS_TRANSIENT_TO_ON;
+        return mPowerStatus == HdmiControlManager.POWER_STATUS_ON
+                || mPowerStatus == HdmiControlManager.POWER_STATUS_TRANSIENT_TO_ON;
     }
 
     boolean isPowerStandbyOrTransient() {
-        return mPowerStatus == HdmiCec.POWER_STATUS_STANDBY
-                || mPowerStatus == HdmiCec.POWER_STATUS_TRANSIENT_TO_STANDBY;
+        return mPowerStatus == HdmiControlManager.POWER_STATUS_STANDBY
+                || mPowerStatus == HdmiControlManager.POWER_STATUS_TRANSIENT_TO_STANDBY;
     }
 
     boolean isPowerStandby() {
-        return mPowerStatus == HdmiCec.POWER_STATUS_STANDBY;
+        return mPowerStatus == HdmiControlManager.POWER_STATUS_STANDBY;
     }
 
     @ServiceThreadOnly
@@ -1157,9 +1159,9 @@
     @ServiceThreadOnly
     private void onWakeUp() {
         assertRunOnServiceThread();
-        mPowerStatus = HdmiCec.POWER_STATUS_TRANSIENT_TO_ON;
+        mPowerStatus = HdmiControlManager.POWER_STATUS_TRANSIENT_TO_ON;
         if (mCecController != null) {
-            mCecController.setOption(HdmiCec.OPTION_CEC_SERVICE_CONTROL, HdmiCec.ENABLED);
+            mCecController.setOption(HdmiTvClient.OPTION_CEC_SERVICE_CONTROL, HdmiTvClient.ENABLED);
             initializeLocalDevices(mLocalDevices);
         } else {
             Slog.i(TAG, "Device does not support HDMI-CEC.");
@@ -1170,7 +1172,7 @@
     @ServiceThreadOnly
     private void onStandby() {
         assertRunOnServiceThread();
-        mPowerStatus = HdmiCec.POWER_STATUS_TRANSIENT_TO_STANDBY;
+        mPowerStatus = HdmiControlManager.POWER_STATUS_TRANSIENT_TO_STANDBY;
         for (HdmiCecLocalDevice device : mCecController.getLocalDeviceList()) {
             device.onTransitionToStandby(mStandbyMessageReceived);
         }
@@ -1184,15 +1186,15 @@
     @ServiceThreadOnly
     void onPendingActionsCleared() {
         assertRunOnServiceThread();
-        if (mPowerStatus != HdmiCec.POWER_STATUS_TRANSIENT_TO_STANDBY) {
+        if (mPowerStatus != HdmiControlManager.POWER_STATUS_TRANSIENT_TO_STANDBY) {
             return;
         }
-        mPowerStatus = HdmiCec.POWER_STATUS_STANDBY;
+        mPowerStatus = HdmiControlManager.POWER_STATUS_STANDBY;
         for (HdmiCecLocalDevice device : mCecController.getLocalDeviceList()) {
             device.onStandBy(mStandbyMessageReceived);
         }
         mStandbyMessageReceived = false;
-        mCecController.setOption(HdmiCec.OPTION_CEC_SERVICE_CONTROL, HdmiCec.DISABLED);
+        mCecController.setOption(HdmiTvClient.OPTION_CEC_SERVICE_CONTROL, HdmiTvClient.DISABLED);
     }
 
     boolean isProhibitMode() {
diff --git a/services/core/java/com/android/server/hdmi/HdmiUtils.java b/services/core/java/com/android/server/hdmi/HdmiUtils.java
index 51d26ef..3a43f83 100644
--- a/services/core/java/com/android/server/hdmi/HdmiUtils.java
+++ b/services/core/java/com/android/server/hdmi/HdmiUtils.java
@@ -16,8 +16,7 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
-import android.hardware.hdmi.HdmiCecMessage;
+import android.hardware.hdmi.HdmiCecDeviceInfo;
 import android.util.Slog;
 import android.util.SparseArray;
 
@@ -30,9 +29,100 @@
  */
 final class HdmiUtils {
 
+    private static final int[] ADDRESS_TO_TYPE = {
+        HdmiCecDeviceInfo.DEVICE_TV,  // ADDR_TV
+        HdmiCecDeviceInfo.DEVICE_RECORDER,  // ADDR_RECORDER_1
+        HdmiCecDeviceInfo.DEVICE_RECORDER,  // ADDR_RECORDER_2
+        HdmiCecDeviceInfo.DEVICE_TUNER,  // ADDR_TUNER_1
+        HdmiCecDeviceInfo.DEVICE_PLAYBACK,  // ADDR_PLAYBACK_1
+        HdmiCecDeviceInfo.DEVICE_AUDIO_SYSTEM,  // ADDR_AUDIO_SYSTEM
+        HdmiCecDeviceInfo.DEVICE_TUNER,  // ADDR_TUNER_2
+        HdmiCecDeviceInfo.DEVICE_TUNER,  // ADDR_TUNER_3
+        HdmiCecDeviceInfo.DEVICE_PLAYBACK,  // ADDR_PLAYBACK_2
+        HdmiCecDeviceInfo.DEVICE_RECORDER,  // ADDR_RECORDER_3
+        HdmiCecDeviceInfo.DEVICE_TUNER,  // ADDR_TUNER_4
+        HdmiCecDeviceInfo.DEVICE_PLAYBACK,  // ADDR_PLAYBACK_3
+        HdmiCecDeviceInfo.DEVICE_RESERVED,
+        HdmiCecDeviceInfo.DEVICE_RESERVED,
+        HdmiCecDeviceInfo.DEVICE_TV,  // ADDR_SPECIFIC_USE
+    };
+
+    private static final String[] DEFAULT_NAMES = {
+        "TV",
+        "Recorder_1",
+        "Recorder_2",
+        "Tuner_1",
+        "Playback_1",
+        "AudioSystem",
+        "Tuner_2",
+        "Tuner_3",
+        "Playback_2",
+        "Recorder_3",
+        "Tuner_4",
+        "Playback_3",
+        "Reserved_1",
+        "Reserved_2",
+        "Secondary_TV",
+    };
+
     private HdmiUtils() { /* cannot be instantiated */ }
 
     /**
+     * Check if the given type is valid. A valid type is one of the actual
+     * logical device types defined in the standard ({@link #DEVICE_TV},
+     * {@link #DEVICE_PLAYBACK}, {@link #DEVICE_TUNER}, {@link #DEVICE_RECORDER},
+     * and {@link #DEVICE_AUDIO_SYSTEM}).
+     *
+     * @param type device type
+     * @return true if the given type is valid
+     */
+    static boolean isValidType(int type) {
+        return (HdmiCecDeviceInfo.DEVICE_TV <= type && type <= HdmiCecDeviceInfo.DEVICE_AUDIO_SYSTEM)
+                && type != HdmiCecDeviceInfo.DEVICE_RESERVED;
+    }
+
+    /**
+     * Check if the given logical address is valid. A logical address is valid
+     * if it is one allocated for an actual device which allows communication
+     * with other logical devices.
+     *
+     * @param address logical address
+     * @return true if the given address is valid
+     */
+    static boolean isValidAddress(int address) {
+        return (Constants.ADDR_TV <= address && address <= Constants.ADDR_SPECIFIC_USE);
+    }
+
+    /**
+     * Return the device type for the given logical address.
+     *
+     * @param address logical address
+     * @return device type for the given logical address; DEVICE_INACTIVE
+     *         if the address is not valid.
+     */
+    static int getTypeFromAddress(int address) {
+        if (isValidAddress(address)) {
+            return ADDRESS_TO_TYPE[address];
+        }
+        return HdmiCecDeviceInfo.DEVICE_INACTIVE;
+    }
+
+    /**
+     * Return the default device name for a logical address. This is the name
+     * by which the logical device is known to others until a name is
+     * set explicitly using HdmiCecService.setOsdName.
+     *
+     * @param address logical address
+     * @return default device name; empty string if the address is not valid
+     */
+    static String getDefaultDeviceName(int address) {
+        if (isValidAddress(address)) {
+            return DEFAULT_NAMES[address];
+        }
+        return "";
+    }
+
+    /**
      * Verify if the given address is for the given device type.  If not it will throw
      * {@link IllegalArgumentException}.
      *
@@ -41,7 +131,7 @@
      * @throw IllegalArgumentException
      */
     static void verifyAddressType(int logicalAddress, int deviceType) {
-        int actualDeviceType = HdmiCec.getTypeFromAddress(logicalAddress);
+        int actualDeviceType = getTypeFromAddress(logicalAddress);
         if (actualDeviceType != deviceType) {
             throw new IllegalArgumentException("Device type missmatch:[Expected:" + deviceType
                     + ", Actual:" + actualDeviceType);
@@ -74,7 +164,7 @@
     static boolean parseCommandParamSystemAudioStatus(HdmiCecMessage cmd) {
         // TODO: Handle the exception when the length is wrong.
         return cmd.getParams().length > 0
-                && cmd.getParams()[0] == HdmiConstants.SYSTEM_AUDIO_STATUS_ON;
+                && cmd.getParams()[0] == Constants.SYSTEM_AUDIO_STATUS_ON;
     }
 
     /**
@@ -192,5 +282,4 @@
         }
         return true;
     }
-
 }
diff --git a/services/core/java/com/android/server/hdmi/HotplugDetectionAction.java b/services/core/java/com/android/server/hdmi/HotplugDetectionAction.java
index 8ee92f3..c299981 100644
--- a/services/core/java/com/android/server/hdmi/HotplugDetectionAction.java
+++ b/services/core/java/com/android/server/hdmi/HotplugDetectionAction.java
@@ -16,9 +16,7 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
 import android.hardware.hdmi.HdmiCecDeviceInfo;
-import android.hardware.hdmi.HdmiCecMessage;
 import android.util.Slog;
 
 import com.android.server.hdmi.HdmiControlService.DevicePollingCallback;
@@ -46,7 +44,8 @@
     private static final int STATE_WAIT_FOR_NEXT_POLLING = 1;
 
     // All addresses except for broadcast (unregistered address).
-    private static final int NUM_OF_ADDRESS = HdmiCec.ADDR_SPECIFIC_USE - HdmiCec.ADDR_TV + 1;
+    private static final int NUM_OF_ADDRESS = Constants.ADDR_SPECIFIC_USE
+            - Constants.ADDR_TV + 1;
 
     private int mTimeoutCount = 0;
 
@@ -126,8 +125,8 @@
             public void onPollingFinished(List<Integer> ackedAddress) {
                 checkHotplug(ackedAddress, false);
             }
-        }, HdmiConstants.POLL_ITERATION_IN_ORDER
-                | HdmiConstants.POLL_STRATEGY_REMOTES_DEVICES, POLL_RETRY_COUNT);
+        }, Constants.POLL_ITERATION_IN_ORDER
+                | Constants.POLL_STRATEGY_REMOTES_DEVICES, POLL_RETRY_COUNT);
     }
 
     private void pollAudioSystem() {
@@ -138,8 +137,8 @@
             public void onPollingFinished(List<Integer> ackedAddress) {
                 checkHotplug(ackedAddress, true);
             }
-        }, HdmiConstants.POLL_ITERATION_IN_ORDER
-                | HdmiConstants.POLL_STRATEGY_SYSTEM_AUDIO, POLL_RETRY_COUNT);
+        }, Constants.POLL_ITERATION_IN_ORDER
+                | Constants.POLL_STRATEGY_SYSTEM_AUDIO, POLL_RETRY_COUNT);
     }
 
     private void checkHotplug(List<Integer> ackedAddress, boolean audioOnly) {
@@ -167,7 +166,7 @@
         BitSet set = new BitSet(NUM_OF_ADDRESS);
         for (HdmiCecDeviceInfo info : infoList) {
             if (audioOnly) {
-                if (info.getDeviceType() == HdmiCec.DEVICE_AUDIO_SYSTEM) {
+                if (info.getDeviceType() == HdmiCecDeviceInfo.DEVICE_AUDIO_SYSTEM) {
                     set.set(info.getLogicalAddress());
                 }
             } else {
@@ -233,7 +232,7 @@
     }
 
     private void mayDisableSystemAudioAndARC(int address) {
-        if (HdmiCec.getTypeFromAddress(address) != HdmiCec.DEVICE_AUDIO_SYSTEM) {
+        if (HdmiUtils.getTypeFromAddress(address) != HdmiCecDeviceInfo.DEVICE_AUDIO_SYSTEM) {
             return;
         }
 
diff --git a/services/core/java/com/android/server/hdmi/NewDeviceAction.java b/services/core/java/com/android/server/hdmi/NewDeviceAction.java
index 5cb6e9f..9f7bb60 100644
--- a/services/core/java/com/android/server/hdmi/NewDeviceAction.java
+++ b/services/core/java/com/android/server/hdmi/NewDeviceAction.java
@@ -15,9 +15,7 @@
  */
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
 import android.hardware.hdmi.HdmiCecDeviceInfo;
-import android.hardware.hdmi.HdmiCecMessage;
 import android.util.Slog;
 
 import java.io.UnsupportedEncodingException;
@@ -65,12 +63,13 @@
         super(source);
         mDeviceLogicalAddress = deviceLogicalAddress;
         mDevicePhysicalAddress = devicePhysicalAddress;
-        mVendorId = HdmiCec.UNKNOWN_VENDOR_ID;
+        mVendorId = Constants.UNKNOWN_VENDOR_ID;
     }
 
     @Override
     public boolean start() {
-        if (HdmiCec.getTypeFromAddress(getSourceAddress()) == HdmiCec.DEVICE_AUDIO_SYSTEM) {
+        if (HdmiUtils.getTypeFromAddress(getSourceAddress())
+                == HdmiCecDeviceInfo.DEVICE_AUDIO_SYSTEM) {
             if (tv().getAvrDeviceInfo() == null) {
                 // TODO: Start system audio initiation action
             }
@@ -82,7 +81,7 @@
         }
 
         mState = STATE_WAITING_FOR_SET_OSD_NAME;
-        if (mayProcessCommandIfCached(mDeviceLogicalAddress, HdmiCec.MESSAGE_SET_OSD_NAME)) {
+        if (mayProcessCommandIfCached(mDeviceLogicalAddress, Constants.MESSAGE_SET_OSD_NAME)) {
             return true;
         }
 
@@ -111,7 +110,7 @@
         }
 
         if (mState == STATE_WAITING_FOR_SET_OSD_NAME) {
-            if (opcode == HdmiCec.MESSAGE_SET_OSD_NAME) {
+            if (opcode == Constants.MESSAGE_SET_OSD_NAME) {
                 try {
                     mDisplayName = new String(params, "US-ASCII");
                 } catch (UnsupportedEncodingException e) {
@@ -119,15 +118,15 @@
                 }
                 requestVendorId();
                 return true;
-            } else if (opcode == HdmiCec.MESSAGE_FEATURE_ABORT) {
+            } else if (opcode == Constants.MESSAGE_FEATURE_ABORT) {
                 int requestOpcode = params[1] & 0xFF;
-                if (requestOpcode == HdmiCec.MESSAGE_SET_OSD_NAME) {
+                if (requestOpcode == Constants.MESSAGE_SET_OSD_NAME) {
                     requestVendorId();
                     return true;
                 }
             }
         } else if (mState == STATE_WAITING_FOR_DEVICE_VENDOR_ID) {
-            if (opcode == HdmiCec.MESSAGE_DEVICE_VENDOR_ID) {
+            if (opcode == Constants.MESSAGE_DEVICE_VENDOR_ID) {
                 if (params.length == 3) {
                     mVendorId = HdmiUtils.threeBytesToInt(params);
                 } else {
@@ -136,9 +135,9 @@
                 addDeviceInfo();
                 finish();
                 return true;
-            } else if (opcode == HdmiCec.MESSAGE_FEATURE_ABORT) {
+            } else if (opcode == Constants.MESSAGE_FEATURE_ABORT) {
                 int requestOpcode = params[1] & 0xFF;
-                if (requestOpcode == HdmiCec.MESSAGE_DEVICE_VENDOR_ID) {
+                if (requestOpcode == Constants.MESSAGE_DEVICE_VENDOR_ID) {
                     addDeviceInfo();
                     finish();
                     return true;
@@ -160,7 +159,8 @@
         // At first, transit to waiting status for <Device Vendor Id>.
         mState = STATE_WAITING_FOR_DEVICE_VENDOR_ID;
         // If the message is already in cache, process it.
-        if (mayProcessCommandIfCached(mDeviceLogicalAddress, HdmiCec.MESSAGE_DEVICE_VENDOR_ID)) {
+        if (mayProcessCommandIfCached(mDeviceLogicalAddress,
+                Constants.MESSAGE_DEVICE_VENDOR_ID)) {
             return;
         }
         sendCommand(HdmiCecMessageBuilder.buildGiveDeviceVendorIdCommand(getSourceAddress(),
@@ -170,11 +170,11 @@
 
     private void addDeviceInfo() {
         if (mDisplayName == null) {
-            mDisplayName = HdmiCec.getDefaultDeviceName(mDeviceLogicalAddress);
+            mDisplayName = HdmiUtils.getDefaultDeviceName(mDeviceLogicalAddress);
         }
         tv().addCecDevice(new HdmiCecDeviceInfo(
                 mDeviceLogicalAddress, mDevicePhysicalAddress,
-                HdmiCec.getTypeFromAddress(mDeviceLogicalAddress),
+                HdmiUtils.getTypeFromAddress(mDeviceLogicalAddress),
                 mVendorId, mDisplayName));
     }
 
diff --git a/services/core/java/com/android/server/hdmi/OneTouchPlayAction.java b/services/core/java/com/android/server/hdmi/OneTouchPlayAction.java
index ebb906a..40ce7ed 100644
--- a/services/core/java/com/android/server/hdmi/OneTouchPlayAction.java
+++ b/services/core/java/com/android/server/hdmi/OneTouchPlayAction.java
@@ -15,8 +15,6 @@
  */
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
-import android.hardware.hdmi.HdmiCecMessage;
 import android.hardware.hdmi.HdmiControlManager;
 import android.hardware.hdmi.IHdmiControlCallback;
 import android.os.RemoteException;
@@ -98,11 +96,11 @@
         if (mState != STATE_WAITING_FOR_REPORT_POWER_STATUS) {
             return false;
         }
-        if (cmd.getOpcode() == HdmiCec.MESSAGE_REPORT_POWER_STATUS) {
+        if (cmd.getOpcode() == Constants.MESSAGE_REPORT_POWER_STATUS) {
             int status = cmd.getParams()[0];
-            if (status == HdmiCec.POWER_STATUS_ON) {
+            if (status == HdmiControlManager.POWER_STATUS_ON) {
                 broadcastActiveSource();
-                invokeCallback(HdmiCec.RESULT_SUCCESS);
+                invokeCallback(HdmiControlManager.RESULT_SUCCESS);
                 finish();
             }
             return true;
@@ -121,7 +119,7 @@
                 addTimer(mState, FeatureAction.TIMEOUT_MS);
             } else {
                 // Couldn't wake up the TV for whatever reason. Report failure.
-                invokeCallback(HdmiCec.RESULT_TIMEOUT);
+                invokeCallback(HdmiControlManager.RESULT_TIMEOUT);
                 finish();
             }
         }
diff --git a/services/core/java/com/android/server/hdmi/RequestArcAction.java b/services/core/java/com/android/server/hdmi/RequestArcAction.java
index a2e08f1..cf44607 100644
--- a/services/core/java/com/android/server/hdmi/RequestArcAction.java
+++ b/services/core/java/com/android/server/hdmi/RequestArcAction.java
@@ -16,8 +16,8 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
-import android.hardware.hdmi.HdmiCecMessage;
+import android.hardware.hdmi.HdmiCecDeviceInfo;
+
 import android.util.Slog;
 
 /**
@@ -42,8 +42,8 @@
      */
     RequestArcAction(HdmiCecLocalDevice source, int avrAddress) {
         super(source);
-        HdmiUtils.verifyAddressType(getSourceAddress(), HdmiCec.DEVICE_TV);
-        HdmiUtils.verifyAddressType(avrAddress, HdmiCec.DEVICE_AUDIO_SYSTEM);
+        HdmiUtils.verifyAddressType(getSourceAddress(), HdmiCecDeviceInfo.DEVICE_TV);
+        HdmiUtils.verifyAddressType(avrAddress, HdmiCecDeviceInfo.DEVICE_AUDIO_SYSTEM);
         mAvrAddress = avrAddress;
     }
 
@@ -58,7 +58,7 @@
             // Handles only <Feature Abort> here and, both <Initiate ARC> and <Terminate ARC>
             // are handled in HdmiControlService itself because both can be
             // received wihtout <Request ARC Initiation> or <Request ARC Termination>.
-            case HdmiCec.MESSAGE_FEATURE_ABORT:
+            case Constants.MESSAGE_FEATURE_ABORT:
                 disableArcTransmission();
                 finish();
                 return true;
diff --git a/services/core/java/com/android/server/hdmi/RequestArcInitiationAction.java b/services/core/java/com/android/server/hdmi/RequestArcInitiationAction.java
index 55fb65a..692f961 100644
--- a/services/core/java/com/android/server/hdmi/RequestArcInitiationAction.java
+++ b/services/core/java/com/android/server/hdmi/RequestArcInitiationAction.java
@@ -16,8 +16,6 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCecMessage;
-
 /**
  * Feature action that handles ARC action initiated by TV devices.
  *
@@ -42,7 +40,7 @@
         sendCommand(command, new HdmiControlService.SendMessageCallback() {
             @Override
             public void onSendCompleted(int error) {
-                if (error == HdmiConstants.SEND_RESULT_SUCCESS) {
+                if (error == Constants.SEND_RESULT_SUCCESS) {
                     mState = STATE_WATING_FOR_REQUEST_ARC_REQUEST_RESPONSE;
                     addTimer(mState, TIMEOUT_MS);
                 } else {
diff --git a/services/core/java/com/android/server/hdmi/RequestArcTerminationAction.java b/services/core/java/com/android/server/hdmi/RequestArcTerminationAction.java
index 62ca8f6..31cbe32 100644
--- a/services/core/java/com/android/server/hdmi/RequestArcTerminationAction.java
+++ b/services/core/java/com/android/server/hdmi/RequestArcTerminationAction.java
@@ -16,8 +16,6 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCecMessage;
-
 /**
  * Feature action to handle <Request ARC Termination>.
  *
@@ -42,7 +40,7 @@
         sendCommand(command, new HdmiControlService.SendMessageCallback() {
             @Override
             public void onSendCompleted(int error) {
-                if (error == HdmiConstants.SEND_RESULT_SUCCESS) {
+                if (error == Constants.SEND_RESULT_SUCCESS) {
                     mState = STATE_WATING_FOR_REQUEST_ARC_REQUEST_RESPONSE;
                     addTimer(mState, TIMEOUT_MS);
                 } else {
diff --git a/services/core/java/com/android/server/hdmi/RoutingControlAction.java b/services/core/java/com/android/server/hdmi/RoutingControlAction.java
index 04e5cac..46dc453 100644
--- a/services/core/java/com/android/server/hdmi/RoutingControlAction.java
+++ b/services/core/java/com/android/server/hdmi/RoutingControlAction.java
@@ -17,9 +17,8 @@
 package com.android.server.hdmi;
 
 import android.annotation.Nullable;
-import android.hardware.hdmi.HdmiCec;
 import android.hardware.hdmi.HdmiCecDeviceInfo;
-import android.hardware.hdmi.HdmiCecMessage;
+import android.hardware.hdmi.HdmiControlManager;
 import android.hardware.hdmi.IHdmiControlCallback;
 import android.os.RemoteException;
 import android.util.Slog;
@@ -86,7 +85,7 @@
         int opcode = cmd.getOpcode();
         byte[] params = cmd.getParams();
         if (mState == STATE_WAIT_FOR_ROUTING_INFORMATION
-                && opcode == HdmiCec.MESSAGE_ROUTING_INFORMATION) {
+                && opcode == Constants.MESSAGE_ROUTING_INFORMATION) {
             // Keep updating the physicalAddress as we receive <Routing Information>.
             // If the routing path doesn't belong to the currently active one, we should
             // ignore it since it might have come from other routing change sequence.
@@ -100,7 +99,7 @@
             addTimer(mState, TIMEOUT_ROUTING_INFORMATION_MS);
             return true;
         } else if (mState == STATE_WAIT_FOR_REPORT_POWER_STATUS
-                  && opcode == HdmiCec.MESSAGE_REPORT_POWER_STATUS) {
+                  && opcode == Constants.MESSAGE_REPORT_POWER_STATUS) {
             handleReportPowerStatus(cmd.getParams()[0]);
             return true;
         }
@@ -115,7 +114,7 @@
                 tv().updateActivePortId(tv().pathToPortId(mCurrentRoutingPath));
             }
         }
-        invokeCallback(HdmiCec.RESULT_SUCCESS);
+        invokeCallback(HdmiControlManager.RESULT_SUCCESS);
         finish();
      }
 
@@ -124,7 +123,8 @@
     }
 
     private static boolean isPowerOnOrTransient(int status) {
-        return status == HdmiCec.POWER_STATUS_ON || status == HdmiCec.POWER_STATUS_TRANSIENT_TO_ON;
+        return status == HdmiControlManager.POWER_STATUS_ON
+                || status == HdmiControlManager.POWER_STATUS_TRANSIENT_TO_ON;
     }
 
     private void sendSetStreamPath() {
@@ -146,7 +146,8 @@
                     queryDevicePowerStatus(deviceLogicalAddress, new SendMessageCallback() {
                         @Override
                         public void onSendCompleted(int error) {
-                            handlDevicePowerStatusAckResult(error == HdmiCec.RESULT_SUCCESS);
+                            handlDevicePowerStatusAckResult(
+                                    error == HdmiControlManager.RESULT_SUCCESS);
                         }
                     });
                 } else {
@@ -158,7 +159,7 @@
                     tv().updateActivePortId(tv().pathToPortId(mCurrentRoutingPath));
                     sendSetStreamPath();
                 }
-                invokeCallback(HdmiCec.RESULT_SUCCESS);
+                invokeCallback(HdmiControlManager.RESULT_SUCCESS);
                 finish();
                 return;
         }
diff --git a/services/core/java/com/android/server/hdmi/SendKeyAction.java b/services/core/java/com/android/server/hdmi/SendKeyAction.java
index a525cda..814e43e 100644
--- a/services/core/java/com/android/server/hdmi/SendKeyAction.java
+++ b/services/core/java/com/android/server/hdmi/SendKeyAction.java
@@ -15,9 +15,8 @@
  */
 package com.android.server.hdmi;
 
-import static com.android.server.hdmi.HdmiConstants.IRT_MS;
+import static com.android.server.hdmi.Constants.IRT_MS;
 
-import android.hardware.hdmi.HdmiCecMessage;
 import android.util.Slog;
 import android.view.KeyEvent;
 
diff --git a/services/core/java/com/android/server/hdmi/SetArcTransmissionStateAction.java b/services/core/java/com/android/server/hdmi/SetArcTransmissionStateAction.java
index cdedd6b..15375f3 100644
--- a/services/core/java/com/android/server/hdmi/SetArcTransmissionStateAction.java
+++ b/services/core/java/com/android/server/hdmi/SetArcTransmissionStateAction.java
@@ -16,8 +16,8 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
-import android.hardware.hdmi.HdmiCecMessage;
+import android.hardware.hdmi.HdmiCecDeviceInfo;
+
 import android.util.Slog;
 
 /**
@@ -45,8 +45,8 @@
     SetArcTransmissionStateAction(HdmiCecLocalDevice source, int avrAddress,
             boolean enabled) {
         super(source);
-        HdmiUtils.verifyAddressType(getSourceAddress(), HdmiCec.DEVICE_TV);
-        HdmiUtils.verifyAddressType(avrAddress, HdmiCec.DEVICE_AUDIO_SYSTEM);
+        HdmiUtils.verifyAddressType(getSourceAddress(), HdmiCecDeviceInfo.DEVICE_TV);
+        HdmiUtils.verifyAddressType(avrAddress, HdmiCecDeviceInfo.DEVICE_AUDIO_SYSTEM);
         mAvrAddress = avrAddress;
         mEnabled = enabled;
     }
@@ -68,7 +68,7 @@
         sendCommand(command, new HdmiControlService.SendMessageCallback() {
             @Override
             public void onSendCompleted(int error) {
-                if (error == HdmiConstants.SEND_RESULT_SUCCESS) {
+                if (error == Constants.SEND_RESULT_SUCCESS) {
                     // Enable ARC status immediately after sending <Report Arc Initiated>.
                     // If AVR responds with <Feature Abort>, disable ARC status again.
                     // This is different from spec that says that turns ARC status to
@@ -110,7 +110,7 @@
         }
 
         int opcode = cmd.getOpcode();
-        if (opcode == HdmiCec.MESSAGE_FEATURE_ABORT) {
+        if (opcode == Constants.MESSAGE_FEATURE_ABORT) {
             setArcStatus(false);
         }
         finish();
diff --git a/services/core/java/com/android/server/hdmi/SystemAudioAction.java b/services/core/java/com/android/server/hdmi/SystemAudioAction.java
index 959a38e..dab8ae9 100644
--- a/services/core/java/com/android/server/hdmi/SystemAudioAction.java
+++ b/services/core/java/com/android/server/hdmi/SystemAudioAction.java
@@ -17,8 +17,8 @@
 package com.android.server.hdmi;
 
 import android.annotation.Nullable;
-import android.hardware.hdmi.HdmiCec;
-import android.hardware.hdmi.HdmiCecMessage;
+import android.hardware.hdmi.HdmiCecDeviceInfo;
+import android.hardware.hdmi.HdmiControlManager;
 import android.hardware.hdmi.IHdmiControlCallback;
 import android.os.RemoteException;
 import android.util.Slog;
@@ -59,7 +59,7 @@
     SystemAudioAction(HdmiCecLocalDevice source, int avrAddress, boolean targetStatus,
             IHdmiControlCallback callback) {
         super(source);
-        HdmiUtils.verifyAddressType(avrAddress, HdmiCec.DEVICE_AUDIO_SYSTEM);
+        HdmiUtils.verifyAddressType(avrAddress, HdmiCecDeviceInfo.DEVICE_AUDIO_SYSTEM);
         mAvrLogicalAddress = avrAddress;
         mTargetAudioStatus = targetStatus;
         mCallback = callback;
@@ -73,12 +73,12 @@
         sendCommand(command, new HdmiControlService.SendMessageCallback() {
             @Override
             public void onSendCompleted(int error) {
-                if (error == HdmiConstants.SEND_RESULT_SUCCESS) {
+                if (error == Constants.SEND_RESULT_SUCCESS) {
                     mState = STATE_WAIT_FOR_SET_SYSTEM_AUDIO_MODE;
                     addTimer(mState, mTargetAudioStatus ? ON_TIMEOUT_MS : OFF_TIMEOUT_MS);
                 } else {
                     setSystemAudioMode(false);
-                    finishWithCallback(HdmiCec.RESULT_EXCEPTION);
+                    finishWithCallback(HdmiControlManager.RESULT_EXCEPTION);
                 }
             }
         });
@@ -88,7 +88,7 @@
         if (!mTargetAudioStatus  // Don't retry for Off case.
                 || mSendRetryCount++ >= MAX_SEND_RETRY_COUNT) {
             setSystemAudioMode(false);
-            finishWithCallback(HdmiCec.RESULT_TIMEOUT);
+            finishWithCallback(HdmiControlManager.RESULT_TIMEOUT);
             return;
         }
         sendSystemAudioModeRequest();
@@ -103,7 +103,7 @@
         switch (mState) {
             case STATE_WAIT_FOR_SET_SYSTEM_AUDIO_MODE:
                 // TODO: Handle <FeatureAbort> of <SystemAudioModeRequest>
-                if (cmd.getOpcode() != HdmiCec.MESSAGE_SET_SYSTEM_AUDIO_MODE
+                if (cmd.getOpcode() != Constants.MESSAGE_SET_SYSTEM_AUDIO_MODE
                         || !HdmiUtils.checkCommandSource(cmd, mAvrLogicalAddress, TAG)) {
                     return false;
                 }
@@ -116,7 +116,7 @@
                     // Unexpected response, consider the request is newly initiated by AVR.
                     // To return 'false' will initiate new SystemAudioActionFromAvr by the control
                     // service.
-                    finishWithCallback(HdmiCec.RESULT_EXCEPTION);
+                    finishWithCallback(HdmiControlManager.RESULT_EXCEPTION);
                     return false;
                 }
             default:
diff --git a/services/core/java/com/android/server/hdmi/SystemAudioActionFromAvr.java b/services/core/java/com/android/server/hdmi/SystemAudioActionFromAvr.java
index ef7e837..a565077 100644
--- a/services/core/java/com/android/server/hdmi/SystemAudioActionFromAvr.java
+++ b/services/core/java/com/android/server/hdmi/SystemAudioActionFromAvr.java
@@ -16,7 +16,8 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
+import android.hardware.hdmi.HdmiCecDeviceInfo;
+import android.hardware.hdmi.HdmiControlManager;
 import android.hardware.hdmi.IHdmiControlCallback;
 
 /**
@@ -36,7 +37,7 @@
     SystemAudioActionFromAvr(HdmiCecLocalDevice source, int avrAddress,
             boolean targetStatus, IHdmiControlCallback callback) {
         super(source, avrAddress, targetStatus, callback);
-        HdmiUtils.verifyAddressType(getSourceAddress(), HdmiCec.DEVICE_TV);
+        HdmiUtils.verifyAddressType(getSourceAddress(), HdmiCecDeviceInfo.DEVICE_TV);
     }
 
     @Override
@@ -48,13 +49,13 @@
 
     private void handleSystemAudioActionFromAvr() {
         if (mTargetAudioStatus == tv().getSystemAudioMode()) {
-            finishWithCallback(HdmiCec.RESULT_SUCCESS);
+            finishWithCallback(HdmiControlManager.RESULT_SUCCESS);
             return;
         }
         if (tv().isProhibitMode()) {
             sendCommand(HdmiCecMessageBuilder.buildFeatureAbortCommand(
                     getSourceAddress(), mAvrLogicalAddress,
-                    HdmiCec.MESSAGE_SET_SYSTEM_AUDIO_MODE, HdmiConstants.ABORT_REFUSED));
+                    Constants.MESSAGE_SET_SYSTEM_AUDIO_MODE, Constants.ABORT_REFUSED));
             mTargetAudioStatus = false;
             sendSystemAudioModeRequest();
             return;
@@ -67,7 +68,7 @@
             startAudioStatusAction();
         } else {
             setSystemAudioMode(false);
-            finishWithCallback(HdmiCec.RESULT_SUCCESS);
+            finishWithCallback(HdmiControlManager.RESULT_SUCCESS);
         }
     }
 }
diff --git a/services/core/java/com/android/server/hdmi/SystemAudioActionFromTv.java b/services/core/java/com/android/server/hdmi/SystemAudioActionFromTv.java
index 2d8f3fc..2146c4e 100644
--- a/services/core/java/com/android/server/hdmi/SystemAudioActionFromTv.java
+++ b/services/core/java/com/android/server/hdmi/SystemAudioActionFromTv.java
@@ -16,7 +16,7 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
+import android.hardware.hdmi.HdmiCecDeviceInfo;
 import android.hardware.hdmi.IHdmiControlCallback;
 
 
@@ -36,7 +36,7 @@
     SystemAudioActionFromTv(HdmiCecLocalDevice sourceAddress, int avrAddress,
             boolean targetStatus, IHdmiControlCallback callback) {
         super(sourceAddress, avrAddress, targetStatus, callback);
-        HdmiUtils.verifyAddressType(getSourceAddress(), HdmiCec.DEVICE_TV);
+        HdmiUtils.verifyAddressType(getSourceAddress(), HdmiCecDeviceInfo.DEVICE_TV);
     }
 
     @Override
diff --git a/services/core/java/com/android/server/hdmi/SystemAudioAutoInitiationAction.java b/services/core/java/com/android/server/hdmi/SystemAudioAutoInitiationAction.java
index 6f4164b..a2b4beb 100644
--- a/services/core/java/com/android/server/hdmi/SystemAudioAutoInitiationAction.java
+++ b/services/core/java/com/android/server/hdmi/SystemAudioAutoInitiationAction.java
@@ -16,9 +16,6 @@
 
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCec;
-import android.hardware.hdmi.HdmiCecMessage;
-
 import com.android.server.hdmi.HdmiControlService.SendMessageCallback;
 
 /**
@@ -50,7 +47,7 @@
                 mAvrAddress), new SendMessageCallback() {
             @Override
             public void onSendCompleted(int error) {
-                if (error != HdmiConstants.SEND_RESULT_SUCCESS) {
+                if (error != Constants.SEND_RESULT_SUCCESS) {
                     tv().setSystemAudioMode(false);
                     finish();
                 }
@@ -65,7 +62,7 @@
         }
 
         switch (cmd.getOpcode()) {
-            case HdmiCec.MESSAGE_SYSTEM_AUDIO_MODE_STATUS:
+            case Constants.MESSAGE_SYSTEM_AUDIO_MODE_STATUS:
                 handleSystemAudioModeStatusMessage();
                 return true;
             default:
diff --git a/services/core/java/com/android/server/hdmi/SystemAudioStatusAction.java b/services/core/java/com/android/server/hdmi/SystemAudioStatusAction.java
index fb61674..941033f 100644
--- a/services/core/java/com/android/server/hdmi/SystemAudioStatusAction.java
+++ b/services/core/java/com/android/server/hdmi/SystemAudioStatusAction.java
@@ -17,8 +17,7 @@
 package com.android.server.hdmi;
 
 import android.annotation.Nullable;
-import android.hardware.hdmi.HdmiCec;
-import android.hardware.hdmi.HdmiCecMessage;
+import android.hardware.hdmi.HdmiControlManager;
 import android.hardware.hdmi.IHdmiControlCallback;
 import android.os.RemoteException;
 import android.util.Slog;
@@ -57,7 +56,7 @@
                 new SendMessageCallback() {
             @Override
             public void onSendCompleted(int error) {
-                if (error != HdmiConstants.SEND_RESULT_SUCCESS) {
+                if (error != Constants.SEND_RESULT_SUCCESS) {
                     handleSendGiveAudioStatusFailure();
                 }
             }
@@ -67,7 +66,7 @@
     private void handleSendGiveAudioStatusFailure() {
         // Inform to all application that the audio status (volumn, mute) of
         // the audio amplifier is unknown.
-        tv().setAudioStatus(false, HdmiConstants.UNKNOWN_VOLUME);
+        tv().setAudioStatus(false, Constants.UNKNOWN_VOLUME);
 
         int uiCommand = tv().getSystemAudioMode()
                 ? HdmiCecKeycode.CEC_KEYCODE_RESTORE_VOLUME_FUNCTION  // SystemAudioMode: ON
@@ -75,7 +74,7 @@
         sendUserControlPressedAndReleased(mAvrAddress, uiCommand);
 
         // Still return SUCCESS to callback.
-        finishWithCallback(HdmiCec.RESULT_SUCCESS);
+        finishWithCallback(HdmiControlManager.RESULT_SUCCESS);
     }
 
     @Override
@@ -85,7 +84,7 @@
         }
 
         switch (cmd.getOpcode()) {
-            case HdmiCec.MESSAGE_REPORT_AUDIO_STATUS:
+            case Constants.MESSAGE_REPORT_AUDIO_STATUS:
                 handleReportAudioStatus(cmd);
                 return true;
         }
@@ -104,7 +103,7 @@
                 // Toggle AVR's mute status to match with the system audio status.
                 sendUserControlPressedAndReleased(mAvrAddress, HdmiCecKeycode.CEC_KEYCODE_MUTE);
             }
-            finishWithCallback(HdmiCec.RESULT_SUCCESS);
+            finishWithCallback(HdmiControlManager.RESULT_SUCCESS);
         } else {
             Slog.e(TAG, "Invalid <Report Audio Status> message:" + cmd);
             handleSendGiveAudioStatusFailure();
diff --git a/services/core/java/com/android/server/hdmi/VendorSpecificAction.java b/services/core/java/com/android/server/hdmi/VendorSpecificAction.java
index c954b50..ff21a57 100644
--- a/services/core/java/com/android/server/hdmi/VendorSpecificAction.java
+++ b/services/core/java/com/android/server/hdmi/VendorSpecificAction.java
@@ -1,7 +1,5 @@
 package com.android.server.hdmi;
 
-import android.hardware.hdmi.HdmiCecMessage;
-
 /**
  * Handles vendor-specific commands that require a sequence of command exchange,
  * or need to manage some states to complete the processing.
diff --git a/services/core/java/com/android/server/hdmi/VolumeControlAction.java b/services/core/java/com/android/server/hdmi/VolumeControlAction.java
index 350ce36..3701f88 100644
--- a/services/core/java/com/android/server/hdmi/VolumeControlAction.java
+++ b/services/core/java/com/android/server/hdmi/VolumeControlAction.java
@@ -16,10 +16,8 @@
 
 package com.android.server.hdmi;
 
-import static com.android.server.hdmi.HdmiConstants.IRT_MS;
+import static com.android.server.hdmi.Constants.IRT_MS;
 
-import android.hardware.hdmi.HdmiCec;
-import android.hardware.hdmi.HdmiCecMessage;
 import android.util.Slog;
 
 import com.android.internal.util.Preconditions;
@@ -156,10 +154,10 @@
         }
 
         switch (cmd.getOpcode()) {
-            case HdmiCec.MESSAGE_REPORT_AUDIO_STATUS:
+            case Constants.MESSAGE_REPORT_AUDIO_STATUS:
                 handleReportAudioStatus(cmd);
                 return true;
-            case HdmiCec.MESSAGE_FEATURE_ABORT:
+            case Constants.MESSAGE_FEATURE_ABORT:
                 // TODO: handle feature abort.
                 finish();
                 return true;