server/soundtrigger_middleware/FakeSoundTriggerHal.java

/*
 * Copyright (C) 2023 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_middleware;

import android.annotation.Nullable;
import android.hardware.soundtrigger3.ISoundTriggerHw;
import android.hardware.soundtrigger3.ISoundTriggerHwCallback;
import android.hardware.soundtrigger3.ISoundTriggerHwGlobalCallback;
import android.media.soundtrigger.ModelParameter;
import android.media.soundtrigger.ModelParameterRange;
import android.media.soundtrigger.PhraseRecognitionEvent;
import android.media.soundtrigger.PhraseRecognitionExtra;
import android.media.soundtrigger.PhraseSoundModel;
import android.media.soundtrigger.Properties;
import android.media.soundtrigger.RecognitionConfig;
import android.media.soundtrigger.RecognitionEvent;
import android.media.soundtrigger.RecognitionMode;
import android.media.soundtrigger.RecognitionStatus;
import android.media.soundtrigger.SoundModel;
import android.media.soundtrigger.SoundModelType;
import android.media.soundtrigger.Status;
import android.media.soundtrigger_middleware.IAcknowledgeEvent;
import android.media.soundtrigger_middleware.IInjectGlobalEvent;
import android.media.soundtrigger_middleware.IInjectModelEvent;
import android.media.soundtrigger_middleware.IInjectRecognitionEvent;
import android.media.soundtrigger_middleware.ISoundTriggerInjection;
import android.os.DeadObjectException;
import android.os.IBinder;
import android.os.Parcel;
import android.os.RemoteException;
import android.os.ServiceSpecificException;
import android.util.Slog;

import com.android.internal.annotations.GuardedBy;
import com.android.internal.util.FunctionalUtils;

import java.util.HashMap;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;


/**
 * Fake HAL implementation, which offers injection via
 * {@link ISoundTriggerInjection}.
 * Since this is a test interface, upon unexpected operations from the framework,
 * we will abort.
 */
public class FakeSoundTriggerHal extends ISoundTriggerHw.Stub {
    private static final String TAG = "FakeSoundTriggerHal";

    // Fake values for valid model param range
    private static final int THRESHOLD_MIN = -10;
    private static final int THRESHOLD_MAX = 10;

    // Logically const
    private final Object mLock = new Object();
    private final Properties mProperties;

    // These cannot be injected, since we rely on:
    // 1) Serialization
    // 2) Running in a different thread
    // And there is no Executor interface with these requirements
    // These factories clean up the pools on finalizer.
    // Package private so the FakeHalFactory can dispatch
    static class ExecutorHolder {
        static final Executor CALLBACK_EXECUTOR =
                Executors.newSingleThreadExecutor();
        static final Executor INJECTION_EXECUTOR =
                Executors.newSingleThreadExecutor();
    }

    // Dispatcher interface for callbacks, using the executors above
    private final InjectionDispatcher mInjectionDispatcher;

    // Created on construction, passed back to clients.
    private final IInjectGlobalEvent.Stub mGlobalEventSession;

    @GuardedBy("mLock")
    private IBinder.DeathRecipient mDeathRecipient;

    @GuardedBy("mLock")
    private GlobalCallbackDispatcher mGlobalCallbackDispatcher = null;

    @GuardedBy("mLock")
    private boolean mIsResourceContended = false;
    @GuardedBy("mLock")
    private final Map<Integer, ModelSession> mModelSessionMap = new HashMap<>();

    // Current version of the STHAL relies on integer model session ids.
    // Generate them monotonically starting at 101
    @GuardedBy("mLock")
    private int mModelKeyCounter = 101;

    @GuardedBy("mLock")
    private boolean mIsDead = false;

    private class ModelSession extends IInjectModelEvent.Stub {
        // Logically const
        private final boolean mIsKeyphrase;
        private final CallbackDispatcher mCallbackDispatcher;
        private final int mModelHandle;

        // Model parameter
        @GuardedBy("FakeSoundTriggerHal.this.mLock")
        private int mThreshold = 0;

        // Mutable
        @GuardedBy("FakeSoundTriggerHal.this.mLock")
        private boolean mIsUnloaded = false; // Latch

        // Only a single recognition session is able to be active for a model
        // session at any given time. Null if no recognition is active.
        @GuardedBy("FakeSoundTriggerHal.this.mLock")
        @Nullable private RecognitionSession mRecognitionSession;

