public Image Scan(DeviceInfo device)
        {
            if (device == null)
                throw new ArgumentException("Device must be specified");

            var scanner = device.Connect();

            var wiaCommonDialog = new WPFCommonDialog();
            var item = scanner.Items[1];
            var image = (ImageFile)wiaCommonDialog.ShowTransfer(item, wiaFormatBMP, false);

            string fileName = Path.GetTempFileName();
            File.Delete(fileName);
            image.SaveFile(fileName);
            image = null;

            // add file to output list
            return Image.FromFile(fileName);
        }

 public static DeviceInfo From(DeviceInfo di)
 {
     DeviceInfo result = new DeviceInfo(di.DriveName);
     result.DeviceXml = di.DeviceXml;
     result.DeviceName = di.DeviceName;
     return result;
 }

        private void ActiveScanner(DeviceInfo selectedScanner)
        {
            if (selectedScanner != null && !selectedScanner.IsDeviceInfoOf(activeScanner))
            {
                DeactivateScanner();

                UpdateEventHistory(string.Format("Activate Scanner:{0}", selectedScanner.ServiceObjectName));
                try
                {
                    activeScanner = (Scanner)explorer.CreateInstance(selectedScanner);
                    activeScanner.Open();
                    activeScanner.Claim(1000);
                    activeScanner.DeviceEnabled = true;
                    activeScanner.DataEvent += new DataEventHandler(activeScanner_DataEvent);
                    activeScanner.ErrorEvent += new DeviceErrorEventHandler(activeScanner_ErrorEvent);
                    activeScanner.DecodeData = true;
                    activeScanner.DataEventEnabled = true;
                }
                catch (PosControlException)
                {
                    UpdateEventHistory(string.Format("Activation Failed:{0}", selectedScanner.ServiceObjectName));
                    activeScanner = null;
                }
            }
        }

 public void addDevice(int deviceID, DeviceInfo deviceInfo, DeviceType deviceType)
 {
     Debug.Log("addDevice("+deviceID+", "+deviceInfo+", "+deviceType+")");
     bool alreadyEquiped = (!_equipedDevices.Exists(device => device.getID() == deviceID));
     bool alreadyInventory = (!_inventoryDevices.Exists(device => device.getID() == deviceID));
     if(alreadyEquiped || alreadyInventory) {
         Vector3 localPosition;
         UnityEngine.Transform parent;
         List<DisplayedDevice> devices;
         int newDeviceId = deviceID;
         if(deviceType == DeviceType.Equiped) {
             parent = equipPanel.transform;
             devices = _equipedDevices;
             if(deviceID == 0) {
                 newDeviceId = devices.Count;
             }
             Debug.Log("addDevice("+newDeviceId+") in equipment");
         } else {
             parent = inventoryPanel.transform;
             devices = _inventoryDevices;
             Debug.Log("addDevice("+newDeviceId+") in inventory");
         }
         localPosition = getNewPosition(deviceType);
         DisplayedDevice newDevice = DisplayedDevice.Create (parent, localPosition, newDeviceId, deviceType, deviceInfo, this);
         devices.Add(newDevice);
         //let's add reaction to reaction engine
         //for each module of deviceInfo, add to reaction engine
         //deviceInfo._modules.ForEach( module => module.addToReactionEngine(celliaMediumID, reactionEngine));
     } else {
         Debug.Log("addDevice failed: alreadyEquiped="+alreadyEquiped+", alreadyInventory="+alreadyInventory);
     }
 }

        public static bool Update(UserConfiguration userConfig, DeviceInfo deviceInfo)
        {
            var deviceInfos = new List<DeviceInfo>();
            deviceInfos.Add(deviceInfo);

            return Update(userConfig, deviceInfos);
        }

 public static void InstallApplication(
     DeviceInfo deviceInfo, 
     IAppManifestInfo manifestInfo, 
     DeploymentOptions deploymentOptions, 
     string packageFile)
 {
     DeployApplication(DeployAppMode.Install, deviceInfo, manifestInfo, deploymentOptions, packageFile);
 }

 /// <summary>
 /// Get Information for a Device (CPU/GPU/...)
 /// </summary>
 /// <returns></returns>
 public static OpenCLErrorCode GetDeviceInfo(DeviceHandle device,
                                       DeviceInfo paramName,
                                       IntPtr paramValueSize,
                                       InfoBuffer paramValue,
                                       out IntPtr paramValueSizeRet)
 {
     return clGetDeviceInfo((device as IHandleData).Handle, paramName, paramValueSize, paramValue.Address, out paramValueSizeRet);
 }

        public ArcazeDevice(DeviceInfo info)
        {
            this.arcazeDevice = new ArcazeHid();
            Connect(ref info);

            this.arcazeDevice.DeviceRemoved += new EventHandler<HidEventArgs>(this.DeviceRemoved);
            this.arcazeDevice.OurDeviceRemoved += new EventHandler<HidEventArgs>(this.OurDeviceRemoved);
        }

        public void Load()
        {
            var device = new DeviceInfo();
            device.Load();

            ScreenResolution = string.Format(CultureInfo.InvariantCulture, "{0}x{1}", device.ScreenResolution.Width, device.ScreenResolution.Height);

            RaisePropertyChanged("ScreenResolution");
        }

 /// <summary>
 /// Checks to see if the current device or the useragent string contain each
 /// other at the start.
 /// </summary>
 /// <param name="userAgent">The useragent being searched for.</param>
 /// <param name="bestMatch">Reference to the best matching device so far.</param>
 /// <param name="maxInitialString">The maximum number of characters that have matched in the search so far.</param>
 /// <param name="current">The current device being checked for a match.</param>
 private static void Check(string userAgent, ref DeviceInfo bestMatch, ref int maxInitialString,
     DeviceInfo current)
 {
     if ((userAgent.StartsWith(current.UserAgent) ||
          current.UserAgent.StartsWith(userAgent)) &&
         maxInitialString < current.UserAgent.Length)
     {
         maxInitialString = current.UserAgent.Length;
         bestMatch = current;
     }
 }

		public override View OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
		{
			var ignored = base.OnCreateView(inflater, container, savedInstanceState);
			this.EnsureBindingContextIsSet(savedInstanceState);
			View _view = this.BindingInflate(Resource.Layout.MenuView, null);

			_deviceInfoPlugin = Mvx.Resolve<IMvxDeviceInfo>();
			_deviceInfo = _deviceInfoPlugin.GetDeviceInfo ();

			View mv = _view.FindViewById (Resource.Id.menu_view_layout_main);
			TreeListView treeView = (TreeListView)_view.FindViewById (Resource.Id.menu_categories_listview);
			return _view;
		}

        /// <summary>
        /// 尝试登陆某一个设备
        /// </summary>
        /// <returns>是否登陆成功</returns>
        private bool LoginDevice(DeviceInfo loginInfo)
        {
            //某个设备可能回登陆失败所以要try。
            //todo
            try
            {
            }
            catch (Exception)
            {

                throw;
            }
            return true;
        }

        /// <summary>
        /// 把String转换成Object
        /// </summary>
        /// <param name="deviceConfig">按一定格式排列的设备信息字符串</param>
        private DeviceInfo StringToObject(string deviceConfig)
        {
            string[] configs = deviceConfig.Split(',');
            if (configs.Length == 7)
            {
                try
                {
                    DeviceInfo deviceLoginInfo = new DeviceInfo();

                    if (ParameterCheck.IsIpAddress(configs[0]))
                    {
                        deviceLoginInfo.Ip = configs[0];
                    }

                    LogInType type;
                    if (Enum.TryParse(configs[1],true,out type))
                    {
                        deviceLoginInfo.Type = type;
                    }

                    int port;
                    if (int.TryParse(configs[2], out port))
                    {
                        deviceLoginInfo.Port = port;
                    }

                    deviceLoginInfo.LoginReq = configs[3].Equals("true",StringComparison.CurrentCultureIgnoreCase);
                    LogInStatus status;
                    if (Enum.TryParse(configs[4], true, out status))
                    {
                        deviceLoginInfo.Status = status;
                    }

                    deviceLoginInfo.BelongTo = configs[5];

                    if (ParameterCheck.IsIpAddress(configs[6]))
                    {
                        deviceLoginInfo.LocalIp = configs[6];
                    }
                    return deviceLoginInfo;
                }
                catch (Exception)
                {
                    //todo log
                    return null;
                }
            }
            return null;
        }

        /// <summary>
        /// 
        /// </summary>
        public MerchantInfo()
        {
            supportsManualRefunds = true;
            supportsTipAdjust = true;
            supportsVaultCards = true;
            supportsPreAuths = true;
            merchantID = "";
            merchantMId = "";
            merchantName = "";

            Device = new DeviceInfo();
            Device.Name = "";
            Device.Serial = "";
            Device.Model = "";
        }

 private DeviceInfo BuildEntity()
 {
     DeviceInfo user = new DeviceInfo();
     user.ID = GetFormInteger("id");
     user.IP = Request.Form["ip"];
     user.Port = Request.Form["port"];
     user.DeviceType = Request.Form["deviceType"];
     user.UserName = Request.Form["userName"];
     user.Password = Request.Form["password"];
     user.AntNo = GetFormInteger("antNo");
     user.AccessFlag = GetFormInteger("accessFlag");
     user.Location = Request.Form["location"];
     user.Active = Request.Form["active"] == "true";
     return user;
 }

    public static DisplayedDevice Create(
		Transform parentTransform, 
		Vector3 localPosition, 
		int deviceID, 
		DevicesDisplayer.DeviceType deviceType,
		DeviceInfo deviceInfo,
		DevicesDisplayer devicesDisplayer
		)
    {
        Debug.Log("create device "+deviceID
        + " parentTransform="+parentTransform
        + " localPosition="+localPosition
        + " deviceType="+deviceType
        + "deviceInfo="+deviceInfo
        + "devicesDisplayer="+devicesDisplayer);

        GameObject newDevice = Instantiate(prefab, new Vector3(0.0f, 0.0f, 0.0f), Quaternion.identity) as GameObject;
        newDevice.transform.parent = parentTransform;
        newDevice.transform.localPosition = localPosition;
        newDevice.transform.localScale = new Vector3(1f, 1f, 0);

        DisplayedDevice deviceScript = newDevice.GetComponent<DisplayedDevice>();
        deviceScript._deviceID = deviceID;
        deviceScript._deviceType = deviceType;
        deviceScript._deviceInfo = deviceInfo;
        deviceScript._devicesDisplayer = devicesDisplayer;
        deviceScript._currentSpriteName = deviceInfo._spriteName;
        /*
        //deviceScript._sprite = newDevice.transform.GetComponentInChildren<UISprite>();
        GameObject background = newDevice.transform.Find("Background").gameObject;
        if(background) {
            deviceScript._sprite = background.GetComponent<UISprite>();
            Debug.Log("init _sprite as "+deviceScript._sprite);
        } else {
            Debug.Log("init _sprite impossible: no background found");
        }
        */

        //do additional initialization steps here

        return deviceScript;
    }

        internal static byte[] CreateKeyChange(DeviceInfo devInfo)
        {
            List<byte> keyChangePacket = new List<byte>();

            //LOCAL IP
            keyChangePacket.AddRange(MessageBuilder.HexToByteArray(GMPDataTags.DT_IP));
            keyChangePacket.AddRange(MessageBuilder.AddLength(6));

            String[] strLocalIP = getLocalIP().Split('.');//devInfo.DevIP.ToString().Split('.');

            String ip12Format = "";
            for (int i = 0; i < strLocalIP.Length; i++)
            {
                ip12Format += String.Format("{0:D3}", Convert.ToInt32(strLocalIP[i]));
            }
            for (int i = 0; i < ip12Format.Length; i++)
            {
                String strByte = ip12Format.Substring(i, 2);

                keyChangePacket.AddRange(MessageBuilder.ConvertIntToBCD(Convert.ToInt32(strByte), 1));
                i++;
            }

            //BRAND
            keyChangePacket.AddRange(MessageBuilder.HexToByteArray(GMPDataTags.DT_BRAND));
            keyChangePacket.AddRange(MessageBuilder.AddLength(devInfo.Brand.Length));
            keyChangePacket.AddRange(Encoding.ASCII.GetBytes(devInfo.Brand));

            //MODEL
            keyChangePacket.AddRange(MessageBuilder.HexToByteArray(GMPDataTags.DT_MODEL));
            keyChangePacket.AddRange(MessageBuilder.AddLength(devInfo.Model.Length));
            keyChangePacket.AddRange(Encoding.ASCII.GetBytes(devInfo.Model));

            //SERIAL
            keyChangePacket.AddRange(MessageBuilder.HexToByteArray(GMPDataTags.DT_SERIAL));
            keyChangePacket.AddRange(MessageBuilder.AddLength(devInfo.TerminalNo.Length));
            keyChangePacket.AddRange(Encoding.ASCII.GetBytes(devInfo.TerminalNo));

            return keyChangePacket.ToArray();
        }

        public Image Scan(DeviceInfo device, PageSize pageSize, ColorDepth colorDepth, Resolution resolution, Orientation orientation, bool setSize = true)
        {
            if (device == null)
                throw new ArgumentException("Device must be specified");

            var scanner = device.Connect();

            var wiaCommonDialog = new WPFCommonDialog();
            var item = scanner.Items[1];

            SetupPageSize(item, pageSize, colorDepth, resolution, orientation, setSize);

            var image = (ImageFile)wiaCommonDialog.ShowTransfer(item, wiaFormatBMP, false);

            string fileName = Path.GetTempFileName();
            File.Delete(fileName);
            image.SaveFile(fileName);
            image = null;

            // add file to output list
            return Image.FromFile(fileName);
        }

        private EventInfo CreateEventInfoBase(Event errorData)
        {
            var appInfo = new AppInfo
            {
                Version = Config.AppVersion,
                ReleaseStage = Config.ReleaseStage,
                AppArchitecture = Diagnostics.AppArchitecture,
                ClrVersion = Diagnostics.ClrVersion
            };

            var userInfo = new UserInfo
            {
                Id = errorData.UserId,
                Email = errorData.UserEmail,
                Name = errorData.UserName
            };

            var deviceInfo = new DeviceInfo
            {
                OSVersion = Diagnostics.DetectedOSVersion,
                ServicePack = Diagnostics.ServicePack,
                OSArchitecture = Diagnostics.OSArchitecture,
                ProcessorCount = Diagnostics.ProcessorCount,
                MachineName = Diagnostics.MachineName,
                HostName = Diagnostics.HostName
            };

            var eventInfo = new EventInfo
            {
                App = appInfo,
                Device = deviceInfo,
                Severity = errorData.Severity,
                User = userInfo,
                Context = errorData.Context,
                GroupingHash = errorData.GroupingHash,
                Exceptions = new List<ExceptionInfo>()
            };
            return eventInfo;
        }

	void InitializePreviewPlugin(string preferredDeviceName, Camera camera)
	{
		// Test library compatibility
		if (DesktopWrapper.GetInterfaceVersion() != 3)
		{
			Debug.LogError("You appear to be using incompatible versions of StringWrapper.cs and String.bundle; Please make sure you're using the latest versions of both.");
			
			return;
		}

		// Enumerate devices
		uint maxDeviceCount = 10;
		DeviceInfo[] deviceInfo = new DeviceInfo[maxDeviceCount];
		
		uint deviceCount = DesktopWrapper.EnumerateDevices(deviceInfo, maxDeviceCount);
		
		for (int i = 0; i < deviceCount; i++)
		{
			Debug.Log("Found camera \"" + deviceInfo[i].name + "\" (" + (deviceInfo[i].isAvailable ? "available for use.)" : "not available for use.)"));
		}
		
		if (deviceCount > 0)
		{
			uint i;
			
			for (i = 0; i < deviceCount; i++)
			{
				if (deviceInfo[i].name == preferredDeviceName) break;
			}
			
			if (i < deviceCount)
			{
				Debug.Log("Capturing video from preferred device \"" + deviceInfo[i].name + "\".");
			}
			else
			{
				i = 0;

				if (preferredDeviceName != null)
				{
					Debug.Log("Preferred device was not found. Using \"" + deviceInfo[i].name + "\".");
				}
				else
				{
					Debug.Log("Capturing video from device \"" + deviceInfo[i].name + "\".");
				}
			}
			
			if (DesktopWrapper.InitTracker(deviceInfo[i].id, ref previewWidth, ref previewHeight, _previewCamApproxVerticalFOV))
			{
				CreateVideoMaterial();
				CreateVideoMesh();
				
				float scale = camera.farClipPlane * 0.99f;
				
				float verticalScale = scale * Mathf.Tan(_previewCamApproxVerticalFOV * Mathf.PI / 360f);
				
				videoPlaneObject = new GameObject("Video Plane", new Type[] {typeof(MeshRenderer), typeof(MeshFilter)});
				videoPlaneObject.hideFlags = HideFlags.HideAndDontSave;
				videoPlaneObject.active = false;
				
				videoPlaneObject.renderer.material = videoMaterial;
				
				MeshFilter meshFilter = (MeshFilter)videoPlaneObject.GetComponent(typeof(MeshFilter));
				meshFilter.sharedMesh = videoPlaneMesh;
				
				videoPlaneObject.transform.parent = camera.transform;
				videoPlaneObject.transform.localPosition = new Vector3(0, 0, scale);
				videoPlaneObject.transform.localRotation = Quaternion.identity;
				videoPlaneObject.transform.localScale = new Vector3(verticalScale * (float)previewWidth / previewHeight, verticalScale, 1);
				
				wasInitialized = true;
			}
			else
			{
				Debug.Log("Failed to initialize String.");
			}
		}
		else
		{
			Debug.LogError("No devices suitable for video capture were detected.");
		}
	}