1 /*
2 * Copyright (c) 2024-2024 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 <unistd.h>
17 #include <sys/mman.h>
18 #include <iomanip>
19
20 #include <buffer_handle_parcel.h>
21 #include "camera_log.h"
22 #include "datetime_ex.h"
23 #include "camera_server_photo_proxy.h"
24 #include "photo_proxy.h"
25
26 namespace OHOS {
27 namespace CameraStandard {
28
29 static std::string g_lastDisplayName = "";
30 static int32_t g_saveIndex = 0;
CameraServerPhotoProxy()31 CameraServerPhotoProxy::CameraServerPhotoProxy()
32 {
33 format_ = 0;
34 photoId_ = "";
35 deferredProcType_ = 0;
36 photoWidth_ = 0;
37 photoHeight_ = 0;
38 bufferHandle_ = nullptr;
39 fileDataAddr_ = nullptr;
40 fileSize_ = 0;
41 isMmaped_ = false;
42 isDeferredPhoto_ = 0;
43 isHighQuality_ = false;
44 mode_ = 0;
45 longitude_ = -1.0;
46 latitude_ = -1.0;
47 captureId_ = 0;
48 burstSeqId_ = -1;
49 burstKey_ = "";
50 isCoverPhoto_ = false;
51 imageFormat_ = 0;
52 cloudImageEnhanceFlag_ = 0;
53 }
54
~CameraServerPhotoProxy()55 CameraServerPhotoProxy::~CameraServerPhotoProxy()
56 {
57 std::lock_guard<std::mutex> lock(mutex_);
58 MEDIA_INFO_LOG("~CameraServerPhotoProxy");
59 CameraFreeBufferHandle(const_cast<BufferHandle*>(bufferHandle_));
60 fileDataAddr_ = nullptr;
61 fileSize_ = 0;
62 }
63
CameraFreeBufferHandle(BufferHandle * handle)64 int32_t CameraServerPhotoProxy::CameraFreeBufferHandle(BufferHandle *handle)
65 {
66 CHECK_ERROR_RETURN_RET_LOG(handle == nullptr, 0, "CameraFreeBufferHandle with nullptr handle");
67 if (handle->fd >= 0) {
68 close(handle->fd);
69 handle->fd = -1;
70 }
71 const uint32_t reserveFds = handle->reserveFds;
72 for (uint32_t i = 0; i < reserveFds; i++) {
73 if (handle->reserve[i] >= 0) {
74 close(handle->reserve[i]);
75 handle->reserve[i] = -1;
76 }
77 }
78 free(handle);
79 return 0;
80 }
81
CreateDisplayName()82 std::string CreateDisplayName()
83 {
84 struct tm currentTime;
85 std::string formattedTime = "";
86 if (GetSystemCurrentTime(¤tTime)) {
87 std::stringstream ss;
88 ss << prefix << std::setw(yearWidth) << std::setfill(placeholder) << currentTime.tm_year + startYear
89 << std::setw(otherWidth) << std::setfill(placeholder) << (currentTime.tm_mon + 1)
90 << std::setw(otherWidth) << std::setfill(placeholder) << currentTime.tm_mday
91 << connector << std::setw(otherWidth) << std::setfill(placeholder) << currentTime.tm_hour
92 << std::setw(otherWidth) << std::setfill(placeholder) << currentTime.tm_min
93 << std::setw(otherWidth) << std::setfill(placeholder) << currentTime.tm_sec;
94 formattedTime = ss.str();
95 } else {
96 MEDIA_ERR_LOG("Failed to get current time.");
97 }
98 if (g_lastDisplayName == formattedTime) {
99 g_saveIndex++;
100 formattedTime = formattedTime + connector + std::to_string(g_saveIndex);
101 MEDIA_INFO_LOG("CreateDisplayName is %{private}s", formattedTime.c_str());
102 return formattedTime;
103 }
104 g_lastDisplayName = formattedTime;
105 g_saveIndex = 0;
106 MEDIA_INFO_LOG("CreateDisplayName is %{private}s", formattedTime.c_str());
107 return formattedTime;
108 }
109
SetDisplayName(std::string displayName)110 void CameraServerPhotoProxy::SetDisplayName(std::string displayName)
111 {
112 displayName_ = displayName;
113 }
114
ReadFromParcel(MessageParcel & parcel)115 void CameraServerPhotoProxy::ReadFromParcel(MessageParcel &parcel)
116 {
117 std::lock_guard<std::mutex> lock(mutex_);
118 photoId_ = parcel.ReadString();
119 deferredProcType_ = parcel.ReadInt32();
120 isDeferredPhoto_ = parcel.ReadInt32();
121 format_ = parcel.ReadInt32();
122 photoWidth_ = parcel.ReadInt32();
123 photoHeight_ = parcel.ReadInt32();
124 isHighQuality_ = parcel.ReadBool();
125 fileSize_ = parcel.ReadUint64();
126 latitude_ = parcel.ReadDouble();
127 longitude_ = parcel.ReadDouble();
128 captureId_ = parcel.ReadInt32();
129 burstSeqId_ = parcel.ReadInt32();
130 imageFormat_ = parcel.ReadInt32();
131 cloudImageEnhanceFlag_ = parcel.ReadUint32();
132 bufferHandle_ = ReadBufferHandle(parcel);
133 MEDIA_INFO_LOG("CameraServerPhotoProxy::ReadFromParcel");
134 }
135
GetCaptureId()136 int32_t CameraServerPhotoProxy::GetCaptureId()
137 {
138 MEDIA_INFO_LOG("CameraServerPhotoProxy::GetCaptureId captureId:%{public}d", captureId_);
139 std::lock_guard<std::mutex> lock(mutex_);
140 return captureId_;
141 }
142
GetBurstSeqId()143 int32_t CameraServerPhotoProxy::GetBurstSeqId()
144 {
145 MEDIA_INFO_LOG("CameraServerPhotoProxy::GetBurstSeqId burstSeqId:%{public}d", burstSeqId_);
146 std::lock_guard<std::mutex> lock(mutex_);
147 return burstSeqId_;
148 }
149
GetPhotoId()150 std::string CameraServerPhotoProxy::GetPhotoId()
151 {
152 MEDIA_INFO_LOG("CameraServerPhotoProxy::GetPhotoId photoId:%{public}s", photoId_.c_str());
153 std::lock_guard<std::mutex> lock(mutex_);
154 return photoId_;
155 }
156
GetDeferredProcType()157 Media::DeferredProcType CameraServerPhotoProxy::GetDeferredProcType()
158 {
159 MEDIA_DEBUG_LOG("CameraServerPhotoProxy::GetDeferredProcType");
160 std::lock_guard<std::mutex> lock(mutex_);
161 if (deferredProcType_ == 0) {
162 return Media::DeferredProcType::BACKGROUND;
163 } else {
164 return Media::DeferredProcType::OFFLINE;
165 }
166 }
167
GetFileDataAddr()168 void* CameraServerPhotoProxy::GetFileDataAddr()
169 {
170 MEDIA_INFO_LOG("CameraServerPhotoProxy::GetFileDataAddr");
171 std::lock_guard<std::mutex> lock(mutex_);
172 CHECK_ERROR_RETURN_RET_LOG(
173 bufferHandle_ == nullptr, fileDataAddr_, "CameraServerPhotoProxy::GetFileDataAddr bufferHandle_ is nullptr");
174 if (!isMmaped_) {
175 MEDIA_INFO_LOG("CameraServerPhotoProxy::GetFileDataAddr mmap");
176 fileDataAddr_ = mmap(nullptr, bufferHandle_->size, PROT_READ, MAP_SHARED, bufferHandle_->fd, 0);
177 CHECK_ERROR_RETURN_RET_LOG(
178 fileDataAddr_ == MAP_FAILED, fileDataAddr_, "CameraServerPhotoProxy::GetFileDataAddr mmap failed");
179 isMmaped_ = true;
180 } else {
181 MEDIA_ERR_LOG("CameraServerPhotoProxy::GetFileDataAddr mmap failed");
182 }
183 return fileDataAddr_;
184 }
185
GetFileSize()186 size_t CameraServerPhotoProxy::GetFileSize()
187 {
188 MEDIA_INFO_LOG("CameraServerPhotoProxy::GetFileSize");
189 std::lock_guard<std::mutex> lock(mutex_);
190 return fileSize_;
191 }
192
GetWidth()193 int32_t CameraServerPhotoProxy::GetWidth()
194 {
195 return photoWidth_;
196 }
197
GetHeight()198 int32_t CameraServerPhotoProxy::GetHeight()
199 {
200 return photoHeight_;
201 }
202
GetFormat()203 PhotoFormat CameraServerPhotoProxy::GetFormat()
204 {
205 auto iter = formatMap.find(imageFormat_);
206 CHECK_ERROR_RETURN_RET(iter != formatMap.end(), iter->second);
207 return Media::PhotoFormat::RGBA;
208 }
209
GetPhotoQuality()210 PhotoQuality CameraServerPhotoProxy::GetPhotoQuality()
211 {
212 return isHighQuality_ ? Media::PhotoQuality::HIGH : Media::PhotoQuality::LOW;
213 }
214
Release()215 void CameraServerPhotoProxy::Release()
216 {
217 MEDIA_INFO_LOG("CameraServerPhotoProxy release enter");
218 if (isMmaped_ && bufferHandle_ != nullptr) {
219 munmap(fileDataAddr_, bufferHandle_->size);
220 } else {
221 MEDIA_ERR_LOG("~CameraServerPhotoProxy munmap failed");
222 }
223 }
224
GetTitle()225 std::string CameraServerPhotoProxy::GetTitle()
226 {
227 return displayName_;
228 }
229
GetExtension()230 std::string CameraServerPhotoProxy::GetExtension()
231 {
232 std::string suffix = suffixJpeg;
233 switch (GetFormat()) {
234 case PhotoFormat::HEIF : {
235 suffix = suffixHeif;
236 break;
237 }
238 case PhotoFormat::DNG : {
239 suffix = suffixDng;
240 break;
241 }
242 default: {
243 suffix = suffixJpeg;
244 break;
245 }
246 }
247 return suffix;
248 }
249
GetLatitude()250 double CameraServerPhotoProxy::GetLatitude()
251 {
252 return latitude_;
253 }
GetLongitude()254 double CameraServerPhotoProxy::GetLongitude()
255 {
256 return longitude_;
257 }
GetShootingMode()258 int32_t CameraServerPhotoProxy::GetShootingMode()
259 {
260 auto iter = modeMap.find(mode_);
261 CHECK_ERROR_RETURN_RET(iter != modeMap.end(), iter->second);
262 return 0;
263 }
SetShootingMode(int32_t mode)264 void CameraServerPhotoProxy::SetShootingMode(int32_t mode)
265 {
266 mode_ = mode;
267 }
268
GetBurstKey()269 std::string CameraServerPhotoProxy::GetBurstKey()
270 {
271 MEDIA_DEBUG_LOG("CameraServerPhotoProxy GetBurstKey");
272 return burstKey_;
273 }
274
IsCoverPhoto()275 bool CameraServerPhotoProxy::IsCoverPhoto()
276 {
277 MEDIA_DEBUG_LOG("CameraServerPhotoProxy IsCoverPhoto");
278 return isCoverPhoto_;
279 }
280
SetBurstInfo(std::string burstKey,bool isCoverPhoto)281 void CameraServerPhotoProxy::SetBurstInfo(std::string burstKey, bool isCoverPhoto)
282 {
283 MEDIA_INFO_LOG("CameraServerPhotoProxy SetBurstInfo");
284 burstKey_ = burstKey;
285 isCoverPhoto_ = isCoverPhoto;
286 isHighQuality_ = true; // tell media lib disable deferred photo
287 }
288
GetCloudImageEnhanceFlag()289 uint32_t CameraServerPhotoProxy::GetCloudImageEnhanceFlag()
290 {
291 MEDIA_DEBUG_LOG("%{public}s get value: %{public}u", __FUNCTION__, cloudImageEnhanceFlag_);
292 return cloudImageEnhanceFlag_;
293 }
294
295 } // namespace CameraStandard
296 } // namespace OHOS
297