private async void OnDeviceAdded(DeviceWatcher deviceWatcher, DeviceInformation deviceInfo)
 {
     await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
     {
         DiscoveredDevices.Add(new DiscoveredDevice(deviceInfo));
     });
 }
예제 #2
0
        /// <summary>
        /// Updates view.
        /// </summary>
        public override void UpdateView()
        {
            DiscoveredDevices devices = ContextController.GetDiscoveredDevices();

            if (devices != null)
            {
                View.DeviceManagementUrl = devices.ServiceAddress;
                View.IP = devices.DeviceAddress != null?devices.DeviceAddress.ToString() : string.Empty;

                if (_client != null && _client.Address != devices.ServiceAddress)
                {
                    View.Clear();
                }
            }
            else
            {
                View.DeviceManagementUrl = string.Empty;
                View.IP = string.Empty;
                View.Clear();
            }
            DeviceEnvironment environment = ContextController.GetDeviceEnvironment();

            if (_client != null)
            {
                _client.Timeout = environment.Timeouts.Message;
            }
        }
예제 #3
0
        /// <summary>
        /// Checks if device address is not empty.
        /// </summary>
        /// <returns>True if device is selected and address is not empty.</returns>
        public bool DeviceNotEmpty()
        {
            DiscoveredDevices devices = ContextController.GetDiscoveredDevices();
            bool bHasAddress          = devices != null && !string.IsNullOrEmpty(devices.ServiceAddress);

            return(bHasAddress);
        }
예제 #4
0
        /// <summary>
        /// Collects parameters for launching current test/current test group/all selected tests
        /// </summary>
        /// <returns></returns>
        public TestSuiteParameters GetParameters()
        {
            TestSuiteParameters parameters = new TestSuiteParameters();
            DiscoveredDevices   devices    = ContextController.GetDiscoveredDevices();

            parameters.Address  = devices.ServiceAddress;
            parameters.CameraIP = devices.DeviceAddress;
            parameters.NetworkInterfaceController = devices.NIC;
            if ((devices.Current != null) && (devices.Current.ByDiscovery != null))
            {
                parameters.CameraUUID = devices.Current.ByDiscovery.UUID;
            }

            DeviceEnvironment env = ContextController.GetDeviceEnvironment();

            parameters.UserName        = env.Credentials.UserName;
            parameters.Password        = env.Credentials.Password;
            parameters.UseUTCTimestamp = env.Credentials.UseUTCTimeStamp;

            DeviceEnvironment environment = ContextController.GetDeviceEnvironment();

            parameters.MessageTimeout   = environment.Timeouts.Message;
            parameters.RebootTimeout    = environment.Timeouts.Reboot;
            parameters.TimeBetweenTests = environment.Timeouts.InterTests;
            parameters.PTZNodeToken     = environment.TestSettings.PTZNodeToken;

            parameters.EnvironmentSettings = new Tests.Common.TestEngine.EnvironmentSettings()
            {
                DnsIpv4            = env.EnvironmentSettings.DnsIpv4,
                NtpIpv4            = env.EnvironmentSettings.NtpIpv4,
                DnsIpv6            = env.EnvironmentSettings.DnsIpv6,
                NtpIpv6            = env.EnvironmentSettings.NtpIpv6,
                DefaultGateway     = env.EnvironmentSettings.GatewayIpv4,
                DefaultGatewayIpv6 = env.EnvironmentSettings.GatewayIpv6
            };

            parameters.UseEmbeddedPassword = environment.TestSettings.UseEmbeddedPassword;
            parameters.Password1           = environment.TestSettings.Password1;
            parameters.Password2           = environment.TestSettings.Password2;
            parameters.SecureMethod        = environment.TestSettings.SecureMethod;
            parameters.VideoSourceToken    = environment.TestSettings.VideoSourceToken;

            parameters.OperationDelay = environment.TestSettings.OperationDelay;
            parameters.RecoveryDelay  = environment.TestSettings.RecoveryDelay;

            parameters.EventTopic                     = environment.TestSettings.EventTopic;
            parameters.SubscriptionTimeout            = environment.TestSettings.SubscriptionTimeout;
            parameters.TopicNamespaces                = environment.TestSettings.TopicNamespaces;
            parameters.RelayOutputDelayTimeMonostable = environment.TestSettings.RelayOutputDelayTimeMonostable;

            Dictionary <string, object> advanced = new Dictionary <string, object>();

            foreach (object o in environment.TestSettings.AdvancedSettings)
            {
                advanced.Add(o.GetType().GUID.ToString(), o);
            }
            parameters.AdvancedPrameters = advanced;

            return(parameters);
        }
        protected override Task StartScanningForDevicesNativeAsync(Guid[] serviceUuids, bool allowDuplicatesKey, CancellationToken scanCancellationToken)
        {
            var hasFilter = serviceUuids?.Any() ?? false;

            DiscoveredDevices.Clear();
            _BleWatcher = new BluetoothLEAdvertisementWatcher();
            _BleWatcher.ScanningMode = BluetoothLEScanningMode.Active;
            _prevScannedDevices      = new List <ulong>();
            Trace.Message("Starting a scan for devices.");
            if (hasFilter)
            {
                //adds filter to native scanner if serviceUuids are specified
                foreach (var uuid in serviceUuids)
                {
                    _BleWatcher.AdvertisementFilter.Advertisement.ServiceUuids.Add(uuid);
                }
                Trace.Message($"ScanFilters: {string.Join(", ", serviceUuids)}");
            }
            //don't allow duplicates except for testing, results in multiple versions
            //of the same device being found
            if (allowDuplicatesKey)
            {
                _BleWatcher.Received += DeviceFoundAsyncDuplicate;
            }
            else
            {
                _BleWatcher.Received += DeviceFoundAsync;
            }
            _BleWatcher.Start();
            return(Task.FromResult(true));
        }