        private ModelSession(int modelHandle, CallbackDispatcher callbackDispatcher,
                boolean isKeyphrase) {
            mModelHandle = modelHandle;
            mCallbackDispatcher = callbackDispatcher;
            mIsKeyphrase = isKeyphrase;
        }

        private RecognitionSession startRecognitionForModel() {
            synchronized (FakeSoundTriggerHal.this.mLock) {
                mRecognitionSession = new RecognitionSession();
                return mRecognitionSession;
            }
        }

        private RecognitionSession stopRecognitionForModel() {
            synchronized (FakeSoundTriggerHal.this.mLock) {
                RecognitionSession session = mRecognitionSession;
                mRecognitionSession = null;
                return session;
            }
        }

        private void forceRecognitionForModel() {
            synchronized (FakeSoundTriggerHal.this.mLock) {
                if (mIsKeyphrase) {
                    PhraseRecognitionEvent phraseEvent =
                            createDefaultKeyphraseEvent(RecognitionStatus.FORCED);
                    mCallbackDispatcher.wrap((ISoundTriggerHwCallback cb) ->
                            cb.phraseRecognitionCallback(mModelHandle, phraseEvent));
                } else {
                    RecognitionEvent event = createDefaultEvent(RecognitionStatus.FORCED);
                    mCallbackDispatcher.wrap((ISoundTriggerHwCallback cb) ->
                            cb.recognitionCallback(mModelHandle, event));
                }
            }
        }

        private void setThresholdFactor(int value) {
            synchronized (FakeSoundTriggerHal.this.mLock) {
                mThreshold = value;
            }
        }

        private int getThresholdFactor() {
            synchronized (FakeSoundTriggerHal.this.mLock) {
                return mThreshold;
            }
        }

        private boolean getIsUnloaded() {
            synchronized (FakeSoundTriggerHal.this.mLock) {
                return mIsUnloaded;
            }
        }

        private RecognitionSession getRecogSession() {
            synchronized (FakeSoundTriggerHal.this.mLock) {
                return mRecognitionSession;
            }
        }


        /** oneway **/
        @Override
        public void triggerUnloadModel() {
            synchronized (FakeSoundTriggerHal.this.mLock) {
                if (mIsDead || mIsUnloaded) return;
                if (mRecognitionSession != null) {
                    // Must abort model before triggering unload
                    mRecognitionSession.triggerAbortRecognition();
                }
                // Invalidate the model session
                mIsUnloaded = true;
                mCallbackDispatcher.wrap((ISoundTriggerHwCallback cb) ->
                        cb.modelUnloaded(mModelHandle));
                // Don't notify the injection that an unload has occurred, since it is what
                // triggered the unload

                // Notify if we could have denied a previous model due to contention
                if (getNumLoadedModelsLocked() == (mProperties.maxSoundModels - 1)
                        && !mIsResourceContended) {
                    mGlobalCallbackDispatcher.wrap((ISoundTriggerHwGlobalCallback cb) ->
                            cb.onResourcesAvailable());
                }
            }
        }

        private class RecognitionSession extends IInjectRecognitionEvent.Stub {

            @Override
            /** oneway **/
            public void triggerRecognitionEvent(byte[] data,
                    @Nullable PhraseRecognitionExtra[] phraseExtras) {
                synchronized (FakeSoundTriggerHal.this.mLock) {
                    // Check if our session has already been invalidated
                    if (mIsDead || mRecognitionSession != this) return;
                    // Invalidate the recognition session
                    mRecognitionSession = null;
                    // Trigger the callback.
                    if (mIsKeyphrase) {
                        PhraseRecognitionEvent phraseEvent =
                                createDefaultKeyphraseEvent(RecognitionStatus.SUCCESS);
                        phraseEvent.common.data = data;
                        if (phraseExtras != null) phraseEvent.phraseExtras = phraseExtras;
                        mCallbackDispatcher.wrap((ISoundTriggerHwCallback cb) ->
                                cb.phraseRecognitionCallback(mModelHandle, phraseEvent));
                    } else {
                        RecognitionEvent event = createDefaultEvent(RecognitionStatus.SUCCESS);
                        event.data = data;
                        mCallbackDispatcher.wrap((ISoundTriggerHwCallback cb) ->
                                cb.recognitionCallback(mModelHandle, event));
                    }
                }
            }

