1 /*
2 * Copyright (c) 2022-2024 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 "distributed_input_sink_switch.h"
17
18 #include "constants_dinput.h"
19 #include "dinput_errcode.h"
20 #include "dinput_log.h"
21 #include "dinput_utils_tool.h"
22
23 namespace OHOS {
24 namespace DistributedHardware {
25 namespace DistributedInput {
DistributedInputSinkSwitch()26 DistributedInputSinkSwitch::DistributedInputSinkSwitch()
27 {
28 InitSwitch();
29 }
30
~DistributedInputSinkSwitch()31 DistributedInputSinkSwitch::~DistributedInputSinkSwitch()
32 {
33 DHLOGI("~DistributedInputSinkSwitch()");
34 InitSwitch();
35 }
36
GetInstance()37 DistributedInputSinkSwitch &DistributedInputSinkSwitch::GetInstance()
38 {
39 static DistributedInputSinkSwitch instance;
40 return instance;
41 }
42
InitSwitch()43 void DistributedInputSinkSwitch::InitSwitch()
44 {
45 DHLOGI("InitSwitch.");
46 std::unique_lock<std::mutex> switchLock(operationMutex_);
47 switchVector_.clear();
48 }
49
StartSwitch(int32_t sessionId)50 int32_t DistributedInputSinkSwitch::StartSwitch(int32_t sessionId)
51 {
52 std::unique_lock<std::mutex> switchLock(operationMutex_);
53 if (switchVector_.empty()) {
54 DHLOGE("StartSwitch sessionId: %{public}d fail,switchVector_ is null.", sessionId);
55 return ERR_DH_INPUT_SERVER_SINK_START_SWITCH_FAIL;
56 } else {
57 bool findOld = false;
58 for (std::vector<SwitchStateData>::iterator it = switchVector_.begin(); it < switchVector_.end(); ++it) {
59 if ((*it).sessionId == sessionId) {
60 (*it).switchState = true;
61 findOld = true;
62 break;
63 }
64 }
65
66 if (findOld) {
67 DHLOGI("StartSwitch sessionId: %{public}d is find.", sessionId);
68 return DH_SUCCESS;
69 } else {
70 DHLOGE("StartSwitch sessionId: %{public}d fail, not found.", sessionId);
71 return ERR_DH_INPUT_SERVER_SINK_START_SWITCH_FAIL;
72 }
73 }
74 }
75
StopSwitch(int32_t sessionId)76 void DistributedInputSinkSwitch::StopSwitch(int32_t sessionId)
77 {
78 std::unique_lock<std::mutex> switchLock(operationMutex_);
79 if (switchVector_.empty()) {
80 DHLOGE("StopSwitch sessionId: %{public}d fail,switchVector_ is null.", sessionId);
81 } else {
82 bool findOld = false;
83 for (std::vector<SwitchStateData>::iterator it = switchVector_.begin(); it < switchVector_.end(); ++it) {
84 if ((*it).sessionId == sessionId) {
85 (*it).switchState = false;
86 findOld = true;
87 break;
88 }
89 }
90
91 if (findOld) {
92 DHLOGI("StopSwitch sessionId: %{public}d is success.", sessionId);
93 } else {
94 DHLOGE("StopSwitch sessionId: %{public}d fail,not find it.", sessionId);
95 }
96 }
97 }
98
StopAllSwitch()99 void DistributedInputSinkSwitch::StopAllSwitch()
100 {
101 std::unique_lock<std::mutex> switchLock(operationMutex_);
102 if (switchVector_.empty()) {
103 DHLOGW("StopAllSwitch switchVector_ is null.");
104 } else {
105 for (std::vector<SwitchStateData>::iterator it = switchVector_.begin(); it < switchVector_.end(); ++it) {
106 (*it).switchState = false;
107 }
108 DHLOGI("StopAllSwitch success.");
109 }
110 }
111
AddSession(int32_t sessionId)112 void DistributedInputSinkSwitch::AddSession(int32_t sessionId)
113 {
114 std::unique_lock<std::mutex> switchLock(operationMutex_);
115 if (switchVector_.empty()) {
116 SwitchStateData tmp(sessionId, false);
117 switchVector_.push_back(tmp);
118 DHLOGI("AddSession sessionId: %{public}d add first.", sessionId);
119 } else {
120 bool findOld = false;
121 for (std::vector<SwitchStateData>::iterator it = switchVector_.begin(); it < switchVector_.end(); ++it) {
122 if ((*it).sessionId == sessionId) {
123 findOld = true;
124 break;
125 }
126 }
127
128 if (findOld) {
129 DHLOGI("AddSession sessionId: %{public}d is find.", sessionId);
130 } else {
131 SwitchStateData tmp(sessionId, false);
132 switchVector_.push_back(tmp);
133 DHLOGI("AddSession sessionId: %{public}d add new.", sessionId);
134 }
135 }
136 }
137
RemoveSession(int32_t sessionId)138 void DistributedInputSinkSwitch::RemoveSession(int32_t sessionId)
139 {
140 std::unique_lock<std::mutex> switchLock(operationMutex_);
141 if (switchVector_.empty()) {
142 DHLOGE("RemoveSession sessionId: %{public}d fail,switch_vector is null.", sessionId);
143 } else {
144 bool findOld = false;
145 for (std::vector<SwitchStateData>::iterator it = switchVector_.begin(); it < switchVector_.end();) {
146 if ((*it).sessionId == sessionId) {
147 it = switchVector_.erase(it);
148 findOld = true;
149 break;
150 } else {
151 ++it;
152 }
153 }
154 if (findOld) {
155 DHLOGI("RemoveSession sessionId: %{public}d is success.", sessionId);
156 } else {
157 DHLOGE("RemoveSession sessionId: %{public}d fail,not find it.", sessionId);
158 }
159 }
160 }
161
GetAllSessionId()162 std::vector<int32_t> DistributedInputSinkSwitch::GetAllSessionId()
163 {
164 std::unique_lock<std::mutex> switchLock(operationMutex_);
165 std::vector<int32_t> tmpVecSession;
166 for (std::vector<SwitchStateData>::iterator it = switchVector_.begin(); it < switchVector_.end(); ++it) {
167 tmpVecSession.push_back((*it).sessionId);
168 }
169 return tmpVecSession;
170 }
171
172 // get current session which state is on, if error return -1.
GetSwitchOpenedSession()173 int32_t DistributedInputSinkSwitch::GetSwitchOpenedSession()
174 {
175 std::unique_lock<std::mutex> switchLock(operationMutex_);
176 if (switchVector_.empty()) {
177 DHLOGE("GetSwitchOpenedSession error, no data.");
178 return ERR_DH_INPUT_SERVER_SINK_GET_OPEN_SESSION_FAIL;
179 }
180 for (std::vector<SwitchStateData>::iterator it = switchVector_.begin(); it < switchVector_.end(); ++it) {
181 if ((*it).switchState == true) {
182 return (*it).sessionId;
183 }
184 }
185 DHLOGE("GetSwitchOpenedSession no session is open.");
186 return ERR_DH_INPUT_SERVER_SINK_GET_OPEN_SESSION_FAIL;
187 }
188 } // namespace DistributedInput
189 } // namespace DistributedHardware
190 } // namespace OHOS
191