caochunlei1@huawei.com

Signed-off-by: caochunlei <caochunlei1@huawei.com>

services/abilitymgr/include/connection_observer_controller.h

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_AAFWK_CONNECTION_OBSERVER_CONTROLLER_H
+#define OHOS_AAFWK_CONNECTION_OBSERVER_CONTROLLER_H
+
+#include <mutex>
+#include <vector>
+
+#include "iconnection_observer.h"
+
+namespace OHOS {
+namespace AAFwk {
+/**
+ * @class ConnectionObserverController
+ * ConnectionObserverController manage connection observers.
+ */
+class ConnectionObserverController : public std::enable_shared_from_this<ConnectionObserverController> {
+public:
+    ConnectionObserverController() = default;
+    ~ConnectionObserverController() = default;
+
+    /**
+     * add connection observer.
+     *
+     * @param observer the observer callback.
+     * @return Returns ERR_OK on success, others on failure.
+     */
+    int AddObserver(const sptr<AbilityRuntime::IConnectionObserver> &observer);
+
+    /**
+     * delete a callback.
+     *
+     * @param observer the observer callback.
+     */
+    void RemoveMissionListener(const sptr<AbilityRuntime::IConnectionObserver> &observer);
+
+    /**
+     * notify observers that extension was connected.
+     *
+     * @param data connection data.
+     */
+    void NotifyExtensionConnected(const AbilityRuntime::ConnectionData& data);
+
+    /**
+     * notify observers that extension was disconnected.
+     *
+     * @param data connection data.
+     */
+    void NotifyExtensionDisconnected(const AbilityRuntime::ConnectionData& data);
+
+    /**
+     * notify observers that dlp ability was opened.
+     *
+     * @param data dlp state data.
+     */
+    void NotifyDlpAbilityOpened(const AbilityRuntime::DlpStateData& data);
+
+    /**
+     * notify observers that dlp ability was closed.
+     *
+     * @param data dlp state data.
+     */
+    void NotifyDlpAbilityClosed(const AbilityRuntime::DlpStateData& data);
+
+private:
+    std::vector<sptr<AbilityRuntime::IConnectionObserver>> GetObservers();
+    void HandleRemoteDied(const wptr<IRemoteObject> &remote);
+
+    template<typename F, typename... Args>
+    void CallObservers(F func, Args&&... args)
+    {
+        auto observers = GetObservers();
+        for (auto& observer : observers) {
+            if (observer) {
+                (observer->*func)(std::forward<Args>(args)...);
+            }
+        }
+    }
+
+    class ObserverDeathRecipient : public IRemoteObject::DeathRecipient {
+    public:
+        using ObserverDeathHandler = std::function<void(const wptr<IRemoteObject> &)>;
+        explicit ObserverDeathRecipient(ObserverDeathHandler handler);
+        ~ObserverDeathRecipient() = default;
+        void OnRemoteDied(const wptr<IRemoteObject> &remote) final;
+
+    private:
+        ObserverDeathHandler deathHandler_;
+    };
+
+private:
+    std::recursive_mutex observerLock_;
+    std::vector<sptr<AbilityRuntime::IConnectionObserver>> observers_;
+    sptr<IRemoteObject::DeathRecipient> observerDeathRecipient_;
+};
+}  // namespace AAFwk
+}  // namespace OHOS
+#endif  // OHOS_AAFWK_CONNECTION_OBSERVER_CONTROLLER_H