            @Override
            /** oneway **/
            public void triggerAbortRecognition() {
                synchronized (FakeSoundTriggerHal.this.mLock) {
                    if (mIsDead || mRecognitionSession != this) return;
                    // Clear the session state
                    mRecognitionSession = null;
                    // Trigger the callback.
                    if (mIsKeyphrase) {
                        mCallbackDispatcher.wrap((ISoundTriggerHwCallback cb) ->
                                cb.phraseRecognitionCallback(mModelHandle,
                                    createDefaultKeyphraseEvent(RecognitionStatus.ABORTED)));
                    } else {
                        mCallbackDispatcher.wrap((ISoundTriggerHwCallback cb) ->
                                cb.recognitionCallback(mModelHandle,
                                    createDefaultEvent(RecognitionStatus.ABORTED)));
                    }
                }
            }
        }
    }

    // Since this is always constructed, it needs to be cheap to create.
    public FakeSoundTriggerHal(ISoundTriggerInjection injection) {
        mProperties = createDefaultProperties();
        mInjectionDispatcher = new InjectionDispatcher(injection);
        mGlobalCallbackDispatcher = null; // If this NPEs before registration, we want to abort.
        // Implement the IInjectGlobalEvent IInterface.
        // Since we can't extend multiple IInterface from the same object, instantiate an instance
        // for our clients.
        mGlobalEventSession = new IInjectGlobalEvent.Stub() {
            /**
             * Simulate a HAL process restart. This method is not included in regular HAL interface,
             * since the entire process is restarted by sending a signal.
             * Since we run in-proc, we must offer an explicit restart method.
             * oneway
             */
            @Override
            public void triggerRestart() {
                synchronized (FakeSoundTriggerHal.this.mLock) {
                    if (mIsDead) return;
                    mIsDead = true;
                    mInjectionDispatcher.wrap((ISoundTriggerInjection cb) ->
                            cb.onRestarted(this));
                    mModelSessionMap.clear();
                    if (mDeathRecipient != null) {
                        final DeathRecipient deathRecipient = mDeathRecipient;
                        ExecutorHolder.CALLBACK_EXECUTOR.execute(() -> {
                            try {
                                deathRecipient.binderDied(FakeSoundTriggerHal.this.asBinder());
                            } catch (Throwable e) {
                                // We don't expect RemoteException at the moment since we run
                                // in the same process
                                Slog.wtf(TAG, "Callback dispatch threw", e);
                            }
                        });
                    }
                }
            }

            // oneway
            @Override
            public void setResourceContention(boolean isResourcesContended,
                        IAcknowledgeEvent callback) {
                synchronized (FakeSoundTriggerHal.this.mLock) {
                    // oneway, so don't throw on death
                    if (mIsDead) {
                        return;
                    }
                    boolean oldIsResourcesContended = mIsResourceContended;
                    mIsResourceContended = isResourcesContended;
                    // Introducing contention is the only injection which can't be
                    // observed by the ST client.
                    mInjectionDispatcher.wrap((ISoundTriggerInjection unused) ->
                            callback.eventReceived());
                    if (!mIsResourceContended && oldIsResourcesContended) {
                        mGlobalCallbackDispatcher.wrap((ISoundTriggerHwGlobalCallback cb) ->
                                    cb.onResourcesAvailable());
                    }
                }
            }

            // oneway
            @Override
            public void triggerOnResourcesAvailable() {
                synchronized (FakeSoundTriggerHal.this.mLock) {
                    // oneway, so don't throw on death
                    if (mIsDead) return;
                    mGlobalCallbackDispatcher.wrap((ISoundTriggerHwGlobalCallback cb) ->
                            cb.onResourcesAvailable());
                }
            }
        };

        // Register the global event injection interface
        mInjectionDispatcher.wrap((ISoundTriggerInjection cb)
                -> cb.registerGlobalEventInjection(mGlobalEventSession));
    }

    /**
     * Get the {@link IInjectGlobalEvent} associated with this instance of the STHAL.
     * Used as a session token, valid until restarted.
     */
    public IInjectGlobalEvent getGlobalEventInjection() {
        return mGlobalEventSession;
    }

    // TODO(b/274467228) we can remove the next three methods when this HAL is moved out-of-proc,
    // so process restart at death notification is appropriately handled by the binder.
    @Override
    public void linkToDeath(IBinder.DeathRecipient recipient, int flags) {
        synchronized (mLock) {
            if (mDeathRecipient != null) {
                Slog.wtf(TAG, "Received two death recipients concurrently");
            }
            mDeathRecipient = recipient;
        }
    }

