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
31namespace android {
32
33class MemoryHeapBase;
34
35class SoundTriggerHwService :
36    public BinderService<SoundTriggerHwService>,
37    public BnSoundTriggerHwService
38{
39    friend class BinderService<SoundTriggerHwService>;
40public:
41    class Module;
42
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);
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
126       sound_trigger_hw_device *hwDevice() const { return mHwDevice; }
127       struct sound_trigger_module_descriptor descriptor() { return mDescriptor; }
128       void setClient(sp<ISoundTriggerClient> client) { mClient = client; }
129       void clearClient() { mClient.clear(); }
130       sp<ISoundTriggerClient> client() const { return mClient; }
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
195private:
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