1 /*
2 * Copyright (c) 2023-2023 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 <sys/mman.h>
17 #include "deferred_proc_session/deferred_photo_proc_session.h"
18 #include "picture_proxy.h"
19 #include "iservice_registry.h"
20 #include "camera_log.h"
21 #include "camera_util.h"
22 #include "system_ability_definition.h"
23 #include "picture_interface.h"
24
25 namespace OHOS {
26 namespace CameraStandard {
27
OnProcessImageDone(const std::string & imageId,const sptr<IPCFileDescriptor> ipcFileDescriptor,const long bytes,uint32_t cloudImageEnhanceFlag)28 int32_t DeferredPhotoProcessingSessionCallback::OnProcessImageDone(const std::string &imageId,
29 const sptr<IPCFileDescriptor> ipcFileDescriptor, const long bytes, uint32_t cloudImageEnhanceFlag)
30 {
31 MEDIA_INFO_LOG("DeferredPhotoProcessingSessionCallback::OnProcessImageDone() is called!"
32 "cloudImageEnhanceFlag: %{public}u", cloudImageEnhanceFlag);
33 CHECK_ERROR_RETURN_RET(ipcFileDescriptor == nullptr, CAMERA_INVALID_ARG);
34 int fd = ipcFileDescriptor->GetFd();
35 void* addr = mmap(nullptr, bytes, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
36 if (deferredPhotoProcSession_ != nullptr && deferredPhotoProcSession_->GetCallback() != nullptr) {
37 if (addr == MAP_FAILED) {
38 MEDIA_ERR_LOG("DeferredPhotoProcessingSessionCallback::OnProcessImageDone() mmap failed");
39 deferredPhotoProcSession_->GetCallback()->OnError(imageId, ERROR_IMAGE_PROC_FAILED);
40 return 0;
41 } else {
42 deferredPhotoProcSession_->GetCallback()->OnProcessImageDone(imageId, static_cast<uint8_t*>(addr), bytes,
43 cloudImageEnhanceFlag);
44 }
45 } else {
46 MEDIA_INFO_LOG("DeferredPhotoProcessingSessionCallback::OnProcessImageDone not set!, Discarding callback");
47 }
48 munmap(addr, bytes);
49 return 0;
50 }
51
OnError(const std::string & imageId,const DeferredProcessing::ErrorCode errorCode)52 int32_t DeferredPhotoProcessingSessionCallback::OnError(const std::string &imageId,
53 const DeferredProcessing::ErrorCode errorCode)
54 {
55 MEDIA_INFO_LOG("DeferredPhotoProcessingSessionCallback::OnError() is called, errorCode: %{public}d", errorCode);
56 if (deferredPhotoProcSession_ != nullptr && deferredPhotoProcSession_->GetCallback() != nullptr) {
57 deferredPhotoProcSession_->GetCallback()->OnError(imageId, DpsErrorCode(errorCode));
58 } else {
59 MEDIA_INFO_LOG("DeferredPhotoProcessingSessionCallback::OnError not set!, Discarding callback");
60 }
61 return 0;
62 }
63
OnStateChanged(const DeferredProcessing::StatusCode status)64 int32_t DeferredPhotoProcessingSessionCallback::OnStateChanged(const DeferredProcessing::StatusCode status)
65 {
66 MEDIA_INFO_LOG("DeferredPhotoProcessingSessionCallback::OnStateChanged() is called, status:%{public}d", status);
67 if (deferredPhotoProcSession_ != nullptr && deferredPhotoProcSession_->GetCallback() != nullptr) {
68 deferredPhotoProcSession_->GetCallback()->OnStateChanged(DpsStatusCode(status));
69 } else {
70 MEDIA_INFO_LOG("DeferredPhotoProcessingSessionCallback::OnStateChanged not set!, Discarding callback");
71 }
72 return 0;
73 }
74
OnProcessImageDone(const std::string & imageId,std::shared_ptr<PictureIntf> pictureIntf,uint32_t cloudImageEnhanceFlag)75 int32_t DeferredPhotoProcessingSessionCallback::OnProcessImageDone(const std::string &imageId,
76 std::shared_ptr<PictureIntf> pictureIntf, uint32_t cloudImageEnhanceFlag)
77 {
78 MEDIA_INFO_LOG("DeferredPhotoProcessingSessionCallback::OnProcessImageDone() is"
79 "called, status:%{public}s, cloudImageEnhanceFlag: %{public}u", imageId.c_str(), cloudImageEnhanceFlag);
80 if (pictureIntf != nullptr) {
81 MEDIA_INFO_LOG("picture is not null");
82 }
83 if (deferredPhotoProcSession_ != nullptr && deferredPhotoProcSession_->GetCallback() != nullptr) {
84 deferredPhotoProcSession_->GetCallback()->OnProcessImageDone(imageId, pictureIntf, cloudImageEnhanceFlag);
85 } else {
86 MEDIA_INFO_LOG("DeferredPhotoProcessingSessionCallback::OnProcessImageDone not set!, Discarding callback");
87 }
88 return 0;
89 }
90
OnDeliveryLowQualityImage(const std::string & imageId,std::shared_ptr<PictureIntf> pictureIntf)91 int32_t DeferredPhotoProcessingSessionCallback::OnDeliveryLowQualityImage(const std::string &imageId,
92 std::shared_ptr<PictureIntf> pictureIntf)
93 {
94 MEDIA_INFO_LOG("DeferredPhotoProcessingSessionCallback::OnDeliveryLowQualityImage() is"
95 "called, status:%{public}s", imageId.c_str());
96 auto callback = deferredPhotoProcSession_->GetCallback();
97 if (pictureIntf != nullptr && callback != nullptr) {
98 MEDIA_INFO_LOG("pictureIntf is not null");
99 callback->OnDeliveryLowQualityImage(imageId, pictureIntf);
100 }
101 return 0;
102 }
103
DeferredPhotoProcSession(int userId,std::shared_ptr<IDeferredPhotoProcSessionCallback> callback)104 DeferredPhotoProcSession::DeferredPhotoProcSession(int userId,
105 std::shared_ptr<IDeferredPhotoProcSessionCallback> callback)
106 {
107 MEDIA_INFO_LOG("enter.");
108 userId_ = userId;
109 callback_ = callback;
110 }
111
~DeferredPhotoProcSession()112 DeferredPhotoProcSession::~DeferredPhotoProcSession()
113 {
114 MEDIA_INFO_LOG("DeferredPhotoProcSession::DeferredPhotoProcSession Destructor!");
115 if (remoteSession_ != nullptr) {
116 (void)remoteSession_->AsObject()->RemoveDeathRecipient(deathRecipient_);
117 remoteSession_ = nullptr;
118 }
119 }
120
BeginSynchronize()121 void DeferredPhotoProcSession::BeginSynchronize()
122 {
123 if (remoteSession_ == nullptr) {
124 MEDIA_ERR_LOG("DeferredPhotoProcSession::BeginSynchronize failed due to binder died.");
125 } else {
126 MEDIA_INFO_LOG("DeferredPhotoProcSession:BeginSynchronize() enter.");
127 remoteSession_->BeginSynchronize();
128 }
129 return;
130 }
131
EndSynchronize()132 void DeferredPhotoProcSession::EndSynchronize()
133 {
134 if (remoteSession_ == nullptr) {
135 MEDIA_ERR_LOG("DeferredPhotoProcSession::EndSynchronize failed due to binder died.");
136 } else {
137 MEDIA_INFO_LOG("DeferredPhotoProcSession::EndSynchronize() enter.");
138 remoteSession_->EndSynchronize();
139 }
140 return;
141 }
142
AddImage(const std::string & imageId,DpsMetadata & metadata,const bool discardable)143 void DeferredPhotoProcSession::AddImage(const std::string& imageId, DpsMetadata& metadata, const bool discardable)
144 {
145 if (remoteSession_ == nullptr) {
146 MEDIA_ERR_LOG("DeferredPhotoProcSession::AddImage failed due to binder died.");
147 } else {
148 MEDIA_INFO_LOG("DeferredPhotoProcSession::AddImage() enter.");
149 remoteSession_->AddImage(imageId, metadata, discardable);
150 }
151 return;
152 }
153
RemoveImage(const std::string & imageId,const bool restorable)154 void DeferredPhotoProcSession::RemoveImage(const std::string& imageId, const bool restorable)
155 {
156 if (remoteSession_ == nullptr) {
157 MEDIA_ERR_LOG("DeferredPhotoProcSession::RemoveImage failed due to binder died.");
158 } else {
159 MEDIA_INFO_LOG("DeferredPhotoProcSession RemoveImage() enter.");
160 remoteSession_->RemoveImage(imageId, restorable);
161 }
162 return;
163 }
164
RestoreImage(const std::string & imageId)165 void DeferredPhotoProcSession::RestoreImage(const std::string& imageId)
166 {
167 if (remoteSession_ == nullptr) {
168 MEDIA_ERR_LOG("DeferredPhotoProcSession::RestoreImage failed due to binder died.");
169 } else {
170 MEDIA_INFO_LOG("DeferredPhotoProcSession RestoreImage() enter.");
171 remoteSession_->RestoreImage(imageId);
172 }
173 return;
174 }
175
ProcessImage(const std::string & appName,const std::string & imageId)176 void DeferredPhotoProcSession::ProcessImage(const std::string& appName, const std::string& imageId)
177 {
178 if (remoteSession_ == nullptr) {
179 MEDIA_ERR_LOG("DeferredPhotoProcSession::ProcessImage failed due to binder died.");
180 } else {
181 MEDIA_INFO_LOG("DeferredPhotoProcSession::ProcessImage() enter.");
182 remoteSession_->ProcessImage(appName, imageId);
183 }
184 return;
185 }
186
CancelProcessImage(const std::string & imageId)187 bool DeferredPhotoProcSession::CancelProcessImage(const std::string& imageId)
188 {
189 if (remoteSession_ == nullptr) {
190 MEDIA_ERR_LOG("DeferredPhotoProcSession::CancelProcessImage failed due to binder died.");
191 return false;
192 }
193 MEDIA_INFO_LOG("DeferredPhotoProcSession:CancelProcessImage() enter.");
194 remoteSession_->CancelProcessImage(imageId);
195 return true;
196 }
197
SetDeferredPhotoSession(sptr<DeferredProcessing::IDeferredPhotoProcessingSession> & session)198 int32_t DeferredPhotoProcSession::SetDeferredPhotoSession(
199 sptr<DeferredProcessing::IDeferredPhotoProcessingSession>& session)
200 {
201 remoteSession_ = session;
202 sptr<IRemoteObject> object = remoteSession_->AsObject();
203 pid_t pid = 0;
204 deathRecipient_ = new(std::nothrow) CameraDeathRecipient(pid);
205 CHECK_ERROR_RETURN_RET_LOG(deathRecipient_ == nullptr, CAMERA_ALLOC_ERROR, "failed to new CameraDeathRecipient.");
206
207 deathRecipient_->SetNotifyCb([this](pid_t pid) { CameraServerDied(pid); });
208 bool result = object->AddDeathRecipient(deathRecipient_);
209 CHECK_ERROR_RETURN_RET_LOG(!result, -1, "failed to add deathRecipient");
210 return 0;
211 }
212
CameraServerDied(pid_t pid)213 void DeferredPhotoProcSession::CameraServerDied(pid_t pid)
214 {
215 MEDIA_ERR_LOG("camera server has died, pid:%{public}d!", pid);
216 if (remoteSession_ != nullptr) {
217 (void)remoteSession_->AsObject()->RemoveDeathRecipient(deathRecipient_);
218 remoteSession_ = nullptr;
219 }
220 deathRecipient_ = nullptr;
221 ReconnectDeferredProcessingSession();
222 if (callback_ != nullptr) {
223 MEDIA_INFO_LOG("Reconnect session successful, send sync requestion.");
224 callback_->OnError("", DpsErrorCode::ERROR_SESSION_SYNC_NEEDED);
225 }
226 return;
227 }
228
ReconnectDeferredProcessingSession()229 void DeferredPhotoProcSession::ReconnectDeferredProcessingSession()
230 {
231 MEDIA_INFO_LOG("DeferredPhotoProcSession::ReconnectDeferredProcessingSession, enter.");
232 ConnectDeferredProcessingSession();
233 if (remoteSession_ == nullptr) {
234 MEDIA_INFO_LOG("Reconnecting deferred processing session failed.");
235 ReconnectDeferredProcessingSession();
236 }
237 return;
238 }
239
ConnectDeferredProcessingSession()240 void DeferredPhotoProcSession::ConnectDeferredProcessingSession()
241 {
242 MEDIA_INFO_LOG("DeferredPhotoProcSession::ConnectDeferredProcessingSession, enter.");
243 CHECK_ERROR_RETURN_LOG(remoteSession_ != nullptr, "remoteSession_ is not null");
244 sptr<IRemoteObject> object = nullptr;
245 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
246 CHECK_ERROR_RETURN_LOG(samgr == nullptr, "Failed to get System ability manager");
247 object = samgr->GetSystemAbility(CAMERA_SERVICE_ID);
248 CHECK_ERROR_RETURN_LOG(object == nullptr, "object is null");
249 serviceProxy_ = iface_cast<ICameraService>(object);
250 CHECK_ERROR_RETURN_LOG(serviceProxy_ == nullptr, "serviceProxy_ is null");
251 sptr<DeferredProcessing::IDeferredPhotoProcessingSession> session = nullptr;
252 sptr<DeferredProcessing::IDeferredPhotoProcessingSessionCallback> remoteCallback = nullptr;
253 sptr<DeferredPhotoProcSession> deferredPhotoProcSession = nullptr;
254 deferredPhotoProcSession = new(std::nothrow) DeferredPhotoProcSession(userId_, callback_);
255 CHECK_ERROR_RETURN(deferredPhotoProcSession == nullptr);
256 remoteCallback = new(std::nothrow) DeferredPhotoProcessingSessionCallback(deferredPhotoProcSession);
257 CHECK_ERROR_RETURN(remoteCallback == nullptr);
258 serviceProxy_->CreateDeferredPhotoProcessingSession(userId_, remoteCallback, session);
259 CHECK_EXECUTE(session, SetDeferredPhotoSession(session));
260 return;
261 }
262
GetCallback()263 std::shared_ptr<IDeferredPhotoProcSessionCallback> DeferredPhotoProcSession::GetCallback()
264 {
265 return callback_;
266 }
267
268 } // namespace CameraStandard
269 } // namespace OHOS