IVibra.c revision bcc5c7225e3b7a1dbf2e9e830987f69167acf06f 
1/*
2 * Copyright (C) 2010 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/* Vibra implementation */
18
19#include "sles_allinclusive.h"
20
21
22static SLresult IVibra_Vibrate(SLVibraItf self, SLboolean vibrate)
23{
24    SL_ENTER_INTERFACE
25
26    IVibra *thiz = (IVibra *) self;
27    interface_lock_poke(thiz);
28    thiz->mVibrate = SL_BOOLEAN_FALSE != vibrate; // normalize
29    interface_unlock_poke(thiz);
30    result = SL_RESULT_SUCCESS;
31
32    SL_LEAVE_INTERFACE
33}
34
35
36static SLresult IVibra_IsVibrating(SLVibraItf self, SLboolean *pVibrating)
37{
38    SL_ENTER_INTERFACE
39
40    if (NULL == pVibrating) {
41        result = SL_RESULT_PARAMETER_INVALID;
42    } else {
43        IVibra *thiz = (IVibra *) self;
44        interface_lock_peek(thiz);
45        SLboolean vibrate = thiz->mVibrate;
46        interface_unlock_peek(thiz);
47        *pVibrating = vibrate;
48        result = SL_RESULT_SUCCESS;
49    }
50
51    SL_LEAVE_INTERFACE
52}
53
54
55static SLresult IVibra_SetFrequency(SLVibraItf self, SLmilliHertz frequency)
56{
57    SL_ENTER_INTERFACE
58
59    const SLVibraDescriptor *d = Vibra_id_descriptors[0].descriptor;
60    if (!d->supportsFrequency) {
61        result = SL_RESULT_PRECONDITIONS_VIOLATED;
62    } else if (!(d->minFrequency <= frequency && frequency <= d->maxFrequency)) {
63        result = SL_RESULT_PARAMETER_INVALID;
64    } else {
65        IVibra *thiz = (IVibra *) self;
66        interface_lock_poke(thiz);
67        thiz->mFrequency = frequency;
68        interface_unlock_poke(thiz);
69        result = SL_RESULT_SUCCESS;
70    }
71
72    SL_LEAVE_INTERFACE
73}
74
75
76static SLresult IVibra_GetFrequency(SLVibraItf self, SLmilliHertz *pFrequency)
77{
78    SL_ENTER_INTERFACE
79
80    if (NULL == pFrequency) {
81        result = SL_RESULT_PARAMETER_INVALID;
82    } else {
83        IVibra *thiz = (IVibra *) self;
84        interface_lock_peek(thiz);
85        SLmilliHertz frequency = thiz->mFrequency;
86        interface_unlock_peek(thiz);
87        *pFrequency = frequency;
88        result = SL_RESULT_SUCCESS;
89    }
90
91    SL_LEAVE_INTERFACE
92}
93
94
95static SLresult IVibra_SetIntensity(SLVibraItf self, SLpermille intensity)
96{
97    SL_ENTER_INTERFACE
98
99    const SLVibraDescriptor *d = Vibra_id_descriptors[0].descriptor;
100    if (!d->supportsIntensity) {
101        result = SL_RESULT_PRECONDITIONS_VIOLATED;
102    } else if (!(0 <= intensity && intensity <= 1000)) {
103        result = SL_RESULT_PARAMETER_INVALID;
104    } else {
105        IVibra *thiz = (IVibra *) self;
106        interface_lock_poke(thiz);
107        thiz->mIntensity = intensity;
108        interface_unlock_poke(thiz);
109        result = SL_RESULT_SUCCESS;
110    }
111
112    SL_LEAVE_INTERFACE
113}
114
115
116static SLresult IVibra_GetIntensity(SLVibraItf self, SLpermille *pIntensity)
117{
118    SL_ENTER_INTERFACE
119
120    if (NULL == pIntensity) {
121        result = SL_RESULT_PARAMETER_INVALID;
122    } else {
123        const SLVibraDescriptor *d = Vibra_id_descriptors[0].descriptor;
124        if (!d->supportsIntensity) {
125            result = SL_RESULT_PRECONDITIONS_VIOLATED;
126        } else {
127            IVibra *thiz = (IVibra *) self;
128            interface_lock_peek(thiz);
129            SLpermille intensity = thiz->mIntensity;
130            interface_unlock_peek(thiz);
131            *pIntensity = intensity;
132            result = SL_RESULT_SUCCESS;
133        }
134    }
135
136    SL_LEAVE_INTERFACE
137}
138
139
140static const struct SLVibraItf_ IVibra_Itf = {
141    IVibra_Vibrate,
142    IVibra_IsVibrating,
143    IVibra_SetFrequency,
144    IVibra_GetFrequency,
145    IVibra_SetIntensity,
146    IVibra_GetIntensity
147};
148
149void IVibra_init(void *self)
150{
151    IVibra *thiz = (IVibra *) self;
152    thiz->mItf = &IVibra_Itf;
153    thiz->mVibrate = SL_BOOLEAN_FALSE;
154    // next 2 values are undefined per spec
155    thiz->mFrequency = Vibra_id_descriptors[0].descriptor->minFrequency;
156    thiz->mIntensity = 1000;
157}
158