1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_HARDWARE_SOUNDTRIGGER_HAL_SERVICE_H 18 #define ANDROID_HARDWARE_SOUNDTRIGGER_HAL_SERVICE_H 19 20 #include <utils/Vector.h> 21 //#include <binder/AppOpsManager.h> 22 #include <binder/MemoryDealer.h> 23 #include <binder/BinderService.h> 24 #include <binder/IAppOpsCallback.h> 25 #include <soundtrigger/ISoundTriggerHwService.h> 26 #include <soundtrigger/ISoundTrigger.h> 27 #include <soundtrigger/ISoundTriggerClient.h> 28 #include <system/sound_trigger.h> 29 #include <hardware/sound_trigger.h> 30 31 namespace android { 32 33 class MemoryHeapBase; 34 35 class SoundTriggerHwService : 36 public BinderService<SoundTriggerHwService>, 37 public BnSoundTriggerHwService 38 { 39 friend class BinderService<SoundTriggerHwService>; 40 public: 41 class Module; 42 getServiceName()43 static char const* getServiceName() { return "media.sound_trigger_hw"; } 44 45 SoundTriggerHwService(); 46 virtual ~SoundTriggerHwService(); 47 48 // ISoundTriggerHwService 49 virtual status_t listModules(struct sound_trigger_module_descriptor *modules, 50 uint32_t *numModules); 51 52 virtual status_t attach(const sound_trigger_module_handle_t handle, 53 const sp<ISoundTriggerClient>& client, 54 sp<ISoundTrigger>& module); 55 56 virtual status_t setCaptureState(bool active); 57 58 virtual status_t onTransact(uint32_t code, const Parcel& data, 59 Parcel* reply, uint32_t flags); 60 61 virtual status_t dump(int fd, const Vector<String16>& args); 62 63 class Model : public RefBase { 64 public: 65 66 enum { 67 STATE_IDLE, 68 STATE_ACTIVE 69 }; 70 71 Model(sound_model_handle_t handle, audio_session_t session, audio_io_handle_t ioHandle, 72 audio_devices_t device, sound_trigger_sound_model_type_t type); ~Model()73 ~Model() {} 74 75 sound_model_handle_t mHandle; 76 int mState; 77 audio_session_t mCaptureSession; 78 audio_io_handle_t mCaptureIOHandle; 79 audio_devices_t mCaptureDevice; 80 sound_trigger_sound_model_type_t mType; 81 struct sound_trigger_recognition_config mConfig; 82 }; 83 84 class CallbackEvent : public RefBase { 85 public: 86 typedef enum { 87 TYPE_RECOGNITION, 88 TYPE_SOUNDMODEL, 89 TYPE_SERVICE_STATE, 90 } event_type; 91 CallbackEvent(event_type type, sp<IMemory> memory, wp<Module> module); 92 93 virtual ~CallbackEvent(); 94 95 event_type mType; 96 sp<IMemory> mMemory; 97 wp<Module> mModule; 98 }; 99 100 class Module : public virtual RefBase, 101 public BnSoundTrigger, 102 public IBinder::DeathRecipient { 103 public: 104 105 Module(const sp<SoundTriggerHwService>& service, 106 sound_trigger_hw_device* hwDevice, 107 sound_trigger_module_descriptor descriptor, 108 const sp<ISoundTriggerClient>& client); 109 110 virtual ~Module(); 111 112 virtual void detach(); 113 114 virtual status_t loadSoundModel(const sp<IMemory>& modelMemory, 115 sound_model_handle_t *handle); 116 117 virtual status_t unloadSoundModel(sound_model_handle_t handle); 118 119 virtual status_t startRecognition(sound_model_handle_t handle, 120 const sp<IMemory>& dataMemory); 121 virtual status_t stopRecognition(sound_model_handle_t handle); 122 123 virtual status_t dump(int fd, const Vector<String16>& args); 124 125 hwDevice()126 sound_trigger_hw_device *hwDevice() const { return mHwDevice; } descriptor()127 struct sound_trigger_module_descriptor descriptor() { return mDescriptor; } setClient(sp<ISoundTriggerClient> client)128 void setClient(sp<ISoundTriggerClient> client) { mClient = client; } clearClient()129 void clearClient() { mClient.clear(); } client()130 sp<ISoundTriggerClient> client() const { return mClient; } service()131 wp<SoundTriggerHwService> service() const { return mService; } 132 133 void onCallbackEvent(const sp<CallbackEvent>& event); 134 135 sp<Model> getModel(sound_model_handle_t handle); 136 137 void setCaptureState_l(bool active); 138 139 // IBinder::DeathRecipient implementation 140 virtual void binderDied(const wp<IBinder> &who); 141 142 private: 143 144 status_t unloadSoundModel_l(sound_model_handle_t handle); 145 146 147 Mutex mLock; 148 wp<SoundTriggerHwService> mService; 149 struct sound_trigger_hw_device* mHwDevice; 150 struct sound_trigger_module_descriptor mDescriptor; 151 sp<ISoundTriggerClient> mClient; 152 DefaultKeyedVector< sound_model_handle_t, sp<Model> > mModels; 153 sound_trigger_service_state_t mServiceState; 154 }; // class Module 155 156 class CallbackThread : public Thread { 157 public: 158 159 CallbackThread(const wp<SoundTriggerHwService>& service); 160 161 virtual ~CallbackThread(); 162 163 // Thread virtuals 164 virtual bool threadLoop(); 165 166 // RefBase 167 virtual void onFirstRef(); 168 169 void exit(); 170 void sendCallbackEvent(const sp<CallbackEvent>& event); 171 172 private: 173 wp<SoundTriggerHwService> mService; 174 Condition mCallbackCond; 175 Mutex mCallbackLock; 176 Vector< sp<CallbackEvent> > mEventQueue; 177 }; 178 179 void detachModule(sp<Module> module); 180 181 static void recognitionCallback(struct sound_trigger_recognition_event *event, void *cookie); 182 sp<IMemory> prepareRecognitionEvent_l(struct sound_trigger_recognition_event *event); 183 void sendRecognitionEvent(struct sound_trigger_recognition_event *event, Module *module); 184 185 static void soundModelCallback(struct sound_trigger_model_event *event, void *cookie); 186 sp<IMemory> prepareSoundModelEvent_l(struct sound_trigger_model_event *event); 187 void sendSoundModelEvent(struct sound_trigger_model_event *event, Module *module); 188 189 sp<IMemory> prepareServiceStateEvent_l(sound_trigger_service_state_t state); 190 void sendServiceStateEvent_l(sound_trigger_service_state_t state, Module *module); 191 192 void sendCallbackEvent_l(const sp<CallbackEvent>& event); 193 void onCallbackEvent(const sp<CallbackEvent>& event); 194 195 private: 196 197 virtual void onFirstRef(); 198 199 Mutex mServiceLock; 200 volatile int32_t mNextUniqueId; 201 DefaultKeyedVector< sound_trigger_module_handle_t, sp<Module> > mModules; 202 sp<CallbackThread> mCallbackThread; 203 sp<MemoryDealer> mMemoryDealer; 204 bool mCaptureState; 205 }; 206 207 } // namespace android 208 209 #endif // ANDROID_HARDWARE_SOUNDTRIGGER_HAL_SERVICE_H 210