/*
|
* Copyright (C) 2008 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.
|
*/
|
|
#ifndef ANDROID_HARDWARE_SOUNDTRIGGER_HAL_SERVICE_H
|
#define ANDROID_HARDWARE_SOUNDTRIGGER_HAL_SERVICE_H
|
|
#include <utils/Vector.h>
|
//#include <binder/AppOpsManager.h>
|
#include <binder/MemoryDealer.h>
|
#include <binder/BinderService.h>
|
#include <binder/IAppOpsCallback.h>
|
#include <soundtrigger/ISoundTriggerHwService.h>
|
#include <soundtrigger/ISoundTrigger.h>
|
#include <soundtrigger/ISoundTriggerClient.h>
|
#include <system/sound_trigger.h>
|
#include "SoundTriggerHalInterface.h"
|
|
namespace android {
|
|
class MemoryHeapBase;
|
|
class SoundTriggerHwService :
|
public BinderService<SoundTriggerHwService>,
|
public BnSoundTriggerHwService
|
{
|
friend class BinderService<SoundTriggerHwService>;
|
public:
|
class Module;
|
class ModuleClient;
|
|
static char const* getServiceName() { return "media.sound_trigger_hw"; }
|
|
SoundTriggerHwService();
|
virtual ~SoundTriggerHwService();
|
|
// ISoundTriggerHwService
|
virtual status_t listModules(const String16& opPackageName,
|
struct sound_trigger_module_descriptor *modules,
|
uint32_t *numModules);
|
|
virtual status_t attach(const String16& opPackageName,
|
const sound_trigger_module_handle_t handle,
|
const sp<ISoundTriggerClient>& client,
|
sp<ISoundTrigger>& module);
|
|
virtual status_t setCaptureState(bool active);
|
|
virtual status_t onTransact(uint32_t code, const Parcel& data,
|
Parcel* reply, uint32_t flags);
|
|
virtual status_t dump(int fd, const Vector<String16>& args);
|
|
class Model : public RefBase {
|
public:
|
|
enum {
|
STATE_IDLE,
|
STATE_ACTIVE
|
};
|
|
Model(sound_model_handle_t handle, audio_session_t session, audio_io_handle_t ioHandle,
|
audio_devices_t device, sound_trigger_sound_model_type_t type,
|
sp<ModuleClient>& moduleClient);
|
~Model() {}
|
|
sound_model_handle_t mHandle;
|
int mState;
|
audio_session_t mCaptureSession;
|
audio_io_handle_t mCaptureIOHandle;
|
audio_devices_t mCaptureDevice;
|
sound_trigger_sound_model_type_t mType;
|
struct sound_trigger_recognition_config mConfig;
|
sp<ModuleClient> mModuleClient;
|
};
|
|
class CallbackEvent : public RefBase {
|
public:
|
typedef enum {
|
TYPE_RECOGNITION,
|
TYPE_SOUNDMODEL,
|
TYPE_SERVICE_STATE,
|
} event_type;
|
CallbackEvent(event_type type, sp<IMemory> memory);
|
|
virtual ~CallbackEvent();
|
|
void setModule(wp<Module> module) { mModule = module; }
|
void setModuleClient(wp<ModuleClient> moduleClient) { mModuleClient = moduleClient; }
|
|
event_type mType;
|
sp<IMemory> mMemory;
|
wp<Module> mModule;
|
wp<ModuleClient> mModuleClient;
|
};
|
|
class Module : public RefBase {
|
public:
|
|
Module(const sp<SoundTriggerHwService>& service,
|
const sp<SoundTriggerHalInterface>& halInterface,
|
sound_trigger_module_descriptor descriptor);
|
|
virtual ~Module();
|
|
virtual status_t loadSoundModel(const sp<IMemory>& modelMemory,
|
sp<ModuleClient> moduleClient,
|
sound_model_handle_t *handle);
|
|
virtual status_t unloadSoundModel(sound_model_handle_t handle);
|
|
virtual status_t startRecognition(sound_model_handle_t handle,
|
const sp<IMemory>& dataMemory);
|
virtual status_t stopRecognition(sound_model_handle_t handle);
|
virtual status_t getModelState(sound_model_handle_t handle);
|
|
sp<SoundTriggerHalInterface> halInterface() const { return mHalInterface; }
|
struct sound_trigger_module_descriptor descriptor() { return mDescriptor; }
|
wp<SoundTriggerHwService> service() const { return mService; }
|
bool isConcurrentCaptureAllowed() const { return mDescriptor.properties.concurrent_capture; }
|
|
sp<Model> getModel(sound_model_handle_t handle);
|
|
void setCaptureState_l(bool active);
|
|
sp<ModuleClient> addClient(const sp<ISoundTriggerClient>& client,
|
const String16& opPackageName);
|
|
void detach(const sp<ModuleClient>& moduleClient);
|
|
void onCallbackEvent(const sp<CallbackEvent>& event);
|
|
private:
|
|
Mutex mLock;
|
wp<SoundTriggerHwService> mService;
|
sp<SoundTriggerHalInterface> mHalInterface;
|
struct sound_trigger_module_descriptor mDescriptor;
|
Vector< sp<ModuleClient> > mModuleClients;
|
DefaultKeyedVector< sound_model_handle_t, sp<Model> > mModels;
|
sound_trigger_service_state_t mServiceState;
|
}; // class Module
|
|
class ModuleClient : public virtual RefBase,
|
public BnSoundTrigger,
|
public IBinder::DeathRecipient {
|
public:
|
|
ModuleClient(const sp<Module>& module,
|
const sp<ISoundTriggerClient>& client,
|
const String16& opPackageName);
|
|
virtual ~ModuleClient();
|
|
virtual void detach();
|
|
virtual status_t loadSoundModel(const sp<IMemory>& modelMemory,
|
sound_model_handle_t *handle);
|
|
virtual status_t unloadSoundModel(sound_model_handle_t handle);
|
|
virtual status_t startRecognition(sound_model_handle_t handle,
|
const sp<IMemory>& dataMemory);
|
virtual status_t stopRecognition(sound_model_handle_t handle);
|
virtual status_t getModelState(sound_model_handle_t handle);
|
|
virtual status_t dump(int fd, const Vector<String16>& args);
|
|
virtual void onFirstRef();
|
|
// IBinder::DeathRecipient implementation
|
virtual void binderDied(const wp<IBinder> &who);
|
|
void onCallbackEvent(const sp<CallbackEvent>& event);
|
|
void setCaptureState_l(bool active);
|
|
sp<ISoundTriggerClient> client() const { return mClient; }
|
|
private:
|
|
mutable Mutex mLock;
|
wp<Module> mModule;
|
sp<ISoundTriggerClient> mClient;
|
const String16 mOpPackageName;
|
}; // class ModuleClient
|
|
class CallbackThread : public Thread {
|
public:
|
|
explicit CallbackThread(const wp<SoundTriggerHwService>& service);
|
|
virtual ~CallbackThread();
|
|
// Thread virtuals
|
virtual bool threadLoop();
|
|
// RefBase
|
virtual void onFirstRef();
|
|
void exit();
|
void sendCallbackEvent(const sp<CallbackEvent>& event);
|
|
private:
|
wp<SoundTriggerHwService> mService;
|
Condition mCallbackCond;
|
Mutex mCallbackLock;
|
Vector< sp<CallbackEvent> > mEventQueue;
|
};
|
|
static void recognitionCallback(struct sound_trigger_recognition_event *event, void *cookie);
|
sp<IMemory> prepareRecognitionEvent(struct sound_trigger_recognition_event *event);
|
void sendRecognitionEvent(struct sound_trigger_recognition_event *event, Module *module);
|
|
static void soundModelCallback(struct sound_trigger_model_event *event, void *cookie);
|
sp<IMemory> prepareSoundModelEvent(struct sound_trigger_model_event *event);
|
void sendSoundModelEvent(struct sound_trigger_model_event *event, Module *module);
|
|
sp<IMemory> prepareServiceStateEvent(sound_trigger_service_state_t state);
|
void sendServiceStateEvent(sound_trigger_service_state_t state, Module *module);
|
void sendServiceStateEvent(sound_trigger_service_state_t state,
|
ModuleClient *moduleClient);
|
|
void sendCallbackEvent(const sp<CallbackEvent>& event);
|
void onCallbackEvent(const sp<CallbackEvent>& event);
|
|
private:
|
|
virtual void onFirstRef();
|
|
Mutex mServiceLock;
|
volatile int32_t mNextUniqueId;
|
DefaultKeyedVector< sound_trigger_module_handle_t, sp<Module> > mModules;
|
sp<CallbackThread> mCallbackThread;
|
sp<MemoryDealer> mMemoryDealer;
|
Mutex mMemoryDealerLock;
|
bool mCaptureState;
|
};
|
|
} // namespace android
|
|
#endif // ANDROID_HARDWARE_SOUNDTRIGGER_HAL_SERVICE_H
|
