1 // Copyright 2023 Google LLC 2 // 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 use crate::{DeviceDiscoveryListener, DiscoveryPublisher, RemoteDevice}; 16 17 pub struct RemoteAuthService<'a, T: DeviceDiscoveryListener> { 18 listeners: Vec<&'a mut T>, 19 } 20 21 impl<'a, T: DeviceDiscoveryListener + PartialEq> RemoteAuthService<'a, T> { new() -> RemoteAuthService<'a, T>22 pub fn new() -> RemoteAuthService<'a, T> { 23 RemoteAuthService { 24 listeners: Vec::new(), 25 } 26 } 27 is_remote_auth_supported() -> bool28 pub fn is_remote_auth_supported() -> bool { 29 true 30 } 31 } 32 33 impl<'a, T: DeviceDiscoveryListener + PartialEq> DiscoveryPublisher<'a, T> 34 for RemoteAuthService<'a, T> 35 { add_listener(&mut self, listener: &'a mut T) -> i3236 fn add_listener(&mut self, listener: &'a mut T) -> i32 { 37 self.listeners.push(listener); 38 (self.listeners.len() - 1) as i32 39 } 40 remove_listener(&mut self, listener_id: i32)41 fn remove_listener(&mut self, listener_id: i32) { 42 let listener_index = listener_id as usize; 43 if self.listeners.len() > listener_index { 44 self.listeners.remove(listener_index); 45 } 46 } 47 device_discovered(&mut self, remote_device: &RemoteDevice)48 fn device_discovered(&mut self, remote_device: &RemoteDevice) { 49 for listener in self.listeners.iter_mut() { 50 listener.on_discovered(remote_device); 51 } 52 } 53 device_lost(&mut self, remote_device: &RemoteDevice)54 fn device_lost(&mut self, remote_device: &RemoteDevice) { 55 for listener in self.listeners.iter_mut() { 56 listener.on_lost(remote_device); 57 } 58 } 59 timed_out(&mut self)60 fn timed_out(&mut self) { 61 for listener in self.listeners.iter_mut() { 62 listener.on_timeout(); 63 } 64 } 65 } 66 67 impl<'a, T: DeviceDiscoveryListener + PartialEq> Default for RemoteAuthService<'a, T> { default() -> Self68 fn default() -> Self { 69 Self::new() 70 } 71 } 72 73 #[cfg(test)] 74 mod tests { 75 use super::*; 76 77 #[derive(PartialEq)] 78 struct TestListener { 79 pub remote_ids: Vec<i32>, 80 pub got_timeout: bool, 81 } 82 83 impl TestListener { new() -> TestListener84 pub fn new() -> TestListener { 85 TestListener { 86 remote_ids: vec![], 87 got_timeout: false, 88 } 89 } 90 } 91 92 impl DeviceDiscoveryListener for TestListener { on_discovered(&mut self, remote_device: &RemoteDevice)93 fn on_discovered(&mut self, remote_device: &RemoteDevice) { 94 self.remote_ids.push(remote_device.id); 95 } 96 on_lost(&mut self, remote_device: &RemoteDevice)97 fn on_lost(&mut self, remote_device: &RemoteDevice) { 98 if let Some(index) = self.remote_ids.iter().position(|i| *i == remote_device.id) { 99 self.remote_ids.remove(index); 100 } 101 } 102 on_timeout(&mut self)103 fn on_timeout(&mut self) { 104 self.got_timeout = true; 105 } 106 } 107 108 #[test] single_listener_discover_notification()109 fn single_listener_discover_notification() { 110 let mut listener = TestListener::new(); 111 let mut ras = RemoteAuthService::new(); 112 let remote_device = RemoteDevice { id: 42 }; 113 114 ras.add_listener(&mut listener); 115 ras.device_discovered(&remote_device); 116 117 assert_eq!(listener.remote_ids.len(), 1); 118 assert_eq!(listener.remote_ids[0], 42); 119 } 120 121 #[test] all_listeners_discover_notification()122 fn all_listeners_discover_notification() { 123 let mut listener1 = TestListener::new(); 124 let mut listener2 = TestListener::new(); 125 let mut ras = RemoteAuthService::new(); 126 let remote_device = RemoteDevice { id: 42 }; 127 128 ras.add_listener(&mut listener1); 129 ras.add_listener(&mut listener2); 130 ras.device_discovered(&remote_device); 131 132 assert_eq!(listener1.remote_ids.len(), 1); 133 assert_eq!(listener2.remote_ids.len(), 1); 134 assert_eq!(listener1.remote_ids[0], 42); 135 assert_eq!(listener2.remote_ids[0], 42); 136 } 137 138 #[test] listeners_discover_notification_for_all_devices()139 fn listeners_discover_notification_for_all_devices() { 140 let mut listener = TestListener::new(); 141 let mut ras = RemoteAuthService::new(); 142 let remote_device1 = RemoteDevice { id: 42 }; 143 let remote_device2 = RemoteDevice { id: 13 }; 144 145 ras.add_listener(&mut listener); 146 ras.device_discovered(&remote_device1); 147 ras.device_discovered(&remote_device2); 148 149 assert_eq!(listener.remote_ids.len(), 2); 150 assert_eq!(listener.remote_ids[0], 42); 151 assert_eq!(listener.remote_ids[1], 13); 152 } 153 154 #[test] single_listener_lost_notification()155 fn single_listener_lost_notification() { 156 let mut listener = TestListener::new(); 157 let mut ras = RemoteAuthService::new(); 158 let remote_device = RemoteDevice { id: 42 }; 159 160 ras.add_listener(&mut listener); 161 ras.device_discovered(&remote_device); 162 ras.device_lost(&remote_device); 163 164 assert_eq!(listener.remote_ids.len(), 0); 165 } 166 167 #[test] all_listeners_lost_notification()168 fn all_listeners_lost_notification() { 169 let mut listener1 = TestListener::new(); 170 let mut listener2 = TestListener::new(); 171 let mut ras = RemoteAuthService::new(); 172 let remote_device = RemoteDevice { id: 42 }; 173 174 ras.add_listener(&mut listener1); 175 ras.add_listener(&mut listener2); 176 ras.device_discovered(&remote_device); 177 ras.device_lost(&remote_device); 178 179 assert_eq!(listener1.remote_ids.len(), 0); 180 assert_eq!(listener2.remote_ids.len(), 0); 181 } 182 183 #[test] listeners_lost_notification_for_all_devices()184 fn listeners_lost_notification_for_all_devices() { 185 let mut listener = TestListener::new(); 186 let mut ras = RemoteAuthService::new(); 187 let remote_device1 = RemoteDevice { id: 42 }; 188 let remote_device2 = RemoteDevice { id: 13 }; 189 let remote_device3 = RemoteDevice { id: 99 }; 190 191 ras.add_listener(&mut listener); 192 ras.device_discovered(&remote_device1); 193 ras.device_discovered(&remote_device2); 194 ras.device_discovered(&remote_device3); 195 196 ras.device_lost(&remote_device2); 197 ras.device_lost(&remote_device3); 198 199 assert_eq!(listener.remote_ids.len(), 1); 200 assert_eq!(listener.remote_ids[0], 42); 201 } 202 203 #[test] single_listener_timeout_notification()204 fn single_listener_timeout_notification() { 205 let mut listener = TestListener::new(); 206 let mut ras = RemoteAuthService::new(); 207 208 ras.add_listener(&mut listener); 209 ras.timed_out(); 210 211 assert!(listener.got_timeout); 212 } 213 214 #[test] all_listeners_timeout_notification()215 fn all_listeners_timeout_notification() { 216 let mut listener1 = TestListener::new(); 217 let mut listener2 = TestListener::new(); 218 let mut ras = RemoteAuthService::new(); 219 220 ras.add_listener(&mut listener1); 221 ras.add_listener(&mut listener2); 222 ras.timed_out(); 223 224 assert!(listener1.got_timeout); 225 assert!(listener2.got_timeout); 226 } 227 228 #[test] listener_can_be_removed()229 fn listener_can_be_removed() { 230 let mut listener = TestListener::new(); 231 let mut ras = RemoteAuthService::new(); 232 let remote_device = RemoteDevice { id: 42 }; 233 234 let id = ras.add_listener(&mut listener); 235 ras.remove_listener(id); 236 ras.device_discovered(&remote_device); 237 238 assert_eq!(listener.remote_ids.len(), 0); 239 } 240 241 #[test] listener_can_be_removed_after_notification()242 fn listener_can_be_removed_after_notification() { 243 let mut listener = TestListener::new(); 244 let mut ras = RemoteAuthService::new(); 245 let remote_device = RemoteDevice { id: 42 }; 246 247 let id = ras.add_listener(&mut listener); 248 ras.device_discovered(&remote_device); 249 ras.remove_listener(id); 250 ras.device_discovered(&remote_device); 251 252 assert_eq!(listener.remote_ids.len(), 1); 253 assert_eq!(listener.remote_ids[0], 42); 254 } 255 } 256