Java Android：通过UDP从线程发送加速计数据

我正在尝试使用MainActivity和SensorEventListener制作应用程序。来自加速计的数据将保存在结构中（类，两个int变量）。 我创建了UDP客户端线程，它在应用程序启动后运行。UDP客户端将这两个变量发送到远程服务器

问题是，我需要知道传感器的数据何时刷新，然后通过UDP客户端（另一个线程）发送。我是android应用程序和java的新手。 如果你能给我一些代码示例来做这件事，那将非常有帮助

代码：

public class MainActivity extends Activity implements SensorEventListener {

Button button;
String theLine = null;
public static final String SERVERIP = "192.168.2.101"; // 'Within' the emulator!
public static final int SERVERPORT = 12345;


private static final int RESULT_SETTINGS = 1;

public boolean bKeepRunning;

private SensorManager mSensorManager;
private Sensor mAccelerometer;

Client client = null;

@Override
public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    addListenerOnButton();

    mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
    mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
}


public class Client extends Thread 
{

    bKeepRunning = true;

    @Override
    public void run() 
    {
        byte[] sendData = new byte[512];
        sendData =intToByteArray(angles.rolling, angles.pitching);
        sendData= reverseArray(sendData);
        InetAddress serverAddr = null;

        try{
            serverAddr = InetAddress.getByName(SERVERIP);
            } catch (UnknownHostException e1) {
                e1.printStackTrace();
                }

        DatagramPacket packet = new DatagramPacket(sendData, sendData.length, serverAddr, SERVERPORT);

        try {
                DatagramSocket socket = new DatagramSocket();

                while(bKeepRunning)
                {
                    socket.send(packet);
                }
            }catch (Exception e) {
                }
    }

    public void kill() 
    { 
        bKeepRunning = false;
    }


}   


public void addListenerOnButton() {

     final Context context = this;

     button = (Button) findViewById(R.id.button1);

     button.setOnClickListener(new OnClickListener() {

     @Override
     public void onClick(View arg0) {

     Intent intent = new Intent(context, SecondActivity.class);
     startActivity(intent);

     }

     });
 }

@Override
public boolean onCreateOptionsMenu(Menu menu) {

    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.settings, menu);

    return super.onCreateOptionsMenu(menu);
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {

    case R.id.menu_settings:
        Intent i = new Intent(this, UserSettingActivity.class);
        startActivityForResult(i, RESULT_SETTINGS);
        break;


    case R.id.about_us:
        Intent j = new Intent(this, UserSettings.class);
        startActivityForResult(j, RESULT_SETTINGS);
        break;

    }

    return true;
}

protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    switch (requestCode) {
    case RESULT_SETTINGS:
        showUserSettings();
        break;

    }

}



public void showUserSettings() {
    SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);

    StringBuilder builder = new StringBuilder();

    builder.append("\n IP Address: " + sharedPrefs.getString("prefipaddress", "NULL"));

    builder.append("\n Port: " + sharedPrefs.getString("prefport", "NULL"));

    TextView settingsTextView = (TextView) findViewById(R.id.textUserSettings);

    settingsTextView.setText(builder.toString());

        }

protected void onResume() {
    super.onResume();
    mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_GAME);
    client = new Client();
    client.start();

}

protected void onPause() {
    super.onPause();
    mSensorManager.unregisterListener(this);
    client.kill();
}

public static class angles
{
     static int rolling;
     static int pitching;
}

