Node.js服务器未从Android应用程序接收套接字

我编写了Android应用程序，当传感器状态发生变化时，它会将套接字推送到Node.js服务器。我在三部手机上进行了测试：

• acer液体e1（加速度计、磁强计）
• 联想p770（加速计）
• 三星galaxy core（加速度计、磁强计）

对于我看到的Andriod应用程序日志中的所有三部手机，该应用程序都正确地获取了方向和旋转矩阵的数据，并且socket.emit也被按下。但acer服务器根本没有接收套接字。我试着在联想上启动我的应用程序——那里的服务器没有问题，但联想没有磁强计。在那之后，我决定在第三部手机三星上测试我的应用程序，神秘的事情就在那里开始了：服务器不时地接收插座。而且我对应用程序和服务器什么都不做，只是等待和观察。我找不到原因，为什么它会周期性地工作

这是我的服务器代码：

var express = require('express');
var app = express.createServer(express.logger()); 
var net = require('net');
app.use(express.static(__dirname + '/public'));
var io = require('socket.io').listen(app);

var viewer;
var reader;

io.sockets.on('connection', function (socket) {
    // Find out who connecting client is.
    socket.emit('whoIs', "");

    socket.on('iAm', function(data) {
        console.log("the connecting client is: " + data);
        switch (data) {
            case 'viewer':
                viewer = socket;
                break;
            case 'reader':
                reader = socket;
                socket.on('sensorChanged', function(time, r0, r1, r2, r3, r4, r5, r6, r7, r8, o0, o1, o2) {
                    if (viewer) {
                        viewer.emit('sensorChanged', time, r0, r1, r2, r3, r4, r5, r6, r7, r8, o0, o1, o2);
                    }
                });
                socket.on('repDetected', function(time) {
                    if (viewer) {
                        viewer.emit('repDetected', time);
                    }
                });
                break;
            default:
                console.log('Got a client of unknown type. type="' + data + '"');
        }
    });
});

if (!Array.prototype.remove) {
    Array.prototype.remove = function(from, to) {
        var rest = this.slice((to || from) + 1 || this.length);
        this.length = from < 0 ? this.length + from : from;
        return this.push.apply(this, rest);
    };
}

if (!Array.prototype.forEach) {
    Array.prototype.forEach = function(fun /*, thisp*/) {
        var len = this.length;
        if (typeof fun != "function")
            throw new TypeError();
        var thisp = arguments[1];
        for (var i = 0; i < len; i++) {
            if (i in this)
                fun.call(thisp, this[i], i, this);
        }
    };
}

var port = process.env.PORT || 3000;
app.listen(port, function() {
    console.log("Listening on " + port);
});

---

我做错了什么？为什么服务器接收用户名（函数名“public void on（字符串事件、IOAcknowledge ack、Object…args）”），但不接收数据（函数名“public void onSensorChanged（传感器事件）”）？对不起我的英语=(（

Offtopic:node.js/V8上的

数组不需要polyfill。forEach

是

套接字前面的代码。emit

命中调用？在调用之前添加一些

println

来找出答案。是的，它被调用了，我调试它并从传感器接收数据，因为rotationMatrix不是空的，您无法使用输出LastAccelerator和lastMagnetometer值

package com.cs.sensorsDataSender;

import io.socket.*;
import java.net.MalformedURLException;
import org.json.*;

import android.app.Activity;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.view.Menu;
import android.view.View;
import android.view.WindowManager;

public class MainActivity extends Activity implements IOCallback, SensorEventListener {

    private float[] lastAccelerometer = new float[3];
    private float[] lastMagnetometer = new float[3];
    private boolean lastAccelerometerSet = false;
    private boolean lastMagnetometerSet = false;

    private float[] rotationMatrix = new float[9];
    private float[] orientation = new float[3];

    private SensorManager sensorManager;
    private Sensor accelerometer;
    private Sensor magnetometer;

    SocketIO socket;
    private boolean emitEvents;

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

        sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);   
        accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        magnetometer = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);

        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

        try {
            socket = new SocketIO("http://192.168.1.21:3000");
            socket.connect(this);
        } catch (MalformedURLException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        emitEvents = false;
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    protected void onResume() {
        super.onResume();
        lastAccelerometerSet = false;
        lastMagnetometerSet = false;
        sensorManager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_GAME);
        sensorManager.registerListener(this, magnetometer, SensorManager.SENSOR_DELAY_NORMAL);
    }

    protected void onPause() {
        super.onPause();
        sensorManager.unregisterListener(this);
    }

    public void onAccuracyChanged(Sensor sensor, int accuracy) {
    }

    public void onSensorChanged(SensorEvent event) {
        if (emitEvents) {
            switch (event.sensor.getType()) {
                case Sensor.TYPE_ACCELEROMETER:
                    System.arraycopy(event.values, 0, lastAccelerometer, 0, event.values.length);
                    lastAccelerometerSet = true;
                    break;
                case Sensor.TYPE_MAGNETIC_FIELD:
                    System.arraycopy(event.values, 0, lastMagnetometer, 0, event.values.length);
                    lastMagnetometerSet = true;
                    break;
            }

            if (lastAccelerometerSet && lastMagnetometerSet) {
                SensorManager.getRotationMatrix(rotationMatrix, null, lastAccelerometer, lastMagnetometer);
                SensorManager.getOrientation(rotationMatrix, orientation);
                socket.emit(
                    "sensorChanged",
                    System.currentTimeMillis(),
                    rotationMatrix[0],
                    rotationMatrix[1],
                    rotationMatrix[2],
                    rotationMatrix[3],
                    rotationMatrix[4],
                    rotationMatrix[5],
                    rotationMatrix[6],
                    rotationMatrix[7],
                    rotationMatrix[8],
                    orientation[0],
                    orientation[1],
                    orientation[2]);
            }
        }
    }

    public void onMessage(JSONObject json, IOAcknowledge ack) {
        try {
            System.out.println("Server said:" + json.toString(2));
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    public void onMessage(String data, IOAcknowledge ack) {
        System.out.println("Server said: " + data);
    }

    public void onError(SocketIOException socketIOException) {
        System.out.println("an Error occured");
        socketIOException.printStackTrace();
    }

    public void onDisconnect() {
        System.out.println("Connection terminated.");
    }

    public void onConnect() {
        System.out.println("Connection established");
    }

    public void on(String event, IOAcknowledge ack, Object... args) {
        System.out.println("Server triggered event '" + event + "'");
        if (event.equals("whoIs")) {
            socket.emit("iAm", "reader");
        }
    }

    public void toggleEvents(View view) {
        emitEvents = !emitEvents;
        if (emitEvents) {
            System.out.println("Emitting events.");
        }
        else {
            System.out.println("Stopped emitting events.");
        }
    }
}