/// <summary>
 /// Generates a collection of audio endpoint devices that meet the specified criteria.
 /// </summary>
 /// <param name="dataFlow">The data-flow direction for the endpoint device.</param>
 /// <param name="stateMask">The state or states of the endpoints that are to be included in the collection.</param>
 /// <returns><see cref="MMDeviceCollection"/> which contains the enumerated devices.</returns>
 public static MMDeviceCollection EnumerateDevices(DataFlow dataFlow, DeviceState stateMask)
 {
     using (var enumerator = new MMDeviceEnumerator())
     {
         return enumerator.EnumAudioEndpoints(dataFlow, stateMask);
     }
 }

 /// <summary>
 /// Generates a collection of audio endpoint devices that meet the specified criteria.
 /// </summary>
 /// <param name="dataFlow">The data-flow direction for the endpoint device.</param>
 /// <param name="stateMask">The state or states of the endpoints that are to be included in the collection.</param>
 /// <returns><see cref="MMDeviceCollection"/> which contains the enumerated devices.</returns>
 public MMDeviceCollection EnumAudioEndpoints(DataFlow dataFlow, DeviceState stateMask)
 {
     IntPtr pcollection;
     CoreAudioAPIException.Try(EnumAudioEndpointsNative(dataFlow, stateMask, out pcollection), InterfaceName,
         "EnumAudioEndpoints");
     return new MMDeviceCollection(pcollection);
 }

 public unsafe int EnumAudioEndpointsNative(DataFlow dataFlow, DeviceState stateMask, out IntPtr collection)
 {
     IntPtr pcollection;
     int result = InteropCalls.CallI(_basePtr, unchecked(dataFlow), unchecked(stateMask), &pcollection, ((void**)(*(void**)_basePtr))[3]);
     collection = pcollection;
     return result;
 }

        public IHttpActionResult GetByState(Guid companyId, DeviceState state)
        {
            IReadOnlyCollection<Device> devices;

            if (state == DeviceState.Pending)
            {
                devices = DeviceRepository.GetPending(companyId);
            }
            else if (state == DeviceState.Approved)
            {
                devices = DeviceRepository.GetApproved(companyId);
            }
            else if (state == DeviceState.Declined)
            {
                devices = DeviceRepository.GetDeclined(companyId);
            }
            else if (state == DeviceState.Blocked)
            {
                devices = DeviceRepository.GetBlocked(companyId);
            }
            else
            {
                throw new NotImplementedException(String.Format("There is no implementation for DeviceState '{0}'", state));
            }

            var model = devices.Select(x => DeviceModel.From(x));

            return Ok(model);
        }

 public AudioDeviceLister(DeviceState state)
 {
     _state = state;
     AudioController.DeviceAdded += AudioControllerOnDeviceAdded;
     AudioController.DeviceRemoved += AudioControllerOnDeviceRemoved;
     AudioController.DeviceStateChanged += AudioControllerOnDeviceStateChanged;
 }

        public HardDrive(RenderWindow window, VirtualMachine virtualMachine, XElement config)
        {
            vm = virtualMachine;
            state = DeviceState.None;

            var errorMsg = "";

            try
            {
                errorMsg = "Bad Port";
                devPort = short.Parse(Util.ElementValue(config, "Port", null));

                errorMsg = "Bad FileName";
                var fileName = Util.ElementValue(config, "FileName", null);
                if (fileName == null)
                    throw new Exception();

                errorMsg = string.Format("Failed to open '{0}'", fileName);
                diskImage = new FileStream(fileName, FileMode.Open);
                sectorCount = (ushort)(new FileInfo(fileName).Length / BytesPerSector);
            }
            catch (Exception e)
            {
                throw new Exception(string.Format("HardDrive: {0}", errorMsg), e);
            }
        }

 /// <summary>
 /// Creates a device with the specific serial number
 /// </summary>
 /// <param name="serialNo">The serial number of the device as a String</param>
 /// <param name="model">The model of the device</param>
 /// <param name="productName">The product name of the device</param>
 /// <param name="state">The state of the device</param>
 internal Device(string serialNo, string model, string productName, string name, DeviceState state)
 {
     mSerialNumber = serialNo;
     mProductName = productName;
     mModel = model;
     mConnectionStatus = state;
     mName = name;
 }

        public override Boolean Open(int Instance = 0)
        {
            if (base.Open(Instance))
            {
                m_State = DeviceState.Reserved;
            }

            return State == DeviceState.Reserved;
        }

 public static DeviceStateRequest From(DeviceState state, DateTime changeDate, string comment)
 {
     return new DeviceStateRequest()
     {
         State = state,
         ChangeDate = changeDate,
         Comment = comment
     };
 }

        public virtual void ApplyState(DeviceState state)
        {
            // Shouldn't change any of these post creation
            state.Name = mState.Name;
            state.DisplayName = mState.DisplayName;
            state.Archetype = mState.Archetype;

            if (!state.Type.Equals(mState.Type))
                throw new InvalidOperationException(string.Format("Type {0} of source state does not match type {1} of target state", state.Type, mState.Type));
        }

 public static StateModel From(DeviceState state, DateTime changeDate, string macAddress, string comment)
 {
     return new StateModel()
     {
         State = state.ToString(),
         ChangeDate = changeDate,
         MacAddress = macAddress,
         Comment = comment
     };
 }

        public override Boolean Close()
        {
            if (IsActive)
            {
                Unplug(0);
                m_State = DeviceState.Disconnected;
            }

            return base.Close();
        }

        protected DeviceBase(DeviceState state, DeviceCreationInfo creationInfo)
        {
            mState = state;
            mState.Name = creationInfo.Configuration.name;
            try
            {
                mState.DisplayName = creationInfo.Configuration.displayName;
            }
            catch (RuntimeBinderException) { }  // Optional

            mState.Type = GetType().ToString();
        }

    public DirectXOutputDevice(Controller controller)
    {
      _controller = controller;
      _deviceState = DeviceState.Stopped;
      _streamWriteProcDelegate = OutputStreamWriteProc;
      _silence = new Silence();

      _deviceNo = GetDeviceNo();

      BASSInit flags = BASSInit.BASS_DEVICE_DEFAULT;

      // Because all deviceinfo is saved in a static dictionary,
      // we need to determine the latency only once.
      if (!_deviceInfos.ContainsKey(_deviceNo))
        flags |= BASSInit.BASS_DEVICE_LATENCY;

      bool result = Bass.BASS_Init(
          _deviceNo,
          44100, //Only relevant for -> pre-XP (VxD drivers)
          flags,
          IntPtr.Zero);

      BASSError? bassInitErrorCode = result ? null : new BASSError?(Bass.BASS_ErrorGetCode());

      // If the GetDeviceNo() method returned BassConstants.BassDefaultDevice, we must request the actual device number
      // of the choosen default device
      _deviceNo = Bass.BASS_GetDevice();

      if (bassInitErrorCode.HasValue)
      {
        if (bassInitErrorCode.Value == BASSError.BASS_ERROR_ALREADY)
        {
          if (!Bass.BASS_SetDevice(_deviceNo))
            throw new BassLibraryException("BASS_SetDevice");
          bassInitErrorCode = null;
        }
      }

      if (bassInitErrorCode.HasValue)
        throw new BassLibraryException("BASS_Init", bassInitErrorCode.Value);

      CollectDeviceInfo(_deviceNo);

      int ms = Convert.ToInt32(Controller.GetSettings().DirectSoundBufferSize.TotalMilliseconds);

      if (!Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_BUFFER, ms))
        throw new BassLibraryException("BASS_SetConfig");

      // Enable update thread while the output device is active
      if (!Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_UPDATEPERIOD, ms / 4))
        throw new BassLibraryException("BASS_SetConfig");
    }

        public override void ApplyState(DeviceState state)
        {
            base.ApplyState(state);

            var newState = (ComputerState)state;
            var currentState = (ComputerState)mState;

            if (newState.Power != currentState.Power)
                SetPower(newState.Power);

            if (newState.MonitorPower != currentState.MonitorPower)
                SetMonitorPower(newState.MonitorPower);
        }

 internal static string GetJavascriptDeviceState(DeviceState state)
 {
     switch (state)
     {
         case DeviceState.Active:
             return ACTIVE;
         case DeviceState.NotPresent:
             return NOTPRESENT;
         case DeviceState.Unplugged:
             return UNPLUGGED;
         case DeviceState.Disabled:
             return DISABLED;
         case DeviceState.All:
             return ALL;
     }
     throw new ArgumentOutOfRangeException("state");
 }

 /// <summary>
 ///     Sets the device state asynchronously
 /// </summary>
 /// <param name="deviceId">The device identifier.</param>
 /// <param name="deviceState">State of the device.</param>
 /// <returns></returns>
 /// <exception cref="DeviceException">Unable to communicate with device with ID=  + deviceId</exception>
 public async Task SetDeviceStateAsync(byte deviceId, DeviceState deviceState)
 {
     try
     {
         var data = new[] { (ushort)deviceState };
         await this.deviceAccessLayer.WriteToDeviceAsync(deviceId, Registry.STATE_ADDR, data);
     }
     catch (Exception e)
     {
         this.logger.Error(
             string.Format(
                 "Unable to set state of device {0} to {1}. Exception occured {2}",
                 deviceId,
                 deviceState,
                 e));
         throw new DeviceException("Unable to communicate with device with ID= " + deviceId);
     }
 }

 void UpdateStatus(DeviceState state)
 {
     //Clear connecting.
     if (state == DeviceState.Connected)
     {
         state &= ~DeviceState.Connecting;
         state |= DeviceState.Initialized;
     }
     m_Status = state;
     if (OnStatusChanged != null)
     {
         OnStatusChanged(this, m_Status);
     }
 }

        private DeviceState SetState()
        {
            string state = null;

            using (StringReader r = new StringReader(Adb.Devices()))
            {
                string line;

                while (r.Peek() != -1)
                {
                    line = r.ReadLine();

                    if (line.Contains(this.serialNumber))
                        state = line.Substring(line.IndexOf('\t') + 1);
                }
            }

            if (state == null)
            {
                using (StringReader r = new StringReader(Fastboot.Devices()))
                {
                    string line;

                    while (r.Peek() != -1)
                    {
                        line = r.ReadLine();

                        if (line.Contains(this.serialNumber))
                            state = line.Substring(line.IndexOf('\t') + 1);
                    }
                }
            }

            switch (state)
            {
                case "device":
                    return DeviceState.ONLINE;
                case "recovery":
                    return DeviceState.RECOVERY;
                case "fastboot":
                    return DeviceState.FASTBOOT;
                default:
                    return DeviceState.UNKNOWN;
            }
        }

 protected virtual void Init()
 {
     this.State = DeviceState.UNKNOWN;
 }