1 /*
2 * Copyright (c) 2022 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 "ability_manager_adapter.h"
17
18 #include "avsession_errors.h"
19 #include "avsession_log.h"
20 #include "bundle_status_adapter.h"
21 #include "ability_connect_helper.h"
22
23 namespace OHOS::AVSession {
AbilityManagerAdapter(const std::string & bundleName,const std::string & abilityName)24 AbilityManagerAdapter::AbilityManagerAdapter(const std::string& bundleName, const std::string& abilityName)
25 {
26 SLOGI("construct bundleName=%{public}s abilityName=%{public}s", bundleName.c_str(), abilityName.c_str());
27 bundleName_ = bundleName;
28 abilityName_ = abilityName;
29 }
30
~AbilityManagerAdapter()31 AbilityManagerAdapter::~AbilityManagerAdapter()
32 {}
33
StartAbilityByCall(std::string & sessionId)34 int32_t AbilityManagerAdapter::StartAbilityByCall(std::string& sessionId)
35 {
36 if (status_ != Status::ABILITY_STATUS_INIT) {
37 SLOGE("Start Ability is running");
38 return ERR_START_ABILITY_IS_RUNNING;
39 }
40 status_ = Status::ABILITY_STATUS_RUNNING;
41 // start executeIntent
42 AppExecFwk::InsightIntentExecuteParam executeParam;
43 bool isSupport = BundleStatusAdapter::GetInstance().GetPlayIntentParam(bundleName_, "", executeParam);
44 int32_t ret = AVSESSION_ERROR;
45 if (bundleName_ != defaultBundleName && isSupport && !executeParam.insightIntentName_.empty()) {
46 SLOGI("Start Ability mediaintent");
47 ret = AbilityConnectHelper::GetInstance().StartAVPlayback(executeParam);
48 } else {
49 ret = AbilityConnectHelper::GetInstance().StartAbilityByCall(bundleName_, abilityName_);
50 }
51 if (ret != AVSESSION_SUCCESS) {
52 SLOGE("Start Ability failed: %{public}d", ret);
53 status_ = Status::ABILITY_STATUS_INIT;
54 return ret;
55 }
56
57 WaitForTimeout(ABILITY_START_TIMEOUT_MS);
58 ret = ERR_START_ABILITY_TIMEOUT;
59 if (status_ == Status::ABILITY_STATUS_SUCCESS) {
60 ret = AVSESSION_SUCCESS;
61 sessionId = sessionId_;
62 }
63 status_ = Status::ABILITY_STATUS_INIT;
64 return ret;
65 }
66
StartAbilityByCallDone(const std::string & sessionId)67 void AbilityManagerAdapter::StartAbilityByCallDone(const std::string& sessionId)
68 {
69 if (status_ != Status::ABILITY_STATUS_RUNNING) {
70 SLOGI("no need to notify");
71 return;
72 }
73 sessionId_ = sessionId;
74 syncCon_.notify_one();
75 }
76
WaitForTimeout(uint32_t timeout)77 void AbilityManagerAdapter::WaitForTimeout(uint32_t timeout)
78 {
79 std::unique_lock<std::mutex> lock(syncMutex_);
80 auto waitStatus = syncCon_.wait_for(lock, std::chrono::milliseconds(timeout));
81 if (waitStatus == std::cv_status::timeout) {
82 SLOGE("StartAbilityByCall timeout");
83 status_ = Status::ABILITY_STATUS_FAILED;
84 return;
85 }
86 status_ = Status::ABILITY_STATUS_SUCCESS;
87 }
88 } // namespace OHOS::AVSession