camera/IProCameraUser.cpp

   1 /*
   2 **
   3 ** Copyright 2013, The Android Open Source Project
   4 **
   5 ** Licensed under the Apache License, Version 2.0 (the "License");
   6 ** you may not use this file except in compliance with the License.
   7 ** You may obtain a copy of the License at
   8 **
   9 **     http://www.apache.org/licenses/LICENSE-2.0
  10 **
  11 ** Unless required by applicable law or agreed to in writing, software
  12 ** distributed under the License is distributed on an "AS IS" BASIS,
  13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 ** See the License for the specific language governing permissions and
  15 ** limitations under the License.
  16 */
  17
  18 // #define LOG_NDEBUG 0
  19 #define LOG_TAG "IProCameraUser"
  20 #include <utils/Log.h>
  21 #include <stdint.h>
  22 #include <sys/types.h>
  23 #include <binder/Parcel.h>
  24 #include <camera/IProCameraUser.h>
  25 #include <gui/IGraphicBufferProducer.h>
  26 #include <gui/Surface.h>
  27 #include "camera/CameraMetadata.h"
  28
  29 namespace android {
  30
  31 enum {
  32     DISCONNECT = IBinder::FIRST_CALL_TRANSACTION,
  33     CONNECT,
  34     EXCLUSIVE_TRY_LOCK,
  35     EXCLUSIVE_LOCK,
  36     EXCLUSIVE_UNLOCK,
  37     HAS_EXCLUSIVE_LOCK,
  38     SUBMIT_REQUEST,
  39     CANCEL_REQUEST,
  40     DELETE_STREAM,
  41     CREATE_STREAM,
  42     CREATE_DEFAULT_REQUEST,
  43     GET_CAMERA_INFO,
  44 };
  45
  46 class BpProCameraUser: public BpInterface<IProCameraUser>
  47 {
  48 public:
  49     BpProCameraUser(const sp<IBinder>& impl)
  50         : BpInterface<IProCameraUser>(impl)
  51     {
  52     }
  53
  54     // disconnect from camera service
  55     void disconnect()
  56     {
  57         ALOGV("disconnect");
  58         Parcel data, reply;
  59         data.writeInterfaceToken(IProCameraUser::getInterfaceDescriptor());
  60         remote()->transact(DISCONNECT, data, &reply);
  61         reply.readExceptionCode();
  62     }
  63
  64     virtual status_t connect(const sp<IProCameraCallbacks>& cameraClient)
  65     {
  66         Parcel data, reply;
  67         data.writeInterfaceToken(IProCameraUser::getInterfaceDescriptor());
  68         data.writeStrongBinder(cameraClient->asBinder());
  69         remote()->transact(CONNECT, data, &reply);
  70         return reply.readInt32();
  71     }
  72
  73     /* Shared ProCameraUser */
  74
  75     virtual status_t exclusiveTryLock()
  76     {
  77         Parcel data, reply;
  78         data.writeInterfaceToken(IProCameraUser::getInterfaceDescriptor());
  79         remote()->transact(EXCLUSIVE_TRY_LOCK, data, &reply);
  80         return reply.readInt32();
  81     }
  82     virtual status_t exclusiveLock()
  83     {
  84         Parcel data, reply;
  85         data.writeInterfaceToken(IProCameraUser::getInterfaceDescriptor());
  86         remote()->transact(EXCLUSIVE_LOCK, data, &reply);
  87         return reply.readInt32();
  88     }
  89
  90     virtual status_t exclusiveUnlock()
  91     {
  92         Parcel data, reply;
  93         data.writeInterfaceToken(IProCameraUser::getInterfaceDescriptor());
  94         remote()->transact(EXCLUSIVE_UNLOCK, data, &reply);
  95         return reply.readInt32();
  96     }
  97
  98     virtual bool hasExclusiveLock()
  99     {
 100         Parcel data, reply;
 101         data.writeInterfaceToken(IProCameraUser::getInterfaceDescriptor());
 102         remote()->transact(HAS_EXCLUSIVE_LOCK, data, &reply);
 103         return !!reply.readInt32();
 104     }
 105
 106     virtual int submitRequest(camera_metadata_t* metadata, bool streaming)
 107     {
 108
 109         Parcel data, reply;
 110         data.writeInterfaceToken(IProCameraUser::getInterfaceDescriptor());
 111
 112         // arg0+arg1
 113         CameraMetadata::writeToParcel(data, metadata);
 114
 115         // arg2 = streaming (bool)
 116         data.writeInt32(streaming);
 117
 118         remote()->transact(SUBMIT_REQUEST, data, &reply);
 119         return reply.readInt32();
 120     }
 121
 122     virtual status_t cancelRequest(int requestId)
 123     {
 124         Parcel data, reply;
 125         data.writeInterfaceToken(IProCameraUser::getInterfaceDescriptor());
 126         data.writeInt32(requestId);
 127
 128         remote()->transact(CANCEL_REQUEST, data, &reply);
 129         return reply.readInt32();
 130     }
 131
 132     virtual status_t deleteStream(int streamId)
 133     {
 134         Parcel data, reply;
 135         data.writeInterfaceToken(IProCameraUser::getInterfaceDescriptor());
 136         data.writeInt32(streamId);
 137
 138         remote()->transact(DELETE_STREAM, data, &reply);
 139         return reply.readInt32();
 140     }
 141
 142     virtual status_t createStream(int width, int height, int format,
 143                           const sp<IGraphicBufferProducer>& bufferProducer,
 144                           /*out*/
 145                           int* streamId)
 146     {
 147         Parcel data, reply;
 148         data.writeInterfaceToken(IProCameraUser::getInterfaceDescriptor());
 149         data.writeInt32(width);
 150         data.writeInt32(height);
 151         data.writeInt32(format);
 152
 153         sp<IBinder> b(bufferProducer->asBinder());
 154         data.writeStrongBinder(b);
 155
 156         remote()->transact(CREATE_STREAM, data, &reply);
 157
 158         int sId = reply.readInt32();
 159         if (streamId) {
 160             *streamId = sId;
 161         }
 162         return reply.readInt32();
 163     }
 164
 165     // Create a request object from a template.
 166     virtual status_t createDefaultRequest(int templateId,
 167                                  /*out*/
 168                                   camera_metadata** request)
 169     {
 170         Parcel data, reply;
 171         data.writeInterfaceToken(IProCameraUser::getInterfaceDescriptor());
 172         data.writeInt32(templateId);
 173         remote()->transact(CREATE_DEFAULT_REQUEST, data, &reply);
 174         CameraMetadata::readFromParcel(reply, /*out*/request);
 175         return reply.readInt32();
 176     }
 177
 178
 179     virtual status_t getCameraInfo(int cameraId, camera_metadata** info)
 180     {
 181         Parcel data, reply;
 182         data.writeInterfaceToken(IProCameraUser::getInterfaceDescriptor());
 183         data.writeInt32(cameraId);
 184         remote()->transact(GET_CAMERA_INFO, data, &reply);
 185         CameraMetadata::readFromParcel(reply, /*out*/info);
 186         return reply.readInt32();
 187     }
 188
 189
 190 private:
 191
 192
 193 };
 194
 195 IMPLEMENT_META_INTERFACE(ProCameraUser, "android.hardware.IProCameraUser");
 196
 197 // ----------------------------------------------------------------------
 198
 199 status_t BnProCameraUser::onTransact(
 200     uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
 201 {
 202     switch(code) {
 203         case DISCONNECT: {
 204             ALOGV("DISCONNECT");
 205             CHECK_INTERFACE(IProCameraUser, data, reply);
 206             disconnect();
 207             reply->writeNoException();
 208             return NO_ERROR;
 209         } break;
 210         case CONNECT: {
 211             CHECK_INTERFACE(IProCameraUser, data, reply);
 212             sp<IProCameraCallbacks> cameraClient =
 213                    interface_cast<IProCameraCallbacks>(data.readStrongBinder());
 214             reply->writeInt32(connect(cameraClient));
 215             return NO_ERROR;
 216         } break;
 217
 218         /* Shared ProCameraUser */
 219         case EXCLUSIVE_TRY_LOCK: {
 220             CHECK_INTERFACE(IProCameraUser, data, reply);
 221             reply->writeInt32(exclusiveTryLock());
 222             return NO_ERROR;
 223         } break;
 224         case EXCLUSIVE_LOCK: {
 225             CHECK_INTERFACE(IProCameraUser, data, reply);
 226             reply->writeInt32(exclusiveLock());
 227             return NO_ERROR;
 228         } break;
 229         case EXCLUSIVE_UNLOCK: {
 230             CHECK_INTERFACE(IProCameraUser, data, reply);
 231             reply->writeInt32(exclusiveUnlock());
 232             return NO_ERROR;
 233         } break;
 234         case HAS_EXCLUSIVE_LOCK: {
 235             CHECK_INTERFACE(IProCameraUser, data, reply);
 236             reply->writeInt32(hasExclusiveLock());
 237             return NO_ERROR;
 238         } break;
 239         case SUBMIT_REQUEST: {
 240             CHECK_INTERFACE(IProCameraUser, data, reply);
 241             camera_metadata_t* metadata;
 242             CameraMetadata::readFromParcel(data, /*out*/&metadata);
 243
 244             // arg2 = streaming (bool)
 245             bool streaming = data.readInt32();
 246
 247             // return code: requestId (int32)
 248             reply->writeInt32(submitRequest(metadata, streaming));
 249
 250             return NO_ERROR;
 251         } break;
 252         case CANCEL_REQUEST: {
 253             CHECK_INTERFACE(IProCameraUser, data, reply);
 254             int requestId = data.readInt32();
 255             reply->writeInt32(cancelRequest(requestId));
 256             return NO_ERROR;
 257         } break;
 258         case DELETE_STREAM: {
 259             CHECK_INTERFACE(IProCameraUser, data, reply);
 260             int streamId = data.readInt32();
 261             reply->writeInt32(deleteStream(streamId));
 262             return NO_ERROR;
 263         } break;
 264         case CREATE_STREAM: {
 265             CHECK_INTERFACE(IProCameraUser, data, reply);
 266             int width, height, format;
 267
 268             width = data.readInt32();
 269             height = data.readInt32();
 270             format = data.readInt32();
 271
 272             sp<IGraphicBufferProducer> bp =
 273                interface_cast<IGraphicBufferProducer>(data.readStrongBinder());
 274
 275             int streamId = -1;
 276             status_t ret;
 277             ret = createStream(width, height, format, bp, &streamId);
 278
 279             reply->writeInt32(streamId);
 280             reply->writeInt32(ret);
 281
 282             return NO_ERROR;
 283         } break;
 284
 285         case CREATE_DEFAULT_REQUEST: {
 286             CHECK_INTERFACE(IProCameraUser, data, reply);
 287
 288             int templateId = data.readInt32();
 289
 290             camera_metadata_t* request = NULL;
 291             status_t ret;
 292             ret = createDefaultRequest(templateId, &request);
 293
 294             CameraMetadata::writeToParcel(*reply, request);
 295             reply->writeInt32(ret);
 296
 297             free_camera_metadata(request);
 298
 299             return NO_ERROR;
 300         } break;
 301         case GET_CAMERA_INFO: {
 302             CHECK_INTERFACE(IProCameraUser, data, reply);
 303
 304             int cameraId = data.readInt32();
 305
 306             camera_metadata_t* info = NULL;
 307             status_t ret;
 308             ret = getCameraInfo(cameraId, &info);
 309
 310             CameraMetadata::writeToParcel(*reply, info);
 311             reply->writeInt32(ret);
 312
 313             free_camera_metadata(info);
 314
 315             return NO_ERROR;
 316         } break;
 317         default:
 318             return BBinder::onTransact(code, data, reply, flags);
 319     }
 320 }
 321
 322 // ----------------------------------------------------------------------------
 323
 324 }; // namespace android