services/core/java/com/android/server/hdmi/HotplugDetectionAction.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.server.hdmi;

 import android.hardware.hdmi.HdmiDeviceInfo;
 import android.util.Slog;

 import com.android.server.hdmi.HdmiControlService.DevicePollingCallback;

 import java.util.BitSet;
 import java.util.List;

 /**
  * Feature action that handles hot-plug detection mechanism.
  * Hot-plug event is initiated by timer after device discovery action.
  *
  * <p>Check all devices every 15 secs except for system audio.
  * If system audio is on, check hot-plug for audio system every 5 secs.
  * For other devices, keep 15 secs period.
  */
 // Seq #3
 final class HotplugDetectionAction extends HdmiCecFeatureAction {
     private static final String TAG = "HotPlugDetectionAction";

     private static final int POLLING_INTERVAL_MS = 5000;
     private static final int TIMEOUT_COUNT = 3;
     private static final int AVR_COUNT_MAX = 3;

     // State in which waits for next polling
     private static final int STATE_WAIT_FOR_NEXT_POLLING = 1;

     // All addresses except for broadcast (unregistered address).
     private static final int NUM_OF_ADDRESS = Constants.ADDR_SPECIFIC_USE
             - Constants.ADDR_TV + 1;

     private int mTimeoutCount = 0;

     // Counter used to ensure the connection to AVR is stable. Occasional failure to get
     // polling response from AVR despite its presence leads to unstable status flipping.
     // This is a workaround to deal with it, by removing the device only if the removal
     // is detected {@code AVR_COUNT_MAX} times in a row.
     private int mAvrStatusCount = 0;

     /**
      * Constructor
      *
      * @param source {@link HdmiCecLocalDevice} instance
      */
     HotplugDetectionAction(HdmiCecLocalDevice source) {
         super(source);
     }

     @Override
     boolean start() {
         Slog.v(TAG, "Hot-plug dection started.");

         mState = STATE_WAIT_FOR_NEXT_POLLING;
         mTimeoutCount = 0;

         // Start timer without polling.
         // The first check for all devices will be initiated 15 seconds later.
         addTimer(mState, POLLING_INTERVAL_MS);
         return true;
     }

     @Override
     boolean processCommand(HdmiCecMessage cmd) {
         // No-op
         return false;
     }

     @Override
     void handleTimerEvent(int state) {
         if (mState != state) {
             return;
         }

         if (mState == STATE_WAIT_FOR_NEXT_POLLING) {
             mTimeoutCount = (mTimeoutCount + 1) % TIMEOUT_COUNT;
             pollDevices();
         }
     }

     /**
      * Start device polling immediately.
      */
     void pollAllDevicesNow() {
         // Clear existing timer to avoid overlapped execution
         mActionTimer.clearTimerMessage();

         mTimeoutCount = 0;
         mState = STATE_WAIT_FOR_NEXT_POLLING;
         pollAllDevices();

         addTimer(mState, POLLING_INTERVAL_MS);
     }

     // This method is called every 5 seconds.
     private void pollDevices() {
         // All device check called every 15 seconds.
         if (mTimeoutCount == 0) {
             pollAllDevices();
         } else {
             if (tv().isSystemAudioActivated()) {
                 pollAudioSystem();
             }
         }

         addTimer(mState, POLLING_INTERVAL_MS);
     }

     private void pollAllDevices() {
         Slog.v(TAG, "Poll all devices.");

         pollDevices(new DevicePollingCallback() {
             @Override
             public void onPollingFinished(List<Integer> ackedAddress) {
                 checkHotplug(ackedAddress, false);
             }
         }, Constants.POLL_ITERATION_IN_ORDER
                 | Constants.POLL_STRATEGY_REMOTES_DEVICES, HdmiConfig.HOTPLUG_DETECTION_RETRY);
     }

     private void pollAudioSystem() {
         Slog.v(TAG, "Poll audio system.");

         pollDevices(new DevicePollingCallback() {
             @Override
             public void onPollingFinished(List<Integer> ackedAddress) {
                 checkHotplug(ackedAddress, true);
             }
         }, Constants.POLL_ITERATION_IN_ORDER
                 | Constants.POLL_STRATEGY_SYSTEM_AUDIO, HdmiConfig.HOTPLUG_DETECTION_RETRY);
     }

     private void checkHotplug(List<Integer> ackedAddress, boolean audioOnly) {
         BitSet currentInfos = infoListToBitSet(tv().getDeviceInfoList(false), audioOnly);
         BitSet polledResult = addressListToBitSet(ackedAddress);

         // At first, check removed devices.
         BitSet removed = complement(currentInfos, polledResult);
         int index = -1;
         while ((index = removed.nextSetBit(index + 1)) != -1) {
             if (index == Constants.ADDR_AUDIO_SYSTEM) {
                 HdmiDeviceInfo avr = tv().getAvrDeviceInfo();
                 if (avr != null && tv().isConnected(avr.getPortId())) {
                     ++mAvrStatusCount;
                     Slog.w(TAG, "Ack not returned from AVR. count: " + mAvrStatusCount);
                     if (mAvrStatusCount < AVR_COUNT_MAX) {
                         continue;
                     }
                 }
             }
             Slog.v(TAG, "Remove device by hot-plug detection:" + index);
             removeDevice(index);
         }

         // Reset the counter if the ack is returned from AVR.
         if (!removed.get(Constants.ADDR_AUDIO_SYSTEM)) {
             mAvrStatusCount = 0;
         }

         // Next, check added devices.
         BitSet added = complement(polledResult, currentInfos);
         index = -1;
         while ((index = added.nextSetBit(index + 1)) != -1) {
             Slog.v(TAG, "Add device by hot-plug detection:" + index);
             addDevice(index);
         }
     }

     private static BitSet infoListToBitSet(List<HdmiDeviceInfo> infoList, boolean audioOnly) {
         BitSet set = new BitSet(NUM_OF_ADDRESS);
         for (HdmiDeviceInfo info : infoList) {
             if (audioOnly) {
                 if (info.getDeviceType() == HdmiDeviceInfo.DEVICE_AUDIO_SYSTEM) {
                     set.set(info.getLogicalAddress());
                 }
             } else {
                 set.set(info.getLogicalAddress());
             }
         }
         return set;
     }

     private static BitSet addressListToBitSet(List<Integer> list) {
         BitSet set = new BitSet(NUM_OF_ADDRESS);
         for (Integer value : list) {
             set.set(value);
         }
         return set;
     }

     // A - B = A & ~B
     private static BitSet complement(BitSet first, BitSet second) {
         // Need to clone it so that it doesn't touch original set.
         BitSet clone = (BitSet) first.clone();
         clone.andNot(second);
         return clone;
     }

     private void addDevice(int addedAddress) {
         // Sending <Give Physical Address> will initiate new device action.
         sendCommand(HdmiCecMessageBuilder.buildGivePhysicalAddress(getSourceAddress(),
                 addedAddress));
     }

     private void removeDevice(int removedAddress) {
         mayChangeRoutingPath(removedAddress);
         mayCancelDeviceSelect(removedAddress);
         mayCancelOneTouchRecord(removedAddress);
         mayDisableSystemAudioAndARC(removedAddress);

         tv().removeCecDevice(removedAddress);
     }

     private void mayChangeRoutingPath(int address) {
         HdmiDeviceInfo info = tv().getCecDeviceInfo(address);
         if (info != null) {
             tv().handleRemoveActiveRoutingPath(info.getPhysicalAddress());
         }
     }

     private void mayCancelDeviceSelect(int address) {
         List<DeviceSelectAction> actions = getActions(DeviceSelectAction.class);
         if (actions.isEmpty()) {
             return;
         }

         // Should have only one Device Select Action
         DeviceSelectAction action = actions.get(0);
         if (action.getTargetAddress() == address) {
             removeAction(DeviceSelectAction.class);
         }
     }

     private void mayCancelOneTouchRecord(int address) {
         List<OneTouchRecordAction> actions = getActions(OneTouchRecordAction.class);
         for (OneTouchRecordAction action : actions) {
             if (action.getRecorderAddress() == address) {
                 removeAction(action);
             }
         }
     }

     private void mayDisableSystemAudioAndARC(int address) {
         if (HdmiUtils.getTypeFromAddress(address) != HdmiDeviceInfo.DEVICE_AUDIO_SYSTEM) {
             return;
         }

         tv().setSystemAudioMode(false);
         if (tv().isArcEstablished()) {
             tv().enableAudioReturnChannel(false);
             addAndStartAction(new RequestArcTerminationAction(localDevice(), address));
         }
     }
 }
	/*
	* Copyright (C) 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.server.hdmi;

	import android.hardware.hdmi.HdmiDeviceInfo;
	import android.util.Slog;

	import com.android.server.hdmi.HdmiControlService.DevicePollingCallback;

	import java.util.BitSet;
	import java.util.List;

	/**
	* Feature action that handles hot-plug detection mechanism.
	* Hot-plug event is initiated by timer after device discovery action.
	*
	* <p>Check all devices every 15 secs except for system audio.
	* If system audio is on, check hot-plug for audio system every 5 secs.
	* For other devices, keep 15 secs period.
	*/
	// Seq #3
	final class HotplugDetectionAction extends HdmiCecFeatureAction {
	private static final String TAG = "HotPlugDetectionAction";

	private static final int POLLING_INTERVAL_MS = 5000;
	private static final int TIMEOUT_COUNT = 3;
	private static final int AVR_COUNT_MAX = 3;

	// State in which waits for next polling
	private static final int STATE_WAIT_FOR_NEXT_POLLING = 1;

	// All addresses except for broadcast (unregistered address).
	private static final int NUM_OF_ADDRESS = Constants.ADDR_SPECIFIC_USE
	- Constants.ADDR_TV + 1;

	private int mTimeoutCount = 0;

	// Counter used to ensure the connection to AVR is stable. Occasional failure to get
	// polling response from AVR despite its presence leads to unstable status flipping.
	// This is a workaround to deal with it, by removing the device only if the removal
	// is detected {@code AVR_COUNT_MAX} times in a row.
	private int mAvrStatusCount = 0;

	/**
	* Constructor
	*
	* @param source {@link HdmiCecLocalDevice} instance
	*/
	HotplugDetectionAction(HdmiCecLocalDevice source) {
	super(source);
	}

	@Override
	boolean start() {
	Slog.v(TAG, "Hot-plug dection started.");

	mState = STATE_WAIT_FOR_NEXT_POLLING;
	mTimeoutCount = 0;

	// Start timer without polling.
	// The first check for all devices will be initiated 15 seconds later.
	addTimer(mState, POLLING_INTERVAL_MS);
	return true;
	}

	@Override
	boolean processCommand(HdmiCecMessage cmd) {
	// No-op
	return false;
	}

	@Override
	void handleTimerEvent(int state) {
	if (mState != state) {
	return;
	}

	if (mState == STATE_WAIT_FOR_NEXT_POLLING) {
	mTimeoutCount = (mTimeoutCount + 1) % TIMEOUT_COUNT;
	pollDevices();
	}
	}

	/**
	* Start device polling immediately.
	*/
	void pollAllDevicesNow() {
	// Clear existing timer to avoid overlapped execution
	mActionTimer.clearTimerMessage();

	mTimeoutCount = 0;
	mState = STATE_WAIT_FOR_NEXT_POLLING;
	pollAllDevices();

	addTimer(mState, POLLING_INTERVAL_MS);
	}

	// This method is called every 5 seconds.
	private void pollDevices() {
	// All device check called every 15 seconds.
	if (mTimeoutCount == 0) {
	pollAllDevices();
	} else {
	if (tv().isSystemAudioActivated()) {
	pollAudioSystem();
	}
	}

	addTimer(mState, POLLING_INTERVAL_MS);
	}

	private void pollAllDevices() {
	Slog.v(TAG, "Poll all devices.");

	pollDevices(new DevicePollingCallback() {
	@Override
	public void onPollingFinished(List<Integer> ackedAddress) {
	checkHotplug(ackedAddress, false);
	}
	}, Constants.POLL_ITERATION_IN_ORDER
	\| Constants.POLL_STRATEGY_REMOTES_DEVICES, HdmiConfig.HOTPLUG_DETECTION_RETRY);
	}

	private void pollAudioSystem() {
	Slog.v(TAG, "Poll audio system.");

	pollDevices(new DevicePollingCallback() {
	@Override
	public void onPollingFinished(List<Integer> ackedAddress) {
	checkHotplug(ackedAddress, true);
	}
	}, Constants.POLL_ITERATION_IN_ORDER
	\| Constants.POLL_STRATEGY_SYSTEM_AUDIO, HdmiConfig.HOTPLUG_DETECTION_RETRY);
	}

	private void checkHotplug(List<Integer> ackedAddress, boolean audioOnly) {
	BitSet currentInfos = infoListToBitSet(tv().getDeviceInfoList(false), audioOnly);
	BitSet polledResult = addressListToBitSet(ackedAddress);

	// At first, check removed devices.
	BitSet removed = complement(currentInfos, polledResult);
	int index = -1;
	while ((index = removed.nextSetBit(index + 1)) != -1) {
	if (index == Constants.ADDR_AUDIO_SYSTEM) {
	HdmiDeviceInfo avr = tv().getAvrDeviceInfo();
	if (avr != null && tv().isConnected(avr.getPortId())) {
	++mAvrStatusCount;
	Slog.w(TAG, "Ack not returned from AVR. count: " + mAvrStatusCount);
	if (mAvrStatusCount < AVR_COUNT_MAX) {
	continue;
	}
	}
	}
	Slog.v(TAG, "Remove device by hot-plug detection:" + index);
	removeDevice(index);
	}

	// Reset the counter if the ack is returned from AVR.
	if (!removed.get(Constants.ADDR_AUDIO_SYSTEM)) {
	mAvrStatusCount = 0;
	}

	// Next, check added devices.
	BitSet added = complement(polledResult, currentInfos);
	index = -1;
	while ((index = added.nextSetBit(index + 1)) != -1) {
	Slog.v(TAG, "Add device by hot-plug detection:" + index);
	addDevice(index);
	}
	}

	private static BitSet infoListToBitSet(List<HdmiDeviceInfo> infoList, boolean audioOnly) {
	BitSet set = new BitSet(NUM_OF_ADDRESS);
	for (HdmiDeviceInfo info : infoList) {
	if (audioOnly) {
	if (info.getDeviceType() == HdmiDeviceInfo.DEVICE_AUDIO_SYSTEM) {
	set.set(info.getLogicalAddress());
	}
	} else {
	set.set(info.getLogicalAddress());
	}
	}
	return set;
	}

	private static BitSet addressListToBitSet(List<Integer> list) {
	BitSet set = new BitSet(NUM_OF_ADDRESS);
	for (Integer value : list) {
	set.set(value);
	}
	return set;
	}

	// A - B = A & ~B
	private static BitSet complement(BitSet first, BitSet second) {
	// Need to clone it so that it doesn't touch original set.
	BitSet clone = (BitSet) first.clone();
	clone.andNot(second);
	return clone;
	}

	private void addDevice(int addedAddress) {
	// Sending <Give Physical Address> will initiate new device action.
	sendCommand(HdmiCecMessageBuilder.buildGivePhysicalAddress(getSourceAddress(),
	addedAddress));
	}

	private void removeDevice(int removedAddress) {
	mayChangeRoutingPath(removedAddress);
	mayCancelDeviceSelect(removedAddress);
	mayCancelOneTouchRecord(removedAddress);
	mayDisableSystemAudioAndARC(removedAddress);

	tv().removeCecDevice(removedAddress);
	}

	private void mayChangeRoutingPath(int address) {
	HdmiDeviceInfo info = tv().getCecDeviceInfo(address);
	if (info != null) {
	tv().handleRemoveActiveRoutingPath(info.getPhysicalAddress());
	}
	}

	private void mayCancelDeviceSelect(int address) {
	List<DeviceSelectAction> actions = getActions(DeviceSelectAction.class);
	if (actions.isEmpty()) {
	return;
	}

	// Should have only one Device Select Action
	DeviceSelectAction action = actions.get(0);
	if (action.getTargetAddress() == address) {
	removeAction(DeviceSelectAction.class);
	}
	}

	private void mayCancelOneTouchRecord(int address) {
	List<OneTouchRecordAction> actions = getActions(OneTouchRecordAction.class);
	for (OneTouchRecordAction action : actions) {
	if (action.getRecorderAddress() == address) {
	removeAction(action);
	}
	}
	}

	private void mayDisableSystemAudioAndARC(int address) {
	if (HdmiUtils.getTypeFromAddress(address) != HdmiDeviceInfo.DEVICE_AUDIO_SYSTEM) {
	return;
	}

	tv().setSystemAudioMode(false);
	if (tv().isArcEstablished()) {
	tv().enableAudioReturnChannel(false);
	addAndStartAction(new RequestArcTerminationAction(localDevice(), address));
	}
	}
	}