services/abilitymgr/src/connection_observer_controller.cpp

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "connection_observer_controller.h"
+
+#include "hilog_wrapper.h"
+
+namespace OHOS {
+namespace AAFwk {
+int ConnectionObserverController::AddObserver(const sptr<AbilityRuntime::IConnectionObserver> &observer)
+{
+    if (!observer) {
+        HILOG_ERROR("observer is invalid");
+        return -1;
+    }
+
+    std::lock_guard<std::recursive_mutex> guard(observerLock_);
+    auto it = std::find_if(observers_.begin(), observers_.end(),
+        [&observer](const sptr<AbilityRuntime::IConnectionObserver> &item) {
+            return (item && item->AsObject() == observer->AsObject());
+        }
+    );
+    if (it != observers_.end()) {
+        HILOG_WARN("observer was already added, do not add again");
+        return 0;
+    }
+
+    if (!observerDeathRecipient_) {
+        std::weak_ptr<ConnectionObserverController> thisWeakPtr(shared_from_this());
+        observerDeathRecipient_ =
+            new ObserverDeathRecipient([thisWeakPtr](const wptr<IRemoteObject> &remote) {
+                auto controller = thisWeakPtr.lock();
+                if (controller) {
+                    controller->HandleRemoteDied(remote);
+                }
+            });
+    }
+    auto observerObj = observer->AsObject();
+    if (observerObj) {
+        observerObj->AddDeathRecipient(observerDeathRecipient_);
+    }
+    observers_.emplace_back(observer);
+
+    return 0;
+}
+
+void ConnectionObserverController::RemoveMissionListener(const sptr<AbilityRuntime::IConnectionObserver> &observer)
+{
+    if (!observer) {
+        HILOG_ERROR("observer is invalid");
+        return;
+    }
+
+    std::lock_guard<std::recursive_mutex> guard(observerLock_);
+    auto it = std::find_if(observers_.begin(), observers_.end(),
+        [&observer](const sptr<AbilityRuntime::IConnectionObserver> item) {
+            return (item && item->AsObject() == observer->AsObject());
+        }
+    );
+    if (it != observers_.end()) {
+        observers_.erase(it);
+    }
+}
+
+void ConnectionObserverController::NotifyExtensionConnected(const AbilityRuntime::ConnectionData& data)
+{
+    CallObservers(&AbilityRuntime::IConnectionObserver::OnExtensionConnected, data);
+}
+
+void ConnectionObserverController::NotifyExtensionDisconnected(const AbilityRuntime::ConnectionData& data)
+{
+    CallObservers(&AbilityRuntime::IConnectionObserver::OnExtensionDisconnected, data);
+}
+
+void ConnectionObserverController::NotifyDlpAbilityOpened(const AbilityRuntime::DlpStateData& data)
+{
+    CallObservers(&AbilityRuntime::IConnectionObserver::OnDlpAbilityOpened, data);
+}
+
+void ConnectionObserverController::NotifyDlpAbilityClosed(const AbilityRuntime::DlpStateData& data)
+{
+    CallObservers(&AbilityRuntime::IConnectionObserver::OnDlpAbilityClosed, data);
+}
+
+std::vector<sptr<AbilityRuntime::IConnectionObserver>> ConnectionObserverController::GetObservers()
+{
+    std::lock_guard<std::recursive_mutex> guard(observerLock_);
+    return observers_;
+}
+
+void ConnectionObserverController::HandleRemoteDied(const wptr<IRemoteObject> &remote)
+{
+    HILOG_DEBUG("remote connection oberver was died.");
+    auto remoteObj = remote.promote();
+    if (!remoteObj) {
+        HILOG_DEBUG("invalid remote object.");
+        return;
+    }
+    remoteObj->RemoveDeathRecipient(observerDeathRecipient_);
+
+    std::lock_guard<std::recursive_mutex> guard(observerLock_);
+    auto it = std::find_if(observers_.begin(), observers_.end(),
+        [&remoteObj](const sptr<AbilityRuntime::IConnectionObserver> item) {
+            return (item && item->AsObject() == remoteObj);
+        }
+    );
+    if (it != observers_.end()) {
+        observers_.erase(it);
+    }
+}
+
+ConnectionObserverController::ObserverDeathRecipient::ObserverDeathRecipient(ObserverDeathHandler handler)
+    : deathHandler_(handler)
+{}
+
+void ConnectionObserverController::ObserverDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
+{
+    if (deathHandler_) {
+        deathHandler_(remote);
+    }
+}
+} // namespace AAFwk
+} // namespace OHOS