Home | History | Annotate | Download | only in gui 
      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 <stdint.h>
     18 #include <sys/types.h>
     19 
     20 #include <utils/Errors.h>
     21 #include <utils/RefBase.h>
     22 #include <utils/Timers.h>
     23 
     24 #include <binder/Parcel.h>
     25 #include <binder/IInterface.h>
     26 
     27 #include <gui/ISensorEventConnection.h>
     28 #include <gui/BitTube.h>
     29 
     30 namespace android {
     31 // ----------------------------------------------------------------------------
     32 
     33 enum {
     34     GET_SENSOR_CHANNEL = IBinder::FIRST_CALL_TRANSACTION,
     35     ENABLE_DISABLE,
     36     SET_EVENT_RATE,
     37     FLUSH_SENSOR
     38 };
     39 
     40 class BpSensorEventConnection : public BpInterface<ISensorEventConnection>
     41 {
     42 public:
     43     BpSensorEventConnection(const sp<IBinder>& impl)
     44         : BpInterface<ISensorEventConnection>(impl)
     45     {
     46     }
     47 
     48     virtual sp<BitTube> getSensorChannel() const
     49     {
     50         Parcel data, reply;
     51         data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
     52         remote()->transact(GET_SENSOR_CHANNEL, data, &reply);
     53         return new BitTube(reply);
     54     }
     55 
     56     virtual status_t enableDisable(int handle, bool enabled, nsecs_t samplingPeriodNs,
     57                                    nsecs_t maxBatchReportLatencyNs, int reservedFlags)
     58     {
     59         Parcel data, reply;
     60         data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
     61         data.writeInt32(handle);
     62         data.writeInt32(enabled);
     63         data.writeInt64(samplingPeriodNs);
     64         data.writeInt64(maxBatchReportLatencyNs);
     65         data.writeInt32(reservedFlags);
     66         remote()->transact(ENABLE_DISABLE, data, &reply);
     67         return reply.readInt32();
     68     }
     69 
     70     virtual status_t setEventRate(int handle, nsecs_t ns)
     71     {
     72         Parcel data, reply;
     73         data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
     74         data.writeInt32(handle);
     75         data.writeInt64(ns);
     76         remote()->transact(SET_EVENT_RATE, data, &reply);
     77         return reply.readInt32();
     78     }
     79 
     80     virtual status_t flush() {
     81         Parcel data, reply;
     82         data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
     83         remote()->transact(FLUSH_SENSOR, data, &reply);
     84         return reply.readInt32();
     85     }
     86 };
     87 
     88 IMPLEMENT_META_INTERFACE(SensorEventConnection, "android.gui.SensorEventConnection");
     89 
     90 // ----------------------------------------------------------------------------
     91 
     92 status_t BnSensorEventConnection::onTransact(
     93     uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
     94 {
     95     switch(code) {
     96         case GET_SENSOR_CHANNEL: {
     97             CHECK_INTERFACE(ISensorEventConnection, data, reply);
     98             sp<BitTube> channel(getSensorChannel());
     99             channel->writeToParcel(reply);
    100             return NO_ERROR;
    101         } break;
    102         case ENABLE_DISABLE: {
    103             CHECK_INTERFACE(ISensorEventConnection, data, reply);
    104             int handle = data.readInt32();
    105             int enabled = data.readInt32();
    106             nsecs_t samplingPeriodNs = data.readInt64();
    107             nsecs_t maxBatchReportLatencyNs = data.readInt64();
    108             int reservedFlags = data.readInt32();
    109             status_t result = enableDisable(handle, enabled, samplingPeriodNs,
    110                                             maxBatchReportLatencyNs, reservedFlags);
    111             reply->writeInt32(result);
    112             return NO_ERROR;
    113         } break;
    114         case SET_EVENT_RATE: {
    115             CHECK_INTERFACE(ISensorEventConnection, data, reply);
    116             int handle = data.readInt32();
    117             int ns = data.readInt64();
    118             status_t result = setEventRate(handle, ns);
    119             reply->writeInt32(result);
    120             return NO_ERROR;
    121         } break;
    122         case FLUSH_SENSOR: {
    123             CHECK_INTERFACE(ISensorEventConnection, data, reply);
    124             status_t result = flush();
    125             reply->writeInt32(result);
    126             return NO_ERROR;
    127         } break;
    128     }
    129     return BBinder::onTransact(code, data, reply, flags);
    130 }
    131 
    132 // ----------------------------------------------------------------------------
    133 }; // namespace android
    134