671 lines
24 KiB
Java
671 lines
24 KiB
Java
/*
|
|
* Copyright (C) 2020 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 android.hardware.input;
|
|
|
|
import android.annotation.NonNull;
|
|
import android.annotation.Nullable;
|
|
import android.hardware.HardwareBuffer;
|
|
import android.hardware.Sensor;
|
|
import android.hardware.SensorAdditionalInfo;
|
|
import android.hardware.SensorDirectChannel;
|
|
import android.hardware.SensorEvent;
|
|
import android.hardware.SensorEventListener;
|
|
import android.hardware.SensorManager;
|
|
import android.hardware.TriggerEventListener;
|
|
import android.os.Build;
|
|
import android.os.Handler;
|
|
import android.os.HandlerThread;
|
|
import android.os.Looper;
|
|
import android.os.MemoryFile;
|
|
import android.os.Message;
|
|
import android.os.RemoteException;
|
|
import android.util.Slog;
|
|
import android.util.SparseArray;
|
|
import android.view.InputDevice;
|
|
|
|
import com.android.internal.annotations.GuardedBy;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
/**
|
|
* Sensor manager implementation that communicates with the input device
|
|
* sensors.
|
|
* @hide
|
|
*/
|
|
public class InputDeviceSensorManager {
|
|
private static final String TAG = "InputDeviceSensorManager";
|
|
private static final boolean DEBUG = false;
|
|
|
|
private static final int MSG_SENSOR_ACCURACY_CHANGED = 1;
|
|
private static final int MSG_SENSOR_CHANGED = 2;
|
|
|
|
private final InputManagerGlobal mGlobal;
|
|
|
|
// sensor map from device id to sensor list
|
|
@GuardedBy("mInputSensorLock")
|
|
private final Map<Integer, List<Sensor>> mSensors = new HashMap<>();
|
|
|
|
private final Object mInputSensorLock = new Object();
|
|
private InputSensorEventListener mInputServiceSensorListener;
|
|
@GuardedBy("mInputSensorLock")
|
|
private final ArrayList<InputSensorEventListenerDelegate> mInputSensorEventListeners =
|
|
new ArrayList<>();
|
|
|
|
// The sensor thread is only initialized if there is a listener added without a handler.
|
|
@GuardedBy("mInputSensorLock")
|
|
@Nullable
|
|
private HandlerThread mSensorThread;
|
|
|
|
public InputDeviceSensorManager(InputManagerGlobal inputManagerGlobal) {
|
|
mGlobal = inputManagerGlobal;
|
|
|
|
// Initialize the sensor list
|
|
initializeSensors();
|
|
}
|
|
|
|
/*
|
|
* Get SensorManager object for specific input device
|
|
*
|
|
* @param deviceId Input device ID
|
|
* @return SensorManager object for input device
|
|
*/
|
|
SensorManager getSensorManager(int deviceId) {
|
|
return new InputSensorManager(deviceId);
|
|
}
|
|
|
|
/*
|
|
* Update input device sensor info for specified input device ID.
|
|
*/
|
|
private void updateInputDeviceSensorInfoLocked(int deviceId) {
|
|
final InputDevice inputDevice = InputDevice.getDevice(deviceId);
|
|
if (inputDevice != null && inputDevice.hasSensor()) {
|
|
final InputSensorInfo[] sensorInfos =
|
|
mGlobal.getSensorList(deviceId);
|
|
populateSensorsForInputDeviceLocked(deviceId, sensorInfos);
|
|
}
|
|
}
|
|
|
|
public void onInputDeviceAdded(int deviceId) {
|
|
synchronized (mInputSensorLock) {
|
|
if (!mSensors.containsKey(deviceId)) {
|
|
updateInputDeviceSensorInfoLocked(deviceId);
|
|
} else {
|
|
Slog.e(TAG, "Received 'device added' notification for device " + deviceId
|
|
+ ", but it is already in the list");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void onInputDeviceRemoved(int deviceId) {
|
|
synchronized (mInputSensorLock) {
|
|
mSensors.remove(deviceId);
|
|
}
|
|
}
|
|
|
|
public void onInputDeviceChanged(int deviceId) {
|
|
synchronized (mInputSensorLock) {
|
|
mSensors.remove(deviceId);
|
|
updateInputDeviceSensorInfoLocked(deviceId);
|
|
}
|
|
}
|
|
|
|
private static boolean sensorEquals(@NonNull Sensor lhs, @NonNull Sensor rhs) {
|
|
return lhs.getType() == rhs.getType() && lhs.getId() == rhs.getId();
|
|
}
|
|
|
|
private void populateSensorsForInputDeviceLocked(int deviceId, InputSensorInfo[] sensorInfos) {
|
|
List<Sensor> sensors = new ArrayList<>();
|
|
for (int i = 0; i < sensorInfos.length; i++) {
|
|
Sensor sensor = new Sensor(sensorInfos[i]);
|
|
if (DEBUG) {
|
|
Slog.d(TAG, "Device " + deviceId + " sensor " + sensor.getStringType() + " added");
|
|
}
|
|
sensors.add(sensor);
|
|
}
|
|
mSensors.put(deviceId, sensors);
|
|
}
|
|
|
|
private void initializeSensors() {
|
|
synchronized (mInputSensorLock) {
|
|
mSensors.clear();
|
|
int[] deviceIds = mGlobal.getInputDeviceIds();
|
|
for (int i = 0; i < deviceIds.length; i++) {
|
|
final int deviceId = deviceIds[i];
|
|
updateInputDeviceSensorInfoLocked(deviceId);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get a sensor object for input device, with specific sensor type.
|
|
* @param deviceId The input devicd ID
|
|
* @param sensorType The sensor type
|
|
* @return The sensor object if exists or null
|
|
*/
|
|
@GuardedBy("mInputSensorLock")
|
|
private Sensor getInputDeviceSensorLocked(int deviceId, int sensorType) {
|
|
List<Sensor> sensors = mSensors.get(deviceId);
|
|
for (Sensor sensor : sensors) {
|
|
if (sensor.getType() == sensorType) {
|
|
return sensor;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@GuardedBy("mInputSensorLock")
|
|
private int findSensorEventListenerLocked(SensorEventListener listener) {
|
|
for (int i = 0; i < mInputSensorEventListeners.size(); i++) {
|
|
if (mInputSensorEventListeners.get(i).getListener() == listener) {
|
|
return i;
|
|
}
|
|
}
|
|
return Integer.MIN_VALUE;
|
|
}
|
|
|
|
private void onInputSensorChanged(int deviceId, int sensorType, int accuracy, long timestamp,
|
|
float[] values) {
|
|
if (DEBUG) {
|
|
Slog.d(TAG, "Sensor changed: deviceId =" + deviceId
|
|
+ " timestamp=" + timestamp + " sensorType=" + sensorType);
|
|
}
|
|
synchronized (mInputSensorLock) {
|
|
Sensor sensor = getInputDeviceSensorLocked(deviceId, sensorType);
|
|
if (sensor == null) {
|
|
Slog.wtf(TAG, "onInputSensorChanged: Got sensor update for device " + deviceId
|
|
+ " but the sensor was not found.");
|
|
return;
|
|
}
|
|
for (int i = 0; i < mInputSensorEventListeners.size(); i++) {
|
|
InputSensorEventListenerDelegate listener =
|
|
mInputSensorEventListeners.get(i);
|
|
if (listener.hasSensorRegistered(deviceId, sensorType)) {
|
|
SensorEvent event = listener.getSensorEvent(sensor);
|
|
if (event == null) {
|
|
Slog.wtf(TAG, "Failed to get SensorEvent.");
|
|
return;
|
|
}
|
|
event.sensor = sensor;
|
|
event.accuracy = accuracy;
|
|
event.timestamp = timestamp;
|
|
System.arraycopy(values, 0, event.values, 0, event.values.length);
|
|
// Call listener for sensor changed
|
|
listener.sendSensorChanged(event);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void onInputSensorAccuracyChanged(int deviceId, int sensorType, int accuracy) {
|
|
if (DEBUG) {
|
|
Slog.d(TAG, "Sensor accuracy changed: "
|
|
+ "accuracy=" + accuracy + ", sensorType=" + sensorType);
|
|
}
|
|
synchronized (mInputSensorLock) {
|
|
for (int i = 0; i < mInputSensorEventListeners.size(); i++) {
|
|
InputSensorEventListenerDelegate listener =
|
|
mInputSensorEventListeners.get(i);
|
|
if (listener.hasSensorRegistered(deviceId, sensorType)) {
|
|
listener.sendSensorAccuracyChanged(deviceId, sensorType, accuracy);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private final class InputSensorEventListener extends IInputSensorEventListener.Stub {
|
|
@Override
|
|
public void onInputSensorChanged(int deviceId, int sensorType, int accuracy, long timestamp,
|
|
float[] values) throws RemoteException {
|
|
InputDeviceSensorManager.this.onInputSensorChanged(
|
|
deviceId, sensorType, accuracy, timestamp, values);
|
|
}
|
|
|
|
@Override
|
|
public void onInputSensorAccuracyChanged(int deviceId, int sensorType, int accuracy)
|
|
throws RemoteException {
|
|
InputDeviceSensorManager.this.onInputSensorAccuracyChanged(deviceId, sensorType,
|
|
accuracy);
|
|
}
|
|
|
|
}
|
|
|
|
private static final class InputSensorEventListenerDelegate extends Handler {
|
|
private final SensorEventListener mListener;
|
|
// List of sensors being listened to
|
|
private final List<Sensor> mSensors = new ArrayList<>();
|
|
// Sensor event array by sensor type, preallocate sensor events for each sensor of listener
|
|
// to avoid allocation and garbage collection for each listener callback.
|
|
private final SparseArray<SensorEvent> mSensorEvents = new SparseArray<>();
|
|
|
|
InputSensorEventListenerDelegate(SensorEventListener listener, Sensor sensor,
|
|
Looper looper) {
|
|
super(looper);
|
|
mListener = listener;
|
|
addSensor(sensor);
|
|
}
|
|
|
|
public List<Sensor> getSensors() {
|
|
return mSensors;
|
|
}
|
|
|
|
public boolean isEmpty() {
|
|
return mSensors.isEmpty();
|
|
}
|
|
|
|
/**
|
|
* Remove sensor from sensor list for listener
|
|
*/
|
|
public void removeSensor(@Nullable Sensor sensor) {
|
|
// If sensor is not specified the listener will be unregistered for all sensors
|
|
// and the sensor list is cleared.
|
|
if (sensor == null) {
|
|
mSensors.clear();
|
|
mSensorEvents.clear();
|
|
return;
|
|
}
|
|
for (Sensor s : mSensors) {
|
|
if (sensorEquals(s, sensor)) {
|
|
mSensors.remove(sensor);
|
|
mSensorEvents.remove(sensor.getType());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a sensor to listener's sensor list
|
|
*/
|
|
public void addSensor(@NonNull Sensor sensor) {
|
|
for (Sensor s : mSensors) {
|
|
if (sensorEquals(s, sensor)) {
|
|
Slog.w(TAG, "Adding sensor " + sensor + " already exist!");
|
|
return;
|
|
}
|
|
}
|
|
mSensors.add(sensor);
|
|
final int vecLength = Sensor.getMaxLengthValuesArray(sensor, Build.VERSION.SDK_INT);
|
|
SensorEvent event = new SensorEvent(sensor, SensorManager.SENSOR_STATUS_NO_CONTACT,
|
|
0 /* timestamp */, new float[vecLength]);
|
|
mSensorEvents.put(sensor.getType(), event);
|
|
}
|
|
|
|
/**
|
|
* Check if the listener has been registered to the sensor
|
|
* @param deviceId The input device ID of the sensor
|
|
* @param sensorType The sensor type of the sensor
|
|
* @return true if specified sensor is registered for the listener.
|
|
*/
|
|
public boolean hasSensorRegistered(int deviceId, int sensorType) {
|
|
for (Sensor sensor : mSensors) {
|
|
if (sensor.getType() == sensorType && sensor.getId() == deviceId) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Get listener handle for the delegate
|
|
*/
|
|
public SensorEventListener getListener() {
|
|
return mListener;
|
|
}
|
|
|
|
/**
|
|
* Get SensorEvent object for input device, with specified sensor.
|
|
*/
|
|
private SensorEvent getSensorEvent(@NonNull Sensor sensor) {
|
|
return mSensorEvents.get(sensor.getType());
|
|
}
|
|
|
|
/**
|
|
* Send sensor changed message
|
|
*/
|
|
public void sendSensorChanged(SensorEvent event) {
|
|
obtainMessage(MSG_SENSOR_CHANGED, event).sendToTarget();
|
|
}
|
|
|
|
/**
|
|
* Send sensor accuracy changed message
|
|
*/
|
|
public void sendSensorAccuracyChanged(int deviceId, int sensorType, int accuracy) {
|
|
obtainMessage(MSG_SENSOR_ACCURACY_CHANGED, deviceId, sensorType, accuracy)
|
|
.sendToTarget();
|
|
}
|
|
|
|
@Override
|
|
public void handleMessage(Message msg) {
|
|
switch (msg.what) {
|
|
case MSG_SENSOR_ACCURACY_CHANGED: {
|
|
final int deviceId = msg.arg1;
|
|
final int sensorType = msg.arg2;
|
|
final int accuracy = (int) msg.obj;
|
|
for (Sensor sensor : mSensors) {
|
|
if (sensor.getId() == deviceId && sensor.getType() == sensorType) {
|
|
mListener.onAccuracyChanged(sensor, accuracy);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case MSG_SENSOR_CHANGED: {
|
|
SensorEvent event = (SensorEvent) msg.obj;
|
|
mListener.onSensorChanged(event);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the default sensor object for input device, for specific sensor type.
|
|
*/
|
|
private Sensor getSensorForInputDevice(int deviceId, int type) {
|
|
synchronized (mInputSensorLock) {
|
|
for (Map.Entry<Integer, List<Sensor>> entry : mSensors.entrySet()) {
|
|
for (Sensor sensor : entry.getValue()) {
|
|
if (sensor.getId() == deviceId && sensor.getType() == type) {
|
|
if (DEBUG) {
|
|
Slog.d(TAG, "Device " + deviceId + " sensor " + sensor.getStringType());
|
|
}
|
|
return sensor;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Return list of sensors that belong to an input device, specified by input device ID.
|
|
*/
|
|
private List<Sensor> getFullSensorListForDevice(int deviceId) {
|
|
List<Sensor> sensors = new ArrayList<Sensor>();
|
|
synchronized (mInputSensorLock) {
|
|
for (Map.Entry<Integer, List<Sensor>> entry : mSensors.entrySet()) {
|
|
for (Sensor sensor : entry.getValue()) {
|
|
if (sensor.getId() == deviceId) {
|
|
if (DEBUG) {
|
|
Slog.d(TAG, "Device " + deviceId + " sensor " + sensor.getStringType());
|
|
}
|
|
sensors.add(sensor);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return sensors;
|
|
}
|
|
|
|
private boolean registerListenerInternal(SensorEventListener listener, Sensor sensor,
|
|
int delayUs, int maxBatchReportLatencyUs, Handler handler) {
|
|
if (DEBUG) {
|
|
Slog.d(TAG, "registerListenerImpl listener=" + listener + " sensor=" + sensor
|
|
+ " delayUs=" + delayUs
|
|
+ " maxBatchReportLatencyUs=" + maxBatchReportLatencyUs);
|
|
}
|
|
if (listener == null) {
|
|
Slog.e(TAG, "listener is null");
|
|
return false;
|
|
}
|
|
|
|
if (sensor == null) {
|
|
Slog.e(TAG, "sensor is null");
|
|
return false;
|
|
}
|
|
|
|
// Trigger Sensors should use the requestTriggerSensor call.
|
|
if (sensor.getReportingMode() == Sensor.REPORTING_MODE_ONE_SHOT) {
|
|
Slog.e(TAG, "Trigger Sensors should use the requestTriggerSensor.");
|
|
return false;
|
|
}
|
|
|
|
if (maxBatchReportLatencyUs < 0 || delayUs < 0) {
|
|
Slog.e(TAG, "maxBatchReportLatencyUs and delayUs should be non-negative");
|
|
return false;
|
|
}
|
|
|
|
synchronized (mInputSensorLock) {
|
|
if (getSensorForInputDevice(sensor.getId(), sensor.getType()) != null) {
|
|
final int deviceId = sensor.getId();
|
|
final InputDevice inputDevice = mGlobal.getInputDevice(deviceId);
|
|
if (inputDevice == null) {
|
|
Slog.e(TAG, "input device not found for sensor " + sensor.getId());
|
|
return false;
|
|
}
|
|
|
|
if (!inputDevice.hasSensor()) {
|
|
Slog.e(TAG, "The device doesn't have the sensor:" + sensor);
|
|
return false;
|
|
}
|
|
if (!mGlobal.enableSensor(deviceId, sensor.getType(), delayUs,
|
|
maxBatchReportLatencyUs)) {
|
|
Slog.e(TAG, "Can't enable the sensor:" + sensor);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Register the InputManagerService sensor listener if not yet.
|
|
if (mInputServiceSensorListener == null) {
|
|
mInputServiceSensorListener = new InputSensorEventListener();
|
|
if (!mGlobal.registerSensorListener(mInputServiceSensorListener)) {
|
|
Slog.e(TAG, "Failed registering the sensor listener");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
int idx = findSensorEventListenerLocked(listener);
|
|
if (idx < 0) {
|
|
InputSensorEventListenerDelegate d =
|
|
new InputSensorEventListenerDelegate(listener, sensor,
|
|
getLooperForListenerLocked(handler));
|
|
mInputSensorEventListeners.add(d);
|
|
} else {
|
|
// The listener is already registered, see if it wants to listen to more sensors.
|
|
mInputSensorEventListeners.get(idx).addSensor(sensor);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
@GuardedBy("mInputSensorLock")
|
|
@NonNull
|
|
private Looper getLooperForListenerLocked(@Nullable Handler requestedHandler) {
|
|
if (requestedHandler != null) {
|
|
return requestedHandler.getLooper();
|
|
}
|
|
if (mSensorThread == null) {
|
|
mSensorThread = new HandlerThread("SensorThread");
|
|
mSensorThread.start();
|
|
}
|
|
return mSensorThread.getLooper();
|
|
}
|
|
|
|
private void unregisterListenerInternal(SensorEventListener listener, Sensor sensor) {
|
|
if (DEBUG) {
|
|
Slog.d(TAG, "unregisterListenerImpl listener=" + listener + " sensor=" + sensor);
|
|
}
|
|
if (listener == null) { // it's OK for the sensor to be null
|
|
throw new IllegalArgumentException("listener must not be null");
|
|
}
|
|
synchronized (mInputSensorLock) {
|
|
int idx = findSensorEventListenerLocked(listener);
|
|
// Track the sensor types and the device Id the listener has registered.
|
|
final List<Sensor> sensorsRegistered;
|
|
if (idx >= 0) {
|
|
InputSensorEventListenerDelegate delegate =
|
|
mInputSensorEventListeners.get(idx);
|
|
sensorsRegistered = new ArrayList<>(delegate.getSensors());
|
|
// Get the sensor types the listener is listening to
|
|
delegate.removeSensor(sensor);
|
|
if (delegate.isEmpty()) {
|
|
// If no sensors to listen, remove the listener delegate
|
|
mInputSensorEventListeners.remove(idx);
|
|
}
|
|
} else {
|
|
Slog.e(TAG, "Listener is not registered");
|
|
return;
|
|
}
|
|
// If no delegation remains, unregister the listener to input service
|
|
if (mInputServiceSensorListener != null && mInputSensorEventListeners.isEmpty()) {
|
|
mGlobal.unregisterSensorListener(mInputServiceSensorListener);
|
|
mInputServiceSensorListener = null;
|
|
}
|
|
// For each sensor type check if it is still in use by other listeners.
|
|
for (Sensor s : sensorsRegistered) {
|
|
final int deviceId = s.getId();
|
|
final int sensorType = s.getType();
|
|
// See if we can disable the sensor
|
|
boolean enableSensor = false;
|
|
for (int i = 0; i < mInputSensorEventListeners.size(); i++) {
|
|
InputSensorEventListenerDelegate delegate =
|
|
mInputSensorEventListeners.get(i);
|
|
if (delegate.hasSensorRegistered(deviceId, sensorType)) {
|
|
enableSensor = true;
|
|
Slog.w(TAG, "device " + deviceId + " still uses sensor " + sensorType);
|
|
break;
|
|
}
|
|
}
|
|
// Sensor is not listened, disable it.
|
|
if (!enableSensor) {
|
|
if (DEBUG) {
|
|
Slog.d(TAG, "device " + deviceId + " sensor " + sensorType + " disabled");
|
|
}
|
|
mGlobal.disableSensor(deviceId, sensorType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean flushInternal(SensorEventListener listener) {
|
|
synchronized (mInputSensorLock) {
|
|
int idx = findSensorEventListenerLocked(listener);
|
|
if (idx < 0) {
|
|
return false;
|
|
}
|
|
for (Sensor sensor : mInputSensorEventListeners.get(idx).getSensors()) {
|
|
final int deviceId = sensor.getId();
|
|
if (!mGlobal.flushSensor(deviceId, sensor.getType())) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sensor Manager class associated with specific input device
|
|
*/
|
|
public class InputSensorManager extends SensorManager {
|
|
// Input device ID that the sensors belong to
|
|
final int mId;
|
|
|
|
InputSensorManager(int deviceId) {
|
|
mId = deviceId;
|
|
}
|
|
|
|
@Override
|
|
public Sensor getDefaultSensor(int type) {
|
|
return getSensorForInputDevice(mId, type);
|
|
}
|
|
|
|
@Override
|
|
protected List<Sensor> getFullSensorList() {
|
|
return getFullSensorListForDevice(mId);
|
|
}
|
|
|
|
@Override
|
|
protected List<Sensor> getFullDynamicSensorList() {
|
|
return new ArrayList<>();
|
|
}
|
|
|
|
@Override
|
|
protected boolean registerListenerImpl(SensorEventListener listener, Sensor sensor,
|
|
int delayUs, Handler handler, int maxBatchReportLatencyUs, int reservedFlags) {
|
|
return registerListenerInternal(listener, sensor, delayUs,
|
|
maxBatchReportLatencyUs, handler);
|
|
}
|
|
|
|
@Override
|
|
protected void unregisterListenerImpl(SensorEventListener listener, Sensor sensor) {
|
|
unregisterListenerInternal(listener, sensor);
|
|
}
|
|
|
|
@Override
|
|
protected boolean flushImpl(SensorEventListener listener) {
|
|
return flushInternal(listener);
|
|
}
|
|
|
|
@Override
|
|
protected SensorDirectChannel createDirectChannelImpl(MemoryFile memoryFile,
|
|
HardwareBuffer hardwareBuffer) {
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
protected void destroyDirectChannelImpl(SensorDirectChannel channel) {
|
|
|
|
}
|
|
|
|
@Override
|
|
protected int configureDirectChannelImpl(SensorDirectChannel channel, Sensor s, int rate) {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
protected void registerDynamicSensorCallbackImpl(DynamicSensorCallback callback,
|
|
Handler handler) {
|
|
|
|
}
|
|
|
|
@Override
|
|
protected void unregisterDynamicSensorCallbackImpl(
|
|
DynamicSensorCallback callback) {
|
|
|
|
}
|
|
|
|
@Override
|
|
protected boolean requestTriggerSensorImpl(TriggerEventListener listener, Sensor sensor) {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
protected boolean cancelTriggerSensorImpl(TriggerEventListener listener, Sensor sensor,
|
|
boolean disable) {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
protected boolean initDataInjectionImpl(boolean enable, int mode) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
protected boolean injectSensorDataImpl(Sensor sensor, float[] values, int accuracy,
|
|
long timestamp) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
protected boolean setOperationParameterImpl(SensorAdditionalInfo parameter) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
}
|