    @Override
    public boolean unlinkToDeath(IBinder.DeathRecipient recipient, int flags) {
        synchronized (mLock) {
            if (mIsDead) return false;
            if (mDeathRecipient != recipient) {
                throw new NoSuchElementException();
            }
            mDeathRecipient = null;
            return true;
        }
    }

    // STHAL method overrides to follow
    @Override
    public Properties getProperties() throws RemoteException {
        synchronized (mLock) {
            if (mIsDead) throw new DeadObjectException();
            Parcel parcel = Parcel.obtain();
            try {
                mProperties.writeToParcel(parcel, 0 /* flags */);
                parcel.setDataPosition(0);
                return Properties.CREATOR.createFromParcel(parcel);
            } finally {
                parcel.recycle();
            }
        }
    }

    @Override
    public void registerGlobalCallback(
            ISoundTriggerHwGlobalCallback callback) throws RemoteException {
        synchronized (mLock) {
            if (mIsDead) throw new DeadObjectException();
            mGlobalCallbackDispatcher = new GlobalCallbackDispatcher(callback);
        }
    }

    @Override
    public int loadSoundModel(SoundModel soundModel,
            ISoundTriggerHwCallback callback) throws RemoteException {
        synchronized (mLock) {
            if (mIsDead) throw new DeadObjectException();
            if (mIsResourceContended || getNumLoadedModelsLocked() == mProperties.maxSoundModels) {
                throw new ServiceSpecificException(Status.RESOURCE_CONTENTION);
            }
            int key = mModelKeyCounter++;
            ModelSession session = new ModelSession(key, new CallbackDispatcher(callback), false);

            mModelSessionMap.put(key, session);

            mInjectionDispatcher.wrap((ISoundTriggerInjection cb) ->
                    cb.onSoundModelLoaded(soundModel, null, session, mGlobalEventSession));
            return key;
        }
    }

    @Override
    public int loadPhraseSoundModel(PhraseSoundModel soundModel,
            ISoundTriggerHwCallback callback) throws RemoteException {
        synchronized (mLock) {
            if (mIsDead) throw new DeadObjectException();
            if (mIsResourceContended || getNumLoadedModelsLocked() == mProperties.maxSoundModels) {
                throw new ServiceSpecificException(Status.RESOURCE_CONTENTION);
            }

            int key = mModelKeyCounter++;
            ModelSession session = new ModelSession(key, new CallbackDispatcher(callback), true);

            mModelSessionMap.put(key, session);

            mInjectionDispatcher.wrap((ISoundTriggerInjection cb) ->
                    cb.onSoundModelLoaded(soundModel.common, soundModel.phrases, session,
                        mGlobalEventSession));
            return key;
        }
    }

    @Override
    public void unloadSoundModel(int modelHandle) throws RemoteException {
        synchronized (mLock) {
            if (mIsDead) throw new DeadObjectException();
            ModelSession session = mModelSessionMap.get(modelHandle);
            if (session == null) {
                Slog.wtf(TAG, "Attempted to unload model which was never loaded");
            }

            if (session.getRecogSession() != null) {
                Slog.wtf(TAG, "Session unloaded before recog stopped!");
            }

            // Session is stale
            if (session.getIsUnloaded()) return;
            mInjectionDispatcher.wrap((ISoundTriggerInjection cb) ->
                    cb.onSoundModelUnloaded(session));

            // Notify if we could have denied a previous model due to contention
            if (getNumLoadedModelsLocked() == (mProperties.maxSoundModels - 1)
                    && !mIsResourceContended) {
                mGlobalCallbackDispatcher.wrap((ISoundTriggerHwGlobalCallback cb) ->
                        cb.onResourcesAvailable());
            }

        }
    }

