public DeviceListViewModel(IDispatcherHelper dispatcherHelper, 
            INavigationService navigationService,
            IAdapter adapter,
            Func<IDevice, DeviceViewModel> deviceViewModelFactory)
        {
            _dispatcherHelper = dispatcherHelper;
            _navigationService = navigationService;
            _adapter = adapter;
            _deviceViewModelFactory = deviceViewModelFactory;

            _adapter.ScanTimeoutElapsed += (s, e) =>
            {
                StopScan();
            };
            _adapter.DeviceDiscovered += (s, e) =>
            {
                if (_devices.All(d => d.ID != e.Device.ID))
                {
                    _dispatcherHelper.RunOnUIThread(() =>
                        {
                            _devices.Add(e.Device);
                        });
                }
            };
        }

 public DockingViewManager(ITransport transport, IAdapter adapter, IScheduler scheduler, LocalScheduler dispatcher)
 {
     _transport = transport;
     _adapter = adapter;
     _scheduler = scheduler;
     _dispatcher = dispatcher;
 }

		public DeviceList (IAdapter adapter)
		{
			InitializeComponent ();
			this.adapter = adapter;
			this.devices = new ObservableCollection<IDevice> ();
			listView.ItemsSource = devices;

			adapter.DeviceDiscovered += (object sender, DeviceDiscoveredEventArgs e) => {
				Device.BeginInvokeOnMainThread(() => {
					devices.Add (e.Device);
				});
			};

			adapter.ScanTimeoutElapsed += (sender, e) => {
				adapter.StopScanningForDevices(); // not sure why it doesn't stop already, if the timeout elapses... or is this a fake timeout we made?
				Device.BeginInvokeOnMainThread ( () => {
					IsBusy = false;
					DisplayAlert("Timeout", "Bluetooth scan timeout elapsed, no heart rate monitors were found", "OK");
				});
			};

			ScanHrmButton.Activated += (sender, e) => {
				InfoFrame.IsVisible = false;
				// this is the UUID for Heart Rate Monitors
				StartScanning (0x180D.UuidFromPartial());
			};
		}

		public DeviceList (IAdapter adapter)
		{
			InitializeComponent ();
			this.adapter = adapter;
			this.devices = new ObservableCollection<IDevice> ();
			listView.ItemsSource = devices;

			adapter.DeviceDiscovered += (object sender, DeviceDiscoveredEventArgs e) => {
				Device.BeginInvokeOnMainThread(() => {
					devices.Add (e.Device);
				});
			};

			adapter.ScanTimeoutElapsed += (sender, e) => {
				IsBusy = false;
				Debug.WriteLine ("Scan timeout");
				if (autoScan) {
					StartScanning ();
				}
			};

			Appearing += (sender, e) => {
				StartScanning();
			};
		}

 public DurationTraderViewModelController(ITransport transport, IAdapter adapter, IScheduler scheduler, LocalScheduler dispatcher)
 {
     transport.GetTradingObservables()
         .SubscribeOn(scheduler)
         .ObserveOn(dispatcher)
         .Subscribe(fSet => adapter.updater(fSet, ViewModel));
 }

		public ServiceList (IAdapter adapter, IDevice device)
		{
			InitializeComponent ();
			this.adapter = adapter;
			this.device = device;
			this.services = new ObservableCollection<IService> ();
			listView.ItemsSource = services;

			// when device is connected
			adapter.DeviceConnected += (s, e) => {
				device = e.Device; // do we need to overwrite this?

				// when services are discovered
				device.ServicesDiscovered += (object se, EventArgs ea) => {
					Debug.WriteLine("device.ServicesDiscovered");
					//services = (List<IService>)device.Services;
					if (services.Count == 0)
						Device.BeginInvokeOnMainThread(() => {
							foreach (var service in device.Services) {
								services.Add(service);
							}
						});
				};
				// start looking for services
				device.DiscoverServices ();

			};
			// TODO: add to IAdapter first
			//adapter.DeviceFailedToConnect += (sender, else) => {};

			DisconnectButton.Activated += (sender, e) => {
				adapter.DisconnectDevice (device);
				Navigation.PopToRootAsync(); // disconnect means start over
			};
		}

 public void SetAdapter(IAdapter adapter)
 {
     if (this.adapter == adapter) return;
     this.adapter = adapter;
     if (adapter != null) adapter.RegisterDataSetObserver(richDataSetObsever);
     ReloadChildViews();
 }

		public TestPage (IAdapter adapter)
		{
			InitializeComponent ();
			this.adapter = adapter;
			this.devices = new ObservableCollection<IDevice> ();
			this.services = new ObservableCollection<IService> ();
			this.characteristics = new ObservableCollection<ICharacteristic> ();

			adapter.BluetoothStateUpdated += Adapter_BluetoothStateUpdated;
			adapter.ScanCompleted += Adapter_ScanCompleted;
			adapter.DeviceDiscovered += Adapter_DeviceDiscovered;
			adapter.DeviceConnected += Adapter_DeviceConnected;
			adapter.DeviceDisconnected += Adapter_DeviceDisconnected;
			adapter.DeviceFailedToConnect += Adapter_DeviceFailedToConnect;
			adapter.CommandResponse += Adapter_CommandResponse;
		
			btnValidate.Clicked += OnStartClicked;
			btnGenerateCode.Clicked += OnGenerateCodeClicked;
			btnDisconnect.Clicked += OnDisconnectDevice;

			btnGenSerial.Clicked += OnGenSerialClicked;
			btnValidateUser.Clicked += BtnValidateUser_Clicked;
			btnChangeUser.Clicked += BtnChangeUser_Clicked;

			//file.CreateFileAsync ("testFile.txt");
		}

		public CharacteristicDetail_TISensor (IAdapter adapter, IDevice device, IService service, ICharacteristic characteristic)
		{
			InitializeComponent ();
			this.characteristic = characteristic;

			Title = characteristic.Name;
		}

    public void SetAdapter(IAdapter adapter)
    {
        mIAdapter = adapter;

        mIDevice.OnConnect(mIAdapter.controller);

    }

 public bool Process(Data data, IAdapter adapter)
 {
     if (data.Device == device && (data.Service & service) > 0)
     {
         double value = Util.DataAdapter.GetGraphableValue(data);
         if (comparison == "<")
         {
             if (value < threshold) Email(value, adapter);
         }
         else if (comparison == "<=")
         {
             if (value <= threshold) Email(value, adapter);
         }
         else if (comparison == "==")
         {
             if (value == threshold) Email(value, adapter);
         }
         else if (comparison == ">=")
         {
             if (value >= threshold) Email(value, adapter);
         }
         else if (comparison == ">")
         {
             if (value > threshold) Email(value, adapter);
         }
     }
     return true;
 }

		public DeviceList (IAdapter adapter)
		{
			InitializeComponent ();
			this.adapter = adapter;
			this.devices = new ObservableCollection<IDevice> ();
			listView.ItemsSource = devices;

			adapter.DeviceDiscovered += (object sender, DeviceDiscoveredEventArgs e) => {
				Device.BeginInvokeOnMainThread(() => {
					//TODO: uncomment this if there are a lot of Bluetooth devices around cluttering your list (and remove the line below)
//					if (e.Device.Name != null) {
//            			if (e.Device.Name.ToLower().Contains("biscuit")) {
//                			devices.Add(e.Device);
//            			}
//            		}
					devices.Add (e.Device);
				});
			};

			adapter.ScanTimeoutElapsed += (sender, e) => {
				IsBusy = false;
				Debug.WriteLine ("Scan timeout");
				if (autoScan) {
					StartScanning ();
				}
			};

			Appearing += (sender, e) => {
				StartScanning();
			};
		}

		Task<ControlClient> ConnectAsync (IAdapter adapter)
		{
			var tcs = new TaskCompletionSource<ControlClient> ();

			adapter.DeviceDiscovered += (object sender, DeviceDiscoveredEventArgs e) => {
				Device.BeginInvokeOnMainThread(async () => {

					// Look for a specific device
					if (e.Device.ID.ToString ().StartsWith ("af18", StringComparison.OrdinalIgnoreCase)) {

						// Connect to the device
						await adapter.ConnectAsync (e.Device);

						// Establish the control client
						using (var stream = new LEStream (e.Device)) {
							var client = new ControlClient (stream);
							client.RunAsync (CancellationToken.None); // Don't await to run in background
							tcs.SetResult (client);
						}

						// Update the UI
						connectLabel.Text = "Yay " + e.Device + "!";
					}
				});
			};

			adapter.StartScanningForDevices();

			return tcs.Task;
		}

 public static void PrintUserInfo(IAdapter adapter)
 {
     Console.WriteLine("Имя:\t\t\t {0}", adapter.Name);
     Console.WriteLine("Возраст:\t\t {0}", adapter.Age);
     Console.WriteLine("Количество друзей:\t {0}", adapter.NumberOfFriends);
     Console.WriteLine("------- -------- ------- -------");
 }

 public RequestResourceContext(IAdapter adapter, IAdaptee adaptee,
     RequestType resource)
 {
     Adaptee = adaptee;
     Adapter = adapter;
     ReqType = resource;
 }

        public override void Initialize(IAdapter adapter)
        {
            base.Initialize(adapter);

            ScreenLayers screenLayers = WaveServices.ScreenLayers;
            screenLayers.AddScene<MyScene>();
            screenLayers.Apply();
        }

 public void SetBinding(IAdapter adapter)
 {
     adapter.Register(
         typeof(ISampleDAO),
         typeof(SampleDAO),
         ContainerEnumerator.LifeCycle.Transient
     );
 }

 public OnlineBookStoreService(IBookRepository bookRepository, IDictionaryRepository dictionaryRepository, IOrderRepository orderRepository, ICustomerRepository customerRepository, IAdapter adapter)
 {
     this._bookRepository = bookRepository;
     this._dictionaryRepository = dictionaryRepository;
     this._orderRepository = orderRepository;
     this._customerRepository = customerRepository;
     this._adapter = adapter;
 }

 public RobotEngine(IAdapter adapter, IHttpServer httpServer, Func<IRobot> robotFunc, Func<IEnumerable<RobotPart>> parts)
 {
     _adapter = adapter;
     _httpServer = httpServer;
     _robotFunc = robotFunc;
     _parts = parts;
     _contextExecutors = new List<IContextExecutor>();
 }

 public static void Refill(this LinearLayout layout, IAdapter adapter)
 {
     layout.RemoveAllViews();
     var count = adapter.Count;
     for (var i = 0; i < count; i++)
     {
         layout.AddView(adapter.GetView(i, null, layout));
     }            
 }