예제 #6
0
 private void OnServiceAdded(object sender, ServiceAnnouncementEventArgs e)
 {
     ServiceAddedSemaphoreSlim.Wait();
     try
     {
         var txtValues = e.Announcement.Txt
                         .Select(i => i.Split('='))
                         .ToDictionary(y => y[0], y => y[1]);
         if (!txtValues.ContainsKey("fn"))
         {
             return;
         }
         var ip = e.Announcement.Addresses[0];
         Uri.TryCreate("https://" + ip, UriKind.Absolute, out Uri myUri);
         var chromecast = new ChromecastReceiver
         {
             DeviceUri        = myUri,
             Name             = txtValues["fn"],
             Model            = txtValues["md"],
             Version          = txtValues["ve"],
             ExtraInformation = txtValues,
             Status           = txtValues["rs"],
             Port             = e.Announcement.Port
         };
         ChromecastReceivedFound?.Invoke(this, chromecast);
         DiscoveredDevices.Add(chromecast);
     }
     finally
     {
         ServiceAddedSemaphoreSlim.Release();
     }
 }
예제 #7
0
 public List <IDevice> GetSystemConnectedOrPairedDevices(Guid[] services = null)
 {
     if (services != null)
     {
         return(DiscoveredDevices.Where(d => services.Contains(d.Id)).ToList());
     }
     return(DiscoveredDevices.ToList());
 }
예제 #8
0
        /// <summary>
        /// Start GetDeviceInformation operation
        /// </summary>
        public void GetDeviceInformation()
        {
            DiscoveredDevices devices = ContextController.GetDiscoveredDevices();
            string            url     = devices.ServiceAddress;

            _requestPending = true;
            ReportOperationStarted();
            InitializeClient(url);
            _client.GetDeviceInformation();
        }
예제 #9
0
 /// <summary>
 /// Updates setup tab control
 /// </summary>
 public override void UpdateView()
 {
     base.UpdateView();
     if (CurrentState == Enums.ApplicationState.Idle)
     {
         DiscoveredDevices devices = ContextController.GetDiscoveredDevices();
         bool enable = (devices != null) && !string.IsNullOrEmpty(devices.ServiceAddress);
         View.EnableGetFromDevice(enable);
     }
 }