    @Override
    public void startRecognition(int modelHandle, int deviceHandle, int ioHandle,
            RecognitionConfig config) throws RemoteException {
        synchronized (mLock) {
            if (mIsDead) throw new DeadObjectException();
            ModelSession session = mModelSessionMap.get(modelHandle);
            if (session == null) {
                Slog.wtf(TAG, "Attempted to start recognition with invalid handle");
            }
            if (mIsResourceContended) {
                throw new ServiceSpecificException(Status.RESOURCE_CONTENTION);
            }
            if (session.getIsUnloaded()) {
                // TODO(b/274470274) this is a deficiency in the existing HAL API, there is no way
                // to handle this race gracefully
                throw new ServiceSpecificException(Status.RESOURCE_CONTENTION);
            }
            ModelSession.RecognitionSession recogSession = session.startRecognitionForModel();

            // TODO(b/274470571) appropriately translate ioHandle to session handle
            mInjectionDispatcher.wrap((ISoundTriggerInjection cb) ->
                    cb.onRecognitionStarted(-1, config, recogSession, session));
        }
    }

    @Override
    public void stopRecognition(int modelHandle) throws RemoteException {
        synchronized (mLock) {
            if (mIsDead) throw new DeadObjectException();
            ModelSession session = mModelSessionMap.get(modelHandle);
            if (session == null) {
                Slog.wtf(TAG, "Attempted to stop recognition with invalid handle");
            }
            ModelSession.RecognitionSession recogSession = session.stopRecognitionForModel();
            if (recogSession != null) {
                mInjectionDispatcher.wrap((ISoundTriggerInjection cb) ->
                        cb.onRecognitionStopped(recogSession));
            }
        }
    }

    @Override
    public void forceRecognitionEvent(int modelHandle) throws RemoteException {
        synchronized (mLock) {
            if (mIsDead) throw new DeadObjectException();
            ModelSession session = mModelSessionMap.get(modelHandle);
            if (session == null) {
                Slog.wtf(TAG, "Attempted to force recognition with invalid handle");
            }

            // TODO(b/274470274) this is a deficiency in the existing HAL API, we could always
            // get a force request for an already stopped model. The only thing to do is
            // drop such a request.
            if (session.getRecogSession() == null) return;
            session.forceRecognitionForModel();
        }
    }

    // TODO(b/274470274) this is a deficiency in the existing HAL API, we could always
    // get model param API requests after model unload.
    // For now, succeed anyway to maintain fidelity to existing HALs.
    @Override
    public @Nullable ModelParameterRange queryParameter(int modelHandle,
            /** ModelParameter **/ int modelParam) throws RemoteException {
        synchronized (mLock) {
            if (mIsDead) throw new DeadObjectException();
            ModelSession session = mModelSessionMap.get(modelHandle);
            if (session == null) {
                Slog.wtf(TAG, "Attempted to get param with invalid handle");
            }
        }
        if (modelParam == ModelParameter.THRESHOLD_FACTOR) {
            ModelParameterRange range = new ModelParameterRange();
            range.minInclusive = THRESHOLD_MIN;
            range.maxInclusive = THRESHOLD_MAX;
            return range;
        } else {
            return null;
        }
    }

    @Override
    public int getParameter(int modelHandle,
            /** ModelParameter **/ int modelParam) throws RemoteException {
        synchronized (mLock) {
            if (mIsDead) throw new DeadObjectException();
            ModelSession session = mModelSessionMap.get(modelHandle);
            if (session == null) {
                Slog.wtf(TAG, "Attempted to get param with invalid handle");
            }
            if (modelParam != ModelParameter.THRESHOLD_FACTOR) {
                throw new IllegalArgumentException();
            }
            return session.getThresholdFactor();
        }
    }

    @Override
    public void setParameter(int modelHandle,
            /** ModelParameter **/ int modelParam, int value) throws RemoteException {
        synchronized (mLock) {
            if (mIsDead) throw new DeadObjectException();
            ModelSession session = mModelSessionMap.get(modelHandle);
            if (session == null) {
                Slog.wtf(TAG, "Attempted to get param with invalid handle");
            }
            if ((modelParam == ModelParameter.THRESHOLD_FACTOR)
                    || (value >= THRESHOLD_MIN && value <= THRESHOLD_MAX)) {
                session.setThresholdFactor(value);
            } else {
                throw new IllegalArgumentException();
            }
            mInjectionDispatcher.wrap((ISoundTriggerInjection cb) ->
                    cb.onParamSet(modelParam, value, session));
        }
    }

    @Override
    public int getInterfaceVersion() throws RemoteException {
        synchronized (mLock) {
            if (mIsDead) throw new DeadObjectException();
        }
        return super.VERSION;
    }

    @Override
    public String getInterfaceHash() throws RemoteException {
        synchronized (mLock) {
            if (mIsDead) throw new DeadObjectException();
        }
        return super.HASH;
    }

