public async void Start()
        {
            try
            {
                _iconFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///IoTOnboardingService/icon72x72.png"));

                await _config.InitAsync();

                var connectionProfiles = NetworkInformation.GetConnectionProfiles();
                foreach (var profile in connectionProfiles)
                {
                    if (profile.IsWlanConnectionProfile)
                    {
                        lock (_stateLock)
                        {
                            _state = OnboardingState.ConfiguredValidated;
                        }
                        break;
                    }
                }

                if (_softAccessPoint == null)
                {
                    _softAccessPoint = new OnboardingAccessPoint(_config.Ssid, _config.Password);
                }

                if (_busAttachment == null)
                {
                    _busAttachment = new AllJoynBusAttachment();
                    _busAttachment.AboutData.DefaultDescription = _config.DefaultDescription;
                    _busAttachment.AboutData.DefaultManufacturer = _config.DefaultManufacturer;

                    _onboardingProducer = new OnboardingProducer(_busAttachment);
                    _onboardingProducer.Service = this;

                    _iconProducer = new IconProducer(_busAttachment);
                    _iconProducer.Service = this;
                }

                if (_deviceWatcher == null)
                {
                    var accessStatus = await WiFiAdapter.RequestAccessAsync();
                    if (accessStatus == WiFiAccessStatus.Allowed)
                    {
                        _deviceWatcher = DeviceInformation.CreateWatcher(WiFiAdapter.GetDeviceSelector());
                        _deviceWatcher.Added += this.HandleAdapterAdded;
                        _deviceWatcher.Removed += this.HandleAdapterRemoved;

                        _deviceWatcher.Start();
                    }
                }
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(ex.Message);
            }
        }
Beispiel #2
0
        public OnboardingService()
        {
            _resourceLoader = ResourceLoader.GetForCurrentView("IoTOnboardingService/Resources");

            _state = OnboardingState.NotConfigured;
            _stateLock = new object();

            var settings = ApplicationData.Current.LocalSettings.Values;
            if (settings.ContainsKey(_onboardingInstanceIdSettingName))
            {
                _onboardingInstanceId = settings[_onboardingInstanceIdSettingName] as string;
            }
            else
            {
                var guid = Guid.NewGuid();
                _onboardingInstanceId = guid.GetHashCode().ToString("X8");
                settings[_onboardingInstanceIdSettingName] = _onboardingInstanceId;
            }
        }
Beispiel #3
0
        public IAsyncOperation<OnboardingOffboardResult> OffboardAsync(AllJoynMessageInfo info)
        {
            return Task.Run(() =>
            {
                lock (_stateLock)
                {
                    if (_state == OnboardingState.ConfiguredValidated || _state == OnboardingState.ConfiguredValidating)
                    {
                        _wlanAdapter.Disconnect();
                    }
                    _state = OnboardingState.NotConfigured;
                    _personalApSsid = null;
                    _personalApPassword = null;
                    _authType = AuthType.Any;

                    _softAccessPoint?.Start();
                }
                return OnboardingOffboardResult.CreateSuccessResult();

            }).AsAsyncOperation();
        }
Beispiel #4
0
        public IAsyncOperation<OnboardingConfigureWifiResult> ConfigureWifiAsync(
            AllJoynMessageInfo info, string interfaceMemberSSID, string interfaceMemberPassphrase, short interfaceMemberAuthType)
        {
            return Task.Run(() =>
            {
                // make sure a valid value is provided for auth type
                if (!Enum.IsDefined(typeof(AuthType), interfaceMemberAuthType))
                {
                    return OnboardingConfigureWifiResult.CreateFailureResult(AllJoynStatus.InvalidArgument3);
                }

                // May want to switch this to concurrent mode if possible:
                // "Concurrent step used to validate the personal AP connection. In this case, the Onboarder application must wait for the
                // ConnectionResult signal to arrive over the AllJoyn session established over the SoftAP link."
                _personalApSsid = interfaceMemberSSID;
                _personalApPassword = interfaceMemberPassphrase;
                _authType = (AuthType)interfaceMemberAuthType;

                lock (_stateLock)
                {
                    _state = OnboardingState.ConfiguredNotValidated;
                }

                // Status "1" indicates the SoftAP will remain available until the Connect method is invoked
                return OnboardingConfigureWifiResult.CreateSuccessResult(1);

            }).AsAsyncOperation();
        }
Beispiel #5
0
        private async void ConnectToNetwork(WiFiAvailableNetwork network)
        {
            lock (_stateLock)
            {
                _state = OnboardingState.ConfiguredValidating;
            }

            WiFiConnectionResult connectionResult;
            if (network.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211)
            {
                connectionResult = await _wlanAdapter.ConnectAsync(network, WiFiReconnectionKind.Automatic);
            }
            else
            {
                connectionResult = await _wlanAdapter.ConnectAsync(network, WiFiReconnectionKind.Automatic, new PasswordCredential { Password = _personalApPassword });
            }

            lock (_stateLock)
            {
                if (connectionResult.ConnectionStatus == WiFiConnectionStatus.Success)
                {
                    _error = OnboardingError.Validated;
                    _errorMessage = null;
                    _state = OnboardingState.ConfiguredValidated;
                }
                else
                {
                    _state = OnboardingState.ConfiguredError;
                    _errorMessage = connectionResult.ConnectionStatus.ToString();

                    switch (connectionResult.ConnectionStatus)
                    {
                        case WiFiConnectionStatus.AccessRevoked:
                        case WiFiConnectionStatus.InvalidCredential:
                            {
                                _error = OnboardingError.Unauthorized;
                                break;
                            }
                        case WiFiConnectionStatus.UnsupportedAuthenticationProtocol:
                            {
                                _error = OnboardingError.UnsupportedProtocol;
                                break;
                            }
                        case WiFiConnectionStatus.NetworkNotAvailable:
                        case WiFiConnectionStatus.Timeout:
                        case WiFiConnectionStatus.UnspecifiedFailure:
                        default:
                            {
                                _error = OnboardingError.ErrorMessage;
                                break;
                            }
                    }
                }
            }
        }
 public OnboardingService()
 {
     _state = OnboardingState.NotConfigured;
     _stateLock = new object();
     _config = new OnboardingConfig();
 }