/**
* 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.soundtrigger;
import static com.android.server.soundtrigger.DeviceStateHandler.SoundTriggerDeviceState;
import static com.android.server.soundtrigger.SoundTriggerEvent.SessionEvent.Type;
import static com.android.server.utils.EventLogger.Event.ALOGW;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.content.Context;
import android.hardware.soundtrigger.IRecognitionStatusCallback;
import android.hardware.soundtrigger.ModelParams;
import android.hardware.soundtrigger.SoundTrigger;
import android.hardware.soundtrigger.SoundTrigger.GenericRecognitionEvent;
import android.hardware.soundtrigger.SoundTrigger.GenericSoundModel;
import android.hardware.soundtrigger.SoundTrigger.Keyphrase;
import android.hardware.soundtrigger.SoundTrigger.KeyphraseRecognitionEvent;
import android.hardware.soundtrigger.SoundTrigger.KeyphraseRecognitionExtra;
import android.hardware.soundtrigger.SoundTrigger.KeyphraseSoundModel;
import android.hardware.soundtrigger.SoundTrigger.ModelParamRange;
import android.hardware.soundtrigger.SoundTrigger.ModuleProperties;
import android.hardware.soundtrigger.SoundTrigger.RecognitionConfig;
import android.hardware.soundtrigger.SoundTrigger.RecognitionEvent;
import android.hardware.soundtrigger.SoundTrigger.SoundModel;
import android.hardware.soundtrigger.SoundTriggerModule;
import android.os.Binder;
import android.os.DeadObjectException;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.RemoteException;
import android.util.Slog;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.logging.MetricsLogger;
import com.android.server.soundtrigger.SoundTriggerEvent.SessionEvent;
import com.android.server.utils.EventLogger.Event;
import com.android.server.utils.EventLogger;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;
import java.util.function.Function;
import java.util.function.Supplier;
/**
* Helper for {@link SoundTrigger} APIs. Supports two types of models:
* (i) A voice model which is exported via the {@link VoiceInteractionService}. There can only be
* a single voice model running on the DSP at any given time.
*
* (ii) Generic sound-trigger models: Supports multiple of these.
*
* Currently this just acts as an abstraction over all SoundTrigger API calls.
* @hide
*/
public class SoundTriggerHelper implements SoundTrigger.StatusListener {
static final String TAG = "SoundTriggerHelper";
// Module ID if there is no available module to connect to.
public static final int INVALID_MODULE_ID = -1;
/**
* Return codes for {@link #startRecognition(int, KeyphraseSoundModel,
* IRecognitionStatusCallback, RecognitionConfig)},
* {@link #stopRecognition(int, IRecognitionStatusCallback)}
*/
public static final int STATUS_ERROR = SoundTrigger.STATUS_ERROR;
public static final int STATUS_OK = SoundTrigger.STATUS_OK;
private static final int INVALID_VALUE = Integer.MIN_VALUE;
private SoundTriggerModule mModule;
private final Object mLock = new Object();
private final Context mContext;
// The SoundTriggerManager layer handles multiple recognition models of type generic and
// keyphrase. We store the ModelData here in a hashmap.
private final HashMap<UUID, ModelData> mModelDataMap = new HashMap<>();
// An index of keyphrase sound models so that we can reach them easily. We support indexing
// keyphrase sound models with a keyphrase ID. Sound model with the same keyphrase ID will
// replace an existing model, thus there is a 1:1 mapping from keyphrase ID to a voice
// sound model.
private final HashMap<Integer, UUID> mKeyphraseUuidMap = new HashMap<>();
// Whether ANY recognition (keyphrase or generic) has been requested.
private boolean mRecognitionRequested = false;
// TODO(b/269366605) Temporary solution to query correct moduleProperties
private final int mModuleId;
private final Function<SoundTrigger.StatusListener, SoundTriggerModule> mModuleProvider;
private final Supplier<List<ModuleProperties>> mModulePropertiesProvider;
private final EventLogger mEventLogger;
@GuardedBy("mLock")
private boolean mIsDetached = false;
@GuardedBy("mLock")
private SoundTriggerDeviceState mDeviceState = SoundTriggerDeviceState.DISABLE;
@GuardedBy("mLock")
private boolean mIsAppOpPermitted = true;
SoundTriggerHelper(Context context, EventLogger eventLogger,
@NonNull Function<SoundTrigger.StatusListener, SoundTriggerModule> moduleProvider,
int moduleId,
@NonNull Supplier<List<ModuleProperties>> modulePropertiesProvider) {
mModuleId = moduleId;
mContext = context;
mModuleProvider = moduleProvider;
mEventLogger = eventLogger;
mModulePropertiesProvider = modulePropertiesProvider;
if (moduleId == INVALID_MODULE_ID) {
mModule = null;
} else {
mModule = mModuleProvider.apply(this);
}
}
/**
* Starts recognition for the given generic sound model ID. This is a wrapper around {@link
* startRecognition()}.
*
* @param modelId UUID of the sound model.
* @param soundModel The generic sound model to use for recognition.
* @param callback Callack for the recognition events related to the given keyphrase.
* @param recognitionConfig Instance of RecognitionConfig containing the parameters for the
* recognition.
* @return One of {@link #STATUS_ERROR} or {@link #STATUS_OK}.
*/
public int startGenericRecognition(UUID modelId, GenericSoundModel soundModel,
IRecognitionStatusCallback callback, RecognitionConfig recognitionConfig,
boolean runInBatterySaverMode) {
MetricsLogger.count(mContext, "sth_start_recognition", 1);
if (modelId == null || soundModel == null || callback == null ||
recognitionConfig == null) {
Slog.w(TAG, "Passed in bad data to startGenericRecognition().");
return STATUS_ERROR;
}
synchronized (mLock) {
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
ModelData modelData = getOrCreateGenericModelDataLocked(modelId);
if (modelData == null) {
Slog.w(TAG, "Irrecoverable error occurred, check UUID / sound model data.");
return STATUS_ERROR;
}
return startRecognition(soundModel, modelData, callback, recognitionConfig,
INVALID_VALUE /* keyphraseId */, runInBatterySaverMode);
}
}
/**
* Starts recognition for the given keyphraseId.
*
* @param keyphraseId The identifier of the keyphrase for which
* the recognition is to be started.
* @param soundModel The sound model to use for recognition.
* @param callback The callback for the recognition events related to the given keyphrase.
* @return One of {@link #STATUS_ERROR} or {@link #STATUS_OK}.
*/
public int startKeyphraseRecognition(int keyphraseId, KeyphraseSoundModel soundModel,
IRecognitionStatusCallback callback, RecognitionConfig recognitionConfig,
boolean runInBatterySaverMode) {
synchronized (mLock) {
MetricsLogger.count(mContext, "sth_start_recognition", 1);
if (soundModel == null || callback == null || recognitionConfig == null) {
return STATUS_ERROR;
}
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
ModelData model = getKeyphraseModelDataLocked(keyphraseId);
if (model != null && !model.isKeyphraseModel()) {
Slog.e(TAG, "Generic model with same UUID exists.");
return STATUS_ERROR;
}
// Process existing model first.
if (model != null && !model.getModelId().equals(soundModel.getUuid())) {
// The existing model has a different UUID, should be replaced.
int status = cleanUpExistingKeyphraseModelLocked(model);
if (status != STATUS_OK) {
return status;
}
removeKeyphraseModelLocked(keyphraseId);
model = null;
}
// We need to create a new one: either no previous models existed for given keyphrase id
// or the existing model had a different UUID and was cleaned up.
if (model == null) {
model = createKeyphraseModelDataLocked(soundModel.getUuid(), keyphraseId);
}
return startRecognition(soundModel, model, callback, recognitionConfig,
keyphraseId, runInBatterySaverMode);
}
}
private int cleanUpExistingKeyphraseModelLocked(ModelData modelData) {
// Stop and clean up a previous ModelData if one exists. This usually is used when the
// previous model has a different UUID for the same keyphrase ID.
int status = tryStopAndUnloadLocked(modelData, true /* stop */, true /* unload */);
if (status != STATUS_OK) {
Slog.w(TAG, "Unable to stop or unload previous model: " +
modelData.toString());
}
return status;
}
private int prepareForRecognition(ModelData modelData) {
if (mModule == null) {
Slog.w(TAG, "prepareForRecognition: cannot attach to sound trigger module");
return STATUS_ERROR;
}
// Load the model if it is not loaded.
if (!modelData.isModelLoaded()) {
// Before we try and load this model, we should first make sure that any other
// models that don't have an active recognition/dead callback are unloaded. Since
// there is a finite limit on the number of models that the hardware may be able to
// have loaded, we want to make sure there's room for our model.
stopAndUnloadDeadModelsLocked();
int[] handle = new int[] { 0 };
int status = mModule.loadSoundModel(modelData.getSoundModel(), handle);
if (status != SoundTrigger.STATUS_OK) {
Slog.w(TAG, "prepareForRecognition: loadSoundModel failed with status: " + status);
return status;
}
modelData.setHandle(handle[0]);
modelData.setLoaded();
}
return STATUS_OK;
}
/**
* Starts recognition for the given sound model. A single routine for both keyphrase and
* generic sound models.
*
* @param soundModel The sound model to use for recognition.
* @param modelData Instance of {@link #ModelData} for the given model.
* @param callback Callback for the recognition events related to the given keyphrase.
* @param recognitionConfig Instance of {@link RecognitionConfig} containing the parameters
* @param keyphraseId Keyphrase ID for keyphrase models only. Pass in INVALID_VALUE for other
* models.
* for the recognition.
* @return One of {@link #STATUS_ERROR} or {@link #STATUS_OK}.
*/
private int startRecognition(SoundModel soundModel, ModelData modelData,
IRecognitionStatusCallback callback, RecognitionConfig recognitionConfig,
int keyphraseId, boolean runInBatterySaverMode) {
synchronized (mLock) {
// TODO Remove previous callback handling
IRecognitionStatusCallback oldCallback = modelData.getCallback();
if (oldCallback != null && oldCallback.asBinder() != callback.asBinder()) {
Slog.w(TAG, "Canceling previous recognition for model id: "
+ modelData.getModelId());
try {
oldCallback.onPreempted();
} catch (RemoteException e) {
Slog.w(TAG, "RemoteException in onDetectionStopped", e);
}
modelData.clearCallback();
}
// If the existing SoundModel is different (for the same UUID for Generic and same
// keyphrase ID for voice), ensure that it is unloaded and stopped before proceeding.
// This works for both keyphrase and generic models. This logic also ensures that a
// previously loaded (or started) model is appropriately stopped. Since this is a
// generalization of the previous logic with a single keyphrase model, we should have
// no regression with the previous version of this code as was given in the
// startKeyphrase() routine.
if (modelData.getSoundModel() != null) {
boolean stopModel = false; // Stop the model after checking that it is started.
boolean unloadModel = false;
if (modelData.getSoundModel().equals(soundModel) && modelData.isModelStarted()) {
// The model has not changed, but the previous model is "started".
// Stop the previously running model.
stopModel = true;
unloadModel = false; // No need to unload if the model hasn't changed.
} else if (!modelData.getSoundModel().equals(soundModel)) {
// We have a different model for this UUID. Stop and unload if needed. This
// helps maintain the singleton restriction for keyphrase sound models.
stopModel = modelData.isModelStarted();
unloadModel = modelData.isModelLoaded();
}
if (stopModel || unloadModel) {
int status = tryStopAndUnloadLocked(modelData, stopModel, unloadModel);
if (status != STATUS_OK) {
Slog.w(TAG, "Unable to stop or unload previous model: " +
modelData.toString());
return status;
}
}
}
modelData.setCallback(callback);
modelData.setRequested(true);
modelData.setRecognitionConfig(recognitionConfig);
modelData.setRunInBatterySaverMode(runInBatterySaverMode);
modelData.setSoundModel(soundModel);
if (isRecognitionAllowed(modelData)) {
int startRecoResult = updateRecognitionLocked(modelData,
false /* Don't notify for synchronous calls */);
if (startRecoResult == SoundTrigger.STATUS_OK) {
return startRecoResult;
} else if (startRecoResult != SoundTrigger.STATUS_BUSY) {
// If we are returning an unexpected error, don't mark the model as requested
modelData.setRequested(false);
return startRecoResult;
}
}
// Either recognition isn't allowed by device state, or the module is busy.
// Dispatch a pause.
try {
if (callback != null) {
mEventLogger.enqueue(new SessionEvent(Type.PAUSE, modelData.getModelId()));
callback.onRecognitionPaused();
}
} catch (RemoteException e) {
mEventLogger.enqueue(new SessionEvent(
Type.PAUSE, modelData.getModelId(), "RemoteException")
.printLog(ALOGW, TAG));
forceStopAndUnloadModelLocked(modelData, e);
}
return STATUS_OK;
}
}
/**
* Stops recognition for the given generic sound model. This is a wrapper for {@link
* #stopRecognition}.
*
* @param modelId The identifier of the generic sound model for which
* the recognition is to be stopped.
* @param callback The callback for the recognition events related to the given sound model.
*
* @return One of {@link #STATUS_ERROR} or {@link #STATUS_OK}.
*/
public int stopGenericRecognition(UUID modelId, IRecognitionStatusCallback callback) {
synchronized (mLock) {
MetricsLogger.count(mContext, "sth_stop_recognition", 1);
if (callback == null || modelId == null) {
Slog.e(TAG, "Null callbackreceived for stopGenericRecognition() for modelid:" +
modelId);
return STATUS_ERROR;
}
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
ModelData modelData = mModelDataMap.get(modelId);
if (modelData == null || !modelData.isGenericModel()) {
Slog.w(TAG, "Attempting stopRecognition on invalid model with id:" + modelId);
return STATUS_ERROR;
}
int status = stopRecognition(modelData, callback);
if (status != SoundTrigger.STATUS_OK) {
Slog.w(TAG, "stopGenericRecognition failed: " + status);
}
return status;
}
}
/**
* Stops recognition for the given {@link Keyphrase} if a recognition is
* currently active. This is a wrapper for {@link #stopRecognition()}.
*
* @param keyphraseId The identifier of the keyphrase for which
* the recognition is to be stopped.
* @param callback The callback for the recognition events related to the given keyphrase.
*
* @return One of {@link #STATUS_ERROR} or {@link #STATUS_OK}.
*/
public int stopKeyphraseRecognition(int keyphraseId, IRecognitionStatusCallback callback) {
synchronized (mLock) {
MetricsLogger.count(mContext, "sth_stop_recognition", 1);
if (callback == null) {
Slog.e(TAG, "Null callback received for stopKeyphraseRecognition() for keyphraseId:" +
keyphraseId);
return STATUS_ERROR;
}
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
ModelData modelData = getKeyphraseModelDataLocked(keyphraseId);
if (modelData == null || !modelData.isKeyphraseModel()) {
Slog.w(TAG, "No model exists for given keyphrase Id " + keyphraseId);
return STATUS_ERROR;
}
int status = stopRecognition(modelData, callback);
if (status != SoundTrigger.STATUS_OK) {
return status;
}
return status;
}
}
/**
* Stops recognition for the given ModelData instance.
*
* @param modelData Instance of {@link #ModelData} sound model.
* @param callback The callback for the recognition events related to the given keyphrase.
* @return One of {@link #STATUS_ERROR} or {@link #STATUS_OK}.
*/
private int stopRecognition(ModelData modelData, IRecognitionStatusCallback callback) {
synchronized (mLock) {
if (callback == null) {
return STATUS_ERROR;
}
if (mModule == null) {
Slog.w(TAG, "Attempting stopRecognition after detach");
return STATUS_ERROR;
}
IRecognitionStatusCallback currentCallback = modelData.getCallback();
if (modelData == null || currentCallback == null ||
(!modelData.isRequested() && !modelData.isModelStarted())) {
// startGenericRecognition hasn't been called or it failed.
Slog.w(TAG, "Attempting stopRecognition without a successful startRecognition");
return STATUS_ERROR;
}
if (currentCallback.asBinder() != callback.asBinder()) {
// We don't allow a different listener to stop the recognition than the one
// that started it.
Slog.w(TAG, "Attempting stopRecognition for another recognition");
return STATUS_ERROR;
}
// Request stop recognition via the update() method.
modelData.setRequested(false);
int status = updateRecognitionLocked(modelData, false);
if (status != SoundTrigger.STATUS_OK) {
return status;
}
// We leave the sound model loaded but not started, this helps us when we start back.
// Also clear the internal state once the recognition has been stopped.
modelData.setLoaded();
modelData.clearCallback();
modelData.setRecognitionConfig(null);
return status;
}
}
// Stop a previously started model if it was started. Optionally, unload if the previous model
// is stale and is about to be replaced.
// Needs to be called with the mLock held.
private int tryStopAndUnloadLocked(ModelData modelData, boolean stopModel,
boolean unloadModel) {
int status = STATUS_OK;
if (modelData.isModelNotLoaded()) {
return status;
}
if (stopModel && modelData.isModelStarted()) {
status = stopRecognitionLocked(modelData,
false /* don't notify for synchronous calls */);
if (status != SoundTrigger.STATUS_OK) {
Slog.w(TAG, "stopRecognition failed: " + status);
return status;
}
}
if (unloadModel && modelData.isModelLoaded()) {
Slog.d(TAG, "Unloading previously loaded stale model.");
if (mModule == null) {
return STATUS_ERROR;
}
status = mModule.unloadSoundModel(modelData.getHandle());
MetricsLogger.count(mContext, "sth_unloading_stale_model", 1);
if (status != SoundTrigger.STATUS_OK) {
Slog.w(TAG, "unloadSoundModel call failed with " + status);
} else {
// Clear the ModelData state if successful.
modelData.clearState();
}
}
return status;
}
public ModuleProperties getModuleProperties() {
synchronized (mLock) {
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
}
for (ModuleProperties moduleProperties : mModulePropertiesProvider.get()) {
if (moduleProperties.getId() == mModuleId) {
return moduleProperties;
}
}
Slog.e(TAG, "Module properties not found for existing moduleId " + mModuleId);
return null;
}
public int unloadKeyphraseSoundModel(int keyphraseId) {
synchronized (mLock) {
MetricsLogger.count(mContext, "sth_unload_keyphrase_sound_model", 1);
ModelData modelData = getKeyphraseModelDataLocked(keyphraseId);
if (mModule == null || modelData == null || !modelData.isModelLoaded()
|| !modelData.isKeyphraseModel()) {
return STATUS_ERROR;
}
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
// Stop recognition if it's the current one.
modelData.setRequested(false);
int status = updateRecognitionLocked(modelData, false);
if (status != SoundTrigger.STATUS_OK) {
Slog.w(TAG, "Stop recognition failed for keyphrase ID:" + status);
}
status = mModule.unloadSoundModel(modelData.getHandle());
if (status != SoundTrigger.STATUS_OK) {
Slog.w(TAG, "unloadKeyphraseSoundModel call failed with " + status);
}
// Remove it from existence.
removeKeyphraseModelLocked(keyphraseId);
return status;
}
}
public int unloadGenericSoundModel(UUID modelId) {
synchronized (mLock) {
MetricsLogger.count(mContext, "sth_unload_generic_sound_model", 1);
if (modelId == null || mModule == null) {
return STATUS_ERROR;
}
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
ModelData modelData = mModelDataMap.get(modelId);
if (modelData == null || !modelData.isGenericModel()) {
Slog.w(TAG, "Unload error: Attempting unload invalid generic model with id:" +
modelId);
return STATUS_ERROR;
}
if (!modelData.isModelLoaded()) {
// Nothing to do here.
Slog.i(TAG, "Unload: Given generic model is not loaded:" + modelId);
return STATUS_OK;
}
if (modelData.isModelStarted()) {
int status = stopRecognitionLocked(modelData,
false /* don't notify for synchronous calls */);
if (status != SoundTrigger.STATUS_OK) {
Slog.w(TAG, "stopGenericRecognition failed: " + status);
}
}
if (mModule == null) {
return STATUS_ERROR;
}
int status = mModule.unloadSoundModel(modelData.getHandle());
if (status != SoundTrigger.STATUS_OK) {
Slog.w(TAG, "unloadGenericSoundModel() call failed with " + status);
Slog.w(TAG, "unloadGenericSoundModel() force-marking model as unloaded.");
}
// Remove it from existence.
mModelDataMap.remove(modelId);
return status;
}
}
public boolean isRecognitionRequested(UUID modelId) {
synchronized (mLock) {
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
ModelData modelData = mModelDataMap.get(modelId);
return modelData != null && modelData.isRequested();
}
}
public void onDeviceStateChanged(SoundTriggerDeviceState state) {
synchronized (mLock) {
if (mIsDetached || mDeviceState == state) {
// Nothing to update
return;
}
mDeviceState = state;
updateAllRecognitionsLocked();
}
}
public void onAppOpStateChanged(boolean isPermitted) {
synchronized (mLock) {
if (mIsAppOpPermitted == isPermitted) {
return;
}
mIsAppOpPermitted = isPermitted;
updateAllRecognitionsLocked();
}
}
public int getGenericModelState(UUID modelId) {
synchronized (mLock) {
MetricsLogger.count(mContext, "sth_get_generic_model_state", 1);
if (modelId == null || mModule == null) {
return STATUS_ERROR;
}
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
ModelData modelData = mModelDataMap.get(modelId);
if (modelData == null || !modelData.isGenericModel()) {
Slog.w(TAG, "GetGenericModelState error: Invalid generic model id:" +
modelId);
return STATUS_ERROR;
}
if (!modelData.isModelLoaded()) {
Slog.i(TAG, "GetGenericModelState: Given generic model is not loaded:" + modelId);
return STATUS_ERROR;
}
if (!modelData.isModelStarted()) {
Slog.i(TAG, "GetGenericModelState: Given generic model is not started:" + modelId);
return STATUS_ERROR;
}
return mModule.getModelState(modelData.getHandle());
}
}
public int setParameter(UUID modelId, @ModelParams int modelParam, int value) {
synchronized (mLock) {
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
return setParameterLocked(mModelDataMap.get(modelId), modelParam, value);
}
}
public int setKeyphraseParameter(int keyphraseId, @ModelParams int modelParam, int value) {
synchronized (mLock) {
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
return setParameterLocked(getKeyphraseModelDataLocked(keyphraseId), modelParam, value);
}
}
private int setParameterLocked(@Nullable ModelData modelData, @ModelParams int modelParam,
int value) {
MetricsLogger.count(mContext, "sth_set_parameter", 1);
if (mModule == null) {
return SoundTrigger.STATUS_NO_INIT;
}
if (modelData == null || !modelData.isModelLoaded()) {
Slog.i(TAG, "SetParameter: Given model is not loaded:" + modelData);
return SoundTrigger.STATUS_BAD_VALUE;
}
return mModule.setParameter(modelData.getHandle(), modelParam, value);
}
public int getParameter(@NonNull UUID modelId, @ModelParams int modelParam) {
synchronized (mLock) {
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
return getParameterLocked(mModelDataMap.get(modelId), modelParam);
}
}
public int getKeyphraseParameter(int keyphraseId, @ModelParams int modelParam) {
synchronized (mLock) {
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
return getParameterLocked(getKeyphraseModelDataLocked(keyphraseId), modelParam);
}
}
private int getParameterLocked(@Nullable ModelData modelData, @ModelParams int modelParam) {
MetricsLogger.count(mContext, "sth_get_parameter", 1);
if (mModule == null) {
throw new UnsupportedOperationException("SoundTriggerModule not initialized");
}
if (modelData == null) {
throw new IllegalArgumentException("Invalid model id");
}
if (!modelData.isModelLoaded()) {
throw new UnsupportedOperationException("Given model is not loaded:" + modelData);
}
return mModule.getParameter(modelData.getHandle(), modelParam);
}
@Nullable
public ModelParamRange queryParameter(@NonNull UUID modelId, @ModelParams int modelParam) {
synchronized (mLock) {
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
return queryParameterLocked(mModelDataMap.get(modelId), modelParam);
}
}
@Nullable
public ModelParamRange queryKeyphraseParameter(int keyphraseId, @ModelParams int modelParam) {
synchronized (mLock) {
if (mIsDetached) {
throw new IllegalStateException("SoundTriggerHelper has been detached");
}
return queryParameterLocked(getKeyphraseModelDataLocked(keyphraseId), modelParam);
}
}
@Nullable
private ModelParamRange queryParameterLocked(@Nullable ModelData modelData,
@ModelParams int modelParam) {
MetricsLogger.count(mContext, "sth_query_parameter", 1);
if (mModule == null) {
return null;
}
if (modelData == null) {
Slog.w(TAG, "queryParameter: Invalid model id");
return null;
}
if (!modelData.isModelLoaded()) {
Slog.i(TAG, "queryParameter: Given model is not loaded:" + modelData);
return null;
}
return mModule.queryParameter(modelData.getHandle(), modelParam);
}
//---- SoundTrigger.StatusListener methods
@Override
public void onRecognition(RecognitionEvent event) {
if (event == null) {
Slog.w(TAG, "Null recognition event!");
return;
}
if (!(event instanceof KeyphraseRecognitionEvent) &&
!(event instanceof GenericRecognitionEvent)) {
Slog.w(TAG, "Invalid recognition event type (not one of generic or keyphrase)!");
return;
}
synchronized (mLock) {
switch (event.status) {
case SoundTrigger.RECOGNITION_STATUS_ABORT:
onRecognitionAbortLocked(event);
break;
case SoundTrigger.RECOGNITION_STATUS_FAILURE:
case SoundTrigger.RECOGNITION_STATUS_SUCCESS:
case SoundTrigger.RECOGNITION_STATUS_GET_STATE_RESPONSE:
if (isKeyphraseRecognitionEvent(event)) {
onKeyphraseRecognitionLocked((KeyphraseRecognitionEvent) event);
} else {
onGenericRecognitionLocked((GenericRecognitionEvent) event);
}
break;
}
}
}
private boolean isKeyphraseRecognitionEvent(RecognitionEvent event) {
return event instanceof KeyphraseRecognitionEvent;
}
@GuardedBy("mLock")
private void onGenericRecognitionLocked(GenericRecognitionEvent event) {
MetricsLogger.count(mContext, "sth_generic_recognition_event", 1);
if (event.status != SoundTrigger.RECOGNITION_STATUS_SUCCESS
&& event.status != SoundTrigger.RECOGNITION_STATUS_GET_STATE_RESPONSE) {
return;
}
ModelData model = getModelDataForLocked(event.soundModelHandle);
if (model == null || !model.isGenericModel()) {
Slog.w(TAG, "Generic recognition event: Model does not exist for handle: "
+ event.soundModelHandle);
return;
}
if (!Objects.equals(event.getToken(), model.getToken())) {
// Stale event, do nothing
return;
}
IRecognitionStatusCallback callback = model.getCallback();
if (callback == null) {
Slog.w(TAG, "Generic recognition event: Null callback for model handle: "
+ event.soundModelHandle);
return;
}
if (!event.recognitionStillActive) {
model.setStopped();
}
try {
mEventLogger.enqueue(new SessionEvent(Type.RECOGNITION, model.getModelId()));
callback.onGenericSoundTriggerDetected((GenericRecognitionEvent) event);
} catch (RemoteException e) {
mEventLogger.enqueue(new SessionEvent(
Type.RECOGNITION, model.getModelId(), "RemoteException")
.printLog(ALOGW, TAG));
forceStopAndUnloadModelLocked(model, e);
return;
}
RecognitionConfig config = model.getRecognitionConfig();
if (config == null) {
Slog.w(TAG, "Generic recognition event: Null RecognitionConfig for model handle: "
+ event.soundModelHandle);
return;
}
model.setRequested(config.allowMultipleTriggers);
// TODO: Remove this block if the lower layer supports multiple triggers.
if (model.isRequested()) {
updateRecognitionLocked(model, true);
}
}
@Override
public void onModelUnloaded(int modelHandle) {
synchronized (mLock) {
MetricsLogger.count(mContext, "sth_sound_model_updated", 1);
onModelUnloadedLocked(modelHandle);
}
}
@Override
public void onResourcesAvailable() {
synchronized (mLock) {
onResourcesAvailableLocked();
}
}
@Override
public void onServiceDied() {
Slog.e(TAG, "onServiceDied!!");
MetricsLogger.count(mContext, "sth_service_died", 1);
synchronized (mLock) {
onServiceDiedLocked();
}
}
private void onModelUnloadedLocked(int modelHandle) {
ModelData modelData = getModelDataForLocked(modelHandle);
if (modelData != null) {
modelData.setNotLoaded();
}
}
@GuardedBy("mLock")
private void onResourcesAvailableLocked() {
mEventLogger.enqueue(new SessionEvent(Type.RESOURCES_AVAILABLE, null));
updateAllRecognitionsLocked();
}
private void onRecognitionAbortLocked(RecognitionEvent event) {
Slog.w(TAG, "Recognition aborted");
MetricsLogger.count(mContext, "sth_recognition_aborted", 1);
ModelData modelData = getModelDataForLocked(event.soundModelHandle);
if (modelData != null && modelData.isModelStarted()) {
if (!Objects.equals(event.getToken(), modelData.getToken())) {
// Stale event, do nothing
return;
}
modelData.setStopped();
try {
IRecognitionStatusCallback callback = modelData.getCallback();
if (callback != null) {
mEventLogger.enqueue(new SessionEvent(Type.PAUSE, modelData.getModelId()));
callback.onRecognitionPaused();
}
} catch (RemoteException e) {
mEventLogger.enqueue(new SessionEvent(
Type.PAUSE, modelData.getModelId(), "RemoteException")
.printLog(ALOGW, TAG));
forceStopAndUnloadModelLocked(modelData, e);
}
}
}
private int getKeyphraseIdFromEvent(KeyphraseRecognitionEvent event) {
if (event == null) {
Slog.w(TAG, "Null RecognitionEvent received.");
return INVALID_VALUE;
}
KeyphraseRecognitionExtra[] keyphraseExtras =
((KeyphraseRecognitionEvent) event).keyphraseExtras;
if (keyphraseExtras == null || keyphraseExtras.length == 0) {
Slog.w(TAG, "Invalid keyphrase recognition event!");
return INVALID_VALUE;
}
// TODO: Handle more than one keyphrase extras.
return keyphraseExtras[0].id;
}
@GuardedBy("mLock")
private void onKeyphraseRecognitionLocked(KeyphraseRecognitionEvent event) {
Slog.i(TAG, "Recognition success");
MetricsLogger.count(mContext, "sth_keyphrase_recognition_event", 1);
int keyphraseId = getKeyphraseIdFromEvent(event);
ModelData modelData = getKeyphraseModelDataLocked(keyphraseId);
if (modelData == null || !modelData.isKeyphraseModel()) {
Slog.e(TAG, "Keyphase model data does not exist for ID:" + keyphraseId);
return;
}
if (!Objects.equals(event.getToken(), modelData.getToken())) {
// Stale event, do nothing
return;
}
if (modelData.getCallback() == null) {
Slog.w(TAG, "Received onRecognition event without callback for keyphrase model.");
return;
}
if (!event.recognitionStillActive) {
modelData.setStopped();
}
try {
mEventLogger.enqueue(new SessionEvent(Type.RECOGNITION, modelData.getModelId()));
modelData.getCallback().onKeyphraseDetected((KeyphraseRecognitionEvent) event);
} catch (RemoteException e) {
mEventLogger.enqueue(new SessionEvent(
Type.RECOGNITION, modelData.getModelId(), "RemoteException")
.printLog(ALOGW, TAG));
forceStopAndUnloadModelLocked(modelData, e);
return;
}
RecognitionConfig config = modelData.getRecognitionConfig();
if (config != null) {
// Whether we should continue by starting this again.
modelData.setRequested(config.allowMultipleTriggers);
}
// TODO: Remove this block if the lower layer supports multiple triggers.
if (modelData.isRequested()) {
updateRecognitionLocked(modelData, true);
}
}
@GuardedBy("mLock")
private void updateAllRecognitionsLocked() {
// updateRecognitionLocked can possibly update the list of models
ArrayList<ModelData> modelDatas = new ArrayList<ModelData>(mModelDataMap.values());
for (ModelData modelData : modelDatas) {
updateRecognitionLocked(modelData, true);
}
}
@GuardedBy("mLock")
private int updateRecognitionLocked(ModelData model, boolean notifyClientOnError) {
boolean shouldStartModel = model.isRequested() && isRecognitionAllowed(model);
if (shouldStartModel == model.isModelStarted()) {
// No-op.
return STATUS_OK;
}
if (shouldStartModel) {
int status = prepareForRecognition(model);
if (status != STATUS_OK) {
Slog.w(TAG, "startRecognition failed to prepare model for recognition");
return status;
}
status = startRecognitionLocked(model, notifyClientOnError);
return status;
} else {
return stopRecognitionLocked(model, notifyClientOnError);
}
}
private void onServiceDiedLocked() {
try {
MetricsLogger.count(mContext, "sth_service_died", 1);
for (ModelData modelData : mModelDataMap.values()) {
IRecognitionStatusCallback callback = modelData.getCallback();
if (callback != null) {
try {
mEventLogger.enqueue(new SessionEvent(Type.MODULE_DIED,
modelData.getModelId()).printLog(ALOGW, TAG));
callback.onModuleDied();
} catch (RemoteException e) {
mEventLogger.enqueue(new SessionEvent(Type.MODULE_DIED,
modelData.getModelId(), "RemoteException")
.printLog(ALOGW, TAG));
}
}
}
} finally {
internalClearModelStateLocked();
if (mModule != null) {
mModule.detach();
try {
// This is best effort
// TODO (b/279507851)
mModule = mModuleProvider.apply(this);
} catch (Exception e) {
mModule = null;
}
}
}
}
// Clears state for all models (generic and keyphrase).
private void internalClearModelStateLocked() {
for (ModelData modelData : mModelDataMap.values()) {
modelData.clearState();
}
}
/**
* Stops and unloads all models. This is intended as a clean-up call with the expectation that
* this instance is not used after.
* @hide
*/
public void detach() {
synchronized (mLock) {
if (mIsDetached) return;
mIsDetached = true;
for (ModelData model : mModelDataMap.values()) {
forceStopAndUnloadModelLocked(model, null);
}
mModelDataMap.clear();
if (mModule != null) {
mModule.detach();
mModule = null;
}
}
}
/**
* Stops and unloads a sound model, and removes any reference to the model if successful.
*
* @param modelData The model data to remove.
* @param exception Optional exception to print in logcat. May be null.
*/
private void forceStopAndUnloadModelLocked(ModelData modelData, Exception exception) {
forceStopAndUnloadModelLocked(modelData, exception, null /* modelDataIterator */);
}
/**
* Stops and unloads a sound model, and removes any reference to the model if successful.
*
* @param modelData The model data to remove.
* @param exception Optional exception to print in logcat. May be null.
* @param modelDataIterator If this function is to be used while iterating over the
* mModelDataMap, you can provide the iterator for the current model data to be used to
* remove the modelData from the map. This avoids generating a
* ConcurrentModificationException, since this function will try and remove the model
* data from the mModelDataMap when it can successfully unload the model.
*/
private void forceStopAndUnloadModelLocked(ModelData modelData, Exception exception,
Iterator modelDataIterator) {
if (exception != null) {
Slog.e(TAG, "forceStopAndUnloadModel", exception);
}
if (mModule == null) {
return;
}
if (modelData.isModelStarted()) {
Slog.d(TAG, "Stopping previously started dangling model " + modelData.getHandle());
if (mModule.stopRecognition(modelData.getHandle()) == STATUS_OK) {
modelData.setStopped();
modelData.setRequested(false);
} else {
Slog.e(TAG, "Failed to stop model " + modelData.getHandle());
}
}
if (modelData.isModelLoaded()) {
Slog.d(TAG, "Unloading previously loaded dangling model " + modelData.getHandle());
if (mModule.unloadSoundModel(modelData.getHandle()) == STATUS_OK) {
// Remove the model data from existence.
if (modelDataIterator != null) {
modelDataIterator.remove();
} else {
mModelDataMap.remove(modelData.getModelId());
}
Iterator it = mKeyphraseUuidMap.entrySet().iterator();
while (it.hasNext()) {
Map.Entry pair = (Map.Entry) it.next();
if (pair.getValue().equals(modelData.getModelId())) {
it.remove();
}
}
modelData.clearState();
} else {
Slog.e(TAG, "Failed to unload model " + modelData.getHandle());
}
}
}
private void stopAndUnloadDeadModelsLocked() {
Iterator it = mModelDataMap.entrySet().iterator();
while (it.hasNext()) {
ModelData modelData = (ModelData) ((Map.Entry) it.next()).getValue();
if (!modelData.isModelLoaded()) {
continue;
}
if (modelData.getCallback() == null
|| (modelData.getCallback().asBinder() != null
&& !modelData.getCallback().asBinder().pingBinder())) {
// No one is listening on this model, so we might as well evict it.
Slog.w(TAG, "Removing model " + modelData.getHandle() + " that has no clients");
forceStopAndUnloadModelLocked(modelData, null /* exception */, it);
}
}
}
private ModelData getOrCreateGenericModelDataLocked(UUID modelId) {
ModelData modelData = mModelDataMap.get(modelId);
if (modelData == null) {
modelData = ModelData.createGenericModelData(modelId);
mModelDataMap.put(modelId, modelData);
} else if (!modelData.isGenericModel()) {
Slog.e(TAG, "UUID already used for non-generic model.");
return null;
}
return modelData;
}
private void removeKeyphraseModelLocked(int keyphraseId) {
UUID uuid = mKeyphraseUuidMap.get(keyphraseId);
if (uuid == null) {
return;
}
mModelDataMap.remove(uuid);
mKeyphraseUuidMap.remove(keyphraseId);
}
private ModelData getKeyphraseModelDataLocked(int keyphraseId) {
UUID uuid = mKeyphraseUuidMap.get(keyphraseId);
if (uuid == null) {
return null;
}
return mModelDataMap.get(uuid);
}
// Use this to create a new ModelData entry for a keyphrase Id. It will overwrite existing
// mapping if one exists.
private ModelData createKeyphraseModelDataLocked(UUID modelId, int keyphraseId) {
mKeyphraseUuidMap.remove(keyphraseId);
mModelDataMap.remove(modelId);
mKeyphraseUuidMap.put(keyphraseId, modelId);
ModelData modelData = ModelData.createKeyphraseModelData(modelId);
mModelDataMap.put(modelId, modelData);
return modelData;
}
// Instead of maintaining a second hashmap of modelHandle -> ModelData, we just
// iterate through to find the right object (since we don't expect 100s of models
// to be stored).
private ModelData getModelDataForLocked(int modelHandle) {
// Fetch ModelData object corresponding to the model handle.
for (ModelData model : mModelDataMap.values()) {
if (model.getHandle() == modelHandle) {
return model;
}
}
return null;
}
/**
* Determines if recognition is allowed at all based on device state
*
* <p>Depending on the state of the SoundTrigger service, whether a call is active, or if
* battery saver mode is enabled, a specific model may or may not be able to run. The result
* of this check is not permanent, and the state of the device can change at any time.
*
* @param modelData Model data to be used for recognition
* @return True if recognition is allowed to run at this time. False if not.
*/
@GuardedBy("mLock")
private boolean isRecognitionAllowed(ModelData modelData) {
if (!mIsAppOpPermitted) {
return false;
}
return switch (mDeviceState) {
case DISABLE -> false;
case CRITICAL -> modelData.shouldRunInBatterySaverMode();
case ENABLE -> true;
default -> throw new AssertionError("Enum changed between compile and runtime");
};
}
// A single routine that implements the start recognition logic for both generic and keyphrase
// models.
@GuardedBy("mLock")
private int startRecognitionLocked(ModelData modelData, boolean notifyClientOnError) {
IRecognitionStatusCallback callback = modelData.getCallback();
RecognitionConfig config = modelData.getRecognitionConfig();
if (callback == null || !modelData.isModelLoaded() || config == null) {
// Nothing to do here.
Slog.w(TAG, "startRecognition: Bad data passed in.");
MetricsLogger.count(mContext, "sth_start_recognition_error", 1);
return STATUS_ERROR;
}
if (!isRecognitionAllowed(modelData)) {
// Nothing to do here.
Slog.w(TAG, "startRecognition requested but not allowed.");
MetricsLogger.count(mContext, "sth_start_recognition_not_allowed", 1);
return STATUS_OK;
}
if (mModule == null) {
return STATUS_ERROR;
}
int status = STATUS_OK;
try {
modelData.setToken(mModule.startRecognitionWithToken(modelData.getHandle(), config));
} catch (Exception e) {
status = SoundTrigger.handleException(e);
}
if (status != SoundTrigger.STATUS_OK) {
Slog.w(TAG, "startRecognition failed with " + status);
MetricsLogger.count(mContext, "sth_start_recognition_error", 1);
// Notify of error if needed.
if (notifyClientOnError) {
try {
mEventLogger.enqueue(new SessionEvent(Type.RESUME_FAILED,
modelData.getModelId(), String.valueOf(status))
.printLog(ALOGW, TAG));
modelData.setRequested(false);
callback.onResumeFailed(status);
} catch (RemoteException e) {
mEventLogger.enqueue(new SessionEvent(Type.RESUME_FAILED,
modelData.getModelId(),
String.valueOf(status) + " - RemoteException")
.printLog(ALOGW, TAG));
forceStopAndUnloadModelLocked(modelData, e);
}
}
} else {
Slog.i(TAG, "startRecognition successful.");
MetricsLogger.count(mContext, "sth_start_recognition_success", 1);
modelData.setStarted();
// Notify of resume if needed.
if (notifyClientOnError) {
try {
mEventLogger.enqueue(new SessionEvent(Type.RESUME,
modelData.getModelId()));
callback.onRecognitionResumed();
} catch (RemoteException e) {
mEventLogger.enqueue(new SessionEvent(Type.RESUME,
modelData.getModelId(), "RemoteException").printLog(ALOGW, TAG));
forceStopAndUnloadModelLocked(modelData, e);
}
}
}
return status;
}
private int stopRecognitionLocked(ModelData modelData, boolean notify) {
if (mModule == null) {
return STATUS_ERROR;
}
IRecognitionStatusCallback callback = modelData.getCallback();
// Stop recognition.
int status = STATUS_OK;
status = mModule.stopRecognition(modelData.getHandle());
if (status != SoundTrigger.STATUS_OK) {
Slog.e(TAG, "stopRecognition call failed with " + status);
MetricsLogger.count(mContext, "sth_stop_recognition_error", 1);
if (notify) {
try {
mEventLogger.enqueue(new SessionEvent(Type.PAUSE_FAILED,
modelData.getModelId(), String.valueOf(status))
.printLog(ALOGW, TAG));
modelData.setRequested(false);
callback.onPauseFailed(status);
} catch (RemoteException e) {
mEventLogger.enqueue(new SessionEvent(Type.PAUSE_FAILED,
modelData.getModelId(),
String.valueOf(status) + " - RemoteException")
.printLog(ALOGW, TAG));
forceStopAndUnloadModelLocked(modelData, e);
}
}
} else {
modelData.setStopped();
MetricsLogger.count(mContext, "sth_stop_recognition_success", 1);
// Notify of pause if needed.
if (notify) {
try {
mEventLogger.enqueue(new SessionEvent(Type.PAUSE,
modelData.getModelId()));
callback.onRecognitionPaused();
} catch (RemoteException e) {
mEventLogger.enqueue(new SessionEvent(Type.PAUSE,
modelData.getModelId(), "RemoteException").printLog(ALOGW, TAG));
forceStopAndUnloadModelLocked(modelData, e);
}
}
}
return status;
}
// Computes whether we have any recognition running at all (voice or generic). Sets
// the mRecognitionRequested variable with the result.
private boolean computeRecognitionRequestedLocked() {
if (mModule == null) {
mRecognitionRequested = false;
return mRecognitionRequested;
}
for (ModelData modelData : mModelDataMap.values()) {
if (modelData.isRequested()) {
mRecognitionRequested = true;
return mRecognitionRequested;
}
}
mRecognitionRequested = false;
return mRecognitionRequested;
}
// This class encapsulates the callbacks, state, handles and any other information that
// represents a model.
private static class ModelData {
// Model not loaded (and hence not started).
static final int MODEL_NOTLOADED = 0;
// Loaded implies model was successfully loaded. Model not started yet.
static final int MODEL_LOADED = 1;
// Started implies model was successfully loaded and start was called.
static final int MODEL_STARTED = 2;
// One of MODEL_NOTLOADED, MODEL_LOADED, MODEL_STARTED (which implies loaded).
private int mModelState;
private UUID mModelId;
// mRequested captures the explicit intent that a start was requested for this model. We
// continue to capture and retain this state even after the model gets started, so that we
// know when a model gets stopped due to "other" reasons, that we should start it again.
// This was the intended behavior of the "mRequested" variable in the previous version of
// this code that we are replicating here.
//
// The "other" reasons include power save, abort being called from the lower layer (due
// to concurrent capture not being supported) and phone call state. Once we recover from
// these transient disruptions, we would start such models again where mRequested == true.
// Thus, mRequested gets reset only when there is an explicit intent to stop the model
// coming from the SoundTriggerService layer that uses this class (and thus eventually
// from the app that manages this model).
private boolean mRequested = false;
// One of SoundModel.TYPE_GENERIC or SoundModel.TYPE_KEYPHRASE. Initially set
// to SoundModel.TYPE_UNKNOWN;
private int mModelType = SoundModel.TYPE_UNKNOWN;
private IRecognitionStatusCallback mCallback = null;
private RecognitionConfig mRecognitionConfig = null;
// Model handle is an integer used by the HAL as an identifier for sound
// models.
private int mModelHandle;
/**
* True if the service should continue listening when battery saver mode is enabled.
* Having this flag set requires the client calling
* {@link SoundTriggerModule#startRecognition(int, RecognitionConfig)} to be granted
* {@link android.Manifest.permission#SOUND_TRIGGER_RUN_IN_BATTERY_SAVER}.
*/
public boolean mRunInBatterySaverMode = false;
// The SoundModel instance, one of KeyphraseSoundModel or GenericSoundModel.
private SoundModel mSoundModel = null;
// Token used to disambiguate recognition sessions.
private IBinder mRecognitionToken = null;
private ModelData(UUID modelId, int modelType) {
mModelId = modelId;
// Private constructor, since we require modelType to be one of TYPE_GENERIC,
// TYPE_KEYPHRASE or TYPE_UNKNOWN.
mModelType = modelType;
}
static ModelData createKeyphraseModelData(UUID modelId) {
return new ModelData(modelId, SoundModel.TYPE_KEYPHRASE);
}
static ModelData createGenericModelData(UUID modelId) {
return new ModelData(modelId, SoundModel.TYPE_GENERIC_SOUND);
}
// Note that most of the functionality in this Java class will not work for
// SoundModel.TYPE_UNKNOWN nevertheless we have it since lower layers support it.
static ModelData createModelDataOfUnknownType(UUID modelId) {
return new ModelData(modelId, SoundModel.TYPE_UNKNOWN);
}
synchronized void setCallback(IRecognitionStatusCallback callback) {
mCallback = callback;
}
synchronized IRecognitionStatusCallback getCallback() {
return mCallback;
}
synchronized boolean isModelLoaded() {
return (mModelState == MODEL_LOADED || mModelState == MODEL_STARTED);
}
synchronized boolean isModelNotLoaded() {
return mModelState == MODEL_NOTLOADED;
}
synchronized void setStarted() {
mModelState = MODEL_STARTED;
}
synchronized void setStopped() {
// If we are moving to the stopped state, we should clear out our
// startRecognition token
mRecognitionToken = null;
mModelState = MODEL_LOADED;
}
synchronized void setLoaded() {
mModelState = MODEL_LOADED;
}
synchronized void setNotLoaded() {
mRecognitionToken = null;
mModelState = MODEL_NOTLOADED;
}
synchronized boolean isModelStarted() {
return mModelState == MODEL_STARTED;
}
synchronized void clearState() {
mModelState = MODEL_NOTLOADED;
mRecognitionToken = null;
mRecognitionConfig = null;
mRequested = false;
mCallback = null;
}
synchronized void clearCallback() {
mCallback = null;
}
synchronized void setHandle(int handle) {
mModelHandle = handle;
}
synchronized void setRecognitionConfig(RecognitionConfig config) {
mRecognitionConfig = config;
}
synchronized void setRunInBatterySaverMode(boolean runInBatterySaverMode) {
mRunInBatterySaverMode = runInBatterySaverMode;
}
synchronized boolean shouldRunInBatterySaverMode() {
return mRunInBatterySaverMode;
}
synchronized int getHandle() {
return mModelHandle;
}
synchronized UUID getModelId() {
return mModelId;
}
synchronized RecognitionConfig getRecognitionConfig() {
return mRecognitionConfig;
}
// Whether a start recognition was requested.
synchronized boolean isRequested() {
return mRequested;
}
synchronized void setRequested(boolean requested) {
mRequested = requested;
}
synchronized void setSoundModel(SoundModel soundModel) {
mSoundModel = soundModel;
}
synchronized SoundModel getSoundModel() {
return mSoundModel;
}
synchronized IBinder getToken() {
return mRecognitionToken;
}
synchronized void setToken(IBinder token) {
mRecognitionToken = token;
}
synchronized int getModelType() {
return mModelType;
}
synchronized boolean isKeyphraseModel() {
return mModelType == SoundModel.TYPE_KEYPHRASE;
}
synchronized boolean isGenericModel() {
return mModelType == SoundModel.TYPE_GENERIC_SOUND;
}
synchronized String stateToString() {
switch(mModelState) {
case MODEL_NOTLOADED: return "NOT_LOADED";
case MODEL_LOADED: return "LOADED";
case MODEL_STARTED: return "STARTED";
}
return "Unknown state";
}
synchronized String requestedToString() {
return "Requested: " + (mRequested ? "Yes" : "No");
}
synchronized String callbackToString() {
return "Callback: " + (mCallback != null ? mCallback.asBinder() : "null");
}
synchronized String uuidToString() {
return "UUID: " + mModelId;
}
synchronized public String toString() {
return "Handle: " + mModelHandle + "\n" +
"ModelState: " + stateToString() + "\n" +
requestedToString() + "\n" +
callbackToString() + "\n" +
uuidToString() + "\n" +
modelTypeToString() +
"RunInBatterySaverMode=" + mRunInBatterySaverMode;
}
synchronized String modelTypeToString() {
String type = null;
switch (mModelType) {
case SoundModel.TYPE_GENERIC_SOUND: type = "Generic"; break;
case SoundModel.TYPE_UNKNOWN: type = "Unknown"; break;
case SoundModel.TYPE_KEYPHRASE: type = "Keyphrase"; break;
}
return "Model type: " + type + "\n";
}
}
}