예제 #10
0
        /// <summary>
        /// Returns service addresses
        /// </summary>
        public void GetAddress(Onvif.CapabilityCategory[] categories)
        {
            DiscoveredDevices devices = ContextController.GetDiscoveredDevices();

            _deviceClientWorking = true;
            string address = devices != null ? devices.ServiceAddress : string.Empty;

            InitializeDeviceClient(address);
            _deviceClient.GetCapabilities(categories);
        }
예제 #11
0
        /// <summary>
        /// Returns media service address
        /// </summary>
        public void GetMediaAddress()
        {
            DiscoveredDevices devices = ContextController.GetDiscoveredDevices();

            _deviceClientWorking = true;
            string address = devices != null ? devices.ServiceAddress : string.Empty;

            InitializeDeviceClient(address);
            _deviceClient.GetCapabilities(new Device.CapabilityCategory[] { Device.CapabilityCategory.Media });
        }
예제 #12
0
        private void DiscoveredPeripheral(object sender, CBDiscoveredPeripheralEventArgs e)
        {
            var deviceId = Device.DeviceIdentifierToGuid(e.Peripheral.Identifier);

            if (DiscoveredDevices.All(x => x.Id != deviceId))
            {
                var device = new Device(e.Peripheral);
                DiscoveredDevices.Add(device);
                DeviceDiscovered(this, new DeviceDiscoveredEventArgs(device));
            }
        }
예제 #13
0
        /// <summary>
        /// Raises the le scan event.
        /// </summary>
        /// <param name="bleDevice">The BLE device that was discovered.</param>
        /// <param name="rssi">Rssi.</param>
        /// <param name="scanRecord">Scan record.</param>
        public void OnLeScan(BluetoothDevice bleDevice, int rssi, byte[] scanRecord)
        {
            var deviceId = Device.DeviceIdFromAddress(bleDevice.Address);

            if (DiscoveredDevices.All(x => x.Id != deviceId))
            {
                var device = new Device(bleDevice, null, null, rssi, scanRecord);
                DiscoveredDevices.Add(device);
                DeviceDiscovered(this, new DeviceDiscoveredEventArgs(device));
            }
        }
 private async void OnDeviceRemoved(DeviceWatcher deviceWatcher, DeviceInformationUpdate deviceInfoUpdate)
 {
     await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
     {
         foreach (DiscoveredDevice discoveredDevice in DiscoveredDevices)
         {
             if (discoveredDevice.DeviceInfo.Id == deviceInfoUpdate.Id)
             {
                 DiscoveredDevices.Remove(discoveredDevice);
                 break;
             }
         }
     });
 }
예제 #15
0
        /// <summary>
        /// Returns service addresses
        /// </summary>
        public void GetAddress(CapabilityCategory[] categories)
        {
            DiscoveredDevices devices = ContextController.GetDiscoveredDevices();

            _deviceClientWorking = true;
            string address = devices != null ? devices.ServiceAddress : string.Empty;

            InitializeDeviceClient(address);

            DebugInfo info = ContextController.GetDebugInfo();
            bool      capabilitiesStyle = (info.CapabilitiesExchange == CapabilitiesExchangeStyle.GetCapabilities);

            _deviceClient.GetServiceAddresses(capabilitiesStyle, categories);
        }
