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