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