    // Helpers to follow.
    @GuardedBy("mLock")
    private int getNumLoadedModelsLocked() {
        int numModels = 0;
        for (ModelSession session : mModelSessionMap.values()) {
            if (!session.getIsUnloaded()) {
                numModels++;
            }
        }
        return numModels;
    }

    private static Properties createDefaultProperties() {
        Properties properties = new Properties();
        properties.implementor = "android";
        properties.description = "AOSP fake STHAL";
        properties.version = 1;
        properties.uuid = "00000001-0002-0003-0004-deadbeefabcd";
        properties.supportedModelArch = ISoundTriggerInjection.FAKE_HAL_ARCH;
        properties.maxSoundModels = 8;
        properties.maxKeyPhrases = 2;
        properties.maxUsers = 2;
        properties.recognitionModes = RecognitionMode.VOICE_TRIGGER
                | RecognitionMode.GENERIC_TRIGGER;
        properties.captureTransition = true;
        // This is actually not respected, since there is no real AudioRecord
        properties.maxBufferMs = 5000;
        properties.concurrentCapture = true;
        properties.triggerInEvent = false;
        properties.powerConsumptionMw = 0;
        properties.audioCapabilities = 0;
        return properties;
    }

    private static RecognitionEvent createDefaultEvent(
            /** RecognitionStatus **/ int status) {
        RecognitionEvent event = new RecognitionEvent();
        // Overwrite the event appropriately.
        event.status = status;
        event.type = SoundModelType.GENERIC;
        // TODO(b/274466981) make this configurable.
        // For now, some plausible defaults
        event.captureAvailable = true;
        event.captureDelayMs = 50;
        event.capturePreambleMs = 200;
        event.triggerInData = false;
        event.audioConfig = null; // Nullable within AIDL
        event.data = new byte[0];
        // We don't support recognition restart for now
        event.recognitionStillActive = false;
        return event;
    }

    private static PhraseRecognitionEvent createDefaultKeyphraseEvent(
            /**RecognitionStatus **/ int status) {
        RecognitionEvent event = createDefaultEvent(status);
        event.type = SoundModelType.KEYPHRASE;
        PhraseRecognitionEvent phraseEvent = new PhraseRecognitionEvent();
        phraseEvent.common = event;
        phraseEvent.phraseExtras = new PhraseRecognitionExtra[0];
        return phraseEvent;
    }

    // Helper classes to dispatch oneway calls to the appropriate callback interfaces to follow.
    private static class CallbackDispatcher {

        private CallbackDispatcher(ISoundTriggerHwCallback callback) {
            mCallback = callback;
        }

        private void wrap(FunctionalUtils.ThrowingConsumer<ISoundTriggerHwCallback> command) {
            ExecutorHolder.CALLBACK_EXECUTOR.execute(() -> {
                try {
                    command.accept(mCallback);
                } catch (Throwable e) {
                    Slog.wtf(TAG, "Callback dispatch threw", e);
                }
            });
        }

        private final ISoundTriggerHwCallback mCallback;
    }

    private static class GlobalCallbackDispatcher {

        private GlobalCallbackDispatcher(ISoundTriggerHwGlobalCallback callback) {
            mCallback = callback;
        }

        private void wrap(FunctionalUtils.ThrowingConsumer<ISoundTriggerHwGlobalCallback> command) {
            ExecutorHolder.CALLBACK_EXECUTOR.execute(() -> {
                try {
                    command.accept(mCallback);
                } catch (Throwable e) {
                    // We don't expect RemoteException at the moment since we run
                    // in the same process
                    Slog.wtf(TAG, "Callback dispatch threw", e);
                }
            });
        }

        private final ISoundTriggerHwGlobalCallback mCallback;
    }

    private static class InjectionDispatcher {

        private InjectionDispatcher(ISoundTriggerInjection injection) {
            mInjection = injection;
        }

        private void wrap(FunctionalUtils.ThrowingConsumer<ISoundTriggerInjection> command) {
            ExecutorHolder.INJECTION_EXECUTOR.execute(() -> {
                try {
                    command.accept(mInjection);
                } catch (Throwable e) {
                    // We don't expect RemoteException at the moment since we run
                    // in the same process
                    Slog.wtf(TAG, "Callback dispatch threw", e);
                }
            });
        }

        private final ISoundTriggerInjection mInjection;
    }
}