Camera2Client.cpp revision 6706009fa8294c8cdab1cdab4585f00d42df483e 
1/*
2 * Copyright (C) 2012 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#define LOG_TAG "Camera2Client"
18#define ATRACE_TAG ATRACE_TAG_CAMERA
19//#define LOG_NDEBUG 0
20
21#include <utils/Log.h>
22#include <utils/Trace.h>
23
24#include <cutils/properties.h>
25#include <gui/Surface.h>
26
27#include "api1/Camera2Client.h"
28
29#include "api1/client2/StreamingProcessor.h"
30#include "api1/client2/JpegProcessor.h"
31#include "api1/client2/CaptureSequencer.h"
32#include "api1/client2/CallbackProcessor.h"
33#include "api1/client2/ZslProcessor.h"
34#include "api1/client2/ZslProcessor3.h"
35
36#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
37#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
38
39namespace android {
40using namespace camera2;
41
42static int getCallingPid() {
43    return IPCThreadState::self()->getCallingPid();
44}
45
46// Interface used by CameraService
47
48Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
49        const sp<ICameraClient>& cameraClient,
50        const String16& clientPackageName,
51        int cameraId,
52        int cameraFacing,
53        int clientPid,
54        uid_t clientUid,
55        int servicePid,
56        int deviceVersion):
57        Camera2ClientBase(cameraService, cameraClient, clientPackageName,
58                cameraId, cameraFacing, clientPid, clientUid, servicePid),
59        mParameters(cameraId, cameraFacing),
60        mDeviceVersion(deviceVersion)
61{
62    ATRACE_CALL();
63
64    SharedParameters::Lock l(mParameters);
65    l.mParameters.state = Parameters::DISCONNECTED;
66}
67
68status_t Camera2Client::initialize(camera_module_t *module)
69{
70    ATRACE_CALL();
71    ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
72    status_t res;
73
74    res = Camera2ClientBase::initialize(module);
75    if (res != OK) {
76        return res;
77    }
78
79    {
80        SharedParameters::Lock l(mParameters);
81
82        res = l.mParameters.initialize(&(mDevice->info()));
83        if (res != OK) {
84            ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
85                    __FUNCTION__, mCameraId, strerror(-res), res);
86            return NO_INIT;
87        }
88    }
89
90    String8 threadName;
91
92    mStreamingProcessor = new StreamingProcessor(this);
93    threadName = String8::format("C2-%d-StreamProc",
94            mCameraId);
95    mStreamingProcessor->run(threadName.string());
96
97    mFrameProcessor = new FrameProcessor(mDevice, this);
98    threadName = String8::format("C2-%d-FrameProc",
99            mCameraId);
100    mFrameProcessor->run(threadName.string());
101
102    mCaptureSequencer = new CaptureSequencer(this);
103    threadName = String8::format("C2-%d-CaptureSeq",
104            mCameraId);
105    mCaptureSequencer->run(threadName.string());
106
107    mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
108    threadName = String8::format("C2-%d-JpegProc",
109            mCameraId);
110    mJpegProcessor->run(threadName.string());
111
112    switch (mDeviceVersion) {
113        case CAMERA_DEVICE_API_VERSION_2_0: {
114            sp<ZslProcessor> zslProc =
115                    new ZslProcessor(this, mCaptureSequencer);
116            mZslProcessor = zslProc;
117            mZslProcessorThread = zslProc;
118            break;
119        }
120        case CAMERA_DEVICE_API_VERSION_3_0:{
121            sp<ZslProcessor3> zslProc =
122                    new ZslProcessor3(this, mCaptureSequencer);
123            mZslProcessor = zslProc;
124            mZslProcessorThread = zslProc;
125            break;
126        }
127        default:
128            break;
129    }
130    threadName = String8::format("C2-%d-ZslProc",
131            mCameraId);
132    mZslProcessorThread->run(threadName.string());
133
134    mCallbackProcessor = new CallbackProcessor(this);
135    threadName = String8::format("C2-%d-CallbkProc",
136            mCameraId);
137    mCallbackProcessor->run(threadName.string());
138
139    if (gLogLevel >= 1) {
140        SharedParameters::Lock l(mParameters);
141        ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
142              mCameraId);
143        ALOGD("%s", l.mParameters.paramsFlattened.string());
144    }
145
146    return OK;
147}
148
149Camera2Client::~Camera2Client() {
150    ATRACE_CALL();
151    ALOGV("~Camera2Client");
152
153    mDestructionStarted = true;
154
155    disconnect();
156
157    ALOGI("Camera %d: Closed", mCameraId);
158}
159
160status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
161    String8 result;
162    result.appendFormat("Client2[%d] (%p) Client: %s PID: %d, dump:\n",
163            mCameraId,
164            getRemoteCallback()->asBinder().get(),
165            String8(mClientPackageName).string(),
166            mClientPid);
167    result.append("  State: ");
168#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
169
170    const Parameters& p = mParameters.unsafeAccess();
171
172    result.append(Parameters::getStateName(p.state));
173
174    result.append("\n  Current parameters:\n");
175    result.appendFormat("    Preview size: %d x %d\n",
176            p.previewWidth, p.previewHeight);
177    result.appendFormat("    Preview FPS range: %d - %d\n",
178            p.previewFpsRange[0], p.previewFpsRange[1]);
179    result.appendFormat("    Preview HAL pixel format: 0x%x\n",
180            p.previewFormat);
181    result.appendFormat("    Preview transform: %x\n",
182            p.previewTransform);
183    result.appendFormat("    Picture size: %d x %d\n",
184            p.pictureWidth, p.pictureHeight);
185    result.appendFormat("    Jpeg thumbnail size: %d x %d\n",
186            p.jpegThumbSize[0], p.jpegThumbSize[1]);
187    result.appendFormat("    Jpeg quality: %d, thumbnail quality: %d\n",
188            p.jpegQuality, p.jpegThumbQuality);
189    result.appendFormat("    Jpeg rotation: %d\n", p.jpegRotation);
190    result.appendFormat("    GPS tags %s\n",
191            p.gpsEnabled ? "enabled" : "disabled");
192    if (p.gpsEnabled) {
193        result.appendFormat("    GPS lat x long x alt: %f x %f x %f\n",
194                p.gpsCoordinates[0], p.gpsCoordinates[1],
195                p.gpsCoordinates[2]);
196        result.appendFormat("    GPS timestamp: %lld\n",
197                p.gpsTimestamp);
198        result.appendFormat("    GPS processing method: %s\n",
199                p.gpsProcessingMethod.string());
200    }
201
202    result.append("    White balance mode: ");
203    switch (p.wbMode) {
204        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_AUTO)
205        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_INCANDESCENT)
206        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_FLUORESCENT)
207        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT)
208        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_DAYLIGHT)
209        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT)
210        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_TWILIGHT)
211        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_SHADE)
212        default: result.append("UNKNOWN\n");
213    }
214
215    result.append("    Effect mode: ");
216    switch (p.effectMode) {
217        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_OFF)
218        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_MONO)
219        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_NEGATIVE)
220        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SOLARIZE)
221        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SEPIA)
222        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_POSTERIZE)
223        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD)
224        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD)
225        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_AQUA)
226        default: result.append("UNKNOWN\n");
227    }
228
229    result.append("    Antibanding mode: ");
230    switch (p.antibandingMode) {
231        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO)
232        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF)
233        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ)
234        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ)
235        default: result.append("UNKNOWN\n");
236    }
237
238    result.append("    Scene mode: ");
239    switch (p.sceneMode) {
240        case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
241            result.append("AUTO\n"); break;
242        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
243        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
244        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
245        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
246        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
247        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
248        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
249        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
250        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
251        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
252        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
253        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
254        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
255        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
256        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
257        default: result.append("UNKNOWN\n");
258    }
259
260    result.append("    Flash mode: ");
261    switch (p.flashMode) {
262        CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
263        CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
264        CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
265        CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
266        CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
267        CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
268        default: result.append("UNKNOWN\n");
269    }
270
271    result.append("    Focus mode: ");
272    switch (p.focusMode) {
273        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
274        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
275        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
276        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
277        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
278        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
279        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
280        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
281        default: result.append("UNKNOWN\n");
282    }
283
284    result.append("   Focus state: ");
285    switch (p.focusState) {
286        CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_INACTIVE)
287        CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN)
288        CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)
289        CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED)
290        CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN)
291        CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED)
292        CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED)
293        default: result.append("UNKNOWN\n");
294    }
295
296    result.append("    Focusing areas:\n");
297    for (size_t i = 0; i < p.focusingAreas.size(); i++) {
298        result.appendFormat("      [ (%d, %d, %d, %d), weight %d ]\n",
299                p.focusingAreas[i].left,
300                p.focusingAreas[i].top,
301                p.focusingAreas[i].right,
302                p.focusingAreas[i].bottom,
303                p.focusingAreas[i].weight);
304    }
305
306    result.appendFormat("    Exposure compensation index: %d\n",
307            p.exposureCompensation);
308
309    result.appendFormat("    AE lock %s, AWB lock %s\n",
310            p.autoExposureLock ? "enabled" : "disabled",
311            p.autoWhiteBalanceLock ? "enabled" : "disabled" );
312
313    result.appendFormat("    Metering areas:\n");
314    for (size_t i = 0; i < p.meteringAreas.size(); i++) {
315        result.appendFormat("      [ (%d, %d, %d, %d), weight %d ]\n",
316                p.meteringAreas[i].left,
317                p.meteringAreas[i].top,
318                p.meteringAreas[i].right,
319                p.meteringAreas[i].bottom,
320                p.meteringAreas[i].weight);
321    }
322
323    result.appendFormat("    Zoom index: %d\n", p.zoom);
324    result.appendFormat("    Video size: %d x %d\n", p.videoWidth,
325            p.videoHeight);
326
327    result.appendFormat("    Recording hint is %s\n",
328            p.recordingHint ? "set" : "not set");
329
330    result.appendFormat("    Video stabilization is %s\n",
331            p.videoStabilization ? "enabled" : "disabled");
332
333    result.appendFormat("    Selected still capture FPS range: %d - %d\n",
334            p.fastInfo.bestStillCaptureFpsRange[0],
335            p.fastInfo.bestStillCaptureFpsRange[1]);
336
337    result.append("  Current streams:\n");
338    result.appendFormat("    Preview stream ID: %d\n",
339            getPreviewStreamId());
340    result.appendFormat("    Capture stream ID: %d\n",
341            getCaptureStreamId());
342    result.appendFormat("    Recording stream ID: %d\n",
343            getRecordingStreamId());
344
345    result.append("  Quirks for this camera:\n");
346    bool haveQuirk = false;
347    if (p.quirks.triggerAfWithAuto) {
348        result.appendFormat("    triggerAfWithAuto\n");
349        haveQuirk = true;
350    }
351    if (p.quirks.useZslFormat) {
352        result.appendFormat("    useZslFormat\n");
353        haveQuirk = true;
354    }
355    if (p.quirks.meteringCropRegion) {
356        result.appendFormat("    meteringCropRegion\n");
357        haveQuirk = true;
358    }
359    if (p.quirks.partialResults) {
360        result.appendFormat("    usePartialResult\n");
361        haveQuirk = true;
362    }
363    if (!haveQuirk) {
364        result.appendFormat("    none\n");
365    }
366
367    write(fd, result.string(), result.size());
368
369    mStreamingProcessor->dump(fd, args);
370
371    mCaptureSequencer->dump(fd, args);
372
373    mFrameProcessor->dump(fd, args);
374
375    mZslProcessor->dump(fd, args);
376
377    return dumpDevice(fd, args);
378#undef CASE_APPEND_ENUM
379}
380
381// ICamera interface
382
383void Camera2Client::disconnect() {
384    ATRACE_CALL();
385    Mutex::Autolock icl(mBinderSerializationLock);
386
387    // Allow both client and the media server to disconnect at all times
388    int callingPid = getCallingPid();
389    if (callingPid != mClientPid && callingPid != mServicePid) return;
390
391    if (mDevice == 0) return;
392
393    ALOGV("Camera %d: Shutting down", mCameraId);
394
395    /**
396     * disconnect() cannot call any methods that might need to promote a
397     * wp<Camera2Client>, since disconnect can be called from the destructor, at
398     * which point all such promotions will fail.
399     */
400
401    stopPreviewL();
402
403    {
404        SharedParameters::Lock l(mParameters);
405        if (l.mParameters.state == Parameters::DISCONNECTED) return;
406        l.mParameters.state = Parameters::DISCONNECTED;
407    }
408
409    mStreamingProcessor->requestExit();
410    mFrameProcessor->requestExit();
411    mCaptureSequencer->requestExit();
412    mJpegProcessor->requestExit();
413    mZslProcessorThread->requestExit();
414    mCallbackProcessor->requestExit();
415
416    ALOGV("Camera %d: Waiting for threads", mCameraId);
417
418    mStreamingProcessor->join();
419    mFrameProcessor->join();
420    mCaptureSequencer->join();
421    mJpegProcessor->join();
422    mZslProcessorThread->join();
423    mCallbackProcessor->join();
424
425    ALOGV("Camera %d: Deleting streams", mCameraId);
426
427    mStreamingProcessor->deletePreviewStream();
428    mStreamingProcessor->deleteRecordingStream();
429    mJpegProcessor->deleteStream();
430    mCallbackProcessor->deleteStream();
431    mZslProcessor->deleteStream();
432
433    ALOGV("Camera %d: Disconnecting device", mCameraId);
434
435    mDevice->disconnect();
436
437    mDevice.clear();
438
439    CameraService::Client::disconnect();
440}
441
442status_t Camera2Client::connect(const sp<ICameraClient>& client) {
443    ATRACE_CALL();
444    ALOGV("%s: E", __FUNCTION__);
445    Mutex::Autolock icl(mBinderSerializationLock);
446
447    if (mClientPid != 0 && getCallingPid() != mClientPid) {
448        ALOGE("%s: Camera %d: Connection attempt from pid %d; "
449                "current locked to pid %d", __FUNCTION__,
450                mCameraId, getCallingPid(), mClientPid);
451        return BAD_VALUE;
452    }
453
454    mClientPid = getCallingPid();
455
456    mRemoteCallback = client;
457    mSharedCameraCallbacks = client;
458
459    return OK;
460}
461
462status_t Camera2Client::lock() {
463    ATRACE_CALL();
464    ALOGV("%s: E", __FUNCTION__);
465    Mutex::Autolock icl(mBinderSerializationLock);
466    ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
467            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
468
469    if (mClientPid == 0) {
470        mClientPid = getCallingPid();
471        return OK;
472    }
473
474    if (mClientPid != getCallingPid()) {
475        ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
476                __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
477        return EBUSY;
478    }
479
480    return OK;
481}
482
483status_t Camera2Client::unlock() {
484    ATRACE_CALL();
485    ALOGV("%s: E", __FUNCTION__);
486    Mutex::Autolock icl(mBinderSerializationLock);
487    ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
488            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
489
490    if (mClientPid == getCallingPid()) {
491        SharedParameters::Lock l(mParameters);
492        if (l.mParameters.state == Parameters::RECORD ||
493                l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
494            ALOGD("Not allowed to unlock camera during recording.");
495            return INVALID_OPERATION;
496        }
497        mClientPid = 0;
498        mRemoteCallback.clear();
499        mSharedCameraCallbacks.clear();
500        return OK;
501    }
502
503    ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
504            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
505    return EBUSY;
506}
507
508status_t Camera2Client::setPreviewTarget(
509        const sp<IGraphicBufferProducer>& bufferProducer) {
510    ATRACE_CALL();
511    ALOGV("%s: E", __FUNCTION__);
512    Mutex::Autolock icl(mBinderSerializationLock);
513    status_t res;
514    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
515
516    sp<IBinder> binder;
517    sp<ANativeWindow> window;
518    if (bufferProducer != 0) {
519        binder = bufferProducer->asBinder();
520        // Using controlledByApp flag to ensure that the buffer queue remains in
521        // async mode for the old camera API, where many applications depend
522        // on that behavior.
523        window = new Surface(bufferProducer, /*controlledByApp*/ true);
524    }
525    return setPreviewWindowL(binder, window);
526}
527
528status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
529        sp<ANativeWindow> window) {
530    ATRACE_CALL();
531    status_t res;
532
533    if (binder == mPreviewSurface) {
534        ALOGV("%s: Camera %d: New window is same as old window",
535                __FUNCTION__, mCameraId);
536        return NO_ERROR;
537    }
538
539    Parameters::State state;
540    {
541        SharedParameters::Lock l(mParameters);
542        state = l.mParameters.state;
543    }
544    switch (state) {
545        case Parameters::DISCONNECTED:
546        case Parameters::RECORD:
547        case Parameters::STILL_CAPTURE:
548        case Parameters::VIDEO_SNAPSHOT:
549            ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
550                    __FUNCTION__, mCameraId,
551                    Parameters::getStateName(state));
552            return INVALID_OPERATION;
553        case Parameters::STOPPED:
554        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
555            // OK
556            break;
557        case Parameters::PREVIEW:
558            // Already running preview - need to stop and create a new stream
559            res = stopStream();
560            if (res != OK) {
561                ALOGE("%s: Unable to stop preview to swap windows: %s (%d)",
562                        __FUNCTION__, strerror(-res), res);
563                return res;
564            }
565            state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
566            break;
567    }
568
569    mPreviewSurface = binder;
570    res = mStreamingProcessor->setPreviewWindow(window);
571    if (res != OK) {
572        ALOGE("%s: Unable to set new preview window: %s (%d)",
573                __FUNCTION__, strerror(-res), res);
574        return res;
575    }
576
577    if (state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
578        SharedParameters::Lock l(mParameters);
579        l.mParameters.state = state;
580        return startPreviewL(l.mParameters, false);
581    }
582
583    return OK;
584}
585
586void Camera2Client::setPreviewCallbackFlag(int flag) {
587    ATRACE_CALL();
588    ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
589    Mutex::Autolock icl(mBinderSerializationLock);
590
591    if ( checkPid(__FUNCTION__) != OK) return;
592
593    SharedParameters::Lock l(mParameters);
594    setPreviewCallbackFlagL(l.mParameters, flag);
595}
596
597void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
598    status_t res = OK;
599
600    switch(params.state) {
601        case Parameters::STOPPED:
602        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
603        case Parameters::PREVIEW:
604        case Parameters::STILL_CAPTURE:
605            // OK
606            break;
607        default:
608            if (flag & CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) {
609                ALOGE("%s: Camera %d: Can't use preview callbacks "
610                        "in state %d", __FUNCTION__, mCameraId, params.state);
611                return;
612            }
613    }
614
615    if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
616        ALOGV("%s: setting oneshot", __FUNCTION__);
617        params.previewCallbackOneShot = true;
618    }
619    if (params.previewCallbackFlags != (uint32_t)flag) {
620
621        if (params.previewCallbackSurface && flag != CAMERA_FRAME_CALLBACK_FLAG_NOOP) {
622            // Disable any existing preview callback window when enabling
623            // preview callback flags
624            res = mCallbackProcessor->setCallbackWindow(NULL);
625            if (res != OK) {
626                ALOGE("%s: Camera %d: Unable to clear preview callback surface:"
627                        " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
628                return;
629            }
630            params.previewCallbackSurface = false;
631        }
632
633        params.previewCallbackFlags = flag;
634
635        if (params.state == Parameters::PREVIEW) {
636            res = startPreviewL(params, true);
637            if (res != OK) {
638                ALOGE("%s: Camera %d: Unable to refresh request in state %s",
639                        __FUNCTION__, mCameraId,
640                        Parameters::getStateName(params.state));
641            }
642        }
643    }
644}
645
646status_t Camera2Client::setPreviewCallbackTarget(
647        const sp<IGraphicBufferProducer>& callbackProducer) {
648    ATRACE_CALL();
649    ALOGV("%s: E", __FUNCTION__);
650    Mutex::Autolock icl(mBinderSerializationLock);
651    status_t res;
652    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
653
654    sp<ANativeWindow> window;
655    if (callbackProducer != 0) {
656        window = new Surface(callbackProducer);
657    }
658
659    res = mCallbackProcessor->setCallbackWindow(window);
660    if (res != OK) {
661        ALOGE("%s: Camera %d: Unable to set preview callback surface: %s (%d)",
662                __FUNCTION__, mCameraId, strerror(-res), res);
663        return res;
664    }
665
666    SharedParameters::Lock l(mParameters);
667
668    if (window != NULL) {
669        // Disable traditional callbacks when a valid callback target is given
670        l.mParameters.previewCallbackFlags = CAMERA_FRAME_CALLBACK_FLAG_NOOP;
671        l.mParameters.previewCallbackOneShot = false;
672        l.mParameters.previewCallbackSurface = true;
673    } else {
674        // Disable callback target if given a NULL interface.
675        l.mParameters.previewCallbackSurface = false;
676    }
677
678    switch(l.mParameters.state) {
679        case Parameters::PREVIEW:
680            res = startPreviewL(l.mParameters, true);
681            break;
682        case Parameters::RECORD:
683        case Parameters::VIDEO_SNAPSHOT:
684            res = startRecordingL(l.mParameters, true);
685            break;
686        default:
687            break;
688    }
689    if (res != OK) {
690        ALOGE("%s: Camera %d: Unable to refresh request in state %s",
691                __FUNCTION__, mCameraId,
692                Parameters::getStateName(l.mParameters.state));
693    }
694
695    return OK;
696}
697
698
699status_t Camera2Client::startPreview() {
700    ATRACE_CALL();
701    ALOGV("%s: E", __FUNCTION__);
702    Mutex::Autolock icl(mBinderSerializationLock);
703    status_t res;
704    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
705    SharedParameters::Lock l(mParameters);
706    return startPreviewL(l.mParameters, false);
707}
708
709status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
710    ATRACE_CALL();
711    status_t res;
712
713    ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
714
715    if ( (params.state == Parameters::PREVIEW ||
716                    params.state == Parameters::RECORD ||
717                    params.state == Parameters::VIDEO_SNAPSHOT)
718            && !restart) {
719        // Succeed attempt to re-enter a streaming state
720        ALOGI("%s: Camera %d: Preview already active, ignoring restart",
721                __FUNCTION__, mCameraId);
722        return OK;
723    }
724    if (params.state > Parameters::PREVIEW && !restart) {
725        ALOGE("%s: Can't start preview in state %s",
726                __FUNCTION__,
727                Parameters::getStateName(params.state));
728        return INVALID_OPERATION;
729    }
730
731    if (!mStreamingProcessor->haveValidPreviewWindow()) {
732        params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
733        return OK;
734    }
735    params.state = Parameters::STOPPED;
736
737    res = mStreamingProcessor->updatePreviewStream(params);
738    if (res != OK) {
739        ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
740                __FUNCTION__, mCameraId, strerror(-res), res);
741        return res;
742    }
743
744    // We could wait to create the JPEG output stream until first actual use
745    // (first takePicture call). However, this would substantially increase the
746    // first capture latency on HAL3 devices, and potentially on some HAL2
747    // devices. So create it unconditionally at preview start. As a drawback,
748    // this increases gralloc memory consumption for applications that don't
749    // ever take a picture.
750    // TODO: Find a better compromise, though this likely would involve HAL
751    // changes.
752    res = updateProcessorStream(mJpegProcessor, params);
753    if (res != OK) {
754        ALOGE("%s: Camera %d: Can't pre-configure still image "
755                "stream: %s (%d)",
756                __FUNCTION__, mCameraId, strerror(-res), res);
757        return res;
758    }
759
760    Vector<int32_t> outputStreams;
761    bool callbacksEnabled = (params.previewCallbackFlags &
762            CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) ||
763            params.previewCallbackSurface;
764
765    if (callbacksEnabled) {
766        // Can't have recording stream hanging around when enabling callbacks,
767        // since it exceeds the max stream count on some devices.
768        if (mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
769            ALOGV("%s: Camera %d: Clearing out recording stream before "
770                    "creating callback stream", __FUNCTION__, mCameraId);
771            res = mStreamingProcessor->stopStream();
772            if (res != OK) {
773                ALOGE("%s: Camera %d: Can't stop streaming to delete "
774                        "recording stream", __FUNCTION__, mCameraId);
775                return res;
776            }
777            res = mStreamingProcessor->deleteRecordingStream();
778            if (res != OK) {
779                ALOGE("%s: Camera %d: Unable to delete recording stream before "
780                        "enabling callbacks: %s (%d)", __FUNCTION__, mCameraId,
781                        strerror(-res), res);
782                return res;
783            }
784        }
785
786        res = mCallbackProcessor->updateStream(params);
787        if (res != OK) {
788            ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
789                    __FUNCTION__, mCameraId, strerror(-res), res);
790            return res;
791        }
792        outputStreams.push(getCallbackStreamId());
793    }
794    if (params.zslMode && !params.recordingHint) {
795        res = updateProcessorStream(mZslProcessor, params);
796        if (res != OK) {
797            ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
798                    __FUNCTION__, mCameraId, strerror(-res), res);
799            return res;
800        }
801        outputStreams.push(getZslStreamId());
802    }
803
804    outputStreams.push(getPreviewStreamId());
805
806    if (!params.recordingHint) {
807        if (!restart) {
808            res = mStreamingProcessor->updatePreviewRequest(params);
809            if (res != OK) {
810                ALOGE("%s: Camera %d: Can't set up preview request: "
811                        "%s (%d)", __FUNCTION__, mCameraId,
812                        strerror(-res), res);
813                return res;
814            }
815        }
816        res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
817                outputStreams);
818    } else {
819        if (!restart) {
820            res = mStreamingProcessor->updateRecordingRequest(params);
821            if (res != OK) {
822                ALOGE("%s: Camera %d: Can't set up preview request with "
823                        "record hint: %s (%d)", __FUNCTION__, mCameraId,
824                        strerror(-res), res);
825                return res;
826            }
827        }
828        res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
829                outputStreams);
830    }
831    if (res != OK) {
832        ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
833                __FUNCTION__, mCameraId, strerror(-res), res);
834        return res;
835    }
836
837    params.state = Parameters::PREVIEW;
838    return OK;
839}
840
841void Camera2Client::stopPreview() {
842    ATRACE_CALL();
843    ALOGV("%s: E", __FUNCTION__);
844    Mutex::Autolock icl(mBinderSerializationLock);
845    status_t res;
846    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
847    stopPreviewL();
848}
849
850void Camera2Client::stopPreviewL() {
851    ATRACE_CALL();
852    status_t res;
853    const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds
854    Parameters::State state;
855    {
856        SharedParameters::Lock l(mParameters);
857        state = l.mParameters.state;
858    }
859
860    switch (state) {
861        case Parameters::DISCONNECTED:
862            // Nothing to do.
863            break;
864        case Parameters::STOPPED:
865        case Parameters::VIDEO_SNAPSHOT:
866        case Parameters::STILL_CAPTURE:
867            mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout);
868            // no break
869        case Parameters::RECORD:
870        case Parameters::PREVIEW:
871            syncWithDevice();
872            res = stopStream();
873            if (res != OK) {
874                ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
875                        __FUNCTION__, mCameraId, strerror(-res), res);
876            }
877            res = mDevice->waitUntilDrained();
878            if (res != OK) {
879                ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
880                        __FUNCTION__, mCameraId, strerror(-res), res);
881            }
882            // no break
883        case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
884            SharedParameters::Lock l(mParameters);
885            l.mParameters.state = Parameters::STOPPED;
886            commandStopFaceDetectionL(l.mParameters);
887            break;
888        }
889        default:
890            ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
891                    state);
892    }
893}
894
895bool Camera2Client::previewEnabled() {
896    ATRACE_CALL();
897    Mutex::Autolock icl(mBinderSerializationLock);
898    status_t res;
899    if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
900
901    SharedParameters::Lock l(mParameters);
902    return l.mParameters.state == Parameters::PREVIEW;
903}
904
905status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
906    ATRACE_CALL();
907    Mutex::Autolock icl(mBinderSerializationLock);
908    status_t res;
909    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
910
911    SharedParameters::Lock l(mParameters);
912    switch (l.mParameters.state) {
913        case Parameters::RECORD:
914        case Parameters::VIDEO_SNAPSHOT:
915            ALOGE("%s: Camera %d: Can't be called in state %s",
916                    __FUNCTION__, mCameraId,
917                    Parameters::getStateName(l.mParameters.state));
918            return INVALID_OPERATION;
919        default:
920            // OK
921            break;
922    }
923
924    l.mParameters.storeMetadataInBuffers = enabled;
925
926    return OK;
927}
928
929status_t Camera2Client::startRecording() {
930    ATRACE_CALL();
931    ALOGV("%s: E", __FUNCTION__);
932    Mutex::Autolock icl(mBinderSerializationLock);
933    status_t res;
934    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
935    SharedParameters::Lock l(mParameters);
936
937    return startRecordingL(l.mParameters, false);
938}
939
940status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
941    status_t res;
942
943    ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
944
945    switch (params.state) {
946        case Parameters::STOPPED:
947            res = startPreviewL(params, false);
948            if (res != OK) return res;
949            break;
950        case Parameters::PREVIEW:
951            // Ready to go
952            break;
953        case Parameters::RECORD:
954        case Parameters::VIDEO_SNAPSHOT:
955            // OK to call this when recording is already on, just skip unless
956            // we're looking to restart
957            if (!restart) return OK;
958            break;
959        default:
960            ALOGE("%s: Camera %d: Can't start recording in state %s",
961                    __FUNCTION__, mCameraId,
962                    Parameters::getStateName(params.state));
963            return INVALID_OPERATION;
964    };
965
966    if (!params.storeMetadataInBuffers) {
967        ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
968                "non-metadata recording mode requested!", __FUNCTION__,
969                mCameraId);
970        return INVALID_OPERATION;
971    }
972
973    if (!restart) {
974        mCameraService->playSound(CameraService::SOUND_RECORDING);
975        mStreamingProcessor->updateRecordingRequest(params);
976        if (res != OK) {
977            ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
978                    __FUNCTION__, mCameraId, strerror(-res), res);
979            return res;
980        }
981    }
982
983    // Not all devices can support a preview callback stream and a recording
984    // stream at the same time, so assume none of them can.
985    if (mCallbackProcessor->getStreamId() != NO_STREAM) {
986        ALOGV("%s: Camera %d: Clearing out callback stream before "
987                "creating recording stream", __FUNCTION__, mCameraId);
988        res = mStreamingProcessor->stopStream();
989        if (res != OK) {
990            ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
991                    __FUNCTION__, mCameraId);
992            return res;
993        }
994        res = mCallbackProcessor->deleteStream();
995        if (res != OK) {
996            ALOGE("%s: Camera %d: Unable to delete callback stream before "
997                    "record: %s (%d)", __FUNCTION__, mCameraId,
998                    strerror(-res), res);
999            return res;
1000        }
1001    }
1002    // Disable callbacks if they're enabled; can't record and use callbacks,
1003    // and we can't fail record start without stagefright asserting.
1004    params.previewCallbackFlags = 0;
1005
1006    res = updateProcessorStream<
1007            StreamingProcessor,
1008            &StreamingProcessor::updateRecordingStream>(mStreamingProcessor,
1009                                                        params);
1010    if (res != OK) {
1011        ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
1012                __FUNCTION__, mCameraId, strerror(-res), res);
1013        return res;
1014    }
1015
1016    Vector<int32_t> outputStreams;
1017    outputStreams.push(getPreviewStreamId());
1018    outputStreams.push(getRecordingStreamId());
1019
1020    res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1021            outputStreams);
1022    if (res != OK) {
1023        ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
1024                __FUNCTION__, mCameraId, strerror(-res), res);
1025        return res;
1026    }
1027
1028    if (params.state < Parameters::RECORD) {
1029        params.state = Parameters::RECORD;
1030    }
1031
1032    return OK;
1033}
1034
1035void Camera2Client::stopRecording() {
1036    ATRACE_CALL();
1037    ALOGV("%s: E", __FUNCTION__);
1038    Mutex::Autolock icl(mBinderSerializationLock);
1039    SharedParameters::Lock l(mParameters);
1040
1041    status_t res;
1042    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
1043
1044    switch (l.mParameters.state) {
1045        case Parameters::RECORD:
1046            // OK to stop
1047            break;
1048        case Parameters::STOPPED:
1049        case Parameters::PREVIEW:
1050        case Parameters::STILL_CAPTURE:
1051        case Parameters::VIDEO_SNAPSHOT:
1052        default:
1053            ALOGE("%s: Camera %d: Can't stop recording in state %s",
1054                    __FUNCTION__, mCameraId,
1055                    Parameters::getStateName(l.mParameters.state));
1056            return;
1057    };
1058
1059    mCameraService->playSound(CameraService::SOUND_RECORDING);
1060
1061    res = startPreviewL(l.mParameters, true);
1062    if (res != OK) {
1063        ALOGE("%s: Camera %d: Unable to return to preview",
1064                __FUNCTION__, mCameraId);
1065    }
1066}
1067
1068bool Camera2Client::recordingEnabled() {
1069    ATRACE_CALL();
1070    Mutex::Autolock icl(mBinderSerializationLock);
1071
1072    if ( checkPid(__FUNCTION__) != OK) return false;
1073
1074    return recordingEnabledL();
1075}
1076
1077bool Camera2Client::recordingEnabledL() {
1078    ATRACE_CALL();
1079    SharedParameters::Lock l(mParameters);
1080
1081    return (l.mParameters.state == Parameters::RECORD
1082            || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
1083}
1084
1085void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
1086    ATRACE_CALL();
1087    Mutex::Autolock icl(mBinderSerializationLock);
1088    if ( checkPid(__FUNCTION__) != OK) return;
1089
1090    mStreamingProcessor->releaseRecordingFrame(mem);
1091}
1092
1093status_t Camera2Client::autoFocus() {
1094    ATRACE_CALL();
1095    Mutex::Autolock icl(mBinderSerializationLock);
1096    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1097    status_t res;
1098    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1099
1100    int triggerId;
1101    bool notifyImmediately = false;
1102    bool notifySuccess = false;
1103    {
1104        SharedParameters::Lock l(mParameters);
1105        if (l.mParameters.state < Parameters::PREVIEW) {
1106            return INVALID_OPERATION;
1107        }
1108
1109        /**
1110          * If the camera does not support auto-focus, it is a no-op and
1111          * onAutoFocus(boolean, Camera) callback will be called immediately
1112          * with a fake value of success set to true.
1113          *
1114          * Similarly, if focus mode is set to INFINITY, there's no reason to
1115          * bother the HAL.
1116          */
1117        if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1118                l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
1119            notifyImmediately = true;
1120            notifySuccess = true;
1121        }
1122        /**
1123         * If we're in CAF mode, and AF has already been locked, just fire back
1124         * the callback right away; the HAL would not send a notification since
1125         * no state change would happen on a AF trigger.
1126         */
1127        if ( (l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_PICTURE ||
1128                l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) &&
1129                l.mParameters.focusState == ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED ) {
1130            notifyImmediately = true;
1131            notifySuccess = true;
1132        }
1133        /**
1134         * Send immediate notification back to client
1135         */
1136        if (notifyImmediately) {
1137            SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1138            if (l.mRemoteCallback != 0) {
1139                l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
1140                        notifySuccess ? 1 : 0, 0);
1141            }
1142            return OK;
1143        }
1144        /**
1145         * Handle quirk mode for AF in scene modes
1146         */
1147        if (l.mParameters.quirks.triggerAfWithAuto &&
1148                l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED &&
1149                l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO &&
1150                !l.mParameters.focusingAreas[0].isEmpty()) {
1151            ALOGV("%s: Quirk: Switching from focusMode %d to AUTO",
1152                    __FUNCTION__, l.mParameters.focusMode);
1153            l.mParameters.shadowFocusMode = l.mParameters.focusMode;
1154            l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1155            updateRequests(l.mParameters);
1156        }
1157
1158        l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1159        triggerId = l.mParameters.currentAfTriggerId;
1160    }
1161    ATRACE_ASYNC_BEGIN(kAutofocusLabel, triggerId);
1162
1163    syncWithDevice();
1164
1165    mDevice->triggerAutofocus(triggerId);
1166
1167    return OK;
1168}
1169
1170status_t Camera2Client::cancelAutoFocus() {
1171    ATRACE_CALL();
1172    Mutex::Autolock icl(mBinderSerializationLock);
1173    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1174    status_t res;
1175    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1176
1177    int triggerId;
1178    {
1179        SharedParameters::Lock l(mParameters);
1180        // Canceling does nothing in FIXED or INFINITY modes
1181        if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1182                l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
1183            return OK;
1184        }
1185
1186        // An active AF trigger is canceled
1187        if (l.mParameters.afTriggerCounter == l.mParameters.currentAfTriggerId) {
1188            ATRACE_ASYNC_END(kAutofocusLabel, l.mParameters.currentAfTriggerId);
1189        }
1190
1191        triggerId = ++l.mParameters.afTriggerCounter;
1192
1193        // When using triggerAfWithAuto quirk, may need to reset focus mode to
1194        // the real state at this point. No need to cancel explicitly if
1195        // changing the AF mode.
1196        if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) {
1197            ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__,
1198                    l.mParameters.shadowFocusMode);
1199            l.mParameters.focusMode = l.mParameters.shadowFocusMode;
1200            l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID;
1201            updateRequests(l.mParameters);
1202
1203            return OK;
1204        }
1205    }
1206    syncWithDevice();
1207
1208    mDevice->triggerCancelAutofocus(triggerId);
1209
1210    return OK;
1211}
1212
1213status_t Camera2Client::takePicture(int msgType) {
1214    ATRACE_CALL();
1215    Mutex::Autolock icl(mBinderSerializationLock);
1216    status_t res;
1217    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1218
1219    int takePictureCounter;
1220    {
1221        SharedParameters::Lock l(mParameters);
1222        switch (l.mParameters.state) {
1223            case Parameters::DISCONNECTED:
1224            case Parameters::STOPPED:
1225            case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1226                ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
1227                        __FUNCTION__, mCameraId);
1228                return INVALID_OPERATION;
1229            case Parameters::PREVIEW:
1230                // Good to go for takePicture
1231                res = commandStopFaceDetectionL(l.mParameters);
1232                if (res != OK) {
1233                    ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1234                            __FUNCTION__, mCameraId);
1235                    return res;
1236                }
1237                l.mParameters.state = Parameters::STILL_CAPTURE;
1238                break;
1239            case Parameters::RECORD:
1240                // Good to go for video snapshot
1241                l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1242                break;
1243            case Parameters::STILL_CAPTURE:
1244            case Parameters::VIDEO_SNAPSHOT:
1245                ALOGE("%s: Camera %d: Already taking a picture",
1246                        __FUNCTION__, mCameraId);
1247                return INVALID_OPERATION;
1248        }
1249
1250        ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
1251
1252        res = updateProcessorStream(mJpegProcessor, l.mParameters);
1253        if (res != OK) {
1254            ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1255                    __FUNCTION__, mCameraId, strerror(-res), res);
1256            return res;
1257        }
1258        takePictureCounter = ++l.mParameters.takePictureCounter;
1259    }
1260
1261    ATRACE_ASYNC_BEGIN(kTakepictureLabel, takePictureCounter);
1262
1263    // Need HAL to have correct settings before (possibly) triggering precapture
1264    syncWithDevice();
1265
1266    res = mCaptureSequencer->startCapture(msgType);
1267    if (res != OK) {
1268        ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
1269                __FUNCTION__, mCameraId, strerror(-res), res);
1270    }
1271
1272    return res;
1273}
1274
1275status_t Camera2Client::setParameters(const String8& params) {
1276    ATRACE_CALL();
1277    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1278    Mutex::Autolock icl(mBinderSerializationLock);
1279    status_t res;
1280    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1281
1282    SharedParameters::Lock l(mParameters);
1283
1284    res = l.mParameters.set(params);
1285    if (res != OK) return res;
1286
1287    res = updateRequests(l.mParameters);
1288
1289    return res;
1290}
1291
1292String8 Camera2Client::getParameters() const {
1293    ATRACE_CALL();
1294    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1295    Mutex::Autolock icl(mBinderSerializationLock);
1296    if ( checkPid(__FUNCTION__) != OK) return String8();
1297
1298    SharedParameters::ReadLock l(mParameters);
1299
1300    return l.mParameters.get();
1301}
1302
1303status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
1304    ATRACE_CALL();
1305    Mutex::Autolock icl(mBinderSerializationLock);
1306    status_t res;
1307    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1308
1309    ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1310            cmd, arg1, arg2);
1311
1312    switch (cmd) {
1313        case CAMERA_CMD_START_SMOOTH_ZOOM:
1314            return commandStartSmoothZoomL();
1315        case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1316            return commandStopSmoothZoomL();
1317        case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1318            return commandSetDisplayOrientationL(arg1);
1319        case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1320            return commandEnableShutterSoundL(arg1 == 1);
1321        case CAMERA_CMD_PLAY_RECORDING_SOUND:
1322            return commandPlayRecordingSoundL();
1323        case CAMERA_CMD_START_FACE_DETECTION:
1324            return commandStartFaceDetectionL(arg1);
1325        case CAMERA_CMD_STOP_FACE_DETECTION: {
1326            SharedParameters::Lock l(mParameters);
1327            return commandStopFaceDetectionL(l.mParameters);
1328        }
1329        case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1330            return commandEnableFocusMoveMsgL(arg1 == 1);
1331        case CAMERA_CMD_PING:
1332            return commandPingL();
1333        case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1334            return commandSetVideoBufferCountL(arg1);
1335        default:
1336            ALOGE("%s: Unknown command %d (arguments %d, %d)",
1337                    __FUNCTION__, cmd, arg1, arg2);
1338            return BAD_VALUE;
1339    }
1340}
1341
1342status_t Camera2Client::commandStartSmoothZoomL() {
1343    ALOGE("%s: Unimplemented!", __FUNCTION__);
1344    return OK;
1345}
1346
1347status_t Camera2Client::commandStopSmoothZoomL() {
1348    ALOGE("%s: Unimplemented!", __FUNCTION__);
1349    return OK;
1350}
1351
1352status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
1353    int transform = Parameters::degToTransform(degrees,
1354            mCameraFacing == CAMERA_FACING_FRONT);
1355    if (transform == -1) {
1356        ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1357                __FUNCTION__, mCameraId, degrees);
1358        return BAD_VALUE;
1359    }
1360    SharedParameters::Lock l(mParameters);
1361    if (transform != l.mParameters.previewTransform &&
1362            getPreviewStreamId() != NO_STREAM) {
1363        mDevice->setStreamTransform(getPreviewStreamId(), transform);
1364    }
1365    l.mParameters.previewTransform = transform;
1366    return OK;
1367}
1368
1369status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
1370    SharedParameters::Lock l(mParameters);
1371    if (enable) {
1372        l.mParameters.playShutterSound = true;
1373        return OK;
1374    }
1375
1376    // Disabling shutter sound may not be allowed. In that case only
1377    // allow the mediaserver process to disable the sound.
1378    char value[PROPERTY_VALUE_MAX];
1379    property_get("ro.camera.sound.forced", value, "0");
1380    if (strncmp(value, "0", 2) != 0) {
1381        // Disabling shutter sound is not allowed. Deny if the current
1382        // process is not mediaserver.
1383        if (getCallingPid() != getpid()) {
1384            ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1385                    getCallingPid());
1386            return PERMISSION_DENIED;
1387        }
1388    }
1389
1390    l.mParameters.playShutterSound = false;
1391    return OK;
1392}
1393
1394status_t Camera2Client::commandPlayRecordingSoundL() {
1395    mCameraService->playSound(CameraService::SOUND_RECORDING);
1396    return OK;
1397}
1398
1399status_t Camera2Client::commandStartFaceDetectionL(int /*type*/) {
1400    ALOGV("%s: Camera %d: Starting face detection",
1401          __FUNCTION__, mCameraId);
1402    status_t res;
1403    SharedParameters::Lock l(mParameters);
1404    switch (l.mParameters.state) {
1405        case Parameters::DISCONNECTED:
1406        case Parameters::STOPPED:
1407        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1408        case Parameters::STILL_CAPTURE:
1409            ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1410                    __FUNCTION__, mCameraId);
1411            return INVALID_OPERATION;
1412        case Parameters::PREVIEW:
1413        case Parameters::RECORD:
1414        case Parameters::VIDEO_SNAPSHOT:
1415            // Good to go for starting face detect
1416            break;
1417    }
1418    // Ignoring type
1419    if (l.mParameters.fastInfo.bestFaceDetectMode ==
1420            ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) {
1421        ALOGE("%s: Camera %d: Face detection not supported",
1422                __FUNCTION__, mCameraId);
1423        return BAD_VALUE;
1424    }
1425    if (l.mParameters.enableFaceDetect) return OK;
1426
1427    l.mParameters.enableFaceDetect = true;
1428
1429    res = updateRequests(l.mParameters);
1430
1431    return res;
1432}
1433
1434status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
1435    status_t res = OK;
1436    ALOGV("%s: Camera %d: Stopping face detection",
1437          __FUNCTION__, mCameraId);
1438
1439    if (!params.enableFaceDetect) return OK;
1440
1441    params.enableFaceDetect = false;
1442
1443    if (params.state == Parameters::PREVIEW
1444            || params.state == Parameters::RECORD
1445            || params.state == Parameters::VIDEO_SNAPSHOT) {
1446        res = updateRequests(params);
1447    }
1448
1449    return res;
1450}
1451
1452status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
1453    SharedParameters::Lock l(mParameters);
1454    l.mParameters.enableFocusMoveMessages = enable;
1455
1456    return OK;
1457}
1458
1459status_t Camera2Client::commandPingL() {
1460    // Always ping back if access is proper and device is alive
1461    SharedParameters::Lock l(mParameters);
1462    if (l.mParameters.state != Parameters::DISCONNECTED) {
1463        return OK;
1464    } else {
1465        return NO_INIT;
1466    }
1467}
1468
1469status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
1470    if (recordingEnabledL()) {
1471        ALOGE("%s: Camera %d: Error setting video buffer count after "
1472                "recording was started", __FUNCTION__, mCameraId);
1473        return INVALID_OPERATION;
1474    }
1475
1476    return mStreamingProcessor->setRecordingBufferCount(count);
1477}
1478
1479/** Device-related methods */
1480void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1481    ALOGV("%s: Autofocus state now %d, last trigger %d",
1482            __FUNCTION__, newState, triggerId);
1483    bool sendCompletedMessage = false;
1484    bool sendMovingMessage = false;
1485
1486    bool success = false;
1487    bool afInMotion = false;
1488    {
1489        SharedParameters::Lock l(mParameters);
1490        // Trace end of AF state
1491        char tmp[32];
1492        if (l.mParameters.afStateCounter > 0) {
1493            camera_metadata_enum_snprint(
1494                ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1495            ATRACE_ASYNC_END(tmp, l.mParameters.afStateCounter);
1496        }
1497
1498        // Update state
1499        l.mParameters.focusState = newState;
1500        l.mParameters.afStateCounter++;
1501
1502        // Trace start of AF state
1503
1504        camera_metadata_enum_snprint(
1505            ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1506        ATRACE_ASYNC_BEGIN(tmp, l.mParameters.afStateCounter);
1507
1508        switch (l.mParameters.focusMode) {
1509            case Parameters::FOCUS_MODE_AUTO:
1510            case Parameters::FOCUS_MODE_MACRO:
1511                // Don't send notifications upstream if they're not for the current AF
1512                // trigger. For example, if cancel was called in between, or if we
1513                // already sent a notification about this AF call.
1514                if (triggerId != l.mParameters.currentAfTriggerId) break;
1515                switch (newState) {
1516                    case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1517                        success = true;
1518                        // no break
1519                    case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1520                        sendCompletedMessage = true;
1521                        l.mParameters.currentAfTriggerId = -1;
1522                        break;
1523                    case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1524                        // Just starting focusing, ignore
1525                        break;
1526                    case ANDROID_CONTROL_AF_STATE_INACTIVE:
1527                    case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1528                    case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1529                    case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
1530                    default:
1531                        // Unexpected in AUTO/MACRO mode
1532                        ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1533                                __FUNCTION__, newState);
1534                        break;
1535                }
1536                break;
1537            case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1538            case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1539                switch (newState) {
1540                    case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1541                        success = true;
1542                        // no break
1543                    case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1544                        // Don't send notifications upstream if they're not for
1545                        // the current AF trigger. For example, if cancel was
1546                        // called in between, or if we already sent a
1547                        // notification about this AF call.
1548                        // Send both a 'AF done' callback and a 'AF move' callback
1549                        if (triggerId != l.mParameters.currentAfTriggerId) break;
1550                        sendCompletedMessage = true;
1551                        afInMotion = false;
1552                        if (l.mParameters.enableFocusMoveMessages &&
1553                                l.mParameters.afInMotion) {
1554                            sendMovingMessage = true;
1555                        }
1556                        l.mParameters.currentAfTriggerId = -1;
1557                        break;
1558                    case ANDROID_CONTROL_AF_STATE_INACTIVE:
1559                        // Cancel was called, or we switched state; care if
1560                        // currently moving
1561                        afInMotion = false;
1562                        if (l.mParameters.enableFocusMoveMessages &&
1563                                l.mParameters.afInMotion) {
1564                            sendMovingMessage = true;
1565                        }
1566                        break;
1567                    case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1568                        // Start passive scan, inform upstream
1569                        afInMotion = true;
1570                        // no break
1571                    case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1572                    case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
1573                        // Stop passive scan, inform upstream
1574                        if (l.mParameters.enableFocusMoveMessages) {
1575                            sendMovingMessage = true;
1576                        }
1577                        break;
1578                }
1579                l.mParameters.afInMotion = afInMotion;
1580                break;
1581            case Parameters::FOCUS_MODE_EDOF:
1582            case Parameters::FOCUS_MODE_INFINITY:
1583            case Parameters::FOCUS_MODE_FIXED:
1584            default:
1585                if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
1586                    ALOGE("%s: Unexpected AF state change %d "
1587                            "(ID %d) in focus mode %d",
1588                          __FUNCTION__, newState, triggerId,
1589                            l.mParameters.focusMode);
1590                }
1591        }
1592    }
1593    if (sendMovingMessage) {
1594        SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1595        if (l.mRemoteCallback != 0) {
1596            l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
1597                    afInMotion ? 1 : 0, 0);
1598        }
1599    }
1600    if (sendCompletedMessage) {
1601        ATRACE_ASYNC_END(kAutofocusLabel, triggerId);
1602        SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1603        if (l.mRemoteCallback != 0) {
1604            l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
1605                    success ? 1 : 0, 0);
1606        }
1607    }
1608}
1609
1610void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1611    ALOGV("%s: Autoexposure state now %d, last trigger %d",
1612            __FUNCTION__, newState, triggerId);
1613    mCaptureSequencer->notifyAutoExposure(newState, triggerId);
1614}
1615
1616camera2::SharedParameters& Camera2Client::getParameters() {
1617    return mParameters;
1618}
1619
1620int Camera2Client::getPreviewStreamId() const {
1621    return mStreamingProcessor->getPreviewStreamId();
1622}
1623
1624int Camera2Client::getCaptureStreamId() const {
1625    return mJpegProcessor->getStreamId();
1626}
1627
1628int Camera2Client::getCallbackStreamId() const {
1629    return mCallbackProcessor->getStreamId();
1630}
1631
1632int Camera2Client::getRecordingStreamId() const {
1633    return mStreamingProcessor->getRecordingStreamId();
1634}
1635
1636int Camera2Client::getZslStreamId() const {
1637    return mZslProcessor->getStreamId();
1638}
1639
1640status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId,
1641        wp<camera2::FrameProcessor::FilteredListener> listener) {
1642    return mFrameProcessor->registerListener(minId, maxId, listener);
1643}
1644
1645status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId,
1646        wp<camera2::FrameProcessor::FilteredListener> listener) {
1647    return mFrameProcessor->removeListener(minId, maxId, listener);
1648}
1649
1650status_t Camera2Client::stopStream() {
1651    return mStreamingProcessor->stopStream();
1652}
1653
1654const int32_t Camera2Client::kPreviewRequestIdStart;
1655const int32_t Camera2Client::kPreviewRequestIdEnd;
1656const int32_t Camera2Client::kRecordingRequestIdStart;
1657const int32_t Camera2Client::kRecordingRequestIdEnd;
1658const int32_t Camera2Client::kCaptureRequestIdStart;
1659const int32_t Camera2Client::kCaptureRequestIdEnd;
1660
1661/** Utility methods */
1662
1663status_t Camera2Client::updateRequests(Parameters &params) {
1664    status_t res;
1665
1666    ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
1667
1668    res = mStreamingProcessor->incrementStreamingIds();
1669    if (res != OK) {
1670        ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)",
1671                __FUNCTION__, mCameraId, strerror(-res), res);
1672        return res;
1673    }
1674
1675    res = mStreamingProcessor->updatePreviewRequest(params);
1676    if (res != OK) {
1677        ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1678                __FUNCTION__, mCameraId, strerror(-res), res);
1679        return res;
1680    }
1681    res = mStreamingProcessor->updateRecordingRequest(params);
1682    if (res != OK) {
1683        ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1684                __FUNCTION__, mCameraId, strerror(-res), res);
1685        return res;
1686    }
1687
1688    if (params.state == Parameters::PREVIEW) {
1689        res = startPreviewL(params, true);
1690        if (res != OK) {
1691            ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1692                    __FUNCTION__, mCameraId, strerror(-res), res);
1693            return res;
1694        }
1695    } else if (params.state == Parameters::RECORD ||
1696            params.state == Parameters::VIDEO_SNAPSHOT) {
1697        res = startRecordingL(params, true);
1698        if (res != OK) {
1699            ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1700                    __FUNCTION__, mCameraId, strerror(-res), res);
1701            return res;
1702        }
1703    }
1704    return res;
1705}
1706
1707
1708size_t Camera2Client::calculateBufferSize(int width, int height,
1709        int format, int stride) {
1710    switch (format) {
1711        case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1712            return width * height * 2;
1713        case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1714            return width * height * 3 / 2;
1715        case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1716            return width * height * 2;
1717        case HAL_PIXEL_FORMAT_YV12: {      // YV12
1718            size_t ySize = stride * height;
1719            size_t uvStride = (stride / 2 + 0xF) & ~0xF;
1720            size_t uvSize = uvStride * height / 2;
1721            return ySize + uvSize * 2;
1722        }
1723        case HAL_PIXEL_FORMAT_RGB_565:
1724            return width * height * 2;
1725        case HAL_PIXEL_FORMAT_RGBA_8888:
1726            return width * height * 4;
1727        case HAL_PIXEL_FORMAT_RAW_SENSOR:
1728            return width * height * 2;
1729        default:
1730            ALOGE("%s: Unknown preview format: %x",
1731                    __FUNCTION__,  format);
1732            return 0;
1733    }
1734}
1735
1736status_t Camera2Client::syncWithDevice() {
1737    ATRACE_CALL();
1738    const nsecs_t kMaxSyncTimeout = 500000000; // 500 ms
1739    status_t res;
1740
1741    int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
1742    if (activeRequestId == 0) return OK;
1743
1744    res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout);
1745    if (res == TIMED_OUT) {
1746        ALOGE("%s: Camera %d: Timed out waiting sync with HAL",
1747                __FUNCTION__, mCameraId);
1748    } else if (res != OK) {
1749        ALOGE("%s: Camera %d: Error while waiting to sync with HAL",
1750                __FUNCTION__, mCameraId);
1751    }
1752    return res;
1753}
1754
1755template <typename ProcessorT>
1756status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
1757                                              camera2::Parameters params) {
1758    // No default template arguments until C++11, so we need this overload
1759    return updateProcessorStream<ProcessorT, &ProcessorT::updateStream>(
1760            processor, params);
1761}
1762
1763template <typename ProcessorT,
1764          status_t (ProcessorT::*updateStreamF)(const Parameters &)>
1765status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
1766                                              Parameters params) {
1767    status_t res;
1768
1769    // Get raw pointer since sp<T> doesn't have operator->*
1770    ProcessorT *processorPtr = processor.get();
1771    res = (processorPtr->*updateStreamF)(params);
1772
1773    /**
1774     * Can't update the stream if it's busy?
1775     *
1776     * Then we need to stop the device (by temporarily clearing the request
1777     * queue) and then try again. Resume streaming once we're done.
1778     */
1779    if (res == -EBUSY) {
1780        ALOGV("%s: Camera %d: Pausing to update stream", __FUNCTION__,
1781                mCameraId);
1782        res = mStreamingProcessor->togglePauseStream(/*pause*/true);
1783        if (res != OK) {
1784            ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
1785                    __FUNCTION__, mCameraId, strerror(-res), res);
1786        }
1787
1788        res = mDevice->waitUntilDrained();
1789        if (res != OK) {
1790            ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1791                    __FUNCTION__, mCameraId, strerror(-res), res);
1792        }
1793
1794        res = (processorPtr->*updateStreamF)(params);
1795        if (res != OK) {
1796            ALOGE("%s: Camera %d: Failed to update processing stream "
1797                  " despite having halted streaming first: %s (%d)",
1798                  __FUNCTION__, mCameraId, strerror(-res), res);
1799        }
1800
1801        res = mStreamingProcessor->togglePauseStream(/*pause*/false);
1802        if (res != OK) {
1803            ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
1804                    __FUNCTION__, mCameraId, strerror(-res), res);
1805        }
1806    }
1807
1808    return res;
1809}
1810
1811const char* Camera2Client::kAutofocusLabel = "autofocus";
1812const char* Camera2Client::kTakepictureLabel = "take_picture";
1813
1814} // namespace android
1815