@Override
public void onSensorChanged(SensorEvent event) {

    // TODO Auto-generated method stub

    final float alpha = (float) 0.9;
    float[] gravity = new float[3];
    float[] linear_acceleration = new float[3];

    TextView tvX= (TextView)findViewById(R.id.roll);
    TextView tvY= (TextView)findViewById(R.id.pitch);


    gravity[0] = alpha * gravity[0] + (1 - alpha) * event.values[0];
    gravity[1] = alpha * gravity[1] + (1 - alpha) * event.values[1];
    gravity[2] = alpha * gravity[2] + (1 - alpha) * event.values[2];

    linear_acceleration[0] = event.values[0] - gravity[0];
    linear_acceleration[1] = event.values[1] - gravity[1];
    linear_acceleration[2] = event.values[2] - gravity[2];

    String linear_acceleration0 = String.format("%.2f", linear_acceleration[0]).replace(",",".");
    String linear_acceleration1 = String.format("%.2f", linear_acceleration[1]).replace(",",".");
    String linear_acceleration2 = String.format("%.2f", linear_acceleration[2]).replace(",",".");

    linear_acceleration[0] = Float.parseFloat(linear_acceleration0);
    linear_acceleration[1] = Float.parseFloat(linear_acceleration1);
    linear_acceleration[2] = Float.parseFloat(linear_acceleration2);


    //float rotation = (float) (Math.atan2(linear_acceleration[0], linear_acceleration[1])/(Math.PI/180));

    float roll = (float) Math.toDegrees(Math.atan(linear_acceleration[0]/Math.sqrt(Math.pow(linear_acceleration[1], 2) + Math.pow(linear_acceleration[2], 2))));
    float pitch = (float) Math.toDegrees(Math.atan(linear_acceleration[1]/Math.sqrt(Math.pow(linear_acceleration[0], 2) + Math.pow(linear_acceleration[2], 2))));
    float yaw = (float) Math.toDegrees(Math.atan(Math.sqrt(Math.pow(linear_acceleration[0], 2) + Math.pow(linear_acceleration[1], 2))/linear_acceleration[2]));

    String roll_print = String.format("%.2f", roll);
    String pitch_print = String.format("%.2f", pitch);
    roll_print = roll_print.replace(",",".");
    pitch_print = pitch_print.replace(",",".");

    angles.rolling = Math.round(roll);
    angles.pitching = Math.round(pitch);

    tvX.setText(roll_print);
    tvY.setText(pitch_print);

}



@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
    // TODO Auto-generated method stub

}


public static byte[] intToByteArray(int intValue, int intValue1) {

    ByteBuffer b = ByteBuffer.allocate(8);
    //b.order(ByteOrder..BIG_ENDIAN); // optional, the initial order of a byte buffer is always BIG_ENDIAN.
    b.putInt(intValue);
    b.putInt(intValue1);

    byte[] result = b.array();

    //for test
   int testnum= bytesToInt(result);
    System.out.println("reverse value is="+testnum);

return result;}

private static int bytesToInt(byte[] intBytes){
    ByteBuffer bb = ByteBuffer.wrap(intBytes);
    return bb.getInt();}

public byte[] reverseArray(byte[] arr)
{
     int left = 0;
     int right = arr.length - 1;
     while (left < right) {
          byte temp = arr[left];
          arr[left] = arr[right];
          arr[right] = temp;
          left++;
          right--;
     }
     return arr;}

}

