当应用程序变为背景时，服务已停止

Question

嗨，项目中我正在使用服务进行使用SignalR的聊天通信。聊天通信工作正常，但是当应用程序被切换到后台的服务得到了停止我需要完全运行的服务，直到我的应用程序被删除

这里是我的服务代码

public class SignalRService extends Service { 
private HubConnection mHubConnection; 
private HubProxy mHubProxy; 
private Handler mHandler; // to display Toast message 
private final IBinder mBinder = new LocalBinder(); // Binder given to clients 

public SignalRService() { 
} 

@Override 
public void onCreate() { 
    super.onCreate(); 
    mHandler = new Handler(Looper.getMainLooper()); 
} 

@Override 
public int onStartCommand(Intent intent, int flags, int startId) { 
    int result = super.onStartCommand(intent, flags, startId); 
    startSignalR(); 
    return result; 
} 

@Override 
public void onDestroy() { 
    Log.i("onDestroy","onDestroy"); 
    mHubConnection.stop(); 
    super.onDestroy(); 
} 

@Override 
public IBinder onBind(Intent intent) { 
    // Return the communication channel to the service. 
    startSignalR(); 
    return mBinder; 
} 

/** 
* Class used for the client Binder. Because we know this service always 
* runs in the same process as its clients, we don't need to deal with IPC. 
*/ 
public class LocalBinder extends Binder { 
    public SignalRService getService() { 
     // Return this instance of SignalRService so clients can call public methods 
     return SignalRService.this; 
    } 
} 

/** 
* method for clients (activities) 
*/ 
public void sendMessage(String message) { 
    String SERVER_METHOD_SEND = "Send"; 
    mHubProxy.invoke(SERVER_METHOD_SEND, message); 
} 

/** 
* method for clients (activities) 
*/ 
public void sendMessage_To(String receiverName, String message) { 
    String SERVER_METHOD_SEND_TO = "SendChatMessage"; 
    mHubProxy.invoke(SERVER_METHOD_SEND_TO, receiverName, message); 
} 

private void startSignalR() { 
    Platform.loadPlatformComponent(new AndroidPlatformComponent()); 
    Credentials credentials = new Credentials() { 
     @Override 
     public void prepareRequest(Request request) { 
      request.addHeader("User-Name", "BNK"); 
     } 
    }; 

    String serverUrl = "http://10.10.10.180/signalr/hubs"; 
    mHubConnection = new HubConnection(serverUrl); 
    mHubConnection.setCredentials(credentials); 
    String SERVER_HUB_CHAT = "ChatHub"; 
    mHubProxy = mHubConnection.createHubProxy(SERVER_HUB_CHAT); 
    ClientTransport clientTransport = new ServerSentEventsTransport(mHubConnection.getLogger()); 
    SignalRFuture<Void> signalRFuture = mHubConnection.start(clientTransport); 

    try { 
     signalRFuture.get(); 
    } catch (InterruptedException | ExecutionException e) { 
     Log.e("SimpleSignalR", e.toString()); 
     return; 
    } 

    sendMessage("Hello from BNK!"); 

    String CLIENT_METHOD_BROADAST_MESSAGE = "broadcastMessage"; 
    mHubProxy.on(CLIENT_METHOD_BROADAST_MESSAGE, 
      new SubscriptionHandler1<CustomMessage>() { 
       @Override 
       public void run(final CustomMessage msg) { 
        final String finalMsg = msg.UserName + " says " + msg.Message; 
        // display Toast message 
        mHandler.post(new Runnable() { 
         @Override 
         public void run() { 
          Log.i("message","message: "+finalMsg); 
          Toast.makeText(getApplicationContext(), finalMsg, Toast.LENGTH_SHORT).show(); 
         } 
        }); 
       } 
      } 
      , CustomMessage.class); 
}} 

这里是活动代码

public class MainActivity extends AppCompatActivity { 

private final Context mContext = this; 
private SignalRService mService; 
private boolean mBound = false; 

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

    Intent intent = new Intent(); 
    intent.setClass(mContext, SignalRService.class); 
    bindService(intent, mConnection, Context.BIND_AUTO_CREATE); 
} 

@Override 
protected void onStop() { 
    // Unbind from the service 
    Log.i("onStop","onStop"); 
    if (mBound) { 
     unbindService(mConnection); 
     mBound = false; 
    } 
    super.onStop(); 
} 

public void sendMessage(View view) { 
    if (mBound) { 
     // Call a method from the SignalRService. 
     // However, if this call were something that might hang, then this request should 
     // occur in a separate thread to avoid slowing down the activity performance. 
     EditText editText = (EditText) findViewById(R.id.edit_message); 
     EditText editText_Receiver = (EditText) findViewById(R.id.edit_receiver); 
     if (editText != null && editText.getText().length() > 0) { 
      String receiver = editText_Receiver.getText().toString(); 
      String message = editText.getText().toString(); 
      mService.sendMessage_To(receiver, message); 
      mService.sendMessage(message); 
     } 
    } 
} 

/** 
* Defines callbacks for service binding, passed to bindService() 
*/ 
private final ServiceConnection mConnection = new ServiceConnection() { 

    @Override 
    public void onServiceConnected(ComponentName className, 
            IBinder service) { 
     // We've bound to SignalRService, cast the IBinder and get SignalRService instance 
     SignalRService.LocalBinder binder = (SignalRService.LocalBinder) service; 
     mService = binder.getService(); 
     mBound = true; 
    } 

    @Override 
    public void onServiceDisconnected(ComponentName arg0) { 

     Log.i("onServiceDisconnected","onServiceDisconnected"); 

     mBound = false; 
    } 
};} 

我的服务

<service 
     android:name=".SignalRService" 
     android:enabled="true" 
     android:exported="true" > 
    </service> 

PL代码清单ese帮我解决这个问题

Answer 1

如果你绑定了服务和任何组件，系统将自动销毁服务，如果没有其他客户绑定它。

如果要独立运行服务，则必须启动服务而不是绑定。但你不能用，如果你有startService()

启动有关详细信息，你可以看到文档here

Answer 2

你既可以启动并绑定该服务的服务进行通信。

以这种方式，即使多个组件一次绑定到服务，那么它们全部解除绑定，服务将会销毁NOT。请参考

您的服务可以双向工作：它可以启动（无限期运行）并允许绑定。这仅仅是您是否实现了一对回调方法的问题：onStartCommand（）允许组件启动它，onBind（）允许绑定。

// onBind method just return the IBinder, to allow clients to get service. 
@Override 
public IBinder onBind(Intent intent) { 
    return mBinder; 
} 

// onStartCommand just return START_STICKY to let system to 
// try to re-create the service if the servcie's process is killed. 
@Override 
public int onStartCommand(Intent intent, int flags, int startId) { 
    return START_STICKY; 
} 

// and make startSignalR public to allow client to call this method. 
public void startSignalR() { 
} 

在你的客户，没有必要保持一个布尔mBound。

只需绑定服务onCreate，解除服务时onDestroy。当onStop时不要解除绑定。由于onStop可能会多次调用，例如对话框弹出将调用onStop，但是您的活动仍处于前台，这会导致您的服务被破坏。

有关示例代码，请参阅my answer for question: Pass Service From one Activity to Another。