| /* |
| * 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.tv; |
| |
| import static android.media.tv.TvInputManager.INPUT_STATE_CONNECTED; |
| import static android.media.tv.TvInputManager.INPUT_STATE_DISCONNECTED; |
| |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.hardware.hdmi.HdmiControlManager; |
| import android.hardware.hdmi.HdmiDeviceInfo; |
| import android.hardware.hdmi.HdmiHotplugEvent; |
| import android.hardware.hdmi.IHdmiControlService; |
| import android.hardware.hdmi.IHdmiDeviceEventListener; |
| import android.hardware.hdmi.IHdmiHotplugEventListener; |
| import android.hardware.hdmi.IHdmiSystemAudioModeChangeListener; |
| import android.media.AudioDevicePort; |
| import android.media.AudioFormat; |
| import android.media.AudioGain; |
| import android.media.AudioGainConfig; |
| import android.media.AudioManager; |
| import android.media.AudioPatch; |
| import android.media.AudioPort; |
| import android.media.AudioPortConfig; |
| import android.media.tv.ITvInputHardware; |
| import android.media.tv.ITvInputHardwareCallback; |
| import android.media.tv.TvInputHardwareInfo; |
| import android.media.tv.TvInputInfo; |
| import android.media.tv.TvStreamConfig; |
| import android.os.Handler; |
| import android.os.IBinder; |
| import android.os.Message; |
| import android.os.RemoteException; |
| import android.os.ServiceManager; |
| import android.util.ArrayMap; |
| import android.util.Slog; |
| import android.util.SparseArray; |
| import android.util.SparseBooleanArray; |
| import android.view.KeyEvent; |
| import android.view.Surface; |
| |
| import com.android.internal.os.SomeArgs; |
| import com.android.server.SystemService; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * A helper class for TvInputManagerService to handle TV input hardware. |
| * |
| * This class does a basic connection management and forwarding calls to TvInputHal which eventually |
| * calls to tv_input HAL module. |
| * |
| * @hide |
| */ |
| class TvInputHardwareManager implements TvInputHal.Callback { |
| private static final String TAG = TvInputHardwareManager.class.getSimpleName(); |
| |
| private final Context mContext; |
| private final Listener mListener; |
| private final TvInputHal mHal = new TvInputHal(this); |
| private final SparseArray<Connection> mConnections = new SparseArray<>(); |
| private final List<TvInputHardwareInfo> mHardwareList = new ArrayList<>(); |
| private final List<HdmiDeviceInfo> mHdmiDeviceList = new LinkedList<>(); |
| /* A map from a device ID to the matching TV input ID. */ |
| private final SparseArray<String> mHardwareInputIdMap = new SparseArray<>(); |
| /* A map from a HDMI logical address to the matching TV input ID. */ |
| private final SparseArray<String> mHdmiInputIdMap = new SparseArray<>(); |
| private final Map<String, TvInputInfo> mInputMap = new ArrayMap<>(); |
| |
| private final AudioManager mAudioManager; |
| private IHdmiControlService mHdmiControlService; |
| private final IHdmiHotplugEventListener mHdmiHotplugEventListener = |
| new HdmiHotplugEventListener(); |
| private final IHdmiDeviceEventListener mHdmiDeviceEventListener = new HdmiDeviceEventListener(); |
| private final IHdmiSystemAudioModeChangeListener mHdmiSystemAudioModeChangeListener = |
| new HdmiSystemAudioModeChangeListener(); |
| private final BroadcastReceiver mVolumeReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| handleVolumeChange(context, intent); |
| } |
| }; |
| private int mCurrentIndex = 0; |
| private int mCurrentMaxIndex = 0; |
| private final boolean mUseMasterVolume; |
| |
| // TODO: Should handle STANDBY case. |
| private final SparseBooleanArray mHdmiStateMap = new SparseBooleanArray(); |
| private final List<Message> mPendingHdmiDeviceEvents = new LinkedList<>(); |
| |
| // Calls to mListener should happen here. |
| private final Handler mHandler = new ListenerHandler(); |
| |
| private final Object mLock = new Object(); |
| |
| public TvInputHardwareManager(Context context, Listener listener) { |
| mContext = context; |
| mListener = listener; |
| mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); |
| mUseMasterVolume = mContext.getResources().getBoolean( |
| com.android.internal.R.bool.config_useMasterVolume); |
| mHal.init(); |
| } |
| |
| public void onBootPhase(int phase) { |
| if (phase == SystemService.PHASE_SYSTEM_SERVICES_READY) { |
| mHdmiControlService = IHdmiControlService.Stub.asInterface(ServiceManager.getService( |
| Context.HDMI_CONTROL_SERVICE)); |
| if (mHdmiControlService != null) { |
| try { |
| mHdmiControlService.addHotplugEventListener(mHdmiHotplugEventListener); |
| mHdmiControlService.addDeviceEventListener(mHdmiDeviceEventListener); |
| mHdmiControlService.addSystemAudioModeChangeListener( |
| mHdmiSystemAudioModeChangeListener); |
| mHdmiDeviceList.addAll(mHdmiControlService.getInputDevices()); |
| } catch (RemoteException e) { |
| Slog.w(TAG, "Error registering listeners to HdmiControlService:", e); |
| } |
| } else { |
| Slog.w(TAG, "HdmiControlService is not available"); |
| } |
| if (!mUseMasterVolume) { |
| final IntentFilter filter = new IntentFilter(); |
| filter.addAction(AudioManager.VOLUME_CHANGED_ACTION); |
| filter.addAction(AudioManager.STREAM_MUTE_CHANGED_ACTION); |
| mContext.registerReceiver(mVolumeReceiver, filter); |
| } |
| updateVolume(); |
| } |
| } |
| |
| @Override |
| public void onDeviceAvailable(TvInputHardwareInfo info, TvStreamConfig[] configs) { |
| synchronized (mLock) { |
| Connection connection = new Connection(info); |
| connection.updateConfigsLocked(configs); |
| mConnections.put(info.getDeviceId(), connection); |
| buildHardwareListLocked(); |
| mHandler.obtainMessage( |
| ListenerHandler.HARDWARE_DEVICE_ADDED, 0, 0, info).sendToTarget(); |
| if (info.getType() == TvInputHardwareInfo.TV_INPUT_TYPE_HDMI) { |
| processPendingHdmiDeviceEventsLocked(); |
| } |
| } |
| } |
| |
| private void buildHardwareListLocked() { |
| mHardwareList.clear(); |
| for (int i = 0; i < mConnections.size(); ++i) { |
| mHardwareList.add(mConnections.valueAt(i).getHardwareInfoLocked()); |
| } |
| } |
| |
| @Override |
| public void onDeviceUnavailable(int deviceId) { |
| synchronized (mLock) { |
| Connection connection = mConnections.get(deviceId); |
| if (connection == null) { |
| Slog.e(TAG, "onDeviceUnavailable: Cannot find a connection with " + deviceId); |
| return; |
| } |
| connection.resetLocked(null, null, null, null, null); |
| mConnections.remove(deviceId); |
| buildHardwareListLocked(); |
| TvInputHardwareInfo info = connection.getHardwareInfoLocked(); |
| if (info.getType() == TvInputHardwareInfo.TV_INPUT_TYPE_HDMI) { |
| // Remove HDMI devices linked with this hardware. |
| for (Iterator<HdmiDeviceInfo> it = mHdmiDeviceList.iterator(); it.hasNext();) { |
| HdmiDeviceInfo deviceInfo = it.next(); |
| if (deviceInfo.getPortId() == info.getHdmiPortId()) { |
| mHandler.obtainMessage(ListenerHandler.HDMI_DEVICE_REMOVED, 0, 0, |
| deviceInfo).sendToTarget(); |
| it.remove(); |
| } |
| } |
| } |
| mHandler.obtainMessage( |
| ListenerHandler.HARDWARE_DEVICE_REMOVED, 0, 0, info).sendToTarget(); |
| } |
| } |
| |
| @Override |
| public void onStreamConfigurationChanged(int deviceId, TvStreamConfig[] configs) { |
| synchronized (mLock) { |
| Connection connection = mConnections.get(deviceId); |
| if (connection == null) { |
| Slog.e(TAG, "StreamConfigurationChanged: Cannot find a connection with " |
| + deviceId); |
| return; |
| } |
| connection.updateConfigsLocked(configs); |
| String inputId = mHardwareInputIdMap.get(deviceId); |
| if (inputId != null) { |
| mHandler.obtainMessage(ListenerHandler.STATE_CHANGED, |
| convertConnectedToState(configs.length > 0), 0, inputId).sendToTarget(); |
| } |
| ITvInputHardwareCallback callback = connection.getCallbackLocked(); |
| if (callback != null) { |
| try { |
| callback.onStreamConfigChanged(configs); |
| } catch (RemoteException e) { |
| Slog.e(TAG, "error in onStreamConfigurationChanged", e); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void onFirstFrameCaptured(int deviceId, int streamId) { |
| synchronized (mLock) { |
| Connection connection = mConnections.get(deviceId); |
| if (connection == null) { |
| Slog.e(TAG, "FirstFrameCaptured: Cannot find a connection with " |
| + deviceId); |
| return; |
| } |
| Runnable runnable = connection.getOnFirstFrameCapturedLocked(); |
| if (runnable != null) { |
| runnable.run(); |
| connection.setOnFirstFrameCapturedLocked(null); |
| } |
| } |
| } |
| |
| public List<TvInputHardwareInfo> getHardwareList() { |
| synchronized (mLock) { |
| return Collections.unmodifiableList(mHardwareList); |
| } |
| } |
| |
| public List<HdmiDeviceInfo> getHdmiDeviceList() { |
| synchronized (mLock) { |
| return Collections.unmodifiableList(mHdmiDeviceList); |
| } |
| } |
| |
| private boolean checkUidChangedLocked( |
| Connection connection, int callingUid, int resolvedUserId) { |
| Integer connectionCallingUid = connection.getCallingUidLocked(); |
| Integer connectionResolvedUserId = connection.getResolvedUserIdLocked(); |
| if (connectionCallingUid == null || connectionResolvedUserId == null) { |
| return true; |
| } |
| if (connectionCallingUid != callingUid || connectionResolvedUserId != resolvedUserId) { |
| return true; |
| } |
| return false; |
| } |
| |
| private int convertConnectedToState(boolean connected) { |
| if (connected) { |
| return INPUT_STATE_CONNECTED; |
| } else { |
| return INPUT_STATE_DISCONNECTED; |
| } |
| } |
| |
| public void addHardwareTvInput(int deviceId, TvInputInfo info) { |
| synchronized (mLock) { |
| String oldInputId = mHardwareInputIdMap.get(deviceId); |
| if (oldInputId != null) { |
| Slog.w(TAG, "Trying to override previous registration: old = " |
| + mInputMap.get(oldInputId) + ":" + deviceId + ", new = " |
| + info + ":" + deviceId); |
| } |
| mHardwareInputIdMap.put(deviceId, info.getId()); |
| mInputMap.put(info.getId(), info); |
| |
| // Process pending state changes |
| |
| // For logical HDMI devices, they have information from HDMI CEC signals. |
| for (int i = 0; i < mHdmiStateMap.size(); ++i) { |
| TvInputHardwareInfo hardwareInfo = |
| findHardwareInfoForHdmiPortLocked(mHdmiStateMap.keyAt(i)); |
| if (hardwareInfo == null) { |
| continue; |
| } |
| String inputId = mHardwareInputIdMap.get(hardwareInfo.getDeviceId()); |
| if (inputId != null && inputId.equals(info.getId())) { |
| mHandler.obtainMessage(ListenerHandler.STATE_CHANGED, |
| convertConnectedToState(mHdmiStateMap.valueAt(i)), 0, |
| inputId).sendToTarget(); |
| return; |
| } |
| } |
| // For the rest of the devices, we can tell by the number of available streams. |
| Connection connection = mConnections.get(deviceId); |
| if (connection != null) { |
| mHandler.obtainMessage(ListenerHandler.STATE_CHANGED, |
| convertConnectedToState(connection.getConfigsLocked().length > 0), 0, |
| info.getId()).sendToTarget(); |
| return; |
| } |
| } |
| } |
| |
| private static <T> int indexOfEqualValue(SparseArray<T> map, T value) { |
| for (int i = 0; i < map.size(); ++i) { |
| if (map.valueAt(i).equals(value)) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| |
| private static boolean intArrayContains(int[] array, int value) { |
| for (int element : array) { |
| if (element == value) return true; |
| } |
| return false; |
| } |
| |
| public void addHdmiTvInput(int id, TvInputInfo info) { |
| if (info.getType() != TvInputInfo.TYPE_HDMI) { |
| throw new IllegalArgumentException("info (" + info + ") has non-HDMI type."); |
| } |
| synchronized (mLock) { |
| String parentId = info.getParentId(); |
| int parentIndex = indexOfEqualValue(mHardwareInputIdMap, parentId); |
| if (parentIndex < 0) { |
| throw new IllegalArgumentException("info (" + info + ") has invalid parentId."); |
| } |
| String oldInputId = mHdmiInputIdMap.get(id); |
| if (oldInputId != null) { |
| Slog.w(TAG, "Trying to override previous registration: old = " |
| + mInputMap.get(oldInputId) + ":" + id + ", new = " |
| + info + ":" + id); |
| } |
| mHdmiInputIdMap.put(id, info.getId()); |
| mInputMap.put(info.getId(), info); |
| } |
| } |
| |
| public void removeTvInput(String inputId) { |
| synchronized (mLock) { |
| mInputMap.remove(inputId); |
| int hardwareIndex = indexOfEqualValue(mHardwareInputIdMap, inputId); |
| if (hardwareIndex >= 0) { |
| mHardwareInputIdMap.removeAt(hardwareIndex); |
| } |
| int deviceIndex = indexOfEqualValue(mHdmiInputIdMap, inputId); |
| if (deviceIndex >= 0) { |
| mHdmiInputIdMap.removeAt(deviceIndex); |
| } |
| } |
| } |
| |
| /** |
| * Create a TvInputHardware object with a specific deviceId. One service at a time can access |
| * the object, and if more than one process attempts to create hardware with the same deviceId, |
| * the latest service will get the object and all the other hardware are released. The |
| * release is notified via ITvInputHardwareCallback.onReleased(). |
| */ |
| public ITvInputHardware acquireHardware(int deviceId, ITvInputHardwareCallback callback, |
| TvInputInfo info, int callingUid, int resolvedUserId) { |
| if (callback == null) { |
| throw new NullPointerException(); |
| } |
| synchronized (mLock) { |
| Connection connection = mConnections.get(deviceId); |
| if (connection == null) { |
| Slog.e(TAG, "Invalid deviceId : " + deviceId); |
| return null; |
| } |
| if (checkUidChangedLocked(connection, callingUid, resolvedUserId)) { |
| TvInputHardwareImpl hardware = |
| new TvInputHardwareImpl(connection.getHardwareInfoLocked()); |
| try { |
| callback.asBinder().linkToDeath(connection, 0); |
| } catch (RemoteException e) { |
| hardware.release(); |
| return null; |
| } |
| connection.resetLocked(hardware, callback, info, callingUid, resolvedUserId); |
| } |
| return connection.getHardwareLocked(); |
| } |
| } |
| |
| /** |
| * Release the specified hardware. |
| */ |
| public void releaseHardware(int deviceId, ITvInputHardware hardware, int callingUid, |
| int resolvedUserId) { |
| synchronized (mLock) { |
| Connection connection = mConnections.get(deviceId); |
| if (connection == null) { |
| Slog.e(TAG, "Invalid deviceId : " + deviceId); |
| return; |
| } |
| if (connection.getHardwareLocked() != hardware |
| || checkUidChangedLocked(connection, callingUid, resolvedUserId)) { |
| return; |
| } |
| connection.resetLocked(null, null, null, null, null); |
| } |
| } |
| |
| private TvInputHardwareInfo findHardwareInfoForHdmiPortLocked(int port) { |
| for (TvInputHardwareInfo hardwareInfo : mHardwareList) { |
| if (hardwareInfo.getType() == TvInputHardwareInfo.TV_INPUT_TYPE_HDMI |
| && hardwareInfo.getHdmiPortId() == port) { |
| return hardwareInfo; |
| } |
| } |
| return null; |
| } |
| |
| private int findDeviceIdForInputIdLocked(String inputId) { |
| for (int i = 0; i < mConnections.size(); ++i) { |
| Connection connection = mConnections.get(i); |
| if (connection.getInfoLocked().getId().equals(inputId)) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| |
| /** |
| * Get the list of TvStreamConfig which is buffered mode. |
| */ |
| public List<TvStreamConfig> getAvailableTvStreamConfigList(String inputId, int callingUid, |
| int resolvedUserId) { |
| List<TvStreamConfig> configsList = new ArrayList<TvStreamConfig>(); |
| synchronized (mLock) { |
| int deviceId = findDeviceIdForInputIdLocked(inputId); |
| if (deviceId < 0) { |
| Slog.e(TAG, "Invalid inputId : " + inputId); |
| return configsList; |
| } |
| Connection connection = mConnections.get(deviceId); |
| for (TvStreamConfig config : connection.getConfigsLocked()) { |
| if (config.getType() == TvStreamConfig.STREAM_TYPE_BUFFER_PRODUCER) { |
| configsList.add(config); |
| } |
| } |
| } |
| return configsList; |
| } |
| |
| /** |
| * Take a snapshot of the given TV input into the provided Surface. |
| */ |
| public boolean captureFrame(String inputId, Surface surface, final TvStreamConfig config, |
| int callingUid, int resolvedUserId) { |
| synchronized (mLock) { |
| int deviceId = findDeviceIdForInputIdLocked(inputId); |
| if (deviceId < 0) { |
| Slog.e(TAG, "Invalid inputId : " + inputId); |
| return false; |
| } |
| Connection connection = mConnections.get(deviceId); |
| final TvInputHardwareImpl hardwareImpl = connection.getHardwareImplLocked(); |
| if (hardwareImpl != null) { |
| // Stop previous capture. |
| Runnable runnable = connection.getOnFirstFrameCapturedLocked(); |
| if (runnable != null) { |
| runnable.run(); |
| connection.setOnFirstFrameCapturedLocked(null); |
| } |
| |
| boolean result = hardwareImpl.startCapture(surface, config); |
| if (result) { |
| connection.setOnFirstFrameCapturedLocked(new Runnable() { |
| @Override |
| public void run() { |
| hardwareImpl.stopCapture(config); |
| } |
| }); |
| } |
| return result; |
| } |
| } |
| return false; |
| } |
| |
| private void processPendingHdmiDeviceEventsLocked() { |
| for (Iterator<Message> it = mPendingHdmiDeviceEvents.iterator(); it.hasNext(); ) { |
| Message msg = it.next(); |
| HdmiDeviceInfo deviceInfo = (HdmiDeviceInfo) msg.obj; |
| TvInputHardwareInfo hardwareInfo = |
| findHardwareInfoForHdmiPortLocked(deviceInfo.getPortId()); |
| if (hardwareInfo != null) { |
| msg.sendToTarget(); |
| it.remove(); |
| } |
| } |
| } |
| |
| private void updateVolume() { |
| mCurrentMaxIndex = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC); |
| mCurrentIndex = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC); |
| } |
| |
| private void handleVolumeChange(Context context, Intent intent) { |
| String action = intent.getAction(); |
| if (action.equals(AudioManager.VOLUME_CHANGED_ACTION)) { |
| int streamType = intent.getIntExtra(AudioManager.EXTRA_VOLUME_STREAM_TYPE, -1); |
| if (streamType != AudioManager.STREAM_MUSIC) { |
| return; |
| } |
| int index = intent.getIntExtra(AudioManager.EXTRA_VOLUME_STREAM_VALUE, 0); |
| if (index == mCurrentIndex) { |
| return; |
| } |
| mCurrentIndex = index; |
| } else if (action.equals(AudioManager.STREAM_MUTE_CHANGED_ACTION)) { |
| int streamType = intent.getIntExtra(AudioManager.EXTRA_VOLUME_STREAM_TYPE, -1); |
| if (streamType != AudioManager.STREAM_MUSIC) { |
| return; |
| } |
| // volume index will be updated at onMediaStreamVolumeChanged() through updateVolume(). |
| } else { |
| Slog.w(TAG, "Unrecognized intent: " + intent); |
| return; |
| } |
| synchronized (mLock) { |
| for (int i = 0; i < mConnections.size(); ++i) { |
| TvInputHardwareImpl hardwareImpl = mConnections.valueAt(i).getHardwareImplLocked(); |
| if (hardwareImpl != null) { |
| hardwareImpl.onMediaStreamVolumeChanged(); |
| } |
| } |
| } |
| } |
| |
| private float getMediaStreamVolume() { |
| return mUseMasterVolume ? 1.0f : ((float) mCurrentIndex / (float) mCurrentMaxIndex); |
| } |
| |
| private class Connection implements IBinder.DeathRecipient { |
| private final TvInputHardwareInfo mHardwareInfo; |
| private TvInputInfo mInfo; |
| private TvInputHardwareImpl mHardware = null; |
| private ITvInputHardwareCallback mCallback; |
| private TvStreamConfig[] mConfigs = null; |
| private Integer mCallingUid = null; |
| private Integer mResolvedUserId = null; |
| private Runnable mOnFirstFrameCaptured; |
| |
| public Connection(TvInputHardwareInfo hardwareInfo) { |
| mHardwareInfo = hardwareInfo; |
| } |
| |
| // *Locked methods assume TvInputHardwareManager.mLock is held. |
| |
| public void resetLocked(TvInputHardwareImpl hardware, ITvInputHardwareCallback callback, |
| TvInputInfo info, Integer callingUid, Integer resolvedUserId) { |
| if (mHardware != null) { |
| try { |
| mCallback.onReleased(); |
| } catch (RemoteException e) { |
| Slog.e(TAG, "error in Connection::resetLocked", e); |
| } |
| mHardware.release(); |
| } |
| mHardware = hardware; |
| mCallback = callback; |
| mInfo = info; |
| mCallingUid = callingUid; |
| mResolvedUserId = resolvedUserId; |
| mOnFirstFrameCaptured = null; |
| |
| if (mHardware != null && mCallback != null) { |
| try { |
| mCallback.onStreamConfigChanged(getConfigsLocked()); |
| } catch (RemoteException e) { |
| Slog.e(TAG, "error in Connection::resetLocked", e); |
| } |
| } |
| } |
| |
| public void updateConfigsLocked(TvStreamConfig[] configs) { |
| mConfigs = configs; |
| } |
| |
| public TvInputHardwareInfo getHardwareInfoLocked() { |
| return mHardwareInfo; |
| } |
| |
| public TvInputInfo getInfoLocked() { |
| return mInfo; |
| } |
| |
| public ITvInputHardware getHardwareLocked() { |
| return mHardware; |
| } |
| |
| public TvInputHardwareImpl getHardwareImplLocked() { |
| return mHardware; |
| } |
| |
| public ITvInputHardwareCallback getCallbackLocked() { |
| return mCallback; |
| } |
| |
| public TvStreamConfig[] getConfigsLocked() { |
| return mConfigs; |
| } |
| |
| public Integer getCallingUidLocked() { |
| return mCallingUid; |
| } |
| |
| public Integer getResolvedUserIdLocked() { |
| return mResolvedUserId; |
| } |
| |
| public void setOnFirstFrameCapturedLocked(Runnable runnable) { |
| mOnFirstFrameCaptured = runnable; |
| } |
| |
| public Runnable getOnFirstFrameCapturedLocked() { |
| return mOnFirstFrameCaptured; |
| } |
| |
| @Override |
| public void binderDied() { |
| synchronized (mLock) { |
| resetLocked(null, null, null, null, null); |
| } |
| } |
| } |
| |
| private class TvInputHardwareImpl extends ITvInputHardware.Stub { |
| private final TvInputHardwareInfo mInfo; |
| private boolean mReleased = false; |
| private final Object mImplLock = new Object(); |
| |
| private final AudioManager.OnAudioPortUpdateListener mAudioListener = |
| new AudioManager.OnAudioPortUpdateListener() { |
| @Override |
| public void onAudioPortListUpdate(AudioPort[] portList) { |
| synchronized (mImplLock) { |
| updateAudioConfigLocked(); |
| } |
| } |
| |
| @Override |
| public void onAudioPatchListUpdate(AudioPatch[] patchList) { |
| // No-op |
| } |
| |
| @Override |
| public void onServiceDied() { |
| synchronized (mImplLock) { |
| mAudioSource = null; |
| mAudioSink.clear(); |
| mAudioPatch = null; |
| } |
| } |
| }; |
| private int mOverrideAudioType = AudioManager.DEVICE_NONE; |
| private String mOverrideAudioAddress = ""; |
| private AudioDevicePort mAudioSource; |
| private List<AudioDevicePort> mAudioSink = new ArrayList<>(); |
| private AudioPatch mAudioPatch = null; |
| // Set to an invalid value for a volume, so that current volume can be applied at the |
| // first call to updateAudioConfigLocked(). |
| private float mCommittedVolume = -1f; |
| private float mSourceVolume = 0.0f; |
| |
| private TvStreamConfig mActiveConfig = null; |
| |
| private int mDesiredSamplingRate = 0; |
| private int mDesiredChannelMask = AudioFormat.CHANNEL_OUT_DEFAULT; |
| private int mDesiredFormat = AudioFormat.ENCODING_DEFAULT; |
| |
| public TvInputHardwareImpl(TvInputHardwareInfo info) { |
| mInfo = info; |
| mAudioManager.registerAudioPortUpdateListener(mAudioListener); |
| if (mInfo.getAudioType() != AudioManager.DEVICE_NONE) { |
| mAudioSource = findAudioDevicePort(mInfo.getAudioType(), mInfo.getAudioAddress()); |
| findAudioSinkFromAudioPolicy(mAudioSink); |
| } |
| } |
| |
| private void findAudioSinkFromAudioPolicy(List<AudioDevicePort> sinks) { |
| sinks.clear(); |
| ArrayList<AudioPort> devicePorts = new ArrayList<AudioPort>(); |
| if (mAudioManager.listAudioDevicePorts(devicePorts) != AudioManager.SUCCESS) { |
| return; |
| } |
| int sinkDevice = mAudioManager.getDevicesForStream(AudioManager.STREAM_MUSIC); |
| for (AudioPort port : devicePorts) { |
| AudioDevicePort devicePort = (AudioDevicePort) port; |
| if ((devicePort.type() & sinkDevice) != 0) { |
| sinks.add(devicePort); |
| } |
| } |
| } |
| |
| private AudioDevicePort findAudioDevicePort(int type, String address) { |
| if (type == AudioManager.DEVICE_NONE) { |
| return null; |
| } |
| ArrayList<AudioPort> devicePorts = new ArrayList<AudioPort>(); |
| if (mAudioManager.listAudioDevicePorts(devicePorts) != AudioManager.SUCCESS) { |
| return null; |
| } |
| for (AudioPort port : devicePorts) { |
| AudioDevicePort devicePort = (AudioDevicePort) port; |
| if (devicePort.type() == type && devicePort.address().equals(address)) { |
| return devicePort; |
| } |
| } |
| return null; |
| } |
| |
| public void release() { |
| synchronized (mImplLock) { |
| mAudioManager.unregisterAudioPortUpdateListener(mAudioListener); |
| if (mAudioPatch != null) { |
| mAudioManager.releaseAudioPatch(mAudioPatch); |
| mAudioPatch = null; |
| } |
| mReleased = true; |
| } |
| } |
| |
| // A TvInputHardwareImpl object holds only one active session. Therefore, if a client |
| // attempts to call setSurface with different TvStreamConfig objects, the last call will |
| // prevail. |
| @Override |
| public boolean setSurface(Surface surface, TvStreamConfig config) |
| throws RemoteException { |
| synchronized (mImplLock) { |
| if (mReleased) { |
| throw new IllegalStateException("Device already released."); |
| } |
| |
| int result = TvInputHal.SUCCESS; |
| if (surface == null) { |
| // The value of config is ignored when surface == null. |
| if (mActiveConfig != null) { |
| result = mHal.removeStream(mInfo.getDeviceId(), mActiveConfig); |
| mActiveConfig = null; |
| } else { |
| // We already have no active stream. |
| return true; |
| } |
| } else { |
| // It's impossible to set a non-null surface with a null config. |
| if (config == null) { |
| return false; |
| } |
| // Remove stream only if we have an existing active configuration. |
| if (mActiveConfig != null && !config.equals(mActiveConfig)) { |
| result = mHal.removeStream(mInfo.getDeviceId(), mActiveConfig); |
| if (result != TvInputHal.SUCCESS) { |
| mActiveConfig = null; |
| } |
| } |
| // Proceed only if all previous operations succeeded. |
| if (result == TvInputHal.SUCCESS) { |
| result = mHal.addOrUpdateStream(mInfo.getDeviceId(), surface, config); |
| if (result == TvInputHal.SUCCESS) { |
| mActiveConfig = config; |
| } |
| } |
| } |
| updateAudioConfigLocked(); |
| return result == TvInputHal.SUCCESS; |
| } |
| } |
| |
| /** |
| * Update audio configuration (source, sink, patch) all up to current state. |
| */ |
| private void updateAudioConfigLocked() { |
| boolean sinkUpdated = updateAudioSinkLocked(); |
| boolean sourceUpdated = updateAudioSourceLocked(); |
| // We can't do updated = updateAudioSinkLocked() || updateAudioSourceLocked() here |
| // because Java won't evaluate the latter if the former is true. |
| |
| if (mAudioSource == null || mAudioSink.isEmpty() || mActiveConfig == null) { |
| if (mAudioPatch != null) { |
| mAudioManager.releaseAudioPatch(mAudioPatch); |
| mAudioPatch = null; |
| } |
| return; |
| } |
| |
| updateVolume(); |
| float volume = mSourceVolume * getMediaStreamVolume(); |
| AudioGainConfig sourceGainConfig = null; |
| if (mAudioSource.gains().length > 0 && volume != mCommittedVolume) { |
| AudioGain sourceGain = null; |
| for (AudioGain gain : mAudioSource.gains()) { |
| if ((gain.mode() & AudioGain.MODE_JOINT) != 0) { |
| sourceGain = gain; |
| break; |
| } |
| } |
| // NOTE: we only change the source gain in MODE_JOINT here. |
| if (sourceGain != null) { |
| int steps = (sourceGain.maxValue() - sourceGain.minValue()) |
| / sourceGain.stepValue(); |
| int gainValue = sourceGain.minValue(); |
| if (volume < 1.0f) { |
| gainValue += sourceGain.stepValue() * (int) (volume * steps + 0.5); |
| } else { |
| gainValue = sourceGain.maxValue(); |
| } |
| // size of gain values is 1 in MODE_JOINT |
| int[] gainValues = new int[] { gainValue }; |
| sourceGainConfig = sourceGain.buildConfig(AudioGain.MODE_JOINT, |
| sourceGain.channelMask(), gainValues, 0); |
| } else { |
| Slog.w(TAG, "No audio source gain with MODE_JOINT support exists."); |
| } |
| } |
| |
| AudioPortConfig sourceConfig = mAudioSource.activeConfig(); |
| List<AudioPortConfig> sinkConfigs = new ArrayList<>(); |
| AudioPatch[] audioPatchArray = new AudioPatch[] { mAudioPatch }; |
| boolean shouldRecreateAudioPatch = sourceUpdated || sinkUpdated; |
| |
| for (AudioDevicePort audioSink : mAudioSink) { |
| AudioPortConfig sinkConfig = audioSink.activeConfig(); |
| int sinkSamplingRate = mDesiredSamplingRate; |
| int sinkChannelMask = mDesiredChannelMask; |
| int sinkFormat = mDesiredFormat; |
| // If sinkConfig != null and values are set to default, |
| // fill in the sinkConfig values. |
| if (sinkConfig != null) { |
| if (sinkSamplingRate == 0) { |
| sinkSamplingRate = sinkConfig.samplingRate(); |
| } |
| if (sinkChannelMask == AudioFormat.CHANNEL_OUT_DEFAULT) { |
| sinkChannelMask = sinkConfig.channelMask(); |
| } |
| if (sinkFormat == AudioFormat.ENCODING_DEFAULT) { |
| sinkChannelMask = sinkConfig.format(); |
| } |
| } |
| |
| if (sinkConfig == null |
| || sinkConfig.samplingRate() != sinkSamplingRate |
| || sinkConfig.channelMask() != sinkChannelMask |
| || sinkConfig.format() != sinkFormat) { |
| // Check for compatibility and reset to default if necessary. |
| if (!intArrayContains(audioSink.samplingRates(), sinkSamplingRate) |
| && audioSink.samplingRates().length > 0) { |
| sinkSamplingRate = audioSink.samplingRates()[0]; |
| } |
| if (!intArrayContains(audioSink.channelMasks(), sinkChannelMask)) { |
| sinkChannelMask = AudioFormat.CHANNEL_OUT_DEFAULT; |
| } |
| if (!intArrayContains(audioSink.formats(), sinkFormat)) { |
| sinkFormat = AudioFormat.ENCODING_DEFAULT; |
| } |
| sinkConfig = audioSink.buildConfig(sinkSamplingRate, sinkChannelMask, |
| sinkFormat, null); |
| shouldRecreateAudioPatch = true; |
| } |
| sinkConfigs.add(sinkConfig); |
| } |
| // sinkConfigs.size() == mAudioSink.size(), and mAudioSink is guaranteed to be |
| // non-empty at the beginning of this method. |
| AudioPortConfig sinkConfig = sinkConfigs.get(0); |
| if (sourceConfig == null || sourceGainConfig != null) { |
| int sourceSamplingRate = 0; |
| if (intArrayContains(mAudioSource.samplingRates(), sinkConfig.samplingRate())) { |
| sourceSamplingRate = sinkConfig.samplingRate(); |
| } else if (mAudioSource.samplingRates().length > 0) { |
| // Use any sampling rate and hope audio patch can handle resampling... |
| sourceSamplingRate = mAudioSource.samplingRates()[0]; |
| } |
| int sourceChannelMask = AudioFormat.CHANNEL_IN_DEFAULT; |
| for (int inChannelMask : mAudioSource.channelMasks()) { |
| if (AudioFormat.channelCountFromOutChannelMask(sinkConfig.channelMask()) |
| == AudioFormat.channelCountFromInChannelMask(inChannelMask)) { |
| sourceChannelMask = inChannelMask; |
| break; |
| } |
| } |
| int sourceFormat = AudioFormat.ENCODING_DEFAULT; |
| if (intArrayContains(mAudioSource.formats(), sinkConfig.format())) { |
| sourceFormat = sinkConfig.format(); |
| } |
| sourceConfig = mAudioSource.buildConfig(sourceSamplingRate, sourceChannelMask, |
| sourceFormat, sourceGainConfig); |
| shouldRecreateAudioPatch = true; |
| } |
| if (shouldRecreateAudioPatch) { |
| mCommittedVolume = volume; |
| mAudioManager.createAudioPatch( |
| audioPatchArray, |
| new AudioPortConfig[] { sourceConfig }, |
| sinkConfigs.toArray(new AudioPortConfig[0])); |
| mAudioPatch = audioPatchArray[0]; |
| if (sourceGainConfig != null) { |
| mAudioManager.setAudioPortGain(mAudioSource, sourceGainConfig); |
| } |
| } |
| } |
| |
| @Override |
| public void setStreamVolume(float volume) throws RemoteException { |
| synchronized (mImplLock) { |
| if (mReleased) { |
| throw new IllegalStateException("Device already released."); |
| } |
| mSourceVolume = volume; |
| updateAudioConfigLocked(); |
| } |
| } |
| |
| @Override |
| public boolean dispatchKeyEventToHdmi(KeyEvent event) throws RemoteException { |
| synchronized (mImplLock) { |
| if (mReleased) { |
| throw new IllegalStateException("Device already released."); |
| } |
| } |
| if (mInfo.getType() != TvInputHardwareInfo.TV_INPUT_TYPE_HDMI) { |
| return false; |
| } |
| // TODO(hdmi): mHdmiClient.sendKeyEvent(event); |
| return false; |
| } |
| |
| private boolean startCapture(Surface surface, TvStreamConfig config) { |
| synchronized (mImplLock) { |
| if (mReleased) { |
| return false; |
| } |
| if (surface == null || config == null) { |
| return false; |
| } |
| if (config.getType() != TvStreamConfig.STREAM_TYPE_BUFFER_PRODUCER) { |
| return false; |
| } |
| |
| int result = mHal.addOrUpdateStream(mInfo.getDeviceId(), surface, config); |
| return result == TvInputHal.SUCCESS; |
| } |
| } |
| |
| private boolean stopCapture(TvStreamConfig config) { |
| synchronized (mImplLock) { |
| if (mReleased) { |
| return false; |
| } |
| if (config == null) { |
| return false; |
| } |
| |
| int result = mHal.removeStream(mInfo.getDeviceId(), config); |
| return result == TvInputHal.SUCCESS; |
| } |
| } |
| |
| private boolean updateAudioSourceLocked() { |
| if (mInfo.getAudioType() == AudioManager.DEVICE_NONE) { |
| return false; |
| } |
| AudioDevicePort previousSource = mAudioSource; |
| mAudioSource = findAudioDevicePort(mInfo.getAudioType(), mInfo.getAudioAddress()); |
| return mAudioSource == null ? (previousSource != null) |
| : !mAudioSource.equals(previousSource); |
| } |
| |
| private boolean updateAudioSinkLocked() { |
| if (mInfo.getAudioType() == AudioManager.DEVICE_NONE) { |
| return false; |
| } |
| List<AudioDevicePort> previousSink = mAudioSink; |
| mAudioSink = new ArrayList<>(); |
| if (mOverrideAudioType == AudioManager.DEVICE_NONE) { |
| findAudioSinkFromAudioPolicy(mAudioSink); |
| } else { |
| AudioDevicePort audioSink = |
| findAudioDevicePort(mOverrideAudioType, mOverrideAudioAddress); |
| if (audioSink != null) { |
| mAudioSink.add(audioSink); |
| } |
| } |
| |
| // Returns true if mAudioSink and previousSink differs. |
| if (mAudioSink.size() != previousSink.size()) { |
| return true; |
| } |
| previousSink.removeAll(mAudioSink); |
| return !previousSink.isEmpty(); |
| } |
| |
| private void handleAudioSinkUpdated() { |
| synchronized (mImplLock) { |
| updateAudioConfigLocked(); |
| } |
| } |
| |
| @Override |
| public void overrideAudioSink(int audioType, String audioAddress, int samplingRate, |
| int channelMask, int format) { |
| synchronized (mImplLock) { |
| mOverrideAudioType = audioType; |
| mOverrideAudioAddress = audioAddress; |
| |
| mDesiredSamplingRate = samplingRate; |
| mDesiredChannelMask = channelMask; |
| mDesiredFormat = format; |
| |
| updateAudioConfigLocked(); |
| } |
| } |
| |
| public void onMediaStreamVolumeChanged() { |
| synchronized (mImplLock) { |
| updateAudioConfigLocked(); |
| } |
| } |
| } |
| |
| interface Listener { |
| public void onStateChanged(String inputId, int state); |
| public void onHardwareDeviceAdded(TvInputHardwareInfo info); |
| public void onHardwareDeviceRemoved(TvInputHardwareInfo info); |
| public void onHdmiDeviceAdded(HdmiDeviceInfo device); |
| public void onHdmiDeviceRemoved(HdmiDeviceInfo device); |
| public void onHdmiDeviceUpdated(String inputId, HdmiDeviceInfo device); |
| } |
| |
| private class ListenerHandler extends Handler { |
| private static final int STATE_CHANGED = 1; |
| private static final int HARDWARE_DEVICE_ADDED = 2; |
| private static final int HARDWARE_DEVICE_REMOVED = 3; |
| private static final int HDMI_DEVICE_ADDED = 4; |
| private static final int HDMI_DEVICE_REMOVED = 5; |
| private static final int HDMI_DEVICE_UPDATED = 6; |
| |
| @Override |
| public final void handleMessage(Message msg) { |
| switch (msg.what) { |
| case STATE_CHANGED: { |
| String inputId = (String) msg.obj; |
| int state = msg.arg1; |
| mListener.onStateChanged(inputId, state); |
| break; |
| } |
| case HARDWARE_DEVICE_ADDED: { |
| TvInputHardwareInfo info = (TvInputHardwareInfo) msg.obj; |
| mListener.onHardwareDeviceAdded(info); |
| break; |
| } |
| case HARDWARE_DEVICE_REMOVED: { |
| TvInputHardwareInfo info = (TvInputHardwareInfo) msg.obj; |
| mListener.onHardwareDeviceRemoved(info); |
| break; |
| } |
| case HDMI_DEVICE_ADDED: { |
| HdmiDeviceInfo info = (HdmiDeviceInfo) msg.obj; |
| mListener.onHdmiDeviceAdded(info); |
| break; |
| } |
| case HDMI_DEVICE_REMOVED: { |
| HdmiDeviceInfo info = (HdmiDeviceInfo) msg.obj; |
| mListener.onHdmiDeviceRemoved(info); |
| break; |
| } |
| case HDMI_DEVICE_UPDATED: { |
| HdmiDeviceInfo info = (HdmiDeviceInfo) msg.obj; |
| String inputId = null; |
| synchronized (mLock) { |
| inputId = mHdmiInputIdMap.get(info.getId()); |
| } |
| if (inputId != null) { |
| mListener.onHdmiDeviceUpdated(inputId, info); |
| } else { |
| Slog.w(TAG, "Could not resolve input ID matching the device info; " |
| + "ignoring."); |
| } |
| break; |
| } |
| default: { |
| Slog.w(TAG, "Unhandled message: " + msg); |
| break; |
| } |
| } |
| } |
| } |
| |
| // Listener implementations for HdmiControlService |
| |
| private final class HdmiHotplugEventListener extends IHdmiHotplugEventListener.Stub { |
| @Override |
| public void onReceived(HdmiHotplugEvent event) { |
| synchronized (mLock) { |
| mHdmiStateMap.put(event.getPort(), event.isConnected()); |
| TvInputHardwareInfo hardwareInfo = |
| findHardwareInfoForHdmiPortLocked(event.getPort()); |
| if (hardwareInfo == null) { |
| return; |
| } |
| String inputId = mHardwareInputIdMap.get(hardwareInfo.getDeviceId()); |
| if (inputId == null) { |
| return; |
| } |
| mHandler.obtainMessage(ListenerHandler.STATE_CHANGED, |
| convertConnectedToState(event.isConnected()), 0, inputId).sendToTarget(); |
| } |
| } |
| } |
| |
| private final class HdmiDeviceEventListener extends IHdmiDeviceEventListener.Stub { |
| @Override |
| public void onStatusChanged(HdmiDeviceInfo deviceInfo, int status) { |
| if (!deviceInfo.isSourceType()) return; |
| synchronized (mLock) { |
| int messageType = 0; |
| Object obj = null; |
| switch (status) { |
| case HdmiControlManager.DEVICE_EVENT_ADD_DEVICE: { |
| if (findHdmiDeviceInfo(deviceInfo.getId()) == null) { |
| mHdmiDeviceList.add(deviceInfo); |
| } else { |
| Slog.w(TAG, "The list already contains " + deviceInfo + "; ignoring."); |
| return; |
| } |
| messageType = ListenerHandler.HDMI_DEVICE_ADDED; |
| obj = deviceInfo; |
| break; |
| } |
| case HdmiControlManager.DEVICE_EVENT_REMOVE_DEVICE: { |
| HdmiDeviceInfo originalDeviceInfo = findHdmiDeviceInfo(deviceInfo.getId()); |
| if (!mHdmiDeviceList.remove(originalDeviceInfo)) { |
| Slog.w(TAG, "The list doesn't contain " + deviceInfo + "; ignoring."); |
| return; |
| } |
| messageType = ListenerHandler.HDMI_DEVICE_REMOVED; |
| obj = deviceInfo; |
| break; |
| } |
| case HdmiControlManager.DEVICE_EVENT_UPDATE_DEVICE: { |
| HdmiDeviceInfo originalDeviceInfo = findHdmiDeviceInfo(deviceInfo.getId()); |
| if (!mHdmiDeviceList.remove(originalDeviceInfo)) { |
| Slog.w(TAG, "The list doesn't contain " + deviceInfo + "; ignoring."); |
| return; |
| } |
| mHdmiDeviceList.add(deviceInfo); |
| messageType = ListenerHandler.HDMI_DEVICE_UPDATED; |
| obj = deviceInfo; |
| break; |
| } |
| } |
| |
| Message msg = mHandler.obtainMessage(messageType, 0, 0, obj); |
| if (findHardwareInfoForHdmiPortLocked(deviceInfo.getPortId()) != null) { |
| msg.sendToTarget(); |
| } else { |
| mPendingHdmiDeviceEvents.add(msg); |
| } |
| } |
| } |
| |
| private HdmiDeviceInfo findHdmiDeviceInfo(int id) { |
| for (HdmiDeviceInfo info : mHdmiDeviceList) { |
| if (info.getId() == id) { |
| return info; |
| } |
| } |
| return null; |
| } |
| } |
| |
| private final class HdmiSystemAudioModeChangeListener extends |
| IHdmiSystemAudioModeChangeListener.Stub { |
| @Override |
| public void onStatusChanged(boolean enabled) throws RemoteException { |
| synchronized (mLock) { |
| for (int i = 0; i < mConnections.size(); ++i) { |
| TvInputHardwareImpl impl = mConnections.valueAt(i).getHardwareImplLocked(); |
| if (impl != null) { |
| impl.handleAudioSinkUpdated(); |
| } |
| } |
| } |
| } |
| } |
| } |
