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 "connection_observer_controller.h"
17
18 #include "connection_observer_errors.h"
19 #include "hilog_wrapper.h"
20
21 namespace OHOS {
22 namespace AAFwk {
23 using namespace OHOS::AbilityRuntime;
AddObserver(const sptr<AbilityRuntime::IConnectionObserver> & observer)24 int ConnectionObserverController::AddObserver(const sptr<AbilityRuntime::IConnectionObserver> &observer)
25 {
26 if (!observer) {
27 HILOG_ERROR("observer is invalid");
28 return AbilityRuntime::ERR_INVALID_OBSERVER;
29 }
30
31 std::lock_guard<ffrt::mutex> guard(observerLock_);
32 auto it = std::find_if(observers_.begin(), observers_.end(), [&observer](const sptr<IConnectionObserver> &item) {
33 return (item && item->AsObject() == observer->AsObject());
34 });
35 if (it != observers_.end()) {
36 HILOG_WARN("observer was already added, do not add again");
37 return 0;
38 }
39
40 if (!observerDeathRecipient_) {
41 std::weak_ptr<ConnectionObserverController> thisWeakPtr(shared_from_this());
42 observerDeathRecipient_ =
43 new ObserverDeathRecipient([thisWeakPtr](const wptr<IRemoteObject> &remote) {
44 auto controller = thisWeakPtr.lock();
45 if (controller) {
46 controller->HandleRemoteDied(remote);
47 }
48 });
49 }
50 auto observerObj = observer->AsObject();
51 if (!observerObj || !observerObj->AddDeathRecipient(observerDeathRecipient_)) {
52 HILOG_ERROR("AddDeathRecipient failed.");
53 }
54 observers_.emplace_back(observer);
55
56 return 0;
57 }
58
RemoveObserver(const sptr<AbilityRuntime::IConnectionObserver> & observer)59 void ConnectionObserverController::RemoveObserver(const sptr<AbilityRuntime::IConnectionObserver> &observer)
60 {
61 if (!observer) {
62 HILOG_ERROR("observer is invalid");
63 return;
64 }
65
66 std::lock_guard<ffrt::mutex> guard(observerLock_);
67 auto it = std::find_if(observers_.begin(), observers_.end(), [&observer](const sptr<IConnectionObserver> item) {
68 return (item && item->AsObject() == observer->AsObject());
69 });
70 if (it != observers_.end()) {
71 observers_.erase(it);
72 }
73 }
74
NotifyExtensionConnected(const AbilityRuntime::ConnectionData & data)75 void ConnectionObserverController::NotifyExtensionConnected(const AbilityRuntime::ConnectionData& data)
76 {
77 CallObservers(&AbilityRuntime::IConnectionObserver::OnExtensionConnected, data);
78 }
79
NotifyExtensionDisconnected(const AbilityRuntime::ConnectionData & data)80 void ConnectionObserverController::NotifyExtensionDisconnected(const AbilityRuntime::ConnectionData& data)
81 {
82 CallObservers(&AbilityRuntime::IConnectionObserver::OnExtensionDisconnected, data);
83 }
84
NotifyDlpAbilityOpened(const AbilityRuntime::DlpStateData & data)85 void ConnectionObserverController::NotifyDlpAbilityOpened(const AbilityRuntime::DlpStateData& data)
86 {
87 CallObservers(&AbilityRuntime::IConnectionObserver::OnDlpAbilityOpened, data);
88 }
89
NotifyDlpAbilityClosed(const AbilityRuntime::DlpStateData & data)90 void ConnectionObserverController::NotifyDlpAbilityClosed(const AbilityRuntime::DlpStateData& data)
91 {
92 CallObservers(&AbilityRuntime::IConnectionObserver::OnDlpAbilityClosed, data);
93 }
94
GetObservers()95 std::vector<sptr<AbilityRuntime::IConnectionObserver>> ConnectionObserverController::GetObservers()
96 {
97 std::lock_guard<ffrt::mutex> guard(observerLock_);
98 return observers_;
99 }
100
HandleRemoteDied(const wptr<IRemoteObject> & remote)101 void ConnectionObserverController::HandleRemoteDied(const wptr<IRemoteObject> &remote)
102 {
103 HILOG_DEBUG("remote connection oberver was died.");
104 auto remoteObj = remote.promote();
105 if (!remoteObj) {
106 HILOG_DEBUG("invalid remote object.");
107 return;
108 }
109 remoteObj->RemoveDeathRecipient(observerDeathRecipient_);
110
111 std::lock_guard<ffrt::mutex> guard(observerLock_);
112 auto it = std::find_if(observers_.begin(), observers_.end(), [&remoteObj](const sptr<IConnectionObserver> item) {
113 return (item && item->AsObject() == remoteObj);
114 });
115 if (it != observers_.end()) {
116 observers_.erase(it);
117 }
118 }
119
ObserverDeathRecipient(ObserverDeathHandler handler)120 ConnectionObserverController::ObserverDeathRecipient::ObserverDeathRecipient(ObserverDeathHandler handler)
121 : deathHandler_(handler)
122 {}
123
OnRemoteDied(const wptr<IRemoteObject> & remote)124 void ConnectionObserverController::ObserverDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
125 {
126 if (deathHandler_) {
127 deathHandler_(remote);
128 }
129 }
130 } // namespace AAFwk
131 } // namespace OHOS
132