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#include <sensor/ISensorEventConnection.h>
18
19#include <stdint.h>
20#include <sys/types.h>
21
22#include <utils/Errors.h>
23#include <utils/RefBase.h>
24#include <utils/Timers.h>
25
26#include <binder/Parcel.h>
27#include <binder/IInterface.h>
28
29#include <sensor/BitTube.h>
30
31namespace android {
32// ----------------------------------------------------------------------------
33
34enum {
35    GET_SENSOR_CHANNEL = IBinder::FIRST_CALL_TRANSACTION,
36    ENABLE_DISABLE,
37    SET_EVENT_RATE,
38    FLUSH_SENSOR,
39    CONFIGURE_CHANNEL
40};
41
42class BpSensorEventConnection : public BpInterface<ISensorEventConnection>
43{
44public:
45    explicit BpSensorEventConnection(const sp<IBinder>& impl)
46        : BpInterface<ISensorEventConnection>(impl)
47    {
48    }
49
50    virtual ~BpSensorEventConnection();
51
52    virtual sp<BitTube> getSensorChannel() const
53    {
54        Parcel data, reply;
55        data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
56        remote()->transact(GET_SENSOR_CHANNEL, data, &reply);
57        return new BitTube(reply);
58    }
59
60    virtual status_t enableDisable(int handle, bool enabled, nsecs_t samplingPeriodNs,
61                                   nsecs_t maxBatchReportLatencyNs, int reservedFlags)
62    {
63        Parcel data, reply;
64        data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
65        data.writeInt32(handle);
66        data.writeInt32(enabled);
67        data.writeInt64(samplingPeriodNs);
68        data.writeInt64(maxBatchReportLatencyNs);
69        data.writeInt32(reservedFlags);
70        remote()->transact(ENABLE_DISABLE, data, &reply);
71        return reply.readInt32();
72    }
73
74    virtual status_t setEventRate(int handle, nsecs_t ns)
75    {
76        Parcel data, reply;
77        data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
78        data.writeInt32(handle);
79        data.writeInt64(ns);
80        remote()->transact(SET_EVENT_RATE, data, &reply);
81        return reply.readInt32();
82    }
83
84    virtual status_t flush() {
85        Parcel data, reply;
86        data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
87        remote()->transact(FLUSH_SENSOR, data, &reply);
88        return reply.readInt32();
89    }
90
91    virtual int32_t configureChannel(int32_t handle, int32_t rateLevel) {
92        Parcel data, reply;
93        data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
94        data.writeInt32(handle);
95        data.writeInt32(rateLevel);
96        remote()->transact(CONFIGURE_CHANNEL, data, &reply);
97        return reply.readInt32();
98    }
99};
100
101// Out-of-line virtual method definition to trigger vtable emission in this
102// translation unit (see clang warning -Wweak-vtables)
103BpSensorEventConnection::~BpSensorEventConnection() {}
104
105IMPLEMENT_META_INTERFACE(SensorEventConnection, "android.gui.SensorEventConnection");
106
107// ----------------------------------------------------------------------------
108
109status_t BnSensorEventConnection::onTransact(
110    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
111{
112    switch(code) {
113        case GET_SENSOR_CHANNEL: {
114            CHECK_INTERFACE(ISensorEventConnection, data, reply);
115            sp<BitTube> channel(getSensorChannel());
116            channel->writeToParcel(reply);
117            return NO_ERROR;
118        }
119        case ENABLE_DISABLE: {
120            CHECK_INTERFACE(ISensorEventConnection, data, reply);
121            int handle = data.readInt32();
122            int enabled = data.readInt32();
123            nsecs_t samplingPeriodNs = data.readInt64();
124            nsecs_t maxBatchReportLatencyNs = data.readInt64();
125            int reservedFlags = data.readInt32();
126            status_t result = enableDisable(handle, enabled, samplingPeriodNs,
127                                            maxBatchReportLatencyNs, reservedFlags);
128            reply->writeInt32(result);
129            return NO_ERROR;
130        }
131        case SET_EVENT_RATE: {
132            CHECK_INTERFACE(ISensorEventConnection, data, reply);
133            int handle = data.readInt32();
134            nsecs_t ns = data.readInt64();
135            status_t result = setEventRate(handle, ns);
136            reply->writeInt32(result);
137            return NO_ERROR;
138        }
139        case FLUSH_SENSOR: {
140            CHECK_INTERFACE(ISensorEventConnection, data, reply);
141            status_t result = flush();
142            reply->writeInt32(result);
143            return NO_ERROR;
144        }
145        case CONFIGURE_CHANNEL: {
146            CHECK_INTERFACE(ISensorEventConnection, data, reply);
147            int handle = data.readInt32();
148            int rateLevel = data.readInt32();
149            status_t result = configureChannel(handle, rateLevel);
150            reply->writeInt32(result);
151            return NO_ERROR;
152        }
153
154    }
155    return BBinder::onTransact(code, data, reply, flags);
156}
157
158// ----------------------------------------------------------------------------
159}; // namespace android
160