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

   1 /*
   2  * Copyright (C) 2014 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.android.server.hdmi;
  17
  18 import android.hardware.hdmi.HdmiDeviceInfo;
  19 import android.util.Slog;
  20
  21 import com.android.server.hdmi.HdmiCecLocalDevice.ActiveSource;
  22 import java.io.UnsupportedEncodingException;
  23
  24 /**
  25  * Feature action that discovers the information of a newly found logical device.
  26  *
  27  * This action is created when receiving &lt;Report Physical Address&gt;, a CEC command a newly
  28  * connected HDMI-CEC device broadcasts to announce its advent. Additional commands are issued in
  29  * this action to gather more information on the device such as OSD name and device vendor ID.
  30  *
  31  * <p>The result is made in the form of {@link HdmiDeviceInfo} object, and passed to service
  32  * for the management through its life cycle.
  33  *
  34  * <p>Package-private, accessed by {@link HdmiControlService} only.
  35  */
  36 final class NewDeviceAction extends HdmiCecFeatureAction {
  37
  38     private static final String TAG = "NewDeviceAction";
  39
  40     // State in which the action sent <Give OSD Name> and is waiting for <Set OSD Name>
  41     // that contains the name of the device for display on screen.
  42     static final int STATE_WAITING_FOR_SET_OSD_NAME = 1;
  43
  44     // State in which the action sent <Give Device Vendor ID> and is waiting for
  45     // <Device Vendor ID> that contains the vendor ID of the device.
  46     static final int STATE_WAITING_FOR_DEVICE_VENDOR_ID = 2;
  47
  48     private final int mDeviceLogicalAddress;
  49     private final int mDevicePhysicalAddress;
  50     private final int mDeviceType;
  51
  52     private int mVendorId;
  53     private String mDisplayName;
  54     private int mTimeoutRetry;
  55
  56     /**
  57      * Constructor.
  58      *
  59      * @param source {@link HdmiCecLocalDevice} instance
  60      * @param deviceLogicalAddress logical address of the device in interest
  61      * @param devicePhysicalAddress physical address of the device in interest
  62      * @param deviceType type of the device
  63      */
  64     NewDeviceAction(HdmiCecLocalDevice source, int deviceLogicalAddress,
  65             int devicePhysicalAddress, int deviceType) {
  66         super(source);
  67         mDeviceLogicalAddress = deviceLogicalAddress;
  68         mDevicePhysicalAddress = devicePhysicalAddress;
  69         mDeviceType = deviceType;
  70         mVendorId = Constants.UNKNOWN_VENDOR_ID;
  71     }
  72
  73     @Override
  74     public boolean start() {
  75         requestOsdName(true);
  76         return true;
  77     }
  78
  79     private void requestOsdName(boolean firstTry) {
  80         if (firstTry) {
  81             mTimeoutRetry = 0;
  82         }
  83         mState = STATE_WAITING_FOR_SET_OSD_NAME;
  84         if (mayProcessCommandIfCached(mDeviceLogicalAddress, Constants.MESSAGE_SET_OSD_NAME)) {
  85             return;
  86         }
  87
  88         sendCommand(HdmiCecMessageBuilder.buildGiveOsdNameCommand(getSourceAddress(),
  89                 mDeviceLogicalAddress));
  90         addTimer(mState, HdmiConfig.TIMEOUT_MS);
  91     }
  92
  93     @Override
  94     public boolean processCommand(HdmiCecMessage cmd) {
  95         // For the logical device in interest, we want two more pieces of information -
  96         // osd name and vendor id. They are requested in sequence. In case we don't
  97         // get the expected responses (either by timeout or by receiving <feature abort> command),
  98         // set them to a default osd name and unknown vendor id respectively.
  99         int opcode = cmd.getOpcode();
 100         int src = cmd.getSource();
 101         byte[] params = cmd.getParams();
 102
 103         if (mDeviceLogicalAddress != src) {
 104             return false;
 105         }
 106
 107         if (mState == STATE_WAITING_FOR_SET_OSD_NAME) {
 108             if (opcode == Constants.MESSAGE_SET_OSD_NAME) {
 109                 try {
 110                     mDisplayName = new String(params, "US-ASCII");
 111                 } catch (UnsupportedEncodingException e) {
 112                     Slog.e(TAG, "Failed to get OSD name: " + e.getMessage());
 113                 }
 114                 requestVendorId(true);
 115                 return true;
 116             } else if (opcode == Constants.MESSAGE_FEATURE_ABORT) {
 117                 int requestOpcode = params[0] & 0xFF;
 118                 if (requestOpcode == Constants.MESSAGE_GIVE_OSD_NAME) {
 119                     requestVendorId(true);
 120                     return true;
 121                 }
 122             }
 123         } else if (mState == STATE_WAITING_FOR_DEVICE_VENDOR_ID) {
 124             if (opcode == Constants.MESSAGE_DEVICE_VENDOR_ID) {
 125                 mVendorId = HdmiUtils.threeBytesToInt(params);
 126                 addDeviceInfo();
 127                 finish();
 128                 return true;
 129             } else if (opcode == Constants.MESSAGE_FEATURE_ABORT) {
 130                 int requestOpcode = params[0] & 0xFF;
 131                 if (requestOpcode == Constants.MESSAGE_GIVE_DEVICE_VENDOR_ID) {
 132                     addDeviceInfo();
 133                     finish();
 134                     return true;
 135                 }
 136             }
 137         }
 138         return false;
 139     }
 140
 141     private boolean mayProcessCommandIfCached(int destAddress, int opcode) {
 142         HdmiCecMessage message = getCecMessageCache().getMessage(destAddress, opcode);
 143         if (message != null) {
 144             return processCommand(message);
 145         }
 146         return false;
 147     }
 148
 149     private void requestVendorId(boolean firstTry) {
 150         if (firstTry) {
 151             mTimeoutRetry = 0;
 152         }
 153         // At first, transit to waiting status for <Device Vendor Id>.
 154         mState = STATE_WAITING_FOR_DEVICE_VENDOR_ID;
 155         // If the message is already in cache, process it.
 156         if (mayProcessCommandIfCached(mDeviceLogicalAddress,
 157                 Constants.MESSAGE_DEVICE_VENDOR_ID)) {
 158             return;
 159         }
 160         sendCommand(HdmiCecMessageBuilder.buildGiveDeviceVendorIdCommand(getSourceAddress(),
 161                 mDeviceLogicalAddress));
 162         addTimer(mState, HdmiConfig.TIMEOUT_MS);
 163     }
 164
 165     private void addDeviceInfo() {
 166         // The device should be in the device list with default information.
 167         if (!tv().isInDeviceList(mDeviceLogicalAddress, mDevicePhysicalAddress)) {
 168             Slog.w(TAG, String.format("Device not found (%02x, %04x)",
 169                     mDeviceLogicalAddress, mDevicePhysicalAddress));
 170             return;
 171         }
 172         if (mDisplayName == null) {
 173             mDisplayName = HdmiUtils.getDefaultDeviceName(mDeviceLogicalAddress);
 174         }
 175         HdmiDeviceInfo deviceInfo = new HdmiDeviceInfo(
 176                 mDeviceLogicalAddress, mDevicePhysicalAddress,
 177                 tv().getPortId(mDevicePhysicalAddress),
 178                 mDeviceType, mVendorId, mDisplayName);
 179         tv().addCecDevice(deviceInfo);
 180
 181         // Consume CEC messages we already got for this newly found device.
 182         tv().processDelayedMessages(mDeviceLogicalAddress);
 183
 184         if (HdmiUtils.getTypeFromAddress(mDeviceLogicalAddress)
 185                 == HdmiDeviceInfo.DEVICE_AUDIO_SYSTEM) {
 186             tv().onNewAvrAdded(deviceInfo);
 187         }
 188     }
 189
 190     @Override
 191     public void handleTimerEvent(int state) {
 192         if (mState == STATE_NONE || mState != state) {
 193             return;
 194         }
 195         if (state == STATE_WAITING_FOR_SET_OSD_NAME) {
 196             if (++mTimeoutRetry < HdmiConfig.TIMEOUT_RETRY) {
 197                 requestOsdName(false);
 198                 return;
 199             }
 200             // Osd name request timed out. Try vendor id
 201             requestVendorId(true);
 202         } else if (state == STATE_WAITING_FOR_DEVICE_VENDOR_ID) {
 203             if (++mTimeoutRetry < HdmiConfig.TIMEOUT_RETRY) {
 204                 requestVendorId(false);
 205                 return;
 206             }
 207             // vendor id timed out. Go ahead creating the device info what we've got so far.
 208             addDeviceInfo();
 209             finish();
 210         }
 211     }
 212
 213     boolean isActionOf(ActiveSource activeSource) {
 214         return (mDeviceLogicalAddress == activeSource.logicalAddress)
 215                 && (mDevicePhysicalAddress == activeSource.physicalAddress);
 216     }
 217 }