1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2024-2024. All rights reserved.
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 "incall_observer.h"
17 #include <unistd.h>
18 #include <functional>
19 #include "call_manager_client.h"
20 #include "media_log.h"
21 #include "media_errors.h"
22 #include "hisysevent.h"
23 #include "telephony_observer_client.h"
24 #include "telephony_types.h"
25 #include "telephony_errors.h"
26
27 namespace {
28 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_SCREENCAPTURE, "InCallObserver"};
29 }
30
31 using namespace OHOS;
32 using namespace OHOS::Telephony;
33 namespace OHOS {
34 namespace Media {
35
GetInstance()36 InCallObserver& InCallObserver::GetInstance()
37 {
38 static InCallObserver instance;
39 instance.Init();
40 return instance;
41 }
42
InCallObserver()43 InCallObserver::InCallObserver(): taskQue_("IncallObs")
44 {
45 taskQue_.Start();
46 MEDIA_LOGI("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this));
47 }
48
~InCallObserver()49 InCallObserver::~InCallObserver()
50 {
51 UnRegisterObserver();
52 taskQue_.Stop();
53 MEDIA_LOGI("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this));
54 }
55
IsInCall(bool refreshState)56 bool InCallObserver::IsInCall(bool refreshState)
57 {
58 if (refreshState) {
59 UnRegisterObserver();
60 RegisterObserver();
61 }
62 MEDIA_LOGI("InCallObserver is inCall: %{public}d", inCall_.load());
63 return inCall_.load();
64 }
65
RegisterInCallObserverCallBack(std::weak_ptr<InCallObserverCallBack> callback)66 bool InCallObserver::RegisterInCallObserverCallBack(std::weak_ptr<InCallObserverCallBack> callback)
67 {
68 MEDIA_LOGI("InCallObserver::RegisterInCallObserverCallBack START.");
69 std::unique_lock<std::mutex> lock(mutex_);
70 auto task = std::make_shared<TaskHandler<bool>>([&, this, callback] {
71 auto callbackPtr = callback.lock();
72 if (callbackPtr) {
73 inCallObserverCallBacks_.push_back(callback);
74 return true;
75 }
76 MEDIA_LOGI("0x%{public}06" PRIXPTR "InCallObserver CallBack is null", FAKE_POINTER(this));
77 return false;
78 });
79 int32_t ret = taskQue_.EnqueueTask(task);
80 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, false, "RegisterInCallObserverCallBack: EnqueueTask failed.");
81
82 auto result = task->GetResult();
83 CHECK_AND_RETURN_RET_LOG(result.HasResult(), false, "RegisterInCallObserverCallBack: GetResult failed.");
84 MEDIA_LOGI("InCallObserver::RegisterInCallObserverCallBack vecSize: %{public}d",
85 static_cast<int32_t>(inCallObserverCallBacks_.size()));
86 return result.Value();
87 }
88
UnregisterInCallObserverCallBack(std::weak_ptr<InCallObserverCallBack> callback)89 void InCallObserver::UnregisterInCallObserverCallBack(std::weak_ptr<InCallObserverCallBack> callback)
90 {
91 MEDIA_LOGI("InCallObserver::UnregisterInCallObserverCallBack START.");
92 std::unique_lock<std::mutex> lock(mutex_);
93 auto task = std::make_shared<TaskHandler<void>>([&, this, callback] {
94 auto unregisterCallBack = callback.lock();
95 for (auto iter = inCallObserverCallBacks_.begin(); iter != inCallObserverCallBacks_.end();) {
96 auto iterCallback = (*iter).lock();
97 if (iterCallback == unregisterCallBack || iterCallback == nullptr) {
98 MEDIA_LOGD("0x%{public}06" PRIXPTR "UnregisterInCallObserverCallBack",
99 FAKE_POINTER(iterCallback.get()));
100 iter = inCallObserverCallBacks_.erase(iter);
101 } else {
102 iter++;
103 }
104 }
105 MEDIA_LOGI("UnregisterInCallObserverCallBack END. inCallObserverCallBacks_.size(): %{public}d",
106 static_cast<int32_t>(inCallObserverCallBacks_.size()));
107 });
108 taskQue_.EnqueueTask(task);
109 MEDIA_LOGI("InCallObserver::UnregisterInCallObserverCallBack END.");
110 }
111
OnCallStateUpdated(bool inCall)112 bool InCallObserver::OnCallStateUpdated(bool inCall)
113 {
114 MEDIA_LOGD("InCallObserver::OnCallStateUpdated START.");
115 std::unique_lock<std::mutex> lock(mutex_);
116 if (inCall_.load() == inCall) {
117 return true;
118 }
119 MEDIA_LOGI("Update InCall Status %{public}d", static_cast<int32_t>(inCall));
120 inCall_.store(inCall);
121 bool ret = true;
122 for (auto iter = inCallObserverCallBacks_.begin(); iter != inCallObserverCallBacks_.end(); iter++) {
123 auto callbackPtr = (*iter).lock();
124 MEDIA_LOGD("0x%{public}06" PRIXPTR "OnCallStateUpdated", FAKE_POINTER(callbackPtr.get()));
125 if (callbackPtr) {
126 MEDIA_LOGD("0x%{public}06" PRIXPTR "OnCallStateUpdated NotifyTelCallStateUpdated start",
127 FAKE_POINTER(callbackPtr.get()));
128 ret &= callbackPtr->NotifyTelCallStateUpdated(inCall);
129 MEDIA_LOGD("OnCallStateUpdated NotifyTelCallStateUpdated ret: %{public}d.", ret);
130 }
131 }
132 return ret;
133 }
134
Init()135 bool InCallObserver::Init()
136 {
137 if (isTelephonyStateListenerDied_) {
138 MEDIA_LOGI("0x%{public}06" PRIXPTR " InCallObserver Init, Register Observer", FAKE_POINTER(this));
139 UnRegisterObserver();
140 RegisterObserver();
141 isTelephonyStateListenerDied_ = false;
142 } else {
143 MEDIA_LOGI("InCallObserver exist : %{public}d", isTelephonyStateListenerDied_);
144 }
145 return true;
146 }
147
RegisterObserver()148 bool InCallObserver::RegisterObserver()
149 {
150 MEDIA_LOGI("InCallObserver Register InCall Listener");
151 std::unique_lock<std::mutex> lock(mutex_);
152 bool ret = false;
153 auto telephonyObserver_ = std::make_unique<MediaTelephonyListener>().release();
154 auto observerRes = TelephonyObserverClient::GetInstance().AddStateObserver(telephonyObserver_, -1,
155 TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE, true);
156 if (observerRes == OHOS::Telephony::TELEPHONY_SUCCESS) {
157 ret = true;
158 mediaTelephonyListeners_.push_back(telephonyObserver_);
159 } else {
160 MEDIA_LOGI("InCallObserver Register Listener observer ret:%{public}d", observerRes);
161 }
162 return ret;
163 }
164
UnRegisterObserver()165 void InCallObserver::UnRegisterObserver()
166 {
167 MEDIA_LOGI("UnRegister InCall Listener");
168 std::unique_lock<std::mutex> lock(mutex_);
169 TelephonyObserverClient::GetInstance().RemoveStateObserver(-1,
170 TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE);
171 mediaTelephonyListeners_.clear();
172 }
173 }
174 }