Home | History | Annotate | Download | only in camera2 
      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 "CameraRequest"
     20 #include <utils/Log.h>
     21 
     22 #include <camera/camera2/CaptureRequest.h>
     23 
     24 #include <binder/Parcel.h>
     25 #include <gui/Surface.h>
     26 
     27 namespace android {
     28 
     29 status_t CaptureRequest::readFromParcel(Parcel* parcel) {
     30     if (parcel == NULL) {
     31         ALOGE("%s: Null parcel", __FUNCTION__);
     32         return BAD_VALUE;
     33     }
     34 
     35     mMetadata.clear();
     36     mSurfaceList.clear();
     37 
     38     status_t err;
     39 
     40     if ((err = mMetadata.readFromParcel(parcel)) != OK) {
     41         ALOGE("%s: Failed to read metadata from parcel", __FUNCTION__);
     42         return err;
     43     }
     44     ALOGV("%s: Read metadata from parcel", __FUNCTION__);
     45 
     46     int32_t size;
     47     if ((err = parcel->readInt32(&size)) != OK) {
     48         ALOGE("%s: Failed to read surface list size from parcel", __FUNCTION__);
     49         return err;
     50     }
     51     ALOGV("%s: Read surface list size = %d", __FUNCTION__, size);
     52 
     53     // Do not distinguish null arrays from 0-sized arrays.
     54     for (int i = 0; i < size; ++i) {
     55         // Parcel.writeParcelableArray
     56         size_t len;
     57         const char16_t* className = parcel->readString16Inplace(&len);
     58         ALOGV("%s: Read surface class = %s", __FUNCTION__,
     59               className != NULL ? String8(className).string() : "<null>");
     60 
     61         if (className == NULL) {
     62             continue;
     63         }
     64 
     65         // Surface.writeToParcel
     66         String16 name = parcel->readString16();
     67         ALOGV("%s: Read surface name = %s",
     68               __FUNCTION__, String8(name).string());
     69         sp<IBinder> binder(parcel->readStrongBinder());
     70         ALOGV("%s: Read surface binder = %p",
     71               __FUNCTION__, binder.get());
     72 
     73         sp<Surface> surface;
     74 
     75         if (binder != NULL) {
     76             sp<IGraphicBufferProducer> gbp =
     77                     interface_cast<IGraphicBufferProducer>(binder);
     78             surface = new Surface(gbp);
     79         }
     80 
     81         mSurfaceList.push_back(surface);
     82     }
     83 
     84     return OK;
     85 }
     86 
     87 status_t CaptureRequest::writeToParcel(Parcel* parcel) const {
     88     if (parcel == NULL) {
     89         ALOGE("%s: Null parcel", __FUNCTION__);
     90         return BAD_VALUE;
     91     }
     92 
     93     status_t err;
     94 
     95     if ((err = mMetadata.writeToParcel(parcel)) != OK) {
     96         return err;
     97     }
     98 
     99     int32_t size = static_cast<int32_t>(mSurfaceList.size());
    100 
    101     // Send 0-sized arrays when it's empty. Do not send null arrays.
    102     parcel->writeInt32(size);
    103 
    104     for (int32_t i = 0; i < size; ++i) {
    105         sp<Surface> surface = mSurfaceList[i];
    106 
    107         sp<IBinder> binder;
    108         if (surface != 0) {
    109             binder = surface->getIGraphicBufferProducer()->asBinder();
    110         }
    111 
    112         // not sure if readParcelableArray does this, hard to tell from source
    113         parcel->writeString16(String16("android.view.Surface"));
    114 
    115         // Surface.writeToParcel
    116         parcel->writeString16(String16("unknown_name"));
    117         // Surface.nativeWriteToParcel
    118         parcel->writeStrongBinder(binder);
    119     }
    120 
    121     return OK;
    122 }
    123 
    124 }; // namespace android
    125