Android 关于后台杀死App之后改变服务器状态的一些尝试

前言：

　　如题，我的需求是：我需要在App在后台运行（未退出），调出最近运行记录，杀死App服务时，程序能够向服务器发送一条指令，以此达到我想要的目的。

　　Android方面刚刚才开始玩，我一开始想的是可不可以在Activity中监听到，比如onDestroy()方法，但是打Log看了之后是没有的。度娘是万能的，百度一波后，我在逼乎上找到了另一个思路，那就是创建一个Server，很多人的博客中也都指出了，App在后台被杀死时，Service的onTaskRemoved()方法是可以监听到的。

Service的onTaskRemoved()监听App在后台被杀死：

　　首先，一个Service类是必要的，其中onTaskRemoved()中的Http请求就是我需要跟服务器的交互

 package com.example.demo02;

 import android.app.Service;
 import android.content.Intent;
 import android.content.res.Configuration;
 import android.os.IBinder;
 import android.support.annotation.Nullable;
 import android.util.Log;

 import com.example.http.UserHttpClientUtil;

 public class SimpleService extends Service {
     private static final String TAG = "SimpleService";

     /**
      * 绑定服务时才会调用
      * 必须要实现的方法
      * @param intent
      * @return
      */
     @Nullable
     @Override
     public IBinder onBind(Intent intent) {
         Log.d(TAG, "onBind: ");
         return null;
     }

     /**
      * 首次创建服务时，系统将调用此方法来执行一次性设置程序（在调用 onStartCommand() 或 onBind() 之前）。
      * 如果服务已在运行，则不会调用此方法。该方法只被调用一次
      */
     @Override
     public void onCreate() {
         super.onCreate();
     }

     /**
      * 每次通过startService()方法启动Service时都会被回调。
      * @param intent
      * @param flags
      * @param startId
      * @return
      */
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
         return START_STICKY;
     }

     /**
      * 服务销毁时的回调
      */
     @Override
     public void onDestroy() {
         super.onDestroy();
     }

     @Override
     public void onStart(Intent intent, int startId) {
         super.onStart(intent, startId);
     }

     @Override
     public void onConfigurationChanged(Configuration newConfig) {
         super.onConfigurationChanged(newConfig);
     }

     @Override
     public void onLowMemory() {
         super.onLowMemory();
     }

     @Override
     public void onTrimMemory(int level) {
         super.onTrimMemory(level);
     }

     @Override
     public boolean onUnbind(Intent intent) {
         return super.onUnbind(intent);
     }

     @Override
     public void onRebind(Intent intent) {
         super.onRebind(intent);
         Log.d(TAG, "onRebind: ");
     }

     @Override
     public void onTaskRemoved(Intent rootIntent) {
         super.onTaskRemoved(rootIntent);
         new Thread(new Runnable() {
             @Override
             public void run() {
                 UserHttpClientUtil.exitCurrentAccount(LoginActivity.userInfoMapContextCache.get("userNo"));
             }
         }).start();
     }

 }

　　然后，在Activity中启动它

 intent = new Intent(this, SimpleService.class);
 getApplicationContext().startService(intent);

　　AndroidManifest.xml中

 <service
    android:name=".SimpleService"
    android:enabled="true"
    android:exported="true">
    <intent-filter>
       <action android:name="com.example.demo02.AndroidApplication.intentService" />
    </intent-filter>
 </service>

　　但是，我在测试的发现这种监听好像并不稳定，有时是可以监听到的，有时又监听不到，这肯定是不行的。（老式的Android是长按Home间调出最近运行记录，但是新式的Android并不是这样了，我不知道是不是这方面的原因）后来我又尝试重写Application，在Application中启动Service

 package com.example.demo02;

 import android.app.Application;
 import android.content.res.Configuration;
 import android.util.Log;

 import com.example.common.DefaultExceptionHandler;
 import com.example.common.MyLifecycleHandler;
 import com.example.http.UserHttpClientUtil;

 import static com.example.demo02.LoginActivity.userInfoMapContextCache;

 public class AndroidApplication extends Application {
     private static AndroidApplication instance;
     private static final String TAG = "AndroidApplication";
     @Override
     public void onCreate() {
         super.onCreate();
         instance = this;
         Intent intentService = new Intent(this, SimpleService.class);
         getApplicationContext().startService(intentService);
     }

     public static AndroidApplication getInstance(){
         return instance;
     }
 }

　　但是结果仍然是一样的

　　执念：我始终认为这一种方法是可行的，可能是我哪一方面写的有问题，如果有大神看出，望指正，不胜感激。

　　这种方法暂时是走不通了，但是问题总是要解决的。经过一番思考，想出了一个上不得台面的方法：我其实需要的是在App在后台被杀死的情况下（非程序崩溃），改变一下用户的状态，那么我可不可以在程序中监听App处于前台还是后台，当处于前台时，每进入一个页面，我都更新一下状态为在线（这是为了无论从哪个页面进入后台，App再次进入前台时，状态都能够更新，这个可以在ActivityLifecycleCallbacks的onActivityResumed()方法中实现），当App位于后台运行时，我就更新状态为离线（我使用了Application中的onTrimMemory()方法来实现）。

