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 "media_log.h"
20 #include "media_errors.h"
21 #include "hisysevent.h"
22 #include "telephony_observer_client.h"
23 #include "telephony_types.h"
24 #include "telephony_errors.h"
25
26 namespace {
27 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_PLAYER, "InCallObserver"};
28 }
29
30 using namespace OHOS;
31 using namespace OHOS::Telephony;
32 namespace OHOS {
33 namespace Media {
34
GetInstance()35 InCallObserver& InCallObserver::GetInstance()
36 {
37 static InCallObserver instance;
38 instance.Init();
39 return instance;
40 }
41
InCallObserver()42 InCallObserver::InCallObserver()
43 {
44 MEDIA_LOGI("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this));
45 }
46
~InCallObserver()47 InCallObserver::~InCallObserver()
48 {
49 UnRegisterObserver();
50 MEDIA_LOGI("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this));
51 }
52
IsInCall()53 bool InCallObserver::IsInCall()
54 {
55 UnRegisterObserver();
56 RegisterObserver();
57 return inCall_;
58 }
59
RegisterInCallObserverCallBack(std::weak_ptr<InCallObserverCallBack> callback)60 bool InCallObserver::RegisterInCallObserverCallBack(std::weak_ptr<InCallObserverCallBack> callback)
61 {
62 std::unique_lock<std::mutex> lock(mutex_);
63 auto callbackPtr = callback.lock();
64 if (callbackPtr) {
65 inCallObserverCallBack_ = callback;
66 return true;
67 } else {
68 MEDIA_LOGI("0x%{public}06" PRIXPTR "InCallObserver CallBack is null", FAKE_POINTER(this));
69 }
70 return false;
71 }
72
UnRegisterInCallObserverCallBack()73 void InCallObserver::UnRegisterInCallObserverCallBack()
74 {
75 if (!inCallObserverCallBack_.expired()) {
76 inCallObserverCallBack_.reset();
77 }
78 }
79
OnCallStateUpdated(bool inCall)80 bool InCallObserver::OnCallStateUpdated(bool inCall)
81 {
82 std::unique_lock<std::mutex> lock(mutex_);
83 if (inCall_.load() != inCall) {
84 MEDIA_LOGI("Update InCall Status %{public}d", static_cast<int32_t>(inCall));
85 inCall_.store(inCall);
86 }
87 if (inCall) {
88 auto callbackPtr = inCallObserverCallBack_.lock();
89 if (callbackPtr) {
90 MEDIA_LOGI("0x%{public}06" PRIXPTR " Stop and Release CallBack", FAKE_POINTER(this));
91 return callbackPtr->StopAndRelease(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_CALL);
92 } else {
93 MEDIA_LOGI("0x%{public}06" PRIXPTR "InCallObserver CallBack is null", FAKE_POINTER(this));
94 }
95 }
96 return true;
97 }
98
Init()99 bool InCallObserver::Init()
100 {
101 if (isTelephonyStateListenerDied_) {
102 MEDIA_LOGI("0x%{public}06" PRIXPTR " InCallObserver Init, Register Observer", FAKE_POINTER(this));
103 UnRegisterObserver();
104 RegisterObserver();
105 isTelephonyStateListenerDied_ = false;
106 } else {
107 MEDIA_LOGI("InCallObserver exist : %{public}d", isTelephonyStateListenerDied_);
108 }
109 return true;
110 }
111
RegisterObserver()112 bool InCallObserver::RegisterObserver()
113 {
114 MEDIA_LOGI("InCallObserver Register InCall Listener");
115 std::unique_lock<std::mutex> lock(mutex_);
116 bool ret = false;
117 for (int slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
118 MEDIA_LOGI("InCallObserver Register Listener slotId:%{public}d", slotId);
119 auto telephonyObserver_ = std::make_unique<MediaTelephonyListener>().release();
120 auto res = TelephonyObserverClient::GetInstance().AddStateObserver(telephonyObserver_, slotId,
121 TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE, true);
122 MEDIA_LOGI("InCallObserver Register Listener observer ret:%{public}d", res);
123 if (res == OHOS::Telephony::TELEPHONY_SUCCESS) {
124 ret = true;
125 mediaTelephonyListeners_.push_back(telephonyObserver_);
126 }
127 }
128 return ret;
129 }
130
UnRegisterObserver()131 void InCallObserver::UnRegisterObserver()
132 {
133 MEDIA_LOGI("UnRegister InCall Listener");
134 std::unique_lock<std::mutex> lock(mutex_);
135 for (int slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
136 MEDIA_LOGI("UnRegister Listener slotId:%{public}d", slotId);
137 TelephonyObserverClient::GetInstance().RemoveStateObserver(slotId,
138 TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE);
139 }
140 mediaTelephonyListeners_.clear();
141 }
142 }
143 }