公共类MainActivity扩展活动实现SensorEventListener{
按钮；
字符串theLine=null；
emulator内的公共静态最终字符串SERVERIP=“192.168.2.101”/“/”！
公共静态最终int服务器端口=12345；
私有静态最终整数结果_设置=1；
公共服务运营；
私人传感器管理器；
专用传感器mAccelerometer；
Client=null；
@凌驾
创建时的公共void（Bundle savedInstanceState）
{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
addListenerOnButton（）；
msSensorManager=（SensorManager）getSystemService（传感器服务）；
mAccelerometer=msSensorManager.getDefaultSensor（传感器类型\加速计）；
}
公共类客户端扩展线程
{
bKeepRunning=true；
@凌驾
公开募捐
{
字节[]sendData=新字节[512]；
sendData=intToByteArray（角度.滚动，角度.俯仰）；
sendData=reverseArray（sendData）；
inetAddressServerAddr=null；
试一试{
serverAddr=InetAddress.getByName（SERVERIP）；
}捕获（未知后异常e1）{
e1.printStackTrace（）；
}
DatagramPacket数据包=新的DatagramPacket（sendData，sendData.length，serverAddr，SERVERPORT）；
试一试{
DatagramSocket套接字=新DatagramSocket（）；
同时（运行时）
{
socket.send（包）；
}
}捕获（例外e）{
}
}
公共空杀（）
{ 
bKeepRunning=false；
}
}   
public void addListenerOnButton（）{
最终上下文=此；
按钮=（按钮）findViewById（R.id.button1）；
setOnClickListener（新的OnClickListener（）{
@凌驾
公共void onClick（视图arg0）{
意向意向=新意向（上下文，SecondActivity.class）；
星触觉（意向）；
}
});
}
@凌驾
公共布尔onCreateOptions菜单（菜单）{
MenuInflater充气机=getMenuInflater（）；
充气机。充气（右菜单。设置，菜单）；
返回super.onCreateOptions菜单（菜单）；
}
@凌驾
公共布尔值onOptionsItemSelected（菜单项项）{
开关（item.getItemId（））{
案例R.id.菜单\u设置：
Intent i=新Intent（这是UserSettingActivity.class）；
startActivityForResult（i，结果设置）；
打破
案例R.id.关于美国：
Intent j=新Intent（这是UserSettings.class）；
startActivityForResult（j，结果设置）；
打破
}
返回true；
}
受保护的void onActivityResult（int请求代码、int结果代码、意图数据）{
super.onActivityResult（请求代码、结果代码、数据）；
开关（请求代码）{
案例结果设置：
showUserSettings（）；
打破
}
}
public void showUserSettings（）{
SharedPreferences SharedPrefers=PreferenceManager.getDefaultSharedPreferences（此）；
StringBuilder=新的StringBuilder（）；
append（“\n IP地址：”+sharedPrefs.getString（“prefipaddress”，“NULL”））；
builder.append（“\n端口：”+sharedPrefs.getString（“预端口”，“空”））；
TextView设置TextView=（TextView）findViewById（R.id.textUserSettings）；
settingsTextView.setText（builder.toString（））；
}
受保护的void onResume（）{
super.onResume（）；
msSensorManager.registerListener（这是mAccelerometer、SensorManager.SENSOR\u DELAY\u游戏）；
client=新客户端（）；
client.start（）；
}
受保护的void onPause（）{
super.onPause（）；
mSensorManager.unregisterListener（此）；
client.kill（）；
}
公共静态类角度
{
静态轧制；
静态内俯仰；
}
@凌驾
传感器更改时的公共无效（传感器事件）{
//TODO自动生成的方法存根
最终浮动α=（浮动）0.9；
浮动[]重力=新浮动[3]；
浮动[]线性加速度=新浮动[3]；
TextView tvX=（TextView）findViewById（R.id.roll）；
TextView tvY=（TextView）findViewById（R.id.pitch）；
重力[0]=α*重力[0]+（1-α）*事件值[0]；
重力[1]=α*重力[1]+（1-α）*事件值[1]；
重力[2]=α*重力[2]+（1-α）*事件值[2]；
线性加速度[0]=事件值[0]-重力[0]；
线性加速度[1]=事件值[1]-重力[1]；
线性加速度[2]=事件值[2]-重力[2]；
字符串线性加速度0=String.format（“%.2f”，线性加速度[0]）。替换（“，”，”）；
字符串线性加速度1=String.format（“%.2f”，线性加速度[1]）。替换（“，”，”）；
String linear_acceleration2=String.format（“%.2f”，linear_acceleration[2]）。替换（“，”，”）；
线性加速[0]=浮点。解析浮点（线性加速0）；
线性加速度[1]=Float.parseFloat（线性加速度1）；
线性加速度[2]=Float.parseFloat（线性加速度2）；
//浮点旋转=（浮点）（数学atan2（线性加速度[0]，线性加速度[1]）/（数学PI/180））；
float roll=（float）Math.toDegrees（Math.atan（线性加速度[0]/Math.sqrt（Math.pow（线性加速度[1]，2）+Math.pow（线性加速度[2]，2））；
浮球俯仰=（浮球）数学toDegrees（数学atan（线性加速度[1]/数学sqrt（数学pow（线性加速度[0]，2）+数学pow（线性加速度[2]，2）））；
浮动偏航=（浮动）数学角度（数学角度）