예제 #16
0
        public void EnableControls(bool enable)
        {
            Invoke(new Action(() =>
            {
                DiscoveredDevices devices = ContextController.GetDiscoveredDevices();
                string address            = devices != null ? devices.ServiceAddress : string.Empty;

                bool testProfileSelected = false;
                if (cmbMediaProfile.SelectedItem != null)
                {
                    testProfileSelected = IsTestProfile(((MediaProfileWrapper)cmbMediaProfile.SelectedItem).Profile);
                }

                btnGetMediaUrl.Enabled = enable && !string.IsNullOrEmpty(address);
                btnGetMediaUrl.Refresh();
                btnGetProfiles.Enabled = enable && !string.IsNullOrEmpty(MediaAddress);
                btnGetProfiles.Refresh();
                btnDeleteProfile.Enabled = enable && testProfileSelected;
                btnDeleteProfile.Refresh();
                buttonGetVideoSources.Enabled = testProfileSelected && enable && !string.IsNullOrEmpty(MediaAddress);
                buttonGetVideoSources.Refresh();
                buttonGetVideoEncoders.Enabled = testProfileSelected && enable && !string.IsNullOrEmpty(MediaAddress);
                buttonGetVideoEncoders.Refresh();
                buttonGetVideoCodecs.Enabled = buttonGetVideoEncoders.Enabled && (cmbVideoEncoder.SelectedItem != null);
                buttonGetVideoCodecs.Refresh();
                buttonGetAudioSources.Enabled = testProfileSelected && enable && !string.IsNullOrEmpty(MediaAddress);
                buttonGetAudioSources.Refresh();
                buttonGetAudioEncoders.Enabled = testProfileSelected && enable && !string.IsNullOrEmpty(MediaAddress);
                buttonGetAudioEncoders.Refresh();
                buttonGetAudioCodecs.Enabled = buttonGetAudioEncoders.Enabled && (cmbAudioEncoder.SelectedItem != null);
                buttonGetAudioCodecs.Refresh();
                btnGetStreams.Enabled = (enable && cmbVideoResolution.SelectedItem != null) || (_videoWindow != null);

                cmbMediaProfile.Enabled    = enable;
                cmbAudioCodec.Enabled      = testProfileSelected && enable;
                cmbAudioEncoder.Enabled    = testProfileSelected && enable;
                cmbAudioSource.Enabled     = testProfileSelected && enable;
                cmbVideoCodec.Enabled      = testProfileSelected && enable;
                cmbVideoEncoder.Enabled    = testProfileSelected && enable;
                cmbVideoResolution.Enabled = testProfileSelected && enable;
                txtVideoBitrate.Enabled    = testProfileSelected && enable && (cmbVideoCodec.SelectedItem != null);
                txtVideoFramerate.Enabled  = testProfileSelected && enable && (cmbVideoCodec.SelectedItem != null);
                cmbVideoSource.Enabled     = testProfileSelected && enable;
                cmbAudioBitrate.Enabled    = testProfileSelected && enable;
                cmbTransport.Enabled       = testProfileSelected && enable;

                btnGetStreams.Refresh();
            }));
        }
        private void btnWatcher_Click(object sender, RoutedEventArgs e)
        {
            if (_fWatcherStarted == false)
            {
                _publisher.Start();

                if (_publisher.Status != WiFiDirectAdvertisementPublisherStatus.Started)
                {
                    rootPage.NotifyUser("Failed to start advertisement.", NotifyType.ErrorMessage);
                    return;
                }

                DiscoveredDevices.Clear();
                rootPage.NotifyUser("Finding Devices...", NotifyType.StatusMessage);

                String deviceSelector = WiFiDirectDevice.GetDeviceSelector(
                    Utils.GetSelectedItemTag <WiFiDirectDeviceSelectorType>(cmbDeviceSelector));

                _deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector, new string[] { "System.Devices.WiFiDirect.InformationElements" });

                _deviceWatcher.Added   += OnDeviceAdded;
                _deviceWatcher.Removed += OnDeviceRemoved;
                _deviceWatcher.Updated += OnDeviceUpdated;
                _deviceWatcher.EnumerationCompleted += OnEnumerationCompleted;
                _deviceWatcher.Stopped += OnStopped;

                _deviceWatcher.Start();

                btnWatcher.Content = "Stop Watcher";
                _fWatcherStarted   = true;
            }
            else
            {
                _publisher.Stop();

                btnWatcher.Content = "Start Watcher";
                _fWatcherStarted   = false;

                _deviceWatcher.Added   -= OnDeviceAdded;
                _deviceWatcher.Removed -= OnDeviceRemoved;
                _deviceWatcher.Updated -= OnDeviceUpdated;
                _deviceWatcher.EnumerationCompleted -= OnEnumerationCompleted;
                _deviceWatcher.Stopped -= OnStopped;

                _deviceWatcher.Stop();

                rootPage.NotifyUser("Device watcher stopped.", NotifyType.StatusMessage);
            }
        }
