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