一条小路：

　　首先，需要判断一个App处于前台还是后台

 package com.example.common;

 import android.app.Activity;
 import android.app.Application;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Message;
 import android.widget.Toast;

 import com.example.demo02.LoginActivity;
 import com.example.http.UserHttpClientUtil;

 import java.util.HashMap;
 import java.util.Map;

 import static com.example.demo02.LoginActivity.userInfoMapContextCache;

 /**
  * 判断一个App处于前台还是后台
  */
 public class MyLifecycleHandler implements Application.ActivityLifecycleCallbacks{

     private static int resumed;
     private static int paused;
     private static int started;
     private static int stopped;

     @Override
     public void onActivityCreated(Activity activity, Bundle bundle) {

     }

     @Override
     public void onActivityStarted(Activity activity) {
         ++started;
     }

     private Map<String, String> UpdateCurrentAccountMap = new HashMap<>();
     private Context context;
     @Override
     public void onActivityResumed(Activity activity) {
         ++resumed;
         context = activity.getApplicationContext();
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if (userInfoMapContextCache.get("userNo") != null && userInfoMapContextCache.get("userNo") != "") {
                     UpdateCurrentAccountMap = UserHttpClientUtil.UpdateCurrentAccount(userInfoMapContextCache.get("userNo"));
                     loginHandler.sendEmptyMessage(0);
                 }
             }
         }).start();
     }

     private Handler loginHandler = new Handler(){
         @Override
         public void handleMessage(Message msg) {
             if (!UpdateCurrentAccountMap.get("lastLoginTime").equals(userInfoMapContextCache.get("lastLoginTime"))) {
                 userInfoMapContextCache.clear();
                 Intent intent = new Intent(context, LoginActivity.class);
                 intent.putExtra("isAccountReset", "true");
                 context.startActivity(intent);
                 Toast.makeText(context, "当前账号已经在其他地方登陆，请重新登陆！", Toast.LENGTH_SHORT).show();
             }
         }
     };

     @Override
     public void onActivityPaused(Activity activity) {
         ++paused;
     }

     @Override
     public void onActivityStopped(Activity activity) {
         ++stopped;
     }

     @Override
     public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {

     }

     @Override
     public void onActivityDestroyed(Activity activity) {

     }

     public static boolean isApplicationVisible() {
         return started > stopped;
     }

     public static boolean isApplicationInForeground() {
         // 当所有 Activity 的状态中处于 resumed 的大于 paused 状态的，即可认为有Activity处于前台状态中
         return resumed > paused;
     }
 }

　　然后，重写Application

 package com.example.demo02;

 import android.app.Application;
 import android.content.res.Configuration;
 import android.util.Log;

 import com.example.common.DefaultExceptionHandler;
 import com.example.common.MyLifecycleHandler;
 import com.example.http.UserHttpClientUtil;

 import static com.example.demo02.LoginActivity.userInfoMapContextCache;

 public class AndroidApplication extends Application {
     private static AndroidApplication instance;
     private static final String TAG = "AndroidApplication";
     @Override
     public void onCreate() {
         super.onCreate();
         instance = this;
         registerActivityLifecycleCallbacks(new MyLifecycleHandler());
     }

     public static AndroidApplication getInstance(){
         return instance;
     }

     @Override
     public void onTrimMemory(int level) {
         super.onTrimMemory(level);
         if (!MyLifecycleHandler.isApplicationInForeground()) {
             new Thread(new Runnable() {
                 @Override
                 public void run() {
                     if (userInfoMapContextCache.get("userNo") != null && userInfoMapContextCache.get("userNo") != "") {
                         UserHttpClientUtil.exitCurrentAccount(userInfoMapContextCache.get("userNo"));
                     }
                 }
             }).start();
         }
     }

     @Override
     public void onLowMemory() {
         super.onLowMemory();
         Log.d(TAG, "onLowMemory: ");
     }

     @Override
     public void onTerminate() {
         super.onTerminate();
         Log.d(TAG, "onTerminate: ");
     }

     @Override
     public void onConfigurationChanged(Configuration newConfig) {
         super.onConfigurationChanged(newConfig);
         Log.d(TAG, "onConfigurationChanged: ");
     }
 }

　　不要忘记将你重写的Application在AndroidManifest中说明

<application
        android:name=".AndroidApplication"

　　但是这种方法有一个坏处，就是在调用系统相机或者相册时，App也是出于后台的，这跟当初的设计理念不符

最后:

　　我感觉Android应该是有监听到App在后台被杀死的方法的，我问了老板和一些搞Android的兄弟，都没有得到想要的答案，如果有大神知晓，望告知，不胜感激！！！