1 /*
2  * Copyright (c) 2021-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 "dcamera_source_service_ipc.h"
17 
18 #include "if_system_ability_manager.h"
19 #include "iservice_registry.h"
20 
21 #include "anonymous_string.h"
22 #include "distributed_camera_constants.h"
23 #include "distributed_camera_errno.h"
24 #include "distributed_hardware_log.h"
25 
26 namespace OHOS {
27 namespace DistributedHardware {
DCameraSourceServiceIpc()28 DCameraSourceServiceIpc::DCameraSourceServiceIpc() : isInit_(false)
29 {
30     DHLOGI("DCameraSourceServiceIpc Create");
31 }
32 
~DCameraSourceServiceIpc()33 DCameraSourceServiceIpc::~DCameraSourceServiceIpc()
34 {
35     DHLOGI("DCameraSourceServiceIpc Delete");
36     UnInit();
37 }
38 
39 IMPLEMENT_SINGLE_INSTANCE(DCameraSourceServiceIpc);
40 
Init()41 void DCameraSourceServiceIpc::Init()
42 {
43     std::lock_guard<std::mutex> autoLock(initCamSrvLock_);
44     DHLOGI("Start");
45     if (isInit_) {
46         DHLOGI("DCameraSourceServiceIpc has already init");
47         return;
48     }
49     sinkRemoteRecipient_ = sptr<SinkRemoteRecipient>(new SinkRemoteRecipient());
50     isInit_ = true;
51     DHLOGI("End");
52 }
53 
UnInit()54 void DCameraSourceServiceIpc::UnInit()
55 {
56     std::lock_guard<std::mutex> autoLock(initCamSrvLock_);
57     DHLOGI("Start");
58     if (!isInit_) {
59         DHLOGI("DCameraSourceServiceIpc has already UnInit");
60         return;
61     }
62     ClearSinkRemoteCamSrv();
63     DHLOGI("Start free recipient");
64     sinkRemoteRecipient_ = nullptr;
65     isInit_ = false;
66     DHLOGI("End");
67 }
68 
GetSinkRemoteCamSrv(const std::string & deviceId)69 sptr<IDistributedCameraSink> DCameraSourceServiceIpc::GetSinkRemoteCamSrv(const std::string& deviceId)
70 {
71     if (deviceId.empty()) {
72         DHLOGE("GetSinkRemoteCamSrv deviceId is empty");
73         return nullptr;
74     }
75     {
76         std::lock_guard<std::mutex> autoLock(sinkRemoteCamSrvLock_);
77         auto iter = remoteSinks_.find(deviceId);
78         if (iter != remoteSinks_.end()) {
79             auto object = iter->second;
80             if (object != nullptr) {
81                 DHLOGI("DCameraSourceServiceIpc GetSinkRemoteCamSrv from cache devId: %{public}s",
82                     GetAnonyString(deviceId).c_str());
83                 return object;
84             }
85         }
86     }
87     DHLOGI("GetSinkRemoteCamSrv remote deviceid is %{public}s", GetAnonyString(deviceId).c_str());
88     auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
89     if (samgr == nullptr) {
90         DHLOGE("GetSinkRemoteCamSrv failed to connect to systemAbilityMgr!");
91         return nullptr;
92     }
93 
94     auto object = samgr->CheckSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID, deviceId);
95     if (object == nullptr) {
96         DHLOGE("GetSinkRemoteCamSrv failed get remote CamSrv %{public}s", GetAnonyString(deviceId).c_str());
97         return nullptr;
98     }
99     int32_t ret = object->AddDeathRecipient(sinkRemoteRecipient_);
100     sptr<IDistributedCameraSink> remoteCamSrvObj = iface_cast<IDistributedCameraSink>(object);
101     if (remoteCamSrvObj == nullptr) {
102         DHLOGI("GetSinkRemoteCamSrv failed, remoteCamSrvObj is null ret: %{public}d", ret);
103         return nullptr;
104     }
105     {
106         std::lock_guard<std::mutex> autoLock(sinkRemoteCamSrvLock_);
107         auto iter = remoteSinks_.find(deviceId);
108         if (iter != remoteSinks_.end()) {
109             iter->second->AsObject()->RemoveDeathRecipient(sinkRemoteRecipient_);
110         }
111         remoteSinks_[deviceId] = remoteCamSrvObj;
112     }
113     DHLOGI("GetSinkRemoteCamSrv success, AddDeathRecipient ret: %{public}d", ret);
114     return remoteCamSrvObj;
115 }
116 
DeleteSinkRemoteCamSrv(const std::string & deviceId)117 void DCameraSourceServiceIpc::DeleteSinkRemoteCamSrv(const std::string& deviceId)
118 {
119     DHLOGI("DeleteSinkRemoteCamSrv devId: %{public}s", GetAnonyString(deviceId).c_str());
120     std::lock_guard<std::mutex> autoLock(sinkRemoteCamSrvLock_);
121     auto item = remoteSinks_.find(deviceId);
122     if (item == remoteSinks_.end()) {
123         DHLOGI("DeleteSinkRemoteCamSrv not found device: %{public}s", GetAnonyString(deviceId).c_str());
124         return;
125     }
126 
127     if (item->second != nullptr) {
128         item->second->AsObject()->RemoveDeathRecipient(sinkRemoteRecipient_);
129     }
130     remoteSinks_.erase(item);
131 }
132 
ClearSinkRemoteCamSrv()133 void DCameraSourceServiceIpc::ClearSinkRemoteCamSrv()
134 {
135     DHLOGI("ClearSinkRemoteCamSrv Start");
136     std::lock_guard<std::mutex> autoLock(sinkRemoteCamSrvLock_);
137     for (auto iter = remoteSinks_.begin(); iter != remoteSinks_.end(); iter++) {
138         if (iter->second != nullptr) {
139             iter->second->AsObject()->RemoveDeathRecipient(sinkRemoteRecipient_);
140         }
141     }
142     remoteSinks_.clear();
143     DHLOGI("ClearSinkRemoteCamSrv end");
144 }
145 
OnRemoteDied(const wptr<IRemoteObject> & remote)146 void DCameraSourceServiceIpc::SinkRemoteRecipient::OnRemoteDied(const wptr<IRemoteObject>& remote)
147 {
148     DHLOGI("SinkRemoteRecipient OnRemoteDied received died notify!");
149     DCameraSourceServiceIpc::GetInstance().OnSinkRemoteCamSrvDied(remote);
150 }
151 
OnSinkRemoteCamSrvDied(const wptr<IRemoteObject> & remote)152 void DCameraSourceServiceIpc::OnSinkRemoteCamSrvDied(const wptr<IRemoteObject>& remote)
153 {
154     DHLOGI("OnSinkRemoteCamSrvDied delete diedRemoted");
155     std::lock_guard<std::mutex> autoLock(sinkRemoteCamSrvLock_);
156     sptr<IRemoteObject> diedRemoted = remote.promote();
157     if (diedRemoted == nullptr) {
158         DHLOGE("OnSinkRemoteCamSrvDied promote failed!");
159         return;
160     }
161     auto iter = std::find_if(remoteSinks_.begin(), remoteSinks_.end(), [&](
162         const std::pair<std::string, sptr<IDistributedCameraSink>> &item)->bool {
163             return item.second->AsObject() == diedRemoted;
164         });
165     if (iter == remoteSinks_.end()) {
166         DHLOGI("OnSinkRemoteCamSrvDied not found remote object");
167         return;
168     }
169 
170     DHLOGI("OnSinkRemoteCamSrvDied remote.devId: %{public}s", GetAnonyString(iter->first).c_str());
171     if (iter->second != nullptr) {
172         iter->second->AsObject()->RemoveDeathRecipient(sinkRemoteRecipient_);
173     }
174     remoteSinks_.erase(iter);
175 }
176 } // namespace DistributedHardware
177 } // namespace OHOS
178