1 /*
2  * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "hstream_capture_stub.h"
17 #include "camera_log.h"
18 #include "camera_util.h"
19 #include "metadata_utils.h"
20 #include "camera_service_ipc_interface_code.h"
21 
22 namespace OHOS {
23 namespace CameraStandard {
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)24 int HStreamCaptureStub::OnRemoteRequest(
25     uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
26 {
27     DisableJeMalloc();
28     int errCode = -1;
29 
30     CHECK_AND_RETURN_RET(data.ReadInterfaceToken() == GetDescriptor(), errCode);
31     errCode = OperatePermissionCheck(code);
32     CHECK_AND_RETURN_RET(errCode == CAMERA_OK, errCode);
33     switch (code) {
34         case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_CAPTURE_START):
35             errCode = HStreamCaptureStub::HandleCapture(data);
36             break;
37         case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_CAPTURE_CANCEL):
38             errCode = CancelCapture();
39             break;
40         case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_CAPTURE_CONFIRM):
41             errCode = HStreamCaptureStub::HandleConfirmCapture(data);
42             break;
43         case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_CAPTURE_SET_CALLBACK):
44             errCode = HStreamCaptureStub::HandleSetCallback(data);
45             break;
46         case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_CAPTURE_RELEASE):
47             errCode = Release();
48             break;
49         case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_SERVICE_SET_THUMBNAIL):
50             errCode = HandleSetThumbnail(data);
51             break;
52         case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_ENABLE_RAW_DELIVERY):
53             errCode = HandleEnableRawDelivery(data);
54             break;
55         case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_SERVICE_ENABLE_DEFERREDTYPE):
56             errCode = HandleEnableDeferredType(data);
57             break;
58         case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_GET_DEFERRED_PHOTO):
59             errCode = IsDeferredPhotoEnabled();
60             break;
61         case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_GET_DEFERRED_VIDEO):
62             errCode = IsDeferredVideoEnabled();
63             break;
64         case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_SET_VIDEO_CODEC_TYPE):
65             errCode = HandleSetMovingPhotoVideoCodecType(data);
66             break;
67         case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_SET_BUFFER_PRODUCER_INFO):
68             errCode = HandleSetBufferProducerInfo(data);
69             break;
70         case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_PHOTO_ROTATION):
71             errCode = HandleSetCameraPhotoRotation(data);
72             break;
73         case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_CAPTURE_DFX):
74             errCode = HandleAcquireBufferToPrepareProxy(data);
75             break;
76         default:
77             MEDIA_ERR_LOG("HStreamCaptureStub request code %{public}u not handled", code);
78             errCode = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
79             break;
80     }
81 
82     return errCode;
83 }
84 
HandleCapture(MessageParcel & data)85 int32_t HStreamCaptureStub::HandleCapture(MessageParcel &data)
86 {
87     std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = nullptr;
88     OHOS::Camera::MetadataUtils::DecodeCameraMetadata(data, metadata);
89 
90     return Capture(metadata);
91 }
92 
HandleConfirmCapture(MessageParcel & data)93 int32_t HStreamCaptureStub::HandleConfirmCapture(MessageParcel &data)
94 {
95     CHECK_AND_RETURN_RET(CheckSystemApp(), CAMERA_NO_PERMISSION);
96     return ConfirmCapture();
97 }
98 
HandleSetThumbnail(MessageParcel & data)99 int32_t HStreamCaptureStub::HandleSetThumbnail(MessageParcel &data)
100 {
101     sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
102     CHECK_AND_RETURN_RET_LOG(remoteObj != nullptr, IPC_STUB_INVALID_DATA_ERR,
103         "HStreamCaptureStub HandleCreatePhotoOutput BufferProducer is null");
104     sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
105     CHECK_AND_RETURN_RET_LOG(producer != nullptr, IPC_STUB_INVALID_DATA_ERR,
106                              "HStreamCaptureStub HandleSetThumbnail producer is null");
107     bool isEnabled = data.ReadBool();
108     int32_t ret = SetThumbnail(isEnabled, producer);
109     MEDIA_DEBUG_LOG("HStreamCaptureStub HandleSetThumbnail result: %{public}d", ret);
110     return ret;
111 }
112 
HandleEnableRawDelivery(MessageParcel & data)113 int32_t HStreamCaptureStub::HandleEnableRawDelivery(MessageParcel &data)
114 {
115     bool enabled = data.ReadBool();
116     int32_t ret = EnableRawDelivery(enabled);
117     MEDIA_DEBUG_LOG("HStreamCaptureStub HandleEnableRawDelivery result: %{public}d", ret);
118     return ret;
119 }
120 
HandleSetBufferProducerInfo(MessageParcel & data)121 int32_t HStreamCaptureStub::HandleSetBufferProducerInfo(MessageParcel &data)
122 {
123     std::string bufferName = data.ReadString();
124     sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
125     CHECK_AND_RETURN_RET_LOG(remoteObj != nullptr, IPC_STUB_INVALID_DATA_ERR,
126         "HStreamCaptureStub HandleSetBufferProducerInfo BufferProducer is null");
127     sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
128     CHECK_AND_RETURN_RET_LOG(producer != nullptr, IPC_STUB_INVALID_DATA_ERR,
129                              "HStreamCaptureStub HandleSetBufferProducerInfo producer is null");
130     int32_t ret = SetBufferProducerInfo(bufferName, producer);
131     MEDIA_DEBUG_LOG("HStreamCaptureStub HandleSetBufferProducerInfo result: %{public}d", ret);
132     return ret;
133 }
134 
HandleEnableDeferredType(MessageParcel & data)135 int32_t HStreamCaptureStub::HandleEnableDeferredType(MessageParcel &data)
136 {
137     CHECK_AND_RETURN_RET(CheckSystemApp(), CAMERA_NO_PERMISSION);
138     int32_t type = data.ReadInt32();
139     int32_t ret = DeferImageDeliveryFor(type);
140     MEDIA_DEBUG_LOG("HStreamCaptureStub HandleEnableDeferredType result: %{public}d", ret);
141     return ret;
142 }
143 
HandleSetMovingPhotoVideoCodecType(MessageParcel & data)144 int32_t HStreamCaptureStub::HandleSetMovingPhotoVideoCodecType(MessageParcel &data)
145 {
146     int32_t type = data.ReadInt32();
147     int32_t ret = SetMovingPhotoVideoCodecType(type);
148     MEDIA_DEBUG_LOG("HStreamCaptureStub HandleSetMovingPhotoVideoCodecType result: %{public}d", ret);
149     return ret;
150 }
151 
HandleSetCallback(MessageParcel & data)152 int32_t HStreamCaptureStub::HandleSetCallback(MessageParcel &data)
153 {
154     auto remoteObject = data.ReadRemoteObject();
155     CHECK_AND_RETURN_RET_LOG(remoteObject != nullptr, IPC_STUB_INVALID_DATA_ERR,
156                              "HStreamCaptureStub HandleSetCallback StreamCaptureCallback is null");
157 
158     auto callback = iface_cast<IStreamCaptureCallback>(remoteObject);
159     CHECK_AND_RETURN_RET_LOG(callback != nullptr, IPC_STUB_INVALID_DATA_ERR,
160                              "HStreamCaptureStub HandleSetCallback callback is null");
161     return SetCallback(callback);
162 }
163 
HandleSetCameraPhotoRotation(MessageParcel & data)164 int32_t HStreamCaptureStub::HandleSetCameraPhotoRotation(MessageParcel& data)
165 {
166     bool isEnable = data.ReadBool();
167 
168     int ret = SetCameraPhotoRotation(isEnable);
169     CHECK_ERROR_PRINT_LOG(ret != ERR_NONE, "HStreamCaptureStub::SetCameraPhotoRotation failed : %{public}d", ret);
170     return ret;
171 }
172 
HandleAcquireBufferToPrepareProxy(MessageParcel & data)173 int32_t HStreamCaptureStub::HandleAcquireBufferToPrepareProxy(MessageParcel& data)
174 {
175     int32_t captureId = data.ReadInt32();
176     int32_t ret = AcquireBufferToPrepareProxy(captureId);
177     CHECK_ERROR_PRINT_LOG(ret != ERR_NONE,
178                           "HStreamCaptureStub::HandleAcquireBufferToPrepareProxy failed : %{public}d", ret);
179     return ret;
180 }
181 } // namespace CameraStandard
182 } // namespace OHOS
183