Java Android:startService赢得'；无法启动目标服务

主活动应启动处理套接字通信的服务。这只是一个测试：

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    this.requestWindowFeature(Window.FEATURE_NO_TITLE);
    this.setContentView(R.layout.contacts_test);

    this.startService(new Intent(getApplicationContext(), WebSocketService.class));

    final WebSocketService service = WebSocketService.getInstance();

    service.runWhenConnected(new Runnable() {
        @Override
        public void run() {
            service.getWebSocket().emit("login", new Credentials("...", "..."));
        }
    });

    service.registerHandler("login successful", new WebSocketEventHandler() {
        @Override
        public void onEvent(WebSocket webSocket, Object... args) {
            Log.i("SOCKET-IO", "Login successful");
        }
    });
}

您可以在下面找到该服务的代码。但是在开始阅读之前，请注意控制流甚至不会到达服务构造函数或onCreate方法；这是我无法理解的事情。服务在清单中声明：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="org.gtd.test"
          android:versionCode="1"
          android:versionName="1.0">
    <uses-sdk android:minSdkVersion="15"/>

    <application android:label="@string/app_name" android:icon="@drawable/tmp">
        <activity android:name="MyActivity" android:label="@string/app_name" android:theme="@style/LightCustomTheme"> </activity>
        <activity android:name="PickersTestActivity" android:theme="@style/LightCustomTheme">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
        <activity android:name=".ContactsTestActivity" android:theme="@style/LightCustomTheme">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
        <service android:name="org.pickme.service.WebSocketService" android:enabled="true">
            <intent-filter>
                <action android:name="org.pickme.service.WebSocketService" />
            </intent-filter>
        </service>
    </application>

    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
</manifest>

我正在为socket.io使用Gotox java客户端。但是套接字甚至还没有启动，所以这不是问题所在（在服务之外使用它是可行的）

