1 /*
2 * Copyright (C) 2021 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 "recorder_server.h"
17 #include "map"
18 #include "media_log.h"
19 #include "media_errors.h"
20 #include "engine_factory_repo.h"
21 #include "param_wrapper.h"
22 #include "accesstoken_kit.h"
23 #include "ipc_skeleton.h"
24 #include "media_dfx.h"
25 #include "hitrace/tracechain.h"
26 #include "media_utils.h"
27 #ifdef SUPPORT_RECORDER_CREATE_FILE
28 #include "media_library_adapter.h"
29 #include "system_ability_definition.h"
30 #include "iservice_registry.h"
31 #include "hcamera_service_proxy.h"
32 #endif
33 #ifdef SUPPORT_POWER_MANAGER
34 #include "shutdown/shutdown_priority.h"
35 #endif
36
37 namespace {
38 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_RECORDER, "RecorderServer"};
39 const std::map<OHOS::Media::RecorderServer::RecStatus, std::string> RECORDER_STATE_MAP = {
40 {OHOS::Media::RecorderServer::REC_INITIALIZED, "initialized"},
41 {OHOS::Media::RecorderServer::REC_CONFIGURED, "configured"},
42 {OHOS::Media::RecorderServer::REC_PREPARED, "prepared"},
43 {OHOS::Media::RecorderServer::REC_RECORDING, "recording"},
44 {OHOS::Media::RecorderServer::REC_PAUSED, "paused"},
45 {OHOS::Media::RecorderServer::REC_ERROR, "error"},
46 };
47 const std::string VID_DEBUG_INFO_KEY = "com.openharmony.timed_metadata.vid_maker_info";
48 }
49
50 namespace OHOS {
51 namespace Media {
52 const std::string START_TAG = "RecorderCreate->Start";
53 const std::string STOP_TAG = "RecorderStop->Destroy";
54 #define CHECK_STATUS_FAILED_AND_LOGE_RET(statusFailed, ret) \
55 do { \
56 if (statusFailed) { \
57 MEDIA_LOGE("invalid status, current status is %{public}s", GetStatusDescription(status_).c_str()); \
58 return ret; \
59 }; \
60 } while (false)
61
Create()62 std::shared_ptr<IRecorderService> RecorderServer::Create()
63 {
64 std::shared_ptr<RecorderServer> server = std::make_shared<RecorderServer>();
65 int32_t ret = server->Init();
66 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, nullptr, "failed to init RecorderServer");
67 return server;
68 }
69
RecorderServer()70 RecorderServer::RecorderServer()
71 : taskQue_("RecorderServer")
72 {
73 MEDIA_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this));
74 taskQue_.Start();
75 instanceId_ = OHOS::HiviewDFX::HiTraceChain::GetId().GetChainId();
76 CreateMediaInfo(AVRECORDER, IPCSkeleton::GetCallingUid(), instanceId_);
77 }
78
~RecorderServer()79 RecorderServer::~RecorderServer()
80 {
81 MEDIA_LOGD("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this));
82 {
83 std::lock_guard<std::mutex> lock(mutex_);
84 auto task = std::make_shared<TaskHandler<void>>([&, this] {
85 recorderEngine_ = nullptr;
86 #ifdef SUPPORT_POWER_MANAGER
87 syncCallback_ = nullptr;
88 #endif
89 });
90 (void)taskQue_.EnqueueTask(task);
91 (void)task->GetResult();
92 taskQue_.Stop();
93 }
94 }
95
Init()96 int32_t RecorderServer::Init()
97 {
98 MediaTrace trace("RecorderServer::Init");
99 uint32_t tokenId = IPCSkeleton::GetCallingTokenID();
100 uint64_t fullTokenId = IPCSkeleton::GetCallingFullTokenID();
101 int32_t appUid = IPCSkeleton::GetCallingUid();
102 int32_t appPid = IPCSkeleton::GetCallingPid();
103 bundleName_ = GetClientBundleName(appUid);
104
105 auto task = std::make_shared<TaskHandler<MediaServiceErrCode>>([&, this] {
106 auto engineFactory = EngineFactoryRepo::Instance().GetEngineFactory(
107 IEngineFactory::Scene::SCENE_RECORDER, appUid);
108 CHECK_AND_RETURN_RET_LOG(engineFactory != nullptr, MSERR_CREATE_REC_ENGINE_FAILED,
109 "failed to get factory");
110 recorderEngine_ = engineFactory->CreateRecorderEngine(appUid, appPid, tokenId, fullTokenId);
111 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_CREATE_REC_ENGINE_FAILED,
112 "failed to create recorder engine");
113 recorderEngine_->SetCallingInfo(bundleName_, instanceId_);
114 return MSERR_OK;
115 });
116 int32_t ret = taskQue_.EnqueueTask(task);
117 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
118
119 auto result = task->GetResult();
120 CHECK_AND_RETURN_RET_LOG(result.Value() == MSERR_OK, result.Value(), "Result failed");
121
122 status_ = REC_INITIALIZED;
123 #ifdef SUPPORT_POWER_MANAGER
124 syncCallback_ = new SaveDocumentSyncCallback();
125 #endif
126 return MSERR_OK;
127 }
128
GetStatusDescription(OHOS::Media::RecorderServer::RecStatus status)129 const std::string& RecorderServer::GetStatusDescription(OHOS::Media::RecorderServer::RecStatus status)
130 {
131 static const std::string ILLEGAL_STATE = "PLAYER_STATUS_ILLEGAL";
132 CHECK_AND_RETURN_RET(status >= OHOS::Media::RecorderServer::REC_INITIALIZED &&
133 status <= OHOS::Media::RecorderServer::REC_ERROR, ILLEGAL_STATE);
134
135 return RECORDER_STATE_MAP.find(status)->second;
136 }
137
OnError(ErrorType errorType,int32_t errorCode)138 void RecorderServer::OnError(ErrorType errorType, int32_t errorCode)
139 {
140 std::lock_guard<std::mutex> lock(cbMutex_);
141 lastErrMsg_ = MSErrorToExtErrorString(static_cast<MediaServiceErrCode>(errorCode));
142 SetErrorInfo(errorCode, lastErrMsg_);
143 CHECK_AND_RETURN(recorderCb_ != nullptr);
144 recorderCb_->OnError(static_cast<RecorderErrorType>(errorType), errorCode);
145 }
146
OnInfo(InfoType type,int32_t extra)147 void RecorderServer::OnInfo(InfoType type, int32_t extra)
148 {
149 std::lock_guard<std::mutex> lock(cbMutex_);
150
151 CHECK_AND_RETURN_LOG(recorderCb_ != nullptr, "RecorderServer OnInfo recorderCb_ is null");
152 recorderCb_->OnInfo(type, extra);
153 }
154
OnAudioCaptureChange(const AudioRecorderChangeInfo & audioRecorderChangeInfo)155 void RecorderServer::OnAudioCaptureChange(const AudioRecorderChangeInfo &audioRecorderChangeInfo)
156 {
157 MEDIA_LOGI("RecorderServer OnAudioCaptureChange start.");
158 std::lock_guard<std::mutex> lock(cbMutex_);
159
160 CHECK_AND_RETURN_LOG(recorderCb_ != nullptr, "RecorderServer OnAudioCaptureChange recorderCb_ is null");
161 recorderCb_->OnAudioCaptureChange(audioRecorderChangeInfo);
162 }
163
SetVideoSource(VideoSourceType source,int32_t & sourceId)164 int32_t RecorderServer::SetVideoSource(VideoSourceType source, int32_t &sourceId)
165 {
166 MediaTrace trace("RecorderServer::SetVideoSource");
167 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetVideoSource in, source(%{public}d), sourceId(%{public}d)",
168 FAKE_POINTER(this), source, sourceId);
169 std::lock_guard<std::mutex> lock(mutex_);
170 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_INITIALIZED, MSERR_INVALID_OPERATION);
171 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
172 config_.videoSource = source;
173 config_.withVideo = true;
174 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
175 return recorderEngine_->SetVideoSource(source, sourceId);
176 });
177 int32_t ret = taskQue_.EnqueueTask(task);
178 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
179
180 auto result = task->GetResult();
181 return result.Value();
182 }
183
SetVideoEncoder(int32_t sourceId,VideoCodecFormat encoder)184 int32_t RecorderServer::SetVideoEncoder(int32_t sourceId, VideoCodecFormat encoder)
185 {
186 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetVideoSource in, sourceId(%{public}d), encoder(%{public}d)",
187 FAKE_POINTER(this), sourceId, encoder);
188 std::lock_guard<std::mutex> lock(mutex_);
189 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
190 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
191 config_.videoCodec = encoder;
192 VidEnc vidEnc(encoder);
193 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
194 return recorderEngine_->Configure(sourceId, vidEnc);
195 });
196 int32_t ret = taskQue_.EnqueueTask(task);
197 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
198
199 auto result = task->GetResult();
200 return result.Value();
201 }
202
SetVideoSize(int32_t sourceId,int32_t width,int32_t height)203 int32_t RecorderServer::SetVideoSize(int32_t sourceId, int32_t width, int32_t height)
204 {
205 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetVideoSize in, sourceId(%{public}d), width(%{public}d), "
206 "height(%{public}d)", FAKE_POINTER(this), sourceId, width, height);
207 std::lock_guard<std::mutex> lock(mutex_);
208 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
209 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
210 config_.width = width;
211 config_.height = height;
212 VidRectangle vidSize(width, height);
213 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
214 return recorderEngine_->Configure(sourceId, vidSize);
215 });
216 int32_t ret = taskQue_.EnqueueTask(task);
217 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
218
219 auto result = task->GetResult();
220 return result.Value();
221 }
222
SetVideoFrameRate(int32_t sourceId,int32_t frameRate)223 int32_t RecorderServer::SetVideoFrameRate(int32_t sourceId, int32_t frameRate)
224 {
225 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetVideoFrameRate in, sourceId(%{public}d), "
226 "frameRate(%{public}d)", FAKE_POINTER(this), sourceId, frameRate);
227 std::lock_guard<std::mutex> lock(mutex_);
228 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
229 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
230 config_.frameRate = frameRate;
231 VidFrameRate vidFrameRate(frameRate);
232 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
233 return recorderEngine_->Configure(sourceId, vidFrameRate);
234 });
235 int32_t ret = taskQue_.EnqueueTask(task);
236 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
237
238 auto result = task->GetResult();
239 return result.Value();
240 }
241
SetVideoEncodingBitRate(int32_t sourceId,int32_t rate)242 int32_t RecorderServer::SetVideoEncodingBitRate(int32_t sourceId, int32_t rate)
243 {
244 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetVideoEncodingBitRate in, sourceId(%{public}d), "
245 "rate(%{public}d)", FAKE_POINTER(this), sourceId, rate);
246 std::lock_guard<std::mutex> lock(mutex_);
247 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
248 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
249 config_.bitRate = rate;
250 VidBitRate vidBitRate(rate);
251 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
252 return recorderEngine_->Configure(sourceId, vidBitRate);
253 });
254 int32_t ret = taskQue_.EnqueueTask(task);
255 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
256
257 auto result = task->GetResult();
258 return result.Value();
259 }
260
SetVideoIsHdr(int32_t sourceId,bool isHdr)261 int32_t RecorderServer::SetVideoIsHdr(int32_t sourceId, bool isHdr)
262 {
263 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetVideoIsHdr in, sourceId(%{public}d), isHdr(%{public}d)",
264 FAKE_POINTER(this), sourceId, isHdr);
265 std::lock_guard<std::mutex> lock(mutex_);
266 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
267 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
268 config_.isHdr = isHdr;
269 VidIsHdr vidIsHdr(isHdr);
270 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
271 return recorderEngine_->Configure(sourceId, vidIsHdr);
272 });
273 int32_t ret = taskQue_.EnqueueTask(task);
274 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
275
276 auto result = task->GetResult();
277 return result.Value();
278 }
279
SetVideoEnableTemporalScale(int32_t sourceId,bool enableTemporalScale)280 int32_t RecorderServer::SetVideoEnableTemporalScale(int32_t sourceId, bool enableTemporalScale)
281 {
282 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetVideoEnableTemporalScale in, sourceId(%{public}d), "
283 "enableTemporalScale(%{public}d)", FAKE_POINTER(this), sourceId, enableTemporalScale);
284 std::lock_guard<std::mutex> lock(mutex_);
285 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
286 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
287 config_.enableTemporalScale = enableTemporalScale;
288 VidEnableTemporalScale vidEnableTemporalScale(enableTemporalScale);
289 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
290 return recorderEngine_->Configure(sourceId, vidEnableTemporalScale);
291 });
292 int32_t ret = taskQue_.EnqueueTask(task);
293 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
294
295 auto result = task->GetResult();
296 return result.Value();
297 }
298
SetVideoEnableStableQualityMode(int32_t sourceId,bool enableStableQualityMode)299 int32_t RecorderServer::SetVideoEnableStableQualityMode(int32_t sourceId, bool enableStableQualityMode)
300 {
301 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetVideoEnableStableQualityMode in, sourceId(%{public}d), "
302 "enableStableQualityMode(%{public}d)", FAKE_POINTER(this), sourceId, enableStableQualityMode);
303 std::lock_guard<std::mutex> lock(mutex_);
304 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
305 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
306 config_.enableStableQualityMode = enableStableQualityMode;
307 VidEnableStableQualityMode vidEnableStableQualityMode(enableStableQualityMode);
308 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
309 return recorderEngine_->Configure(sourceId, vidEnableStableQualityMode);
310 });
311 int32_t ret = taskQue_.EnqueueTask(task);
312 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
313
314 auto result = task->GetResult();
315 return result.Value();
316 }
317
SetMetaSource(MetaSourceType source,int32_t & sourceId)318 int32_t RecorderServer::SetMetaSource(MetaSourceType source, int32_t &sourceId)
319 {
320 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetMetaSource in, source(%{public}d), "
321 "sourceId(%{public}d)", FAKE_POINTER(this), source, sourceId);
322
323 std::lock_guard<std::mutex> lock(mutex_);
324 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_INITIALIZED, MSERR_INVALID_OPERATION);
325 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
326
327 config_.metaSource = source;
328 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
329 return recorderEngine_->SetMetaSource(source, sourceId);
330 });
331
332 int32_t ret = taskQue_.EnqueueTask(task);
333 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
334
335 auto result = task->GetResult();
336 return result.Value();
337 }
338
SetMetaMimeType(int32_t sourceId,const std::string_view & type)339 int32_t RecorderServer::SetMetaMimeType(int32_t sourceId, const std::string_view &type)
340 {
341 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetMetaMimeType in, sourceId(%{public}d), "
342 "MimeType(%{public}s)", FAKE_POINTER(this), sourceId, type.data());
343
344 std::lock_guard<std::mutex> lock(mutex_);
345 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
346 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
347
348 config_.metaMimeType = type;
349 MetaMimeType metaMimeType(type);
350 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
351 return recorderEngine_->Configure(sourceId, metaMimeType);
352 });
353
354 int32_t ret = taskQue_.EnqueueTask(task);
355 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
356
357 auto result = task->GetResult();
358 return result.Value();
359 }
360
SetMetaTimedKey(int32_t sourceId,const std::string_view & timedKey)361 int32_t RecorderServer::SetMetaTimedKey(int32_t sourceId, const std::string_view &timedKey)
362 {
363 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetMetaTimedKey in, sourceId(%{public}d), "
364 "MetaTimedKey(%{public}s)", FAKE_POINTER(this), sourceId, timedKey.data());
365
366 std::lock_guard<std::mutex> lock(mutex_);
367 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
368 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
369
370 config_.metaTimedKey = timedKey;
371 MetaTimedKey metaTimedKey(timedKey);
372 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
373 return recorderEngine_->Configure(sourceId, metaTimedKey);
374 });
375 int32_t ret = taskQue_.EnqueueTask(task);
376 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
377
378 auto result = task->GetResult();
379 return result.Value();
380 }
381
SetMetaSourceTrackMime(int32_t sourceId,const std::string_view & srcTrackMime)382 int32_t RecorderServer::SetMetaSourceTrackMime(int32_t sourceId, const std::string_view &srcTrackMime)
383 {
384 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetMetaSourceTrackMime in, sourceId(%{public}d), "
385 "sourceTrackMime(%{public}s)", FAKE_POINTER(this), sourceId, srcTrackMime.data());
386 std::lock_guard<std::mutex> lock(mutex_);
387 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
388 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
389
390 config_.metaSrcTrackMime = srcTrackMime;
391 MetaSourceTrackMime metaSrcTrackMime(srcTrackMime);
392 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
393 return recorderEngine_->Configure(sourceId, metaSrcTrackMime);
394 });
395 int32_t ret = taskQue_.EnqueueTask(task);
396 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
397
398 auto result = task->GetResult();
399 return result.Value();
400 }
401
SetCaptureRate(int32_t sourceId,double fps)402 int32_t RecorderServer::SetCaptureRate(int32_t sourceId, double fps)
403 {
404 MEDIA_LOGI("SetCaptureRate sourceId(%{public}d), fps(%{public}lf)", sourceId, fps);
405 std::lock_guard<std::mutex> lock(mutex_);
406 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
407 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
408 config_.captureRate = fps;
409 CaptureRate captureRate(fps);
410 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
411 return recorderEngine_->Configure(sourceId, captureRate);
412 });
413 int32_t ret = taskQue_.EnqueueTask(task);
414 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
415
416 auto result = task->GetResult();
417 return result.Value();
418 }
419
GetSurface(int32_t sourceId)420 sptr<OHOS::Surface> RecorderServer::GetSurface(int32_t sourceId)
421 {
422 MEDIA_LOGI("ecorderServer:0x%{public}06" PRIXPTR " GetSurface in, sourceId(%{public}d)",
423 FAKE_POINTER(this), sourceId);
424 std::lock_guard<std::mutex> lock(mutex_);
425 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_PREPARED && status_ != REC_RECORDING && status_ != REC_PAUSED,
426 nullptr);
427 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, nullptr, "engine is nullptr");
428 auto task = std::make_shared<TaskHandler<sptr<OHOS::Surface>>>([&, this] {
429 return recorderEngine_->GetSurface(sourceId);
430 });
431 int32_t ret = taskQue_.EnqueueTask(task);
432 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, nullptr, "EnqueueTask failed");
433
434 auto result = task->GetResult();
435 return result.Value();
436 }
437
GetMetaSurface(int32_t sourceId)438 sptr<OHOS::Surface> RecorderServer::GetMetaSurface(int32_t sourceId)
439 {
440 MEDIA_LOGI("ecorderServer:0x%{public}06" PRIXPTR " GetMetaSurface in, sourceId(%{public}d)",
441 FAKE_POINTER(this), sourceId);
442 std::lock_guard<std::mutex> lock(mutex_);
443 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_PREPARED && status_ != REC_RECORDING && status_ != REC_PAUSED,
444 nullptr);
445 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, nullptr, "engine is nullptr");
446 auto task = std::make_shared<TaskHandler<sptr<OHOS::Surface>>>([&, this] {
447 return recorderEngine_->GetMetaSurface(sourceId);
448 });
449 int32_t ret = taskQue_.EnqueueTask(task);
450 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, nullptr, "EnqueueTask failed");
451
452 auto result = task->GetResult();
453 return result.Value();
454 }
455
SetAudioSource(AudioSourceType source,int32_t & sourceId)456 int32_t RecorderServer::SetAudioSource(AudioSourceType source, int32_t &sourceId)
457 {
458 MediaTrace trace("RecorderServer::SetAudioSource");
459 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetAudioSource in, source(%{public}d), sourceId(%{public}d)",
460 FAKE_POINTER(this), source, sourceId);
461 std::lock_guard<std::mutex> lock(mutex_);
462 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_INITIALIZED, MSERR_INVALID_OPERATION);
463 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
464
465 config_.audioSource = source;
466 config_.withAudio = true;
467 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
468 return recorderEngine_->SetAudioSource(source, sourceId);
469 });
470 int32_t ret = taskQue_.EnqueueTask(task);
471 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
472
473 auto result = task->GetResult();
474 return result.Value();
475 }
476
SetAudioDataSource(const std::shared_ptr<IAudioDataSource> & audioSource,int32_t & sourceId)477 int32_t RecorderServer::SetAudioDataSource(const std::shared_ptr<IAudioDataSource>& audioSource, int32_t& sourceId)
478 {
479 std::lock_guard<std::mutex> lock(mutex_);
480 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_INITIALIZED, MSERR_INVALID_OPERATION);
481 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
482
483 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
484 return recorderEngine_->SetAudioDataSource(audioSource, sourceId);
485 });
486 int32_t ret = taskQue_.EnqueueTask(task);
487 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
488
489 auto result = task->GetResult();
490 return result.Value();
491 }
492
SetAudioEncoder(int32_t sourceId,AudioCodecFormat encoder)493 int32_t RecorderServer::SetAudioEncoder(int32_t sourceId, AudioCodecFormat encoder)
494 {
495 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetAudioEncoder in, sourceId(%{public}d), encoder(%{public}d)",
496 FAKE_POINTER(this), sourceId, encoder);
497 std::lock_guard<std::mutex> lock(mutex_);
498 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
499 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
500 config_.audioCodec = encoder;
501 AudEnc audEnc(encoder);
502 MEDIA_LOGD("set audio encoder sourceId:%{public}d, encoder:%{public}d", sourceId, encoder);
503 CHECK_AND_RETURN_RET_LOG(!(encoder == AUDIO_MPEG && config_.format == FORMAT_MPEG_4), MSERR_INVALID_VAL,
504 "mp3 is not supported for mp4 recording");
505 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
506 return recorderEngine_->Configure(sourceId, audEnc);
507 });
508 int32_t ret = taskQue_.EnqueueTask(task);
509 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
510
511 auto result = task->GetResult();
512 return result.Value();
513 }
514
SetAudioSampleRate(int32_t sourceId,int32_t rate)515 int32_t RecorderServer::SetAudioSampleRate(int32_t sourceId, int32_t rate)
516 {
517 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetAudioSampleRate in, sourceId(%{public}d), rate(%{public}d)",
518 FAKE_POINTER(this), sourceId, rate);
519 std::lock_guard<std::mutex> lock(mutex_);
520 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
521 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
522 config_.audioSampleRate = rate;
523 AudSampleRate audSampleRate(rate);
524 MEDIA_LOGD("set audio sampleRate sourceId:%{public}d, rate:%{public}d", sourceId, rate);
525 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
526 return recorderEngine_->Configure(sourceId, audSampleRate);
527 });
528 int32_t ret = taskQue_.EnqueueTask(task);
529 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
530
531 auto result = task->GetResult();
532 return result.Value();
533 }
534
SetAudioChannels(int32_t sourceId,int32_t num)535 int32_t RecorderServer::SetAudioChannels(int32_t sourceId, int32_t num)
536 {
537 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetAudioChannels in, sourceId(%{public}d), num(%{public}d)",
538 FAKE_POINTER(this), sourceId, num);
539 std::lock_guard<std::mutex> lock(mutex_);
540 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
541 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
542 config_.audioChannel = num;
543 AudChannel audChannel(num);
544 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
545 return recorderEngine_->Configure(sourceId, audChannel);
546 });
547 int32_t ret = taskQue_.EnqueueTask(task);
548 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
549
550 auto result = task->GetResult();
551 return result.Value();
552 }
553
SetAudioEncodingBitRate(int32_t sourceId,int32_t bitRate)554 int32_t RecorderServer::SetAudioEncodingBitRate(int32_t sourceId, int32_t bitRate)
555 {
556 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetAudioEncodingBitRate in, sourceId(%{public}d), "
557 "bitRate(%{public}d)", FAKE_POINTER(this), sourceId, bitRate);
558 std::lock_guard<std::mutex> lock(mutex_);
559 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
560 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
561 config_.audioBitRate = bitRate;
562 AudBitRate audBitRate(bitRate);
563 // 64000 audiobitrate from audioencorder
564 CHECK_AND_RETURN_RET_LOG(!(config_.audioCodec == AUDIO_G711MU && config_.audioBitRate != 64000),
565 MSERR_INVALID_VAL, "G711-mulaw only support samplerate 8000 and audiobitrate 64000");
566 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
567 return recorderEngine_->Configure(sourceId, audBitRate);
568 });
569 int32_t ret = taskQue_.EnqueueTask(task);
570 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
571
572 auto result = task->GetResult();
573 return result.Value();
574 }
575
SetMetaConfigs(int32_t sourceId)576 int32_t RecorderServer::SetMetaConfigs(int32_t sourceId)
577 {
578 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetMetaConfigs in, sourceId(%{public}d)",
579 FAKE_POINTER(this), sourceId);
580 CHECK_AND_RETURN_RET_LOG(SetMetaMimeType(sourceId, Plugins::MimeType::TIMED_METADATA) == MSERR_OK,
581 MSERR_EXT_OPERATE_NOT_PERMIT, "set meta mime type failed");
582 if (config_.metaSource == MetaSourceType::VIDEO_META_MAKER_INFO) {
583 CHECK_AND_RETURN_RET_LOG(
584 SetMetaTimedKey(sourceId, VID_DEBUG_INFO_KEY) == MSERR_OK, MSERR_EXT_OPERATE_NOT_PERMIT,
585 "set meta key failed");
586 auto sourceTrackMime = GetVideoMime(config_.videoCodec);
587 CHECK_AND_RETURN_RET_LOG(
588 SetMetaSourceTrackMime(sourceId, sourceTrackMime) == MSERR_OK,
589 MSERR_EXT_OPERATE_NOT_PERMIT, "set meta source track mime failed");
590 }
591 return MSERR_OK;
592 }
593
SetDataSource(DataSourceType dataType,int32_t & sourceId)594 int32_t RecorderServer::SetDataSource(DataSourceType dataType, int32_t &sourceId)
595 {
596 (void)dataType;
597 (void)sourceId;
598 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetDataSource in, dataType(%{public}d), sourceId(%{public}d)",
599 FAKE_POINTER(this), dataType, sourceId);
600 return MSERR_INVALID_OPERATION;
601 }
602
SetUserCustomInfo(Meta & userCustomInfo)603 int32_t RecorderServer::SetUserCustomInfo(Meta &userCustomInfo)
604 {
605 std::lock_guard<std::mutex> lock(mutex_);
606 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
607 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
608
609 config_.customInfo = userCustomInfo;
610 CustomInfo userCustom(userCustomInfo);
611 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
612 return recorderEngine_->Configure(DUMMY_SOURCE_ID, userCustom);
613 });
614 int32_t ret = taskQue_.EnqueueTask(task);
615 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
616
617 auto result = task->GetResult();
618 return result.Value();
619 }
620
SetGenre(std::string & genre)621 int32_t RecorderServer::SetGenre(std::string &genre)
622 {
623 std::lock_guard<std::mutex> lock(mutex_);
624 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
625 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
626
627 config_.genre = genre;
628 GenreInfo genreInfo(genre);
629 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
630 return recorderEngine_->Configure(DUMMY_SOURCE_ID, genreInfo);
631 });
632 int32_t ret = taskQue_.EnqueueTask(task);
633 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
634
635 auto result = task->GetResult();
636 return result.Value();
637 }
638
SetMaxDuration(int32_t duration)639 int32_t RecorderServer::SetMaxDuration(int32_t duration)
640 {
641 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetMaxDuration in, duration(%{public}d)",
642 FAKE_POINTER(this), duration);
643 std::lock_guard<std::mutex> lock(mutex_);
644 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
645 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
646 config_.maxDuration = duration;
647 MaxDuration maxDuration(duration);
648 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
649 return recorderEngine_->Configure(DUMMY_SOURCE_ID, maxDuration);
650 });
651 int32_t ret = taskQue_.EnqueueTask(task);
652 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
653
654 auto result = task->GetResult();
655 return result.Value();
656 }
657
SetOutputFormat(OutputFormatType format)658 int32_t RecorderServer::SetOutputFormat(OutputFormatType format)
659 {
660 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetOutputFormat in, format(%{public}d)",
661 FAKE_POINTER(this), format);
662 std::lock_guard<std::mutex> lock(mutex_);
663 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_INITIALIZED, MSERR_INVALID_OPERATION);
664 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
665 config_.format = format;
666 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
667 return recorderEngine_->SetOutputFormat(format);
668 });
669 int32_t ret = taskQue_.EnqueueTask(task);
670 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
671
672 auto result = task->GetResult();
673 ret = result.Value();
674 status_ = (ret == MSERR_OK ? REC_CONFIGURED : REC_INITIALIZED);
675 return ret;
676 }
677
SetOutputFile(int32_t fd)678 int32_t RecorderServer::SetOutputFile(int32_t fd)
679 {
680 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetOutputFile in, fd is %{public}d", FAKE_POINTER(this), fd);
681 std::lock_guard<std::mutex> lock(mutex_);
682 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
683 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
684 config_.url = fd;
685 OutFd outFileFd(fd);
686 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
687 return recorderEngine_->Configure(DUMMY_SOURCE_ID, outFileFd);
688 });
689 int32_t ret = taskQue_.EnqueueTask(task);
690 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
691
692 auto result = task->GetResult();
693 return result.Value();
694 }
695
SetFileGenerationMode(FileGenerationMode mode)696 int32_t RecorderServer::SetFileGenerationMode(FileGenerationMode mode)
697 {
698 #ifdef SUPPORT_RECORDER_CREATE_FILE
699 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetFileGenerationMode in", FAKE_POINTER(this));
700 std::lock_guard<std::mutex> lock(mutex_);
701 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
702 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
703 CHECK_AND_RETURN_RET_LOG(config_.withVideo, MSERR_INVALID_OPERATION, "Audio-only scenarios are not supported");
704 CHECK_AND_RETURN_RET_LOG(MeidaLibraryAdapter::CreateMediaLibrary(config_.url, config_.uri),
705 MSERR_UNKNOWN, "get fd failed");
706 MEDIA_LOGD("video Fd:%{public}d", config_.url);
707 config_.fileGenerationMode = mode;
708 OutFd outFileFd(config_.url);
709 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
710 return recorderEngine_->Configure(DUMMY_SOURCE_ID, outFileFd);
711 });
712 int32_t ret = taskQue_.EnqueueTask(task);
713 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
714
715 auto result = task->GetResult();
716 return result.Value();
717 #endif
718 return MSERR_INVALID_OPERATION;
719 }
720
SetNextOutputFile(int32_t fd)721 int32_t RecorderServer::SetNextOutputFile(int32_t fd)
722 {
723 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetNextOutputFile in", FAKE_POINTER(this));
724 std::lock_guard<std::mutex> lock(mutex_);
725 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
726 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
727 NextOutFd nextFileFd(fd);
728 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
729 return recorderEngine_->Configure(DUMMY_SOURCE_ID, nextFileFd);
730 });
731 int32_t ret = taskQue_.EnqueueTask(task);
732 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
733
734 auto result = task->GetResult();
735 return result.Value();
736 }
737
SetMaxFileSize(int64_t size)738 int32_t RecorderServer::SetMaxFileSize(int64_t size)
739 {
740 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetMaxFileSize in, size: %{public}" PRIi64 "",
741 FAKE_POINTER(this), size);
742 std::lock_guard<std::mutex> lock(mutex_);
743 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
744 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
745 config_.maxFileSize = size;
746 MaxFileSize maxFileSize(size);
747 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
748 return recorderEngine_->Configure(DUMMY_SOURCE_ID, maxFileSize);
749 });
750 int32_t ret = taskQue_.EnqueueTask(task);
751 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
752
753 auto result = task->GetResult();
754 return result.Value();
755 }
756
SetLocation(float latitude,float longitude)757 void RecorderServer::SetLocation(float latitude, float longitude)
758 {
759 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetLocation in", FAKE_POINTER(this));
760 std::lock_guard<std::mutex> lock(mutex_);
761 if (status_ != REC_CONFIGURED) {
762 return;
763 }
764 CHECK_AND_RETURN_LOG(recorderEngine_ != nullptr, "engine is nullptr");
765 config_.latitude = latitude;
766 config_.longitude = longitude;
767 config_.withLocation = true;
768 GeoLocation geoLocation(latitude, longitude);
769 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
770 return recorderEngine_->Configure(DUMMY_SOURCE_ID, geoLocation);
771 });
772 int32_t ret = taskQue_.EnqueueTask(task);
773 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "EnqueueTask failed");
774
775 (void)task->GetResult();
776 return;
777 }
778
SetOrientationHint(int32_t rotation)779 void RecorderServer::SetOrientationHint(int32_t rotation)
780 {
781 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetOrientationHint in, rotation: %{public}d",
782 FAKE_POINTER(this), rotation);
783 std::lock_guard<std::mutex> lock(mutex_);
784 CHECK_AND_RETURN_LOG(recorderEngine_ != nullptr, "engine is nullptr");
785 config_.rotation = rotation;
786 RotationAngle rotationAngle(rotation);
787 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
788 return recorderEngine_->Configure(DUMMY_SOURCE_ID, rotationAngle);
789 });
790 int32_t ret = taskQue_.EnqueueTask(task);
791 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "EnqueueTask failed");
792
793 (void)task->GetResult();
794 return;
795 }
796
SetRecorderCallback(const std::shared_ptr<RecorderCallback> & callback)797 int32_t RecorderServer::SetRecorderCallback(const std::shared_ptr<RecorderCallback> &callback)
798 {
799 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " SetRecorderCallback in", FAKE_POINTER(this));
800 std::lock_guard<std::mutex> lock(mutex_);
801 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_INITIALIZED && status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
802
803 {
804 std::lock_guard<std::mutex> cbLock(cbMutex_);
805 recorderCb_ = callback;
806 }
807
808 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
809 std::shared_ptr<IRecorderEngineObs> obs = shared_from_this();
810 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
811 MEDIA_LOGI("RecorderServer recorderEngine_->SetObs start.");
812 return recorderEngine_->SetObs(obs);
813 });
814 int32_t ret = taskQue_.EnqueueTask(task);
815 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
816
817 auto result = task->GetResult();
818 return result.Value();
819 }
820
Prepare()821 int32_t RecorderServer::Prepare()
822 {
823 std::lock_guard<std::mutex> lock(mutex_);
824 MediaTrace trace("RecorderServer::Prepare");
825 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " Prepare in", FAKE_POINTER(this));
826 if (status_ == REC_PREPARED) {
827 MEDIA_LOGE("Can not repeat Prepare");
828 return MSERR_INVALID_OPERATION;
829 }
830 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
831 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
832 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
833 return recorderEngine_->Prepare();
834 });
835 int32_t ret = taskQue_.EnqueueTask(task);
836 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
837
838 auto result = task->GetResult();
839 ret = result.Value();
840 status_ = (ret == MSERR_OK ? REC_PREPARED : REC_ERROR);
841 return ret;
842 }
843
Start()844 int32_t RecorderServer::Start()
845 {
846 std::lock_guard<std::mutex> lock(mutex_);
847 MediaTrace trace("RecorderServer::Start");
848 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " Start in", FAKE_POINTER(this));
849 startTime_ = GetCurrentMillisecond();
850 if (status_ == REC_RECORDING) {
851 MEDIA_LOGE("Can not repeat Start");
852 return MSERR_INVALID_OPERATION;
853 }
854 #ifdef SUPPORT_POWER_MANAGER
855 if (syncCallback_) {
856 shutdownClient_.RegisterShutdownCallback(static_cast<sptr<PowerMgr::ISyncShutdownCallback>>(syncCallback_),
857 PowerMgr::ShutdownPriority::HIGH);
858 }
859 #endif
860 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_PREPARED, MSERR_INVALID_OPERATION);
861 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
862 CHECK_AND_RETURN_RET_LOG(config_.fileGenerationMode == APP_CREATE || CheckCameraOutputState(),
863 MSERR_INVALID_OPERATION, "CheckCameraOutputState failed");
864 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
865 return recorderEngine_->Start();
866 });
867 int32_t ret = taskQue_.EnqueueTask(task);
868 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
869
870 auto result = task->GetResult();
871 ret = result.Value();
872 status_ = (ret == MSERR_OK ? REC_RECORDING : REC_ERROR);
873 if (status_ == REC_RECORDING) {
874 int64_t endTime = GetCurrentMillisecond();
875 statisticalEventInfo_.startLatency = static_cast<int32_t>(endTime - startTime_);
876 }
877 return ret;
878 }
879
Pause()880 int32_t RecorderServer::Pause()
881 {
882 MediaTrace trace("RecorderServer::Pause");
883 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " Pause in", FAKE_POINTER(this));
884 std::lock_guard<std::mutex> lock(mutex_);
885 if (status_ == REC_PAUSED) {
886 MEDIA_LOGE("Can not repeat Pause");
887 return MSERR_INVALID_OPERATION;
888 }
889 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_RECORDING, MSERR_INVALID_OPERATION);
890 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
891 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
892 return recorderEngine_->Pause();
893 });
894 int32_t ret = taskQue_.EnqueueTask(task);
895 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
896
897 auto result = task->GetResult();
898 ret = result.Value();
899 status_ = (ret == MSERR_OK ? REC_PAUSED : REC_ERROR);
900 return ret;
901 }
902
Resume()903 int32_t RecorderServer::Resume()
904 {
905 MediaTrace trace("RecorderServer::Resume");
906 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " Resume in", FAKE_POINTER(this));
907 std::lock_guard<std::mutex> lock(mutex_);
908 if (status_ == REC_RECORDING) {
909 MEDIA_LOGE("Can not repeat Resume");
910 return MSERR_INVALID_OPERATION;
911 }
912 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_RECORDING && status_ != REC_PAUSED, MSERR_INVALID_OPERATION);
913 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
914 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
915 return recorderEngine_->Resume();
916 });
917 int32_t ret = taskQue_.EnqueueTask(task);
918 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
919
920 auto result = task->GetResult();
921 ret = result.Value();
922 status_ = (ret == MSERR_OK ? REC_RECORDING : REC_ERROR);
923 return ret;
924 }
925
Stop(bool block)926 int32_t RecorderServer::Stop(bool block)
927 {
928 std::lock_guard<std::mutex> lock(mutex_);
929 MediaTrace trace("RecorderServer::Stop");
930 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " Stop in", FAKE_POINTER(this));
931 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_RECORDING && status_ != REC_PAUSED, MSERR_INVALID_OPERATION);
932
933 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
934 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
935 return recorderEngine_->Stop(block);
936 });
937 int32_t ret = taskQue_.EnqueueTask(task);
938 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
939
940 auto result = task->GetResult();
941 ret = result.Value();
942 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " Stop out ret: %{public}d", FAKE_POINTER(this), ret);
943 status_ = (ret == MSERR_OK ? REC_INITIALIZED : REC_ERROR);
944 if (status_ == REC_INITIALIZED) {
945 int64_t endTime = GetCurrentMillisecond();
946 statisticalEventInfo_.recordDuration = static_cast<int32_t>(endTime - startTime_ -
947 statisticalEventInfo_.startLatency);
948 #ifdef SUPPORT_RECORDER_CREATE_FILE
949 if (config_.fileGenerationMode == FileGenerationMode::AUTO_CREATE_CAMERA_SCENE && config_.uri != "") {
950 recorderCb_->OnPhotoAssertAvailable(config_.uri);
951 }
952 #endif
953 }
954 return ret;
955 }
956
Reset()957 int32_t RecorderServer::Reset()
958 {
959 std::lock_guard<std::mutex> lock(mutex_);
960 MediaTrace trace("RecorderServer::Reset");
961 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " Reset in", FAKE_POINTER(this));
962 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
963 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
964 return recorderEngine_->Reset();
965 });
966 int32_t ret = taskQue_.EnqueueTask(task);
967 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
968
969 auto result = task->GetResult();
970 ret = result.Value();
971 status_ = (ret == MSERR_OK ? REC_INITIALIZED : REC_ERROR);
972 return ret;
973 }
974
Release()975 int32_t RecorderServer::Release()
976 {
977 MediaTrace trace("RecorderServer::Release");
978 MEDIA_LOGI("RecorderServer:0x%{public}06" PRIXPTR " Release in", FAKE_POINTER(this));
979 {
980 std::lock_guard<std::mutex> lock(mutex_);
981 auto task = std::make_shared<TaskHandler<void>>([&, this] {
982 recorderEngine_ = nullptr;
983 });
984 (void)taskQue_.EnqueueTask(task);
985 (void)task->GetResult();
986 #ifdef SUPPORT_POWER_MANAGER
987 if (syncCallback_) {
988 if (!syncCallback_->isShutdown) {
989 shutdownClient_.UnRegisterShutdownCallback(static_cast<sptr<PowerMgr::ISyncShutdownCallback>>
990 (syncCallback_));
991 }
992 }
993 #endif
994 }
995 SetMetaDataReport();
996 return MSERR_OK;
997 }
998
SetFileSplitDuration(FileSplitType type,int64_t timestamp,uint32_t duration)999 int32_t RecorderServer::SetFileSplitDuration(FileSplitType type, int64_t timestamp, uint32_t duration)
1000 {
1001 std::lock_guard<std::mutex> lock(mutex_);
1002 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_RECORDING && status_ != REC_PAUSED, MSERR_INVALID_OPERATION);
1003
1004 (void)type;
1005 (void)timestamp;
1006 (void)duration;
1007 return MSERR_OK;
1008 }
1009
SetParameter(int32_t sourceId,const Format & format)1010 int32_t RecorderServer::SetParameter(int32_t sourceId, const Format &format)
1011 {
1012 (void)sourceId;
1013 (void)format;
1014 return MSERR_OK;
1015 }
1016
DumpInfo(int32_t fd)1017 int32_t RecorderServer::DumpInfo(int32_t fd)
1018 {
1019 std::string dumpString;
1020 dumpString += "In RecorderServer::DumpInfo\n";
1021 dumpString += "RecorderServer current state is: " + std::to_string(status_) + "\n";
1022 if (lastErrMsg_.size() != 0) {
1023 dumpString += "RecorderServer last error is: " + lastErrMsg_ + "\n";
1024 }
1025 dumpString += "RecorderServer videoSource is: " + std::to_string(config_.videoSource) + "\n";
1026 dumpString += "RecorderServer audioSource is: " + std::to_string(config_.audioSource) + "\n";
1027 dumpString += "RecorderServer videoCodec is: " + std::to_string(config_.videoCodec) + "\n";
1028 dumpString += "RecorderServer audioCodec is: " + std::to_string(config_.audioCodec) + "\n";
1029 dumpString += "RecorderServer width is: " + std::to_string(config_.width) + "\n";
1030 dumpString += "RecorderServer height is: " + std::to_string(config_.height) + "\n";
1031 dumpString += "RecorderServer frameRate is: " + std::to_string(config_.frameRate) + "\n";
1032 dumpString += "RecorderServer bitRate is: " + std::to_string(config_.bitRate) + "\n";
1033 dumpString += "RecorderServer captureRate is: " + std::to_string(config_.captureRate) + "\n";
1034 dumpString += "RecorderServer audioSampleRate is: " + std::to_string(config_.audioSampleRate) + "\n";
1035 dumpString += "RecorderServer audioChannel is: " + std::to_string(config_.audioChannel) + "\n";
1036 dumpString += "RecorderServer audioBitRate is: " + std::to_string(config_.audioBitRate) + "\n";
1037 dumpString += "RecorderServer isHdr is: " + std::to_string(config_.isHdr) + "\n";
1038 dumpString += "RecorderServer enableTemporalScale is: " + std::to_string(config_.enableTemporalScale) + "\n";
1039 dumpString += "RecorderServer enableStableQualityMode is: " +
1040 std::to_string(config_.enableStableQualityMode) + "\n";
1041 dumpString += "RecorderServer maxDuration is: " + std::to_string(config_.maxDuration) + "\n";
1042 dumpString += "RecorderServer format is: " + std::to_string(config_.format) + "\n";
1043 dumpString += "RecorderServer maxFileSize is: " + std::to_string(config_.maxFileSize) + "\n";
1044 if (fd != -1) {
1045 write(fd, dumpString.c_str(), dumpString.size());
1046 } else {
1047 MEDIA_LOGI_NO_RELEASE("%{public}s", dumpString.c_str());
1048 }
1049 return MSERR_OK;
1050 }
1051
GetAVRecorderConfig(ConfigMap & configMap)1052 int32_t RecorderServer::GetAVRecorderConfig(ConfigMap &configMap)
1053 {
1054 std::lock_guard<std::mutex> lock(mutex_);
1055 configMap["audioBitrate"] = config_.audioBitRate;
1056 configMap["audioChannels"] = config_.audioChannel;
1057 configMap["audioCodec"] = static_cast<int32_t>(config_.audioCodec);
1058 configMap["audioSampleRate"] = config_.audioSampleRate;
1059 configMap["fileFormat"] = static_cast<int32_t>(config_.format);
1060 configMap["videoBitrate"] = config_.bitRate;
1061 configMap["videoCodec"] = static_cast<int32_t>(config_.videoCodec);
1062 configMap["videoFrameHeight"] = config_.height;
1063 configMap["videoFrameWidth"] = config_.width;
1064 configMap["videoFrameRate"] = config_.frameRate;
1065 configMap["audioSourceType"] = static_cast<int32_t>(config_.audioSource);
1066 configMap["videoSourceType"] = static_cast<int32_t>(config_.videoSource);
1067 configMap["url"] = config_.url;
1068 configMap["rotation"] = config_.rotation;
1069 configMap["withVideo"] = config_.withVideo;
1070 configMap["withAudio"] = config_.withAudio;
1071 configMap["withLocation"] = config_.withLocation;
1072 return MSERR_OK;
1073 }
1074
GetLocation(Location & location)1075 int32_t RecorderServer::GetLocation(Location &location)
1076 {
1077 std::lock_guard<std::mutex> lock(mutex_);
1078 location.latitude = config_.latitude;
1079 location.longitude = config_.longitude;
1080 return MSERR_OK;
1081 }
1082
GetCurrentCapturerChangeInfo(AudioRecorderChangeInfo & changeInfo)1083 int32_t RecorderServer::GetCurrentCapturerChangeInfo(AudioRecorderChangeInfo &changeInfo)
1084 {
1085 std::lock_guard<std::mutex> lock(mutex_);
1086 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
1087 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
1088 return recorderEngine_->GetCurrentCapturerChangeInfo(changeInfo);
1089 });
1090 int32_t ret = taskQue_.EnqueueTask(task);
1091 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
1092
1093 auto result = task->GetResult();
1094 return result.Value();
1095 }
1096
GetAvailableEncoder(std::vector<EncoderCapabilityData> & encoderInfo)1097 int32_t RecorderServer::GetAvailableEncoder(std::vector<EncoderCapabilityData> &encoderInfo)
1098 {
1099 std::lock_guard<std::mutex> lock(mutex_);
1100 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
1101 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
1102 return recorderEngine_->GetAvailableEncoder(encoderInfo);
1103 });
1104 int32_t ret = taskQue_.EnqueueTask(task);
1105 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
1106
1107 auto result = task->GetResult();
1108 return result.Value();
1109 }
1110
GetMaxAmplitude()1111 int32_t RecorderServer::GetMaxAmplitude()
1112 {
1113 std::lock_guard<std::mutex> lock(mutex_);
1114 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
1115 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
1116 return recorderEngine_->GetMaxAmplitude();
1117 });
1118 int32_t ret = taskQue_.EnqueueTask(task);
1119 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
1120
1121 auto result = task->GetResult();
1122 return result.Value();
1123 }
1124
IsWatermarkSupported(bool & isWatermarkSupported)1125 int32_t RecorderServer::IsWatermarkSupported(bool &isWatermarkSupported)
1126 {
1127 MEDIA_LOGI("IsWatermarkSupported in");
1128 std::lock_guard<std::mutex> lock(mutex_);
1129 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
1130 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
1131 return recorderEngine_->IsWatermarkSupported(isWatermarkSupported);
1132 });
1133 int32_t ret = taskQue_.EnqueueTask(task);
1134 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
1135
1136 auto result = task->GetResult();
1137 return result.Value();
1138 }
1139
SetWatermark(std::shared_ptr<AVBuffer> & waterMarkBuffer)1140 int32_t RecorderServer::SetWatermark(std::shared_ptr<AVBuffer> &waterMarkBuffer)
1141 {
1142 MEDIA_LOGI("SetWatermark in");
1143 std::lock_guard<std::mutex> lock(mutex_);
1144 MediaTrace trace("RecorderServer::SetWatermark");
1145 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_PREPARED, MSERR_INVALID_OPERATION);
1146 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
1147 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
1148 return recorderEngine_->SetWatermark(waterMarkBuffer);
1149 });
1150 int32_t ret = taskQue_.EnqueueTask(task);
1151 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
1152
1153 auto result = task->GetResult();
1154 return result.Value();
1155 }
1156
SetMetaDataReport()1157 void RecorderServer::SetMetaDataReport()
1158 {
1159 std::shared_ptr<Media::Meta> meta = std::make_shared<Media::Meta>();
1160 meta->SetData(Tag::RECORDER_ERR_CODE, statisticalEventInfo_.errCode);
1161 meta->SetData(Tag::RECORDER_ERR_MSG, statisticalEventInfo_.errMsg);
1162 meta->SetData(Tag::RECORDER_DURATION, statisticalEventInfo_.recordDuration);
1163 statisticalEventInfo_.containerMime = GetVideoMime(config_.videoCodec) + ";" + GetAudioMime(config_.audioCodec);
1164 meta->SetData(Tag::RECORDER_CONTAINER_MIME, statisticalEventInfo_.containerMime);
1165 meta->SetData(Tag::RECORDER_VIDEO_MIME, GetVideoMime(config_.videoCodec));
1166 statisticalEventInfo_.videoResolution = std::to_string(config_.width) + "x" + std::to_string(config_.height);
1167 meta->SetData(Tag::RECORDER_VIDEO_RESOLUTION, statisticalEventInfo_.videoResolution);
1168 meta->SetData(Tag::RECORDER_VIDEO_BITRATE, config_.bitRate);
1169 if (config_.isHdr) {
1170 statisticalEventInfo_.hdrType = static_cast<int8_t>(HdrType::HDR_TYPE_VIVID);
1171 }
1172 meta->SetData(Tag::RECORDER_HDR_TYPE, statisticalEventInfo_.hdrType);
1173 meta->SetData(Tag::RECORDER_AUDIO_MIME, GetAudioMime(config_.audioCodec));
1174 meta->SetData(Tag::RECORDER_AUDIO_SAMPLE_RATE, config_.audioSampleRate);
1175 meta->SetData(Tag::RECORDER_AUDIO_CHANNEL_COUNT, config_.audioChannel);
1176 meta->SetData(Tag::RECORDER_AUDIO_BITRATE, config_.audioBitRate);
1177 meta->SetData(Tag::RECORDER_START_LATENCY, statisticalEventInfo_.startLatency);
1178 AppendMediaInfo(meta, instanceId_);
1179 ReportMediaInfo(instanceId_);
1180 }
1181
GetCurrentMillisecond()1182 int64_t RecorderServer::GetCurrentMillisecond()
1183 {
1184 std::chrono::system_clock::duration duration = std::chrono::system_clock::now().time_since_epoch();
1185 int64_t time = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
1186 return time;
1187 }
1188
SetErrorInfo(int32_t errCode,std::string & errMsg)1189 void RecorderServer::SetErrorInfo(int32_t errCode, std::string &errMsg)
1190 {
1191 statisticalEventInfo_.errCode = errCode;
1192 statisticalEventInfo_.errMsg = errMsg;
1193 }
1194
GetVideoMime(VideoCodecFormat encoder)1195 std::string RecorderServer::GetVideoMime(VideoCodecFormat encoder)
1196 {
1197 std::string videoMime;
1198 switch (encoder) {
1199 case OHOS::Media::VideoCodecFormat::H264:
1200 videoMime = Plugins::MimeType::VIDEO_AVC;
1201 break;
1202 case OHOS::Media::VideoCodecFormat::MPEG4:
1203 videoMime = Plugins::MimeType::VIDEO_MPEG4;
1204 break;
1205 case OHOS::Media::VideoCodecFormat::H265:
1206 videoMime = Plugins::MimeType::VIDEO_HEVC;
1207 break;
1208 default:
1209 break;
1210 }
1211 return videoMime;
1212 }
1213
GetAudioMime(AudioCodecFormat encoder)1214 std::string RecorderServer::GetAudioMime(AudioCodecFormat encoder)
1215 {
1216 std::string audioMime;
1217 switch (encoder) {
1218 case OHOS::Media::AudioCodecFormat::AUDIO_DEFAULT:
1219 case OHOS::Media::AudioCodecFormat::AAC_LC:
1220 audioMime = Plugins::MimeType::AUDIO_AAC;
1221 break;
1222 default:
1223 break;
1224 }
1225 return audioMime;
1226 }
1227
CheckCameraOutputState()1228 bool RecorderServer::CheckCameraOutputState()
1229 {
1230 #ifdef SUPPORT_RECORDER_CREATE_FILE
1231 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1232 CHECK_AND_RETURN_RET_LOG(samgr != nullptr, false, "Failed to get System ability manager");
1233 auto object = samgr->GetSystemAbility(CAMERA_SERVICE_ID);
1234 CHECK_AND_RETURN_RET_LOG(object != nullptr, false, "object is null");
1235 sptr<CameraStandard::ICameraService> serviceProxy = iface_cast<CameraStandard::HCameraServiceProxy>(object);
1236 CHECK_AND_RETURN_RET_LOG(serviceProxy != nullptr, false, "serviceProxy is null");
1237 int32_t status = 0;
1238 serviceProxy->GetCameraOutputStatus(IPCSkeleton::GetCallingPid(), status);
1239 MEDIA_LOGI("GetCameraOutputStatus %{public}d", status);
1240 return (static_cast<uint32_t>(status) >> 1) & 1; // 2: video out put start
1241 #endif
1242 return true;
1243 }
1244
1245 #ifdef SUPPORT_POWER_MANAGER
OnSyncShutdown()1246 void SaveDocumentSyncCallback::OnSyncShutdown()
1247 {
1248 isShutdown = true;
1249 usleep(intervalTime); // wait 500 ms
1250 }
1251 #endif
1252 } // namespace Media
1253 } // namespace OHOS
1254