resolved conflicts for merge of 364a2677 to master

Change-Id: I21f23c1c5e4408c24c359bef6270dffce47a988d

diff --cc services/camera/libcameraservice/Camera2Client.cpp
index a94c658,16688cf..96bde90
--- 1/services/camera/libcameraservice/Camera2Client.cpp
--- 2/services/camera/libcameraservice/Camera2Client.cpp
+++ b/services/camera/libcameraservice/Camera2Client.cpp
@@@ -600,94 -631,20 +615,85 @@@ void Camera2Client::setPreviewCallbackF
          params.previewCallbackOneShot = true;
      }
      if (params.previewCallbackFlags != (uint32_t)flag) {
 +
 +        if (flag != CAMERA_FRAME_CALLBACK_FLAG_NOOP) {
 +            // Disable any existing preview callback window when enabling
 +            // preview callback flags
 +            res = mCallbackProcessor->setCallbackWindow(NULL);
 +            if (res != OK) {
 +                ALOGE("%s: Camera %d: Unable to clear preview callback surface:"
 +                        " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
 +                return;
 +            }
 +            params.previewCallbackSurface = false;
 +        }
 +
          params.previewCallbackFlags = flag;
  
-         switch(params.state) {
-             case Parameters::PREVIEW:
-                 res = startPreviewL(params, true);
-                 break;
-             case Parameters::RECORD:
-             case Parameters::VIDEO_SNAPSHOT:
-                 res = startRecordingL(params, true);
-                 break;
-             default:
-                 break;
-         }
-         if (res != OK) {
-             ALOGE("%s: Camera %d: Unable to refresh request in state %s",
-                     __FUNCTION__, mCameraId,
-                     Parameters::getStateName(params.state));
+         if (params.state == Parameters::PREVIEW) {
+             res = startPreviewL(params, true);
+             if (res != OK) {
+                 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
+                         __FUNCTION__, mCameraId,
+                         Parameters::getStateName(params.state));
+             }
          }
      }
- 
 +}
 +
 +status_t Camera2Client::setPreviewCallbackTarget(
 +        const sp<IGraphicBufferProducer>& callbackProducer) {
 +    ATRACE_CALL();
 +    ALOGV("%s: E", __FUNCTION__);
 +    Mutex::Autolock icl(mBinderSerializationLock);
 +    status_t res;
 +    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
 +
 +    sp<ANativeWindow> window;
 +    if (callbackProducer != 0) {
 +        window = new Surface(callbackProducer);
 +    }
  
 +    res = mCallbackProcessor->setCallbackWindow(window);
 +    if (res != OK) {
 +        ALOGE("%s: Camera %d: Unable to set preview callback surface: %s (%d)",
 +                __FUNCTION__, mCameraId, strerror(-res), res);
 +        return res;
 +    }
 +
 +    SharedParameters::Lock l(mParameters);
 +
 +    if (window != NULL) {
 +        // Disable traditional callbacks when a valid callback target is given
 +        l.mParameters.previewCallbackFlags = CAMERA_FRAME_CALLBACK_FLAG_NOOP;
 +        l.mParameters.previewCallbackOneShot = false;
 +        l.mParameters.previewCallbackSurface = true;
 +    } else {
 +        // Disable callback target if given a NULL interface.
 +        l.mParameters.previewCallbackSurface = false;
 +    }
 +
 +    switch(l.mParameters.state) {
 +        case Parameters::PREVIEW:
 +            res = startPreviewL(l.mParameters, true);
 +            break;
 +        case Parameters::RECORD:
 +        case Parameters::VIDEO_SNAPSHOT:
 +            res = startRecordingL(l.mParameters, true);
 +            break;
 +        default:
 +            break;
 +    }
 +    if (res != OK) {
 +        ALOGE("%s: Camera %d: Unable to refresh request in state %s",
 +                __FUNCTION__, mCameraId,
 +                Parameters::getStateName(l.mParameters.state));
 +    }
 +
 +    return OK;
  }
  
 +
  status_t Camera2Client::startPreview() {
      ATRACE_CALL();
      ALOGV("%s: E", __FUNCTION__);
@@@ -750,11 -707,29 +756,31 @@@ status_t Camera2Client::startPreviewL(P
      }
  
      Vector<uint8_t> outputStreams;
 -    bool callbacksEnabled = params.previewCallbackFlags &
 -        CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
 +    bool callbacksEnabled = (params.previewCallbackFlags &
 +            CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) ||
 +            params.previewCallbackSurface;
 +
      if (callbacksEnabled) {
+         // Can't have recording stream hanging around when enabling callbacks,
+         // since it exceeds the max stream count on some devices.
+         if (mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
+             ALOGV("%s: Camera %d: Clearing out recording stream before "
+                     "creating callback stream", __FUNCTION__, mCameraId);
+             res = mStreamingProcessor->stopStream();
+             if (res != OK) {
+                 ALOGE("%s: Camera %d: Can't stop streaming to delete "
+                         "recording stream", __FUNCTION__, mCameraId);
+                 return res;
+             }
+             res = mStreamingProcessor->deleteRecordingStream();
+             if (res != OK) {
+                 ALOGE("%s: Camera %d: Unable to delete recording stream before "
+                         "enabling callbacks: %s (%d)", __FUNCTION__, mCameraId,
+                         strerror(-res), res);
+                 return res;
+             }
+         }
+ 
          res = mCallbackProcessor->updateStream(params);
          if (res != OK) {
              ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",

diff --cc services/camera/libcameraservice/camera2/CallbackProcessor.cpp
index bc81409,522f49a..aae2504
--- 1/services/camera/libcameraservice/camera2/CallbackProcessor.cpp
--- 2/services/camera/libcameraservice/camera2/CallbackProcessor.cpp
+++ b/services/camera/libcameraservice/camera2/CallbackProcessor.cpp
@@@ -107,9 -73,11 +107,11 @@@ status_t CallbackProcessor::updateStrea
          callbackFormat = HAL_PIXEL_FORMAT_YCbCr_420_888;
      }
  
 -    if (mCallbackConsumer == 0) {
 -        // Create CPU buffer queue endpoint. Make it async to avoid disconnect
 -        // deadlocks.
 +    if (!mCallbackToApp && mCallbackConsumer == 0) {
 +        // Create CPU buffer queue endpoint, since app hasn't given us one
-         mCallbackConsumer = new CpuConsumer(kCallbackHeapCount);
++        // Make it async to avoid disconnect deadlocks
+         mCallbackConsumer = new CpuConsumer(kCallbackHeapCount,
+                 /*synchronized*/ false);
          mCallbackConsumer->setFrameAvailableListener(this);
          mCallbackConsumer->setName(String8("Camera2Client::CallbackConsumer"));
          mCallbackWindow = new Surface(