package org.pickme.service；
导入android.app.Service；
导入android.content.Intent；
导入android.os.IBinder；
导入android.util.Log；
导入io.socket.IOAcknowledge；
导入io.socket.IOCallback；
导入io.socket.SocketIO；
导入io.socket.SocketIOException；
导入org.json.JSONObject；
导入java.net.MalformedURLException；
导入java.util.ArrayList；
导入java.util.HashMap；
导入java.util.List；
导入java.util.Map；
公共类WebSocketService扩展服务{
私有静态最终字符串服务器\u终结点=”http://192.168.1.83:3000";
私有静态WebSocketService实例；
专用插座；
私人网袋插接器；
私有布尔初始化；
私有线程连接读取；
私有IOCallback-IOCallback；
私有可运行的connectHandler、disconnectHandler；
私有映射事件处理程序；
公共静态WebSocketService getInstance（）{
返回实例；
}
公共布尔值未连接（）{
返回套接字。断开连接（）；
}
公共布尔值已初始化（）{
返回初始化；
}
公共WebSocket getWebSocket（）{
回程振打器；
}
公共WebSocketService（）{
this.ioCallback=newcallbacksub（）；
this.eventHandlers=new HashMap（）；
}
@凌驾
公共IBinder onBind（意向）{
返回null；
}
@凌驾
public void onCreate（）{
super.onCreate（）；
this.initialized=false；
试一试{
this.socket=新的SocketIO（服务器\终端）；
this.initialized=true；
}捕获（格式错误）{
this.initialized=false；
返回；
}
this.initWrappers（）；
this.connectionThread.start（）；
WebSocketService.instance=this；
}
@凌驾
公共空间{
super.ondestory（）；
this.socket.disconnect（）；
WebSocketService.instance=null；
}
@凌驾
公共int onStartCommand（Intent Intent、int标志、int startId）{
返回开始时间；
}
私有void initWrappers（）{
final IOCallback callbackReference=this.IOCallback；
final SocketIO socketReference=this.socket；
this.socketWrapper=新的WebSocket（）{
@凌驾
public void emit（字符串事件、对象…参数）{
emit（事件，参数）；
}
@凌驾
公共空间断开连接（）{
socketReference.disconnect（）；
}
};
this.connectionThread=新线程（new Runnable（））{
@凌驾
公开募捐{
socketReference.connect（callbackReference）；
}
});
}
public void runOnConnect（Runnable connectHandler）{
this.connectHandler=connectHandler；
}
public void runndisconnect（可运行断开处理程序）{
this.disconnectHandler=disconnectHandler；
}
连接时公共无效运行（可运行可运行）{
if（this.isConnected（）&&（runnable！=null））
runnable.run（）；
其他的
此.runOnConnect（可运行）；
}
公共void注册表句柄（字符串事件，WebSocketEventHandler句柄）{
列表处理列表；
if（eventHandlers.containsKey（事件））
handlersList=eventHandlers.get（事件）；
其他的
put（event，handlersList=newarraylist（））；
handlersList.add（处理程序）；
}
public void unregisterHandler（字符串事件、WebSocketEventHandler处理程序）{
如果（！eventHandlers.containsKey（事件））
返回；
List handlersList=eventHandlers.get（事件）；
把手列表。移除（把手）；
}
公共void unregisterHandlers（字符串事件）{
如果（！eventHandlers.containsKey（事件））
返回；
List handlersList=eventHandlers.get（事件）；
eventHandlers.clear（）；
移除（事件）；
}
public void unregisterAllHandlers（）{
eventHandlers.clear（）；
}
私有类callbacksub实现IOCallback{
@凌驾
公共空间与断开连接（）{
if（WebSocketService.this.disconnectHandler！=null）
WebSocketService.this.disconnectHandler.run（）；
}
@凌驾
公共连接无效（）{
if（WebSocketService.this.connectHandler！=null）
WebSocketService.this.connectHandler.run（）；
}
@凌驾
消息上的公共void（字符串数据，IOAcknowledge ack）{}
@凌驾
消息上的公共void（JSONObject json，IOAcknowledge ack）{}
@凌驾
打开公共无效（字符串事件、IOAcknowledge确认、对象…args）{
如果（！WebSocketService.this.eventHandlers.containsKey（事件））{
Log.i（“WEBSOCKET-SERVICE”，事件+“未处理”）；
返回；
}
List handlers=WebSocketService.this.eventHandlers.get（事件）；
for（WebSocketEventHandler处理程序：处理程序）
package org.pickme.service;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
import io.socket.IOAcknowledge;
import io.socket.IOCallback;
import io.socket.SocketIO;
import io.socket.SocketIOException;
import org.json.JSONObject;

import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class WebSocketService extends Service {
    private static final String SERVER_ENDPOINT = "http://192.168.1.83:3000";

    private static WebSocketService instance;

    private SocketIO socket;
    private WebSocket socketWrapper;
    private boolean initialized;

    private Thread connectionThread;
    private IOCallback ioCallback;

    private Runnable connectHandler, disconnectHandler;
    private Map<String, List<WebSocketEventHandler>> eventHandlers;


    public static WebSocketService getInstance() {
        return instance;
    }

    public boolean isConnected() {
        return socket.isConnected();
    }

    public boolean isInitialized() {
        return initialized;
    }

    public WebSocket getWebSocket() {
        return socketWrapper;
    }


    public WebSocketService() {
        this.ioCallback = new CallbackStub();
        this.eventHandlers = new HashMap<String, List<WebSocketEventHandler>>();
    }


    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();

        this.initialized = false;

        try {
            this.socket = new SocketIO(SERVER_ENDPOINT);
            this.initialized = true;
        } catch (MalformedURLException e) {
            this.initialized = false;
            return;
        }

        this.initWrappers();
        this.connectionThread.start();

        WebSocketService.instance = this;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();

        this.socket.disconnect();
        WebSocketService.instance = null;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return START_STICKY;
    }

    private void initWrappers() {
        final IOCallback callbackReference = this.ioCallback;
        final SocketIO socketReference = this.socket;

        this.socketWrapper = new WebSocket() {
            @Override
            public void emit(String event, Object... args) {
                socketReference.emit(event, args);
            }

            @Override
            public void disconnect() {
                socketReference.disconnect();
            }
        };

        this.connectionThread = new Thread(new Runnable() {
            @Override
            public void run() {
                socketReference.connect(callbackReference);
            }
        });
    }


    public void runOnConnect(Runnable connectHandler) {
        this.connectHandler = connectHandler;
    }

    public void runOnDisconnect(Runnable disconnectHandler) {
        this.disconnectHandler = disconnectHandler;
    }

    public void runWhenConnected(Runnable runnable) {
        if (this.isConnected() && (runnable != null))
            runnable.run();
        else
            this.runOnConnect(runnable);
    }

    public void registerHandler(String event, WebSocketEventHandler handler) {
        List<WebSocketEventHandler> handlersList;

        if (eventHandlers.containsKey(event))
            handlersList = eventHandlers.get(event);
        else
            eventHandlers.put(event, handlersList = new ArrayList<WebSocketEventHandler>());

        handlersList.add(handler);
    }

    public void unregisterHandler(String event, WebSocketEventHandler handler) {
        if (!eventHandlers.containsKey(event))
            return;

        List<WebSocketEventHandler> handlersList = eventHandlers.get(event);
        handlersList.remove(handler);
    }

    public void unregisterHandlers(String event) {
        if (!eventHandlers.containsKey(event))
            return;

        List<WebSocketEventHandler> handlersList = eventHandlers.get(event);
        eventHandlers.clear();

        eventHandlers.remove(event);
    }

    public void unregisterAllHandlers() {
        eventHandlers.clear();
    }


    private class CallbackStub implements IOCallback {
        @Override
        public void onDisconnect() {
            if (WebSocketService.this.disconnectHandler != null)
                WebSocketService.this.disconnectHandler.run();
        }

        @Override
        public void onConnect() {
            if (WebSocketService.this.connectHandler != null)
                WebSocketService.this.connectHandler.run();
        }

        @Override
        public void onMessage(String data, IOAcknowledge ack) { }

        @Override
        public void onMessage(JSONObject json, IOAcknowledge ack) { }

        @Override
        public void on(String event, IOAcknowledge ack, Object... args) {
            if (!WebSocketService.this.eventHandlers.containsKey(event)) {
                Log.i("WEBSOCKET-SERVICE", event + " unhandled");
                return;
            }

            List<WebSocketEventHandler> handlers = WebSocketService.this.eventHandlers.get(event);

            for (WebSocketEventHandler handler : handlers)
                handler.onEvent(WebSocketService.this.socketWrapper, args);
        }

        @Override
        public void onError(SocketIOException socketIOException) {
            Log.e("SOCKET-IO", socketIOException.getMessage(), socketIOException);
        }
    }
}

final WebSocketService service = WebSocketService.getInstance();

service.runWhenConnected(...);

this.startService(new Intent(getApplicationContext(), WebSocketService.class));

final WebSocketService service = WebSocketService.getInstance();

    <service android:name="org.pickme.service.WebSocketService" android:enabled="true">
        <intent-filter>
            <action android:name="org.pickme.service.WebSocketService" />
        </intent-filter>
    </service>

Intent myIntent = new Intent(getApplicationContext(), WebSocketService.class));
myIntent.setAction("org.pickme.service.WebSocketService");
this.startService(myIntent);

    <service android:name="org.pickme.service.WebSocketService" android:enabled="true">
    </service>