android/BpAndroidShm.cpp

   1 #include <binder/Parcel.h>
   2 #include <utils/Log.h>
   3 #include "BpAndroidShm.h"
   4
   5 namespace android{
   6
   7     int BpAndroidShm::sendCommand(const char*command) {
   8         Parcel data, reply;
   9         data.writeInterfaceToken(
  10                 IAndroidShm::getInterfaceDescriptor());
  11         data.writeCString(command);
  12         status_t status = remote()->transact(HW_SENDCOMMAND, data, &reply);
  13         if(status != NO_ERROR) {
  14             ALOGE("print sendCommand error: %s", strerror(-status));
  15         } else {
  16             status= reply.readInt32();
  17         }
  18         return status;
  19     }
  20
  21     sp<IMemoryHeap> BpAndroidShm::getBuffer(int index) {
  22         Parcel data, reply;
  23         sp<IMemoryHeap> memHeap = NULL;
  24         data.writeInterfaceToken(IAndroidShm::getInterfaceDescriptor());
  25         data.writeInt32(index);
  26         remote()->transact(HW_GETBUFFER, data, &reply);
  27         memHeap = interface_cast<IMemoryHeap> (reply.readStrongBinder());
  28         return memHeap;
  29     }
  30
  31     BpAndroidShm::BpAndroidShm( const sp<IBinder>& impl)
  32         : BpInterface<IAndroidShm>(impl)
  33     {}
  34
  35     BpAndroidShm::~BpAndroidShm()
  36     {}
  37
  38     int BpAndroidShm::allocShm(const int size) { // if negative return value is error
  39         Parcel data, reply;
  40         data.writeInterfaceToken(IAndroidShm::getInterfaceDescriptor());
  41         data.writeInt32(size);
  42         status_t status = remote()->transact(HW_ALLOC_SHM, data, &reply);
  43         if(status != NO_ERROR) {
  44             ALOGE("print allocShm error: %s", strerror(-status));
  45         } else {
  46             status= reply.readInt32();
  47         }
  48         return status;
  49     }
  50
  51     int BpAndroidShm::removeShm(const unsigned int index) { // shared memory Á¦°Å
  52         Parcel data, reply;
  53         data.writeInterfaceToken(IAndroidShm::getInterfaceDescriptor());
  54         data.writeInt32(index);
  55         status_t status = remote()->transact(HW_REMOVE_SHM, data, &reply);
  56         if(status != NO_ERROR) {
  57             ALOGE("print removeShm error: %s", strerror(-status));
  58         } else {
  59             status= reply.readInt32();
  60         }
  61         return status;
  62     }
  63
  64     int BpAndroidShm::isAllocated(const unsigned int index) { // allocated ¿©ºÎ È®ÀÎ
  65         Parcel data, reply;
  66         data.writeInterfaceToken(IAndroidShm::getInterfaceDescriptor());
  67         data.writeInt32(index);
  68         status_t status = remote()->transact(HW_IS_ALLOCATED, data, &reply);
  69         if(status != NO_ERROR) {
  70             ALOGE("print isAllocated error: %s", strerror(-status));
  71         } else {
  72             status= reply.readInt32();
  73         }
  74         return status;
  75     }
  76
  77     int BpAndroidShm::setRegistryIndex(const unsigned int index) {
  78         Parcel data, reply;
  79         data.writeInterfaceToken(IAndroidShm::getInterfaceDescriptor());
  80         data.writeInt32(index);
  81         status_t status = remote()->transact(HW_SET_REGISTRY_INDEX, data, &reply);
  82         if(status != NO_ERROR) {
  83             ALOGE("print setRegistryIndex error: %s", strerror(-status));
  84         } else {
  85             status= reply.readInt32();
  86         }
  87         return status;
  88     }
  89
  90     int BpAndroidShm::getRegistryIndex() {
  91         Parcel data, reply;
  92         data.writeInterfaceToken(IAndroidShm::getInterfaceDescriptor());
  93         status_t status = remote()->transact(HW_GET_REGISTRY_INDEX, data, &reply);
  94         if(status != NO_ERROR) {
  95             ALOGE("print getRegistryIndex error: %s", strerror(-status));
  96         } else {
  97             status= reply.readInt32();
  98         }
  99         return status;
 100     }
 101
 102     sp<IMemoryHeap> BpAndroidShm::InitSemaphore(const char* name) {
 103         Parcel data, reply;
 104         sp<IMemoryHeap> memHeap = NULL;
 105         data.writeInterfaceToken(IAndroidShm::getInterfaceDescriptor());
 106         data.writeCString(name);
 107         status_t status = remote()->transact(HW_INIT_SEMAPHORE, data, &reply);
 108         memHeap = interface_cast<IMemoryHeap> (reply.readStrongBinder());
 109         return memHeap;
 110     }
 111 };