예제 #18
0
        protected override async Task StartScanningForDevicesNativeAsync(Guid[] serviceUuids, CancellationToken scanCancellationToken)
        {
            // Wait for the PoweredOn state
            await WaitForState(CBCentralManagerState.PoweredOn, scanCancellationToken).ConfigureAwait(false);

            Trace.Message("Adapter: Starting a scan for devices.");

            CBUUID[] serviceCbuuids = null;
            if (serviceUuids != null && serviceUuids.Any())
            {
                serviceCbuuids = serviceUuids.Select(u => CBUUID.FromString(u.ToString())).ToArray();
                Trace.Message("Adapter: Scanning for " + serviceCbuuids.First());
            }

            DiscoveredDevices.Clear();
            _centralManager.ScanForPeripherals(serviceCbuuids);
        }
        protected BluetoothLEManager()
        {
            CentralManager = new CBCentralManager(DispatchQueue.CurrentQueue);
            CentralManager.DiscoveredPeripheral += (object sender, CBDiscoveredPeripheralEventArgs e) =>
            {
                Console.WriteLine("DiscoveredPeripheral: " + e.Peripheral.Name);
                DiscoveredDevices.Add(e.Peripheral);
                DeviceDiscovered(this, e);
            };

            CentralManager.UpdatedState += (object sender, EventArgs e) =>
            {
                Console.WriteLine("UpdatedState: " + CentralManager.State);
            };


            CentralManager.ConnectedPeripheral += (object sender, CBPeripheralEventArgs e) =>
            {
                Console.WriteLine("ConnectedPeripheral: " + e.Peripheral.Name);

                // When a peripheral gets connected, add that peripheral to our running list of
                // connected peripherals
                if (!ConnectedDevices.Contains(e.Peripheral))
                {
                    ConnectedDevices.Add(e.Peripheral);
                }

                // raise our connected event
                DeviceConnected(sender, e);
            };

            CentralManager.DisconnectedPeripheral += (object sender, CBPeripheralErrorEventArgs e) =>
            {
                Console.WriteLine("DisconnectedPeripheral: " + e.Peripheral.Name);

                // When a peripheral disconnects, remove it from our running list.
                if (ConnectedDevices.Contains(e.Peripheral))
                {
                    ConnectedDevices.Remove(e.Peripheral);
                }

                // Raise our disconnected event
                DeviceDisconnected(sender, e);
            };
        }
예제 #20
0
        /// <summary>
        /// Queries PTZ nodes
        /// </summary>
        public void GetPTZNodes()
        {
            DiscoveredDevices         devices      = ContextController.GetDiscoveredDevices();
            string                    address      = devices != null ? devices.ServiceAddress : string.Empty;
            DeviceEnvironment         env          = ContextController.GetDeviceEnvironment();
            ManagementServiceProvider deviceClient = new ManagementServiceProvider(address, env.Timeouts.Message);

            ReportOperationStarted();
            Thread thread = new Thread(new ThreadStart(new Action(() =>
            {
                try
                {
                    Device.Capabilities capabilities = deviceClient.GetCapabilitiesSync(new Device.CapabilityCategory[] { Device.CapabilityCategory.PTZ });
                    if (capabilities.PTZ != null)
                    {
                        string ptzAddress            = capabilities.PTZ.XAddr;
                        PTZServiceProvider ptzClient = new PTZServiceProvider(ptzAddress, env.Timeouts.Message);
                        PTZ.PTZNode[] nodes          = ptzClient.GetNodes();
                        if ((nodes != null) && (nodes.Length > 0))
                        {
                            View.SetPTZNodes(nodes);
                        }
                        else
                        {
                            throw new Exception("No PTZ nodes returned by device");
                        }
                    }
                    else
                    {
                        throw new Exception("Device does not support PTZ service");
                    }
                }
                catch (System.Exception ex)
                {
                    View.ShowError(ex);
                }
                finally
                {
                    ReportOperationCompleted();
                }
            })));

            thread.CurrentUICulture = System.Globalization.CultureInfo.InvariantCulture;
            thread.Start();
        }
