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
26 namespace {
27 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "RecorderServer"};
28 const std::map<OHOS::Media::RecorderServer::RecStatus, std::string> RECORDER_STATE_MAP = {
29 {OHOS::Media::RecorderServer::REC_INITIALIZED, "initialized"},
30 {OHOS::Media::RecorderServer::REC_CONFIGURED, "configured"},
31 {OHOS::Media::RecorderServer::REC_PREPARED, "prepared"},
32 {OHOS::Media::RecorderServer::REC_RECORDING, "recording"},
33 {OHOS::Media::RecorderServer::REC_PAUSED, "paused"},
34 {OHOS::Media::RecorderServer::REC_ERROR, "error"},
35 };
36 }
37
38 namespace OHOS {
39 namespace Media {
40 const std::string START_TAG = "RecorderCreate->Start";
41 const std::string STOP_TAG = "RecorderStop->Destroy";
42 #define CHECK_STATUS_FAILED_AND_LOGE_RET(statusFailed, ret) \
43 do { \
44 if (statusFailed) { \
45 MEDIA_LOGE("invalid status, current status is %{public}s", GetStatusDescription(status_).c_str()); \
46 return ret; \
47 }; \
48 } while (false)
49
Create()50 std::shared_ptr<IRecorderService> RecorderServer::Create()
51 {
52 std::shared_ptr<RecorderServer> server = std::make_shared<RecorderServer>();
53 int32_t ret = server->Init();
54 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, nullptr, "failed to init RecorderServer");
55 return server;
56 }
57
RecorderServer()58 RecorderServer::RecorderServer()
59 : taskQue_("RecorderServer")
60 {
61 MEDIA_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this));
62 taskQue_.Start();
63 }
64
~RecorderServer()65 RecorderServer::~RecorderServer()
66 {
67 MEDIA_LOGD("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this));
68 {
69 std::lock_guard<std::mutex> lock(mutex_);
70 auto task = std::make_shared<TaskHandler<void>>([&, this] {
71 recorderEngine_ = nullptr;
72 });
73 (void)taskQue_.EnqueueTask(task);
74 (void)task->GetResult();
75 taskQue_.Stop();
76 }
77 }
78
Init()79 int32_t RecorderServer::Init()
80 {
81 MediaTrace trace("RecorderServer::Init");
82 uint32_t tokenId = IPCSkeleton::GetCallingTokenID();
83 uint64_t fullTokenId = IPCSkeleton::GetCallingFullTokenID();
84 int32_t appUid = IPCSkeleton::GetCallingUid();
85 int32_t appPid = IPCSkeleton::GetCallingPid();
86
87 auto task = std::make_shared<TaskHandler<MediaServiceErrCode>>([&, this] {
88 auto engineFactory = EngineFactoryRepo::Instance().GetEngineFactory(IEngineFactory::Scene::SCENE_RECORDER);
89 CHECK_AND_RETURN_RET_LOG(engineFactory != nullptr, MSERR_CREATE_REC_ENGINE_FAILED,
90 "failed to get factory");
91 recorderEngine_ = engineFactory->CreateRecorderEngine(appUid, appPid, tokenId, fullTokenId);
92 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_CREATE_REC_ENGINE_FAILED,
93 "failed to create recorder engine");
94 return MSERR_OK;
95 });
96 int32_t ret = taskQue_.EnqueueTask(task);
97 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
98
99 auto result = task->GetResult();
100 CHECK_AND_RETURN_RET_LOG(result.Value() == MSERR_OK, result.Value(), "Result failed");
101
102 status_ = REC_INITIALIZED;
103 BehaviorEventWrite(GetStatusDescription(status_), "Recorder");
104 return MSERR_OK;
105 }
106
GetStatusDescription(OHOS::Media::RecorderServer::RecStatus status)107 const std::string& RecorderServer::GetStatusDescription(OHOS::Media::RecorderServer::RecStatus status)
108 {
109 static const std::string ILLEGAL_STATE = "PLAYER_STATUS_ILLEGAL";
110 CHECK_AND_RETURN_RET(status >= OHOS::Media::RecorderServer::REC_INITIALIZED &&
111 status <= OHOS::Media::RecorderServer::REC_ERROR, ILLEGAL_STATE);
112
113 return RECORDER_STATE_MAP.find(status)->second;
114 }
115
OnError(ErrorType errorType,int32_t errorCode)116 void RecorderServer::OnError(ErrorType errorType, int32_t errorCode)
117 {
118 std::lock_guard<std::mutex> lock(cbMutex_);
119 lastErrMsg_ = MSErrorToExtErrorString(static_cast<MediaServiceErrCode>(errorCode));
120 FaultEventWrite(lastErrMsg_, "Recorder");
121 CHECK_AND_RETURN(recorderCb_ != nullptr);
122 recorderCb_->OnError(static_cast<RecorderErrorType>(errorType), errorCode);
123 }
124
OnInfo(InfoType type,int32_t extra)125 void RecorderServer::OnInfo(InfoType type, int32_t extra)
126 {
127 std::lock_guard<std::mutex> lock(cbMutex_);
128 if (recorderCb_ != nullptr) {
129 recorderCb_->OnInfo(type, extra);
130 }
131 }
132
SetVideoSource(VideoSourceType source,int32_t & sourceId)133 int32_t RecorderServer::SetVideoSource(VideoSourceType source, int32_t &sourceId)
134 {
135 std::lock_guard<std::mutex> lock(mutex_);
136 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_INITIALIZED, MSERR_INVALID_OPERATION);
137 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
138 config_.videoSource = source;
139 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
140 return recorderEngine_->SetVideoSource(source, sourceId);
141 });
142 int32_t ret = taskQue_.EnqueueTask(task);
143 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
144
145 auto result = task->GetResult();
146 return result.Value();
147 }
148
SetVideoEncoder(int32_t sourceId,VideoCodecFormat encoder)149 int32_t RecorderServer::SetVideoEncoder(int32_t sourceId, VideoCodecFormat encoder)
150 {
151 std::lock_guard<std::mutex> lock(mutex_);
152 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
153 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
154 config_.videoCodec = encoder;
155 VidEnc vidEnc(encoder);
156 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
157 return recorderEngine_->Configure(sourceId, vidEnc);
158 });
159 int32_t ret = taskQue_.EnqueueTask(task);
160 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
161
162 auto result = task->GetResult();
163 return result.Value();
164 }
165
SetVideoSize(int32_t sourceId,int32_t width,int32_t height)166 int32_t RecorderServer::SetVideoSize(int32_t sourceId, int32_t width, int32_t height)
167 {
168 std::lock_guard<std::mutex> lock(mutex_);
169 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
170 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
171 config_.width = width;
172 config_.height = height;
173 VidRectangle vidSize(width, height);
174 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
175 return recorderEngine_->Configure(sourceId, vidSize);
176 });
177 int32_t ret = taskQue_.EnqueueTask(task);
178 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
179
180 auto result = task->GetResult();
181 return result.Value();
182 }
183
SetVideoFrameRate(int32_t sourceId,int32_t frameRate)184 int32_t RecorderServer::SetVideoFrameRate(int32_t sourceId, int32_t frameRate)
185 {
186 std::lock_guard<std::mutex> lock(mutex_);
187 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
188 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
189 config_.frameRate = frameRate;
190 VidFrameRate vidFrameRate(frameRate);
191 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
192 return recorderEngine_->Configure(sourceId, vidFrameRate);
193 });
194 int32_t ret = taskQue_.EnqueueTask(task);
195 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
196
197 auto result = task->GetResult();
198 return result.Value();
199 }
200
SetVideoEncodingBitRate(int32_t sourceId,int32_t rate)201 int32_t RecorderServer::SetVideoEncodingBitRate(int32_t sourceId, int32_t rate)
202 {
203 std::lock_guard<std::mutex> lock(mutex_);
204 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
205 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
206 config_.bitRate = rate;
207 VidBitRate vidBitRate(rate);
208 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
209 return recorderEngine_->Configure(sourceId, vidBitRate);
210 });
211 int32_t ret = taskQue_.EnqueueTask(task);
212 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
213
214 auto result = task->GetResult();
215 return result.Value();
216 }
217
SetCaptureRate(int32_t sourceId,double fps)218 int32_t RecorderServer::SetCaptureRate(int32_t sourceId, double fps)
219 {
220 std::lock_guard<std::mutex> lock(mutex_);
221 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
222 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
223 config_.captureRate = fps;
224 CaptureRate captureRate(fps);
225 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
226 return recorderEngine_->Configure(sourceId, captureRate);
227 });
228 int32_t ret = taskQue_.EnqueueTask(task);
229 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
230
231 auto result = task->GetResult();
232 return result.Value();
233 }
234
GetSurface(int32_t sourceId)235 sptr<OHOS::Surface> RecorderServer::GetSurface(int32_t sourceId)
236 {
237 std::lock_guard<std::mutex> lock(mutex_);
238 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_PREPARED && status_ != REC_RECORDING && status_ != REC_PAUSED,
239 nullptr);
240 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, nullptr, "engine is nullptr");
241 auto task = std::make_shared<TaskHandler<sptr<OHOS::Surface>>>([&, this] {
242 return recorderEngine_->GetSurface(sourceId);
243 });
244 int32_t ret = taskQue_.EnqueueTask(task);
245 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, nullptr, "EnqueueTask failed");
246
247 auto result = task->GetResult();
248 return result.Value();
249 }
250
SetAudioSource(AudioSourceType source,int32_t & sourceId)251 int32_t RecorderServer::SetAudioSource(AudioSourceType source, int32_t &sourceId)
252 {
253 std::lock_guard<std::mutex> lock(mutex_);
254 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_INITIALIZED, MSERR_INVALID_OPERATION);
255 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
256
257 config_.audioSource = source;
258 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
259 return recorderEngine_->SetAudioSource(source, sourceId);
260 });
261 int32_t ret = taskQue_.EnqueueTask(task);
262 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
263
264 auto result = task->GetResult();
265 return result.Value();
266 }
267
SetAudioEncoder(int32_t sourceId,AudioCodecFormat encoder)268 int32_t RecorderServer::SetAudioEncoder(int32_t sourceId, AudioCodecFormat encoder)
269 {
270 std::lock_guard<std::mutex> lock(mutex_);
271 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
272 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
273 config_.audioCodec = encoder;
274 AudEnc audEnc(encoder);
275 MEDIA_LOGD("set audio encoder sourceId:%{public}d, encoder:%{public}d", sourceId, encoder);
276 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
277 return recorderEngine_->Configure(sourceId, audEnc);
278 });
279 int32_t ret = taskQue_.EnqueueTask(task);
280 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
281
282 auto result = task->GetResult();
283 return result.Value();
284 }
285
SetAudioSampleRate(int32_t sourceId,int32_t rate)286 int32_t RecorderServer::SetAudioSampleRate(int32_t sourceId, int32_t rate)
287 {
288 std::lock_guard<std::mutex> lock(mutex_);
289 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
290 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
291 config_.audioSampleRate = rate;
292 AudSampleRate audSampleRate(rate);
293 MEDIA_LOGD("set audio sampleRate sourceId:%{public}d, rate:%{public}d", sourceId, rate);
294 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
295 return recorderEngine_->Configure(sourceId, audSampleRate);
296 });
297 int32_t ret = taskQue_.EnqueueTask(task);
298 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
299
300 auto result = task->GetResult();
301 return result.Value();
302 }
303
SetAudioChannels(int32_t sourceId,int32_t num)304 int32_t RecorderServer::SetAudioChannels(int32_t sourceId, int32_t num)
305 {
306 std::lock_guard<std::mutex> lock(mutex_);
307 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
308 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
309 config_.audioChannel = num;
310 AudChannel audChannel(num);
311 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
312 return recorderEngine_->Configure(sourceId, audChannel);
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
SetAudioEncodingBitRate(int32_t sourceId,int32_t bitRate)321 int32_t RecorderServer::SetAudioEncodingBitRate(int32_t sourceId, int32_t bitRate)
322 {
323 std::lock_guard<std::mutex> lock(mutex_);
324 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
325 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
326 config_.audioBitRate = bitRate;
327 AudBitRate audBitRate(bitRate);
328 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
329 return recorderEngine_->Configure(sourceId, audBitRate);
330 });
331 int32_t ret = taskQue_.EnqueueTask(task);
332 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
333
334 auto result = task->GetResult();
335 return result.Value();
336 }
337
SetDataSource(DataSourceType dataType,int32_t & sourceId)338 int32_t RecorderServer::SetDataSource(DataSourceType dataType, int32_t &sourceId)
339 {
340 (void)dataType;
341 (void)sourceId;
342 return MSERR_INVALID_OPERATION;
343 }
344
SetMaxDuration(int32_t duration)345 int32_t RecorderServer::SetMaxDuration(int32_t duration)
346 {
347 std::lock_guard<std::mutex> lock(mutex_);
348 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
349 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
350 config_.maxDuration = duration;
351 MaxDuration maxDuration(duration);
352 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
353 return recorderEngine_->Configure(DUMMY_SOURCE_ID, maxDuration);
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
SetOutputFormat(OutputFormatType format)362 int32_t RecorderServer::SetOutputFormat(OutputFormatType format)
363 {
364 std::lock_guard<std::mutex> lock(mutex_);
365 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_INITIALIZED, MSERR_INVALID_OPERATION);
366 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
367 config_.format = format;
368 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
369 return recorderEngine_->SetOutputFormat(format);
370 });
371 int32_t ret = taskQue_.EnqueueTask(task);
372 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
373
374 auto result = task->GetResult();
375 ret = result.Value();
376 status_ = (ret == MSERR_OK ? REC_CONFIGURED : REC_INITIALIZED);
377 BehaviorEventWrite(GetStatusDescription(status_), "Recorder");
378 return ret;
379 }
380
SetOutputFile(int32_t fd)381 int32_t RecorderServer::SetOutputFile(int32_t fd)
382 {
383 std::lock_guard<std::mutex> lock(mutex_);
384 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
385 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
386 OutFd outFileFd(fd);
387 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
388 return recorderEngine_->Configure(DUMMY_SOURCE_ID, outFileFd);
389 });
390 int32_t ret = taskQue_.EnqueueTask(task);
391 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
392
393 auto result = task->GetResult();
394 return result.Value();
395 }
396
SetNextOutputFile(int32_t fd)397 int32_t RecorderServer::SetNextOutputFile(int32_t fd)
398 {
399 std::lock_guard<std::mutex> lock(mutex_);
400 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
401 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
402 NextOutFd nextFileFd(fd);
403 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
404 return recorderEngine_->Configure(DUMMY_SOURCE_ID, nextFileFd);
405 });
406 int32_t ret = taskQue_.EnqueueTask(task);
407 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
408
409 auto result = task->GetResult();
410 return result.Value();
411 }
412
SetMaxFileSize(int64_t size)413 int32_t RecorderServer::SetMaxFileSize(int64_t size)
414 {
415 std::lock_guard<std::mutex> lock(mutex_);
416 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
417 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
418 config_.maxFileSize = size;
419 MaxFileSize maxFileSize(size);
420 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
421 return recorderEngine_->Configure(DUMMY_SOURCE_ID, maxFileSize);
422 });
423 int32_t ret = taskQue_.EnqueueTask(task);
424 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
425
426 auto result = task->GetResult();
427 return result.Value();
428 }
429
SetLocation(float latitude,float longitude)430 void RecorderServer::SetLocation(float latitude, float longitude)
431 {
432 std::lock_guard<std::mutex> lock(mutex_);
433 if (status_ != REC_CONFIGURED) {
434 return;
435 }
436 CHECK_AND_RETURN_LOG(recorderEngine_ != nullptr, "engine is nullptr");
437 GeoLocation geoLocation(latitude, longitude);
438 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
439 return recorderEngine_->Configure(DUMMY_SOURCE_ID, geoLocation);
440 });
441 int32_t ret = taskQue_.EnqueueTask(task);
442 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "EnqueueTask failed");
443
444 (void)task->GetResult();
445 return;
446 }
447
SetOrientationHint(int32_t rotation)448 void RecorderServer::SetOrientationHint(int32_t rotation)
449 {
450 std::lock_guard<std::mutex> lock(mutex_);
451 CHECK_AND_RETURN_LOG(status_ == REC_CONFIGURED, "status_ error");
452 CHECK_AND_RETURN_LOG(recorderEngine_ != nullptr, "engine is nullptr");
453 RotationAngle rotationAngle(rotation);
454 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
455 return recorderEngine_->Configure(DUMMY_SOURCE_ID, rotationAngle);
456 });
457 int32_t ret = taskQue_.EnqueueTask(task);
458 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "EnqueueTask failed");
459
460 (void)task->GetResult();
461 return;
462 }
463
SetRecorderCallback(const std::shared_ptr<RecorderCallback> & callback)464 int32_t RecorderServer::SetRecorderCallback(const std::shared_ptr<RecorderCallback> &callback)
465 {
466 std::lock_guard<std::mutex> lock(mutex_);
467 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_INITIALIZED && status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
468
469 {
470 std::lock_guard<std::mutex> cbLock(cbMutex_);
471 recorderCb_ = callback;
472 }
473
474 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
475 std::shared_ptr<IRecorderEngineObs> obs = shared_from_this();
476 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
477 return recorderEngine_->SetObs(obs);
478 });
479 int32_t ret = taskQue_.EnqueueTask(task);
480 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
481
482 auto result = task->GetResult();
483 return result.Value();
484 }
485
Prepare()486 int32_t RecorderServer::Prepare()
487 {
488 std::lock_guard<std::mutex> lock(mutex_);
489 MediaTrace trace("RecorderServer::Prepare");
490 if (status_ == REC_PREPARED) {
491 MEDIA_LOGE("Can not repeat Prepare");
492 return MSERR_INVALID_OPERATION;
493 }
494 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_CONFIGURED, MSERR_INVALID_OPERATION);
495 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
496 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
497 return recorderEngine_->Prepare();
498 });
499 int32_t ret = taskQue_.EnqueueTask(task);
500 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
501
502 auto result = task->GetResult();
503 ret = result.Value();
504 status_ = (ret == MSERR_OK ? REC_PREPARED : REC_ERROR);
505 BehaviorEventWrite(GetStatusDescription(status_), "Recorder");
506 return ret;
507 }
508
Start()509 int32_t RecorderServer::Start()
510 {
511 std::lock_guard<std::mutex> lock(mutex_);
512 MediaTrace trace("RecorderServer::Start");
513 if (status_ == REC_RECORDING) {
514 MEDIA_LOGE("Can not repeat Start");
515 return MSERR_INVALID_OPERATION;
516 }
517 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_PREPARED, MSERR_INVALID_OPERATION);
518 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
519 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
520 return recorderEngine_->Start();
521 });
522 int32_t ret = taskQue_.EnqueueTask(task);
523 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
524
525 auto result = task->GetResult();
526 ret = result.Value();
527 status_ = (ret == MSERR_OK ? REC_RECORDING : REC_ERROR);
528 BehaviorEventWrite(GetStatusDescription(status_), "Recorder");
529 return ret;
530 }
531
Pause()532 int32_t RecorderServer::Pause()
533 {
534 MediaTrace trace("RecorderServer::Pause");
535 std::lock_guard<std::mutex> lock(mutex_);
536 if (status_ == REC_PAUSED) {
537 MEDIA_LOGE("Can not repeat Pause");
538 return MSERR_INVALID_OPERATION;
539 }
540 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_RECORDING, MSERR_INVALID_OPERATION);
541 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
542 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
543 return recorderEngine_->Pause();
544 });
545 int32_t ret = taskQue_.EnqueueTask(task);
546 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
547
548 auto result = task->GetResult();
549 ret = result.Value();
550 status_ = (ret == MSERR_OK ? REC_PAUSED : REC_ERROR);
551 BehaviorEventWrite(GetStatusDescription(status_), "Recorder");
552 return ret;
553 }
554
Resume()555 int32_t RecorderServer::Resume()
556 {
557 MediaTrace trace("RecorderServer::Resume");
558 std::lock_guard<std::mutex> lock(mutex_);
559 if (status_ == REC_RECORDING) {
560 MEDIA_LOGE("Can not repeat Resume");
561 return MSERR_INVALID_OPERATION;
562 }
563 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_RECORDING && status_ != REC_PAUSED, MSERR_INVALID_OPERATION);
564 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
565 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
566 return recorderEngine_->Resume();
567 });
568 int32_t ret = taskQue_.EnqueueTask(task);
569 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
570
571 auto result = task->GetResult();
572 ret = result.Value();
573 status_ = (ret == MSERR_OK ? REC_RECORDING : REC_ERROR);
574 BehaviorEventWrite(GetStatusDescription(status_), "Recorder");
575 return ret;
576 }
577
Stop(bool block)578 int32_t RecorderServer::Stop(bool block)
579 {
580 std::lock_guard<std::mutex> lock(mutex_);
581 MediaTrace trace("RecorderServer::Stop");
582 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_RECORDING && status_ != REC_PAUSED, MSERR_INVALID_OPERATION);
583
584 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
585 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
586 return recorderEngine_->Stop(block);
587 });
588 int32_t ret = taskQue_.EnqueueTask(task);
589 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
590
591 auto result = task->GetResult();
592 ret = result.Value();
593 status_ = (ret == MSERR_OK ? REC_INITIALIZED : REC_ERROR);
594 BehaviorEventWrite(GetStatusDescription(status_), "Recorder");
595 return ret;
596 }
597
Reset()598 int32_t RecorderServer::Reset()
599 {
600 std::lock_guard<std::mutex> lock(mutex_);
601 MediaTrace trace("RecorderServer::Reset");
602 CHECK_AND_RETURN_RET_LOG(recorderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
603 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
604 return recorderEngine_->Reset();
605 });
606 int32_t ret = taskQue_.EnqueueTask(task);
607 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
608
609 auto result = task->GetResult();
610 ret = result.Value();
611 status_ = (ret == MSERR_OK ? REC_INITIALIZED : REC_ERROR);
612 BehaviorEventWrite(GetStatusDescription(status_), "Recorder");
613 return ret;
614 }
615
Release()616 int32_t RecorderServer::Release()
617 {
618 {
619 std::lock_guard<std::mutex> lock(mutex_);
620 auto task = std::make_shared<TaskHandler<void>>([&, this] {
621 recorderEngine_ = nullptr;
622 });
623 (void)taskQue_.EnqueueTask(task);
624 (void)task->GetResult();
625 }
626 return MSERR_OK;
627 }
628
SetFileSplitDuration(FileSplitType type,int64_t timestamp,uint32_t duration)629 int32_t RecorderServer::SetFileSplitDuration(FileSplitType type, int64_t timestamp, uint32_t duration)
630 {
631 std::lock_guard<std::mutex> lock(mutex_);
632 CHECK_STATUS_FAILED_AND_LOGE_RET(status_ != REC_RECORDING && status_ != REC_PAUSED, MSERR_INVALID_OPERATION);
633
634 (void)type;
635 (void)timestamp;
636 (void)duration;
637 return MSERR_OK;
638 }
639
SetParameter(int32_t sourceId,const Format & format)640 int32_t RecorderServer::SetParameter(int32_t sourceId, const Format &format)
641 {
642 (void)sourceId;
643 (void)format;
644 return MSERR_OK;
645 }
646
DumpInfo(int32_t fd)647 int32_t RecorderServer::DumpInfo(int32_t fd)
648 {
649 std::string dumpString;
650 dumpString += "In RecorderServer::DumpInfo\n";
651 dumpString += "RecorderServer current state is: " + std::to_string(status_) + "\n";
652 if (lastErrMsg_.size() != 0) {
653 dumpString += "RecorderServer last error is: " + lastErrMsg_ + "\n";
654 }
655 dumpString += "RecorderServer videoSource is: " + std::to_string(config_.videoSource) + "\n";
656 dumpString += "RecorderServer audioSource is: " + std::to_string(config_.audioSource) + "\n";
657 dumpString += "RecorderServer videoCodec is: " + std::to_string(config_.videoCodec) + "\n";
658 dumpString += "RecorderServer audioCodec is: " + std::to_string(config_.audioCodec) + "\n";
659 dumpString += "RecorderServer width is: " + std::to_string(config_.width) + "\n";
660 dumpString += "RecorderServer height is: " + std::to_string(config_.height) + "\n";
661 dumpString += "RecorderServer frameRate is: " + std::to_string(config_.frameRate) + "\n";
662 dumpString += "RecorderServer bitRate is: " + std::to_string(config_.bitRate) + "\n";
663 dumpString += "RecorderServer captureRate is: " + std::to_string(config_.captureRate) + "\n";
664 dumpString += "RecorderServer audioSampleRate is: " + std::to_string(config_.audioSampleRate) + "\n";
665 dumpString += "RecorderServer audioChannel is: " + std::to_string(config_.audioChannel) + "\n";
666 dumpString += "RecorderServer audioBitRate is: " + std::to_string(config_.audioBitRate) + "\n";
667 dumpString += "RecorderServer maxDuration is: " + std::to_string(config_.maxDuration) + "\n";
668 dumpString += "RecorderServer format is: " + std::to_string(config_.format) + "\n";
669 dumpString += "RecorderServer maxFileSize is: " + std::to_string(config_.maxFileSize) + "\n";
670 write(fd, dumpString.c_str(), dumpString.size());
671
672 return MSERR_OK;
673 }
674 } // namespace Media
675 } // namespace OHOS
676