private void btnSensorsType_Click(object sender, EventArgs e)
        {
            checkedListBoxSensorsType.Items.Clear();
            String sensorsTypeStr = null;

            try
            {
                SensorDataService1Client sensorDataService1Client = new SensorDataService1Client();
                sensorsTypeStr = sensorDataService1Client.getSensorsType();
                sensorDataService1Client.Close();

                if (sensorsTypeStr == null || sensorsTypeStr.Length == 0)
                {
                    MessageBox.Show("无可用传感器,或者Android设备未连上Service!", "Error", MessageBoxButtons.OK,
                                    MessageBoxIcon.Error);
                }
                else
                {
                    //保存Android传感器类型到文件
                    SaveFileHelper.SaveFile(sensorsTypeStr, MainForm.baseFilePath + "\\SensorsType.txt");

                    string[] sensorsTypeArr = sensorsTypeStr.Split(',');
                    for (int i = 1; i < sensorsTypeArr.Length; i++)
                    {
                        string[] sensorsTypeItemArr = sensorsTypeArr[i].Split(':');
                        if (androidSensorsTypeSet.Contains((SensorType)(int.Parse(sensorsTypeItemArr[0]))))
                        {
                            continue;
                        }
                        else
                        {
                            sensorsTypeDict.Add(sensorsTypeItemArr[1], (SensorType)(int.Parse(sensorsTypeItemArr[0])));
                            androidSensorsTypeSet.Add((SensorType)(int.Parse(sensorsTypeItemArr[0])));
                        }
                    }
                    foreach (string sensorName in sensorsTypeDict.Keys)
                    {
                        checkedListBoxSensorsType.Items.Add(sensorName);
                    }

                    buttonOK.Enabled = true;
                }
            }
            catch (Exception e1)
            {
                MessageBox.Show("查询失败,可能服务未启动", "Error", MessageBoxButtons.OK,
                                MessageBoxIcon.Error);
                Debug.WriteLine("Er" + e1.ToString());
            }
        }
        private void startToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Clear();
            //清除Queue中原有的数据
            SensorDataService1Client sensorDataService1Client = new SensorDataService1Client();

            sensorDataService1Client.ClearSensorDataQueue();
            sensorDataService1Client.Close();

            startInventoryThread = new Thread(startInventory);
            startInventoryThread.IsBackground = true;
            startInventoryThread.Start();

            windowsToolStripMenuItem.Enabled = true;
            stopToolStripMenuItem.Enabled    = true;
            saveAsToolStripMenuItem.Enabled  = false;
            saveToolStripMenuItem.Enabled    = false;
            startToolStripMenuItem.Enabled   = false;
        }
        public void startInventory()
        {
            while (true)
            {
                List <SensorDataItemXD> sensorDataList = null;
                try
                {
                    SensorDataService1Client sensorDataService1Client = new SensorDataService1Client();
                    SensorDataItemXD[]       sensorDataArr            = sensorDataService1Client.TryDeque();
                    sensorDataService1Client.Close();
                    sensorDataList = new List <SensorDataItemXD>(sensorDataArr);
                }
                catch (EndpointNotFoundException e1)
                {
                    MessageBox.Show("Service is not running!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    Debug.WriteLine(e1.ToString());
                }

                //Debug.WriteLine("" + sensorDataArr.Length);

                if (sensorDataList != null && sensorDataList.Count > 0)
                {
                    foreach (SensorDataItemXD sditemXD in sensorDataList)
                    {
                        //记录第一次获得数据的时间
                        if (firstdata_b)
                        {
                            firstdataTime = sditemXD.Timestamp;
                            firstdata_b   = false;
                        }
                        sditemXD.Timestamp -= firstdataTime;
                        this.BeginInvoke(method: new Action(() =>
                        {
                            //目前支持的传感器类型,增加的话需要在这里更改
                            switch ((SensorType)sditemXD.Type)
                            {
                            case SensorType.TYPE_ACCELEROMETER:
                                if (accelerometerForm.Visible)
                                {
                                    accelerometerForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_MAGNETIC_FIELD:
                                if (magneticForm.Visible)
                                {
                                    magneticForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_ORIENTATION:
                                if (OrientationForm.Visible)
                                {
                                    OrientationForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_GYROSCOPE:
                                if (gyroscopeForm.Visible)
                                {
                                    gyroscopeForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_LIGHT:
                                if (BH1745_BH1745_ALS_DEVICEForm.Visible)
                                {
                                    BH1745_BH1745_ALS_DEVICEForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_PRESSURE:
                                if (pressureForm.Visible)
                                {
                                    pressureForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_PROXIMITY:
                                if (PROXForm.Visible)
                                {
                                    PROXForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_GRAVITY:
                                if (gravityForm.Visible)
                                {
                                    gravityForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_LINEAR_ACCELERATION:
                                if (LinearAccelerationForm.Visible)
                                {
                                    LinearAccelerationForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_ROTATION_VECTOR:
                                if (RotationVectorForm.Visible)
                                {
                                    RotationVectorForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_MAGNETIC_FIELD_UNCALIBRATED:
                                if (magnetometerUncalibratedForm.Visible)
                                {
                                    magnetometerUncalibratedForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_GAME_ROTATION_VECTOR:
                                if (GameRotationVectorForm.Visible)
                                {
                                    GameRotationVectorForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_GYROSCOPE_UNCALIBRATED:
                                if (gyroscopeUncalibratedForm.Visible)
                                {
                                    gyroscopeUncalibratedForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_SIGNIFICANT_MOTION:
                                if (SignificantMotionDetectorForm.Visible)
                                {
                                    SignificantMotionDetectorForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_STEP_DETECTOR:
                                if (StepDetectorForm.Visible)
                                {
                                    StepDetectorForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_STEP_COUNTER:
                                if (StepCounterForm.Visible)
                                {
                                    StepCounterForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_GEOMAGNETIC_ROTATION_VECTOR:
                                if (GeoMagneticRotationVectorForm.Visible)
                                {
                                    GeoMagneticRotationVectorForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_Tilt_Detector:
                                if (TiltDetectorForm.Visible)
                                {
                                    TiltDetectorForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_STATIONARY_DETECT:
                                if (AndroidStationaryDetectorForm.Visible)
                                {
                                    AndroidStationaryDetectorForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_MOTION_DETECT:
                                if (AndroidMotionDetectorForm.Visible)
                                {
                                    AndroidMotionDetectorForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_BASIC_GESTURES:
                                if (BasicGesturesForm.Visible)
                                {
                                    BasicGesturesForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_FACING:
                                if (FacingForm.Visible)
                                {
                                    FacingForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_AMD:
                                if (AMDForm.Visible)
                                {
                                    AMDForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_RMD:
                                if (RMDForm.Visible)
                                {
                                    RMDForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_PEDOMETER:
                                if (PedometerForm.Visible)
                                {
                                    PedometerForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_MOTION_ACCEL:
                                if (MotionAccelForm.Visible)
                                {
                                    MotionAccelForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_COARSE_MOTION_CLASSIFIER:
                                if (CoarseMotionClassifierForm.Visible)
                                {
                                    CoarseMotionClassifierForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_IOD:
                                if (IODForm.Visible)
                                {
                                    IODForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_DPC:
                                if (DPCForm.Visible)
                                {
                                    DPCForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_MUTILSHAKE:
                                if (MultiShakeForm.Visible)
                                {
                                    MultiShakeForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_PERSISTENT_MOTION_DETECTOR:
                                if (PersistentMotionDetectorForm.Visible)
                                {
                                    PersistentMotionDetectorForm.UpdateGraph(sditemXD);
                                }
                                break;

                            case SensorType.TYPE_OEM5_TAPTAP_GESTURE:
                                if (Oem5TaptapGestureForm.Visible)
                                {
                                    Oem5TaptapGestureForm.UpdateGraph(sditemXD);
                                }
                                break;
                            }
                        }
                                                            ));
                        sensorDataTable.AddSensorDataInfo(sditemXD);
                    }
                }
                Thread.Sleep(10);
            }
        }