예제 #21
0
        ///////////////////////////////////////////////////////////////////////////
        //!  @author        Ivan Vagunin
        ////

        /// <summary>
        /// Saves context data.
        /// </summary>
        public void SaveContextData()
        {
            IsolatedStorageFile isoStore = IsolatedStorageFile.GetStore(IsolatedStorageScope.Machine | IsolatedStorageScope.Application,
                                                                        new System.Security.Policy.Url("www.onvif.org/OnvifTestTool"));
            IsolatedStorageFileStream isoFile = new IsolatedStorageFileStream(_dataFileName, FileMode.Create, isoStore);
            // Create a StreamWriter using the isolated storage file
            StreamWriter  writer     = new StreamWriter(isoFile);
            XmlSerializer serializer = new XmlSerializer(typeof(SavedContext));

            SavedContext context = new SavedContext();

            _conformanceTestController.UpdateContext();
            context.SetupInfo = ContextController.GetSetupInfo();
            _discoveryController.UpdateContext();
            DiscoveredDevices devices = ContextController.GetDiscoveredDevices();

            if (devices != null)
            {
                context.DiscoveryContext = new SavedDiscoveryContext();
                context.DiscoveryContext.ServiceAddress    = devices.ServiceAddress;
                context.DiscoveryContext.DeviceAddress     = (devices.DeviceAddress != null) ? devices.DeviceAddress.ToString() : string.Empty;
                context.DiscoveryContext.SearchScopes      = devices.SearchScopes.Replace(System.Environment.NewLine, " ");
                context.DiscoveryContext.ShowSearchOptions = devices.ShowSearchOptions;

                if ((devices.NIC != null) && (devices.NIC.IP != null))
                {
                    context.DiscoveryContext.InterfaceAddress = devices.NIC.IP.ToString();
                }
            }
            _managementController.UpdateContext();
            context.DeviceEnvironment = ContextController.GetDeviceEnvironment();

            _deviceController.UpdateContext();

            context.RequestsInfo = ContextController.GetRequestsInfo();
            context.MediaInfo    = ContextController.GetMediaInfo();
            context.PTZInfo      = ContextController.GetPTZInfo();
            context.DebugInfo    = ContextController.GetDebugInfo();

            serializer.Serialize(writer, context);
            writer.Close();
        }
예제 #22
0
        /// <summary>
        /// Initializes service client, if it's possibly.
        /// </summary>
        /// <returns>True if client has been initialized successfully.</returns>
        bool InitializeClient()
        {
            string            serviceAddress = string.Empty;
            DiscoveredDevices devices        = ContextController.GetDiscoveredDevices();

            if (devices.Current != null)
            {
                serviceAddress = devices.ServiceAddress;
            }

            try
            {
                new Uri(serviceAddress);
            }
            catch (Exception)
            {
                View.ShowError("Device service address is invalid!");
                return(false);
            }

            try
            {
                DeviceEnvironment env = ContextController.GetDeviceEnvironment();

                _client = new ManagementServiceProvider(serviceAddress, env.Timeouts.Message);
                _client.ExceptionThrown             += _client_ExceptionThrown;
                _client.OnDeviceInformationReceived += _client_OnDeviceInformationReceived;
                _client.OperationCompleted          += _client_OperationCompleted;
                _client.OperationStarted            += _client_OperationStarted;
                _client.ResponseReceived            += _client_ResponseReceived;

                _client.Security = ContextController.GetDebugInfo().Security;

                return(true);
            }
            catch (Exception exc)
            {
                View.ShowError(string.Format("Error occurred: {0}", exc.Message));
                return(false);
            }
        }
