mirror of
https://github.com/openharmony/window_window_manager.git
synced 2026-08-24 15:55:05 -04:00
zhouwenbo7
332 lines
11 KiB
C++
332 lines
11 KiB
C++
/*
|
|
* Copyright (c) 2021-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_ROSEN_CLIENT_AGENT_MANAGER_H
|
|
#define OHOS_ROSEN_CLIENT_AGENT_MANAGER_H
|
|
|
|
#include <map>
|
|
#include <mutex>
|
|
#include <set>
|
|
#include <sstream>
|
|
#include "agent_death_recipient.h"
|
|
#include "window_manager_hilog.h"
|
|
#include "ipc_skeleton.h"
|
|
#include "permission.h"
|
|
|
|
namespace OHOS {
|
|
namespace Rosen {
|
|
constexpr int32_t INVALID_PID_ID = -1;
|
|
template <typename T1, typename T2>
|
|
class ClientAgentContainer {
|
|
public:
|
|
ClientAgentContainer();
|
|
virtual ~ClientAgentContainer() = default;
|
|
|
|
bool RegisterAgent(const sptr<T1>& agent, T2 type);
|
|
bool RegisterAttributeAgent(uintptr_t key, const sptr<T1>& agent, const std::vector<T2>& attributes);
|
|
bool UnregisterAgent(const sptr<T1>& agent, T2 type);
|
|
bool UnRegisterAllAttributeAgent(uintptr_t key, const sptr<T1>& agent);
|
|
bool UnRegisterAttribute(uintptr_t key, const sptr<T1>& agent, const std::vector<T2>& attributesOff);
|
|
std::set<sptr<T1>> GetAgentsByType(T2 type);
|
|
void SetAgentDeathCallback(std::function<void(const sptr<IRemoteObject>&)> callback);
|
|
int32_t GetAgentPid(const sptr<T1>& agent);
|
|
bool GetAgentSystem(const sptr<T1>& agent);
|
|
std::map<uintptr_t, std::pair<sptr<T1>, std::set<T2>>> GetAttributeAgentsMap();
|
|
template <typename Func>
|
|
auto ParseAttributeAgentsMap(Func&& func);
|
|
|
|
private:
|
|
void RemoveAgent(const sptr<IRemoteObject>& remoteObject);
|
|
bool UnregisterAgentLocked(std::set<sptr<T1>>& agents, const sptr<IRemoteObject>& agent);
|
|
|
|
static constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "ClientAgentContainer"};
|
|
|
|
struct finder_t {
|
|
explicit finder_t(sptr<IRemoteObject> remoteObject) : remoteObject_(remoteObject) {}
|
|
|
|
bool operator()(sptr<T1> agent)
|
|
{
|
|
if (agent == nullptr) {
|
|
WLOGFE("agent is invalid");
|
|
return false;
|
|
}
|
|
return agent->AsObject() == remoteObject_;
|
|
}
|
|
|
|
sptr<IRemoteObject> remoteObject_;
|
|
};
|
|
|
|
std::recursive_mutex mutex_;
|
|
std::map<T2, std::set<sptr<T1>>> agentMap_;
|
|
std::map<uintptr_t, std::pair<sptr<T1>, std::set<T2>>> attributeAgentMap_;
|
|
std::map<sptr<T1>, int32_t> agentPidMap_;
|
|
std::map<sptr<T1>, bool> agentSystemMap_;
|
|
sptr<AgentDeathRecipient> deathRecipient_;
|
|
std::function<void(const sptr<IRemoteObject>&)> deathCallback_;
|
|
};
|
|
|
|
template<typename T1, typename T2>
|
|
ClientAgentContainer<T1, T2>::ClientAgentContainer() : deathRecipient_(
|
|
new AgentDeathRecipient([this](const sptr<IRemoteObject>& remoteObject) { this->RemoveAgent(remoteObject); })) {}
|
|
|
|
template<typename T1, typename T2>
|
|
bool ClientAgentContainer<T1, T2>::RegisterAgent(const sptr<T1>& agent, T2 type)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock(mutex_);
|
|
if (agent == nullptr) {
|
|
WLOGFE("agent is invalid");
|
|
return false;
|
|
}
|
|
agentMap_[type].insert(agent);
|
|
agentPidMap_[agent] = IPCSkeleton::GetCallingPid();
|
|
agentSystemMap_[agent] = Permission::IsSystemCalling();
|
|
if (deathRecipient_ == nullptr || !agent->AsObject()->AddDeathRecipient(deathRecipient_)) {
|
|
WLOGFI("failed to add death recipient");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
bool ClientAgentContainer<T1, T2>::RegisterAttributeAgent(uintptr_t key, const sptr<T1>& agent,
|
|
const std::vector<T2>& attributes)
|
|
{
|
|
TLOGI(WmsLogTag::DMS, "called");
|
|
std::lock_guard<std::recursive_mutex> lock(mutex_);
|
|
if (agent == nullptr) {
|
|
WLOGFE("agent is invalid");
|
|
return false;
|
|
}
|
|
auto it = attributeAgentMap_.find(key);
|
|
if (it != attributeAgentMap_.end()) {
|
|
for (const auto& attr : attributes) {
|
|
it->second.second.insert(attr);
|
|
}
|
|
} else {
|
|
std::set<std::string> attrSet(attributes.begin(), attributes.end());
|
|
attributeAgentMap_[key] = {agent, attrSet};
|
|
agentPidMap_[agent] = IPCSkeleton::GetCallingPid();
|
|
}
|
|
|
|
auto iter = attributeAgentMap_.find(key);
|
|
if (iter != attributeAgentMap_.end()) {
|
|
std::ostringstream oss;
|
|
oss << "current listened attribute list:[";
|
|
for (const auto attribute : iter->second.second) {
|
|
oss << attribute << ",";
|
|
}
|
|
TLOGI(WmsLogTag::DMS, "%{public}s]", oss.str().c_str());
|
|
}
|
|
if (deathRecipient_ == nullptr || !agent->AsObject()->AddDeathRecipient(deathRecipient_)) {
|
|
WLOGFI("failed to add death recipient");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
bool ClientAgentContainer<T1, T2>::UnRegisterAllAttributeAgent(uintptr_t key, const sptr<T1>& agent)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock(mutex_);
|
|
if (agent == nullptr) {
|
|
WLOGFE("agent is invalid");
|
|
return false;
|
|
}
|
|
if (attributeAgentMap_.count(key) == 0) {
|
|
WLOGFD("repeat unregister agent");
|
|
return true;
|
|
}
|
|
auto agentPidIt = agentPidMap_.find(agent);
|
|
if (agentPidIt != agentPidMap_.end()) {
|
|
int32_t agentPid = agentPidMap_[agent];
|
|
agentPidMap_.erase(agentPidIt);
|
|
WLOGFD("agent pid: %{public}d unregistered", agentPid);
|
|
}
|
|
auto agentSystemIt = agentSystemMap_.find(agent);
|
|
if (agentSystemIt != agentSystemMap_.end()) {
|
|
agentSystemMap_.erase(agentSystemIt);
|
|
}
|
|
attributeAgentMap_.erase(key);
|
|
agent->AsObject()->RemoveDeathRecipient(deathRecipient_);
|
|
return true;
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
bool ClientAgentContainer<T1, T2>::UnRegisterAttribute(uintptr_t key, const sptr<T1>& agent,
|
|
const std::vector<T2>& attributesOff)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock(mutex_);
|
|
if (agent == nullptr) {
|
|
WLOGFE("agent is invalid");
|
|
return false;
|
|
}
|
|
if (attributeAgentMap_.count(key) == 0) {
|
|
WLOGFD("repeat unregister agent");
|
|
return true;
|
|
}
|
|
auto& attributes = attributeAgentMap_.at(key).second;
|
|
for (auto attribute : attributesOff) {
|
|
auto iter = attributes.find(attribute);
|
|
if (iter == attributes.end()) {
|
|
WLOGFD("could not find this attribute: %{public}s", attribute.c_str());
|
|
continue;
|
|
}
|
|
attributes.erase(iter);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
std::map<uintptr_t, std::pair<sptr<T1>, std::set<T2>>> ClientAgentContainer<T1, T2>::GetAttributeAgentsMap()
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock(mutex_);
|
|
return attributeAgentMap_;
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
template <typename Func>
|
|
auto ClientAgentContainer<T1, T2>::ParseAttributeAgentsMap(Func&& func)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock(mutex_);
|
|
return func(attributeAgentMap_);
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
bool ClientAgentContainer<T1, T2>::UnregisterAgent(const sptr<T1>& agent, T2 type)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock(mutex_);
|
|
if (agent == nullptr) {
|
|
WLOGFE("agent is invalid");
|
|
return false;
|
|
}
|
|
if (agentMap_.count(type) == 0) {
|
|
WLOGFD("repeat unregister agent");
|
|
return true;
|
|
}
|
|
auto& agents = agentMap_.at(type);
|
|
UnregisterAgentLocked(agents, agent->AsObject());
|
|
agent->AsObject()->RemoveDeathRecipient(deathRecipient_);
|
|
return true;
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
std::set<sptr<T1>> ClientAgentContainer<T1, T2>::GetAgentsByType(T2 type)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock(mutex_);
|
|
if (agentMap_.count(type) == 0) {
|
|
WLOGFD("no such type of agent registered! type:%{public}u", type);
|
|
return std::set<sptr<T1>>();
|
|
}
|
|
auto agents = agentMap_.at(type);
|
|
std::ostringstream pids;
|
|
for (const auto& agent : agents) {
|
|
auto it = agentPidMap_.find(agent);
|
|
if (it != agentPidMap_.end()) {
|
|
pids << it->second << ",";
|
|
}
|
|
}
|
|
TLOGD(WmsLogTag::WMS_ATTRIBUTE, "type=%{public}u, #agents=%{public}u, pids=[%{public}s]",
|
|
type, static_cast<uint32_t>(agents.size()), pids.str().c_str());
|
|
return agents;
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
bool ClientAgentContainer<T1, T2>::UnregisterAgentLocked(std::set<sptr<T1>>& agents,
|
|
const sptr<IRemoteObject>& agent)
|
|
{
|
|
if (agent == nullptr) {
|
|
WLOGFE("agent is invalid");
|
|
return false;
|
|
}
|
|
auto iter = std::find_if(agents.begin(), agents.end(), finder_t(agent));
|
|
if (iter == agents.end()) {
|
|
WLOGFD("could not find this agent");
|
|
return false;
|
|
}
|
|
auto agentPidIt = agentPidMap_.find(*iter);
|
|
if (agentPidIt != agentPidMap_.end()) {
|
|
int32_t agentPid = agentPidMap_[*iter];
|
|
agentPidMap_.erase(agentPidIt);
|
|
WLOGFD("agent pid: %{public}d unregistered", agentPid);
|
|
}
|
|
agents.erase(iter);
|
|
WLOGFD("agent unregistered");
|
|
return true;
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
void ClientAgentContainer<T1, T2>::RemoveAgent(const sptr<IRemoteObject>& remoteObject)
|
|
{
|
|
TLOGD(WmsLogTag::DEFAULT, "Enter");
|
|
if (remoteObject == nullptr) {
|
|
WLOGFE("remoteObject is invalid");
|
|
return;
|
|
}
|
|
if (deathCallback_ != nullptr) {
|
|
deathCallback_(remoteObject);
|
|
}
|
|
std::lock_guard<std::recursive_mutex> lock(mutex_);
|
|
static bool isEntryAgain = false;
|
|
if (isEntryAgain) {
|
|
WLOGFW("UnregisterAgentLocked entry again");
|
|
}
|
|
isEntryAgain = true;
|
|
for (auto& elem : agentMap_) {
|
|
if (UnregisterAgentLocked(elem.second, remoteObject)) {
|
|
break;
|
|
}
|
|
}
|
|
remoteObject->RemoveDeathRecipient(deathRecipient_);
|
|
isEntryAgain = false;
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
void ClientAgentContainer<T1, T2>::SetAgentDeathCallback(std::function<void(const sptr<IRemoteObject>&)> callback)
|
|
{
|
|
deathCallback_ = callback;
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
int32_t ClientAgentContainer<T1, T2>::GetAgentPid(const sptr<T1>& agent)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock(mutex_);
|
|
if (agent == nullptr) {
|
|
WLOGFE("agent is invalid");
|
|
return INVALID_PID_ID;
|
|
}
|
|
if (agentPidMap_.count(agent) == 0) {
|
|
WLOGFE("agent pid not found");
|
|
return INVALID_PID_ID;
|
|
}
|
|
return agentPidMap_[agent];
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
bool ClientAgentContainer<T1, T2>::GetAgentSystem(const sptr<T1>& agent)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock(mutex_);
|
|
if (agent == nullptr) {
|
|
WLOGFE("agent is invalid");
|
|
return false;
|
|
}
|
|
if (agentSystemMap_.count(agent) == 0) {
|
|
WLOGFE("agent pid not found");
|
|
return false;
|
|
}
|
|
return agentSystemMap_[agent];
|
|
}
|
|
|
|
}
|
|
}
|
|
#endif // OHOS_ROSEN_CLIENT_AGENT_MANAGER_H
|