예제 #23
0
        /// <summary>
        /// Handles button get device information click event
        /// </summary>
        /// <param name="sender">Event sender</param>
        /// <param name="e">Event argument</param>
        private void btnGetDeviceInformation_Click(object sender, EventArgs e)
        {
            DiscoveredDevices devices = ContextController.GetDiscoveredDevices();
            string            url     = devices.ServiceAddress;

            if (!string.IsNullOrEmpty(url))
            {
                try
                {
                    Controller.GetDeviceInformation();
                }
                catch (System.ServiceModel.EndpointNotFoundException)
                {
                    MessageBox.Show(this, "Could not connect to " + url, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                catch (Exception ex)
                {
                    ShowError(ex);
                }
            }
        }
예제 #24
0
        ///////////////////////////////////////////////////////////////////////////
        //!  @author        Ivan Vagunin
        ////

        /// <summary>
        /// Saves context data.
        /// </summary>
        public void SaveContextData()
        {
            IsolatedStorageFile       isoStore = IsolatedStorageFile.GetMachineStoreForAssembly();
            IsolatedStorageFileStream isoFile  = new IsolatedStorageFileStream(_dataFileName, FileMode.Create, isoStore);
            // Create a StreamWriter using the isolated storage file
            StreamWriter  writer     = new StreamWriter(isoFile);
            XmlSerializer serializer = new XmlSerializer(typeof(SavedContext));

            SavedContext context = new SavedContext();

            _setupController.UpdateContext();
            context.SetupInfo = ContextController.GetSetupInfo();
            _discoveryController.UpdateContext();
            DiscoveredDevices devices = ContextController.GetDiscoveredDevices();

            if (devices != null)
            {
                context.DiscoveryContext = new SavedDiscoveryContext();
                context.DiscoveryContext.ServiceAddress = devices.ServiceAddress;
                context.DiscoveryContext.DeviceAddress  = (devices.DeviceAddress != null) ? devices.DeviceAddress.ToString() : string.Empty;
                if ((devices.NIC != null) && (devices.NIC.IP != null))
                {
                    context.DiscoveryContext.InterfaceAddress = devices.NIC.IP.ToString();
                }
            }
            _reportController.UpdateContext();
            context.ReportInfo = ContextController.GetReportInfo();
            _managementController.UpdateContext();
            context.DeviceEnvironment = ContextController.GetDeviceEnvironment();
            _requestsController.UpdateContext();
            context.RequestsInfo = ContextController.GetRequestsInfo();
            _deviceController.MediaController.UpdateContext();
            context.MediaInfo = ContextController.GetMediaInfo();
            _deviceController.PTZController.UpdateContext();
            context.PTZInfo = ContextController.GetPTZInfo();

            serializer.Serialize(writer, context);
            writer.Close();
        }
예제 #25
0
        /// <summary>
        /// Updates application context
        /// </summary>
        public override void UpdateContext()
        {
            DiscoveredDevices devices = new DiscoveredDevices();

            devices.NIC                 = View.NIC;
            devices.Current             = new DeviceInfoFull();
            devices.Current.ByDiscovery = View.Current;
            devices.ServiceAddress      = View.ServiceAddress;
            devices.DeviceAddress       = View.DeviceAddress;

            foreach (DeviceDiscoveryData data in View.Devices)
            {
                DeviceInfoFull info = new DeviceInfoFull();
                info.ByDiscovery = data;
                devices.Discovered.Add(info);
            }
            ContextController.UpdateDiscoveredDevices(devices);

            UpdateCredentials();

            View.UpdateFormTitle();
        }
예제 #26
0
        public void OnLeScan(BluetoothDevice bleDevice, int rssi, byte[] scanRecord)
        {
            Console.WriteLine("Adapter.LeScanCallback: " + bleDevice.Name);
            // TODO: for some reason, this doesn't work, even though they have the same pointer,
            // it thinks that the item doesn't exist. so i had to write my own implementation
            //			if(!_discoveredDevices.Contains(device) ) {
            //				_discoveredDevices.Add (device );
            //			}

            Device device = new Device(bleDevice, null, null, rssi);

            if (!DeviceExistsInDiscoveredList(bleDevice))
            {
                DiscoveredDevices.Add(device);

                // TODO: in the cross platform API, cache the RSSI
                // TODO: shouldn't i only raise this if it's not already in the list?
                DeviceDiscovered(this, new DeviceDiscoveredEventArgs {
                    Device = device
                });
            }
        }