Android 从多任务面板删除应用程序时取消通知

我管理来自我的应用程序（而非服务）的持续通知

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

当我使用“结束”按钮从任务管理器中终止应用程序时，通知消失

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

当我从多任务窗格中删除应用程序时，应用程序将被终止，但通知仍保留

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

我的问题是：

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

• 如何捕获此事件以清除通知
• 当应用程序从多任务窗格中删除时会发生什么？应用程序已销毁，但进程仍处于活动状态？这正常吗

---

作为更新：

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

所有my activities都使用以下方法扩展MyActivity类（扩展Activity）：

@Override protected void onCreate(Bundle state) {
    super.onCreate(state);
    ((MyApplication) getApplication()).onActivityCreate(this, state);
}

@Override protected void onDestroy() {
    super.onDestroy();
    ((MyApplication) getApplication()).onActivityDestroy(this);
}

private List<Activity> activities = new ArrayList<Activity>();

protected final void onActivityCreate(Activity activity, Bundle state) {
    if(activities.isEmpty() && state == null) {
        onStart();
    }
    activities.add(activity);
}

protected final void onActivityDestroy(Activity activity) {
    activities.remove(activity);
    if(activities.isEmpty() && activity.isFinishing()) {
        onExit();
    }
}

protected void onStart() {
    // some code
}

protected void onExit() {
    // some code
    notificationManager.cancel(NOTIFICATION_ID);
}

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

我的应用程序使用以下方法扩展了MyApplication类（它扩展了应用程序）：

@Override protected void onCreate(Bundle state) {
    super.onCreate(state);
    ((MyApplication) getApplication()).onActivityCreate(this, state);
}

@Override protected void onDestroy() {
    super.onDestroy();
    ((MyApplication) getApplication()).onActivityDestroy(this);
}

private List<Activity> activities = new ArrayList<Activity>();

protected final void onActivityCreate(Activity activity, Bundle state) {
    if(activities.isEmpty() && state == null) {
        onStart();
    }
    activities.add(activity);
}

protected final void onActivityDestroy(Activity activity) {
    activities.remove(activity);
    if(activities.isEmpty() && activity.isFinishing()) {
        onExit();
    }
}

protected void onStart() {
    // some code
}

protected void onExit() {
    // some code
    notificationManager.cancel(NOTIFICATION_ID);
}

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

少量日志两次出现一次，而不是全部（例如：13/100）

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

所以，我知道从多任务面板中删除应用程序会强制终止应用程序，而不必等待关闭方法结束并正确完成。。。但为什么不处理呢

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

---

如何强制正确终止？

在主应用程序被终止时终止通知。

ServiceConnection mConnection = new ServiceConnection() {
    public void onServiceConnected(ComponentName className,
            IBinder binder) {
        ((KillBinder) binder).service.startService(new Intent(
                MainActivity.this, KillNotificationsService.class));
        Notification notification = new Notification(
                R.drawable.ic_launcher, "Text",
                System.currentTimeMillis());
        Intent notificationIntent = new Intent(MainActivity.this,
                Place.class);
        PendingIntent contentIntent = PendingIntent.getActivity(
                MainActivity.this, 0, notificationIntent, 0);
        notification.setLatestEventInfo(getApplicationContext(),
                "Text", "Text", contentIntent);
        NotificationManager mNM = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
        mNM.notify(KillNotificationsService.NOTIFICATION_ID,
                notification);
    }

    public void onServiceDisconnected(ComponentName className) {
    }

};
bindService(new Intent(MainActivity.this,
        KillNotificationsService.class), mConnection,
        Context.BIND_AUTO_CREATE);

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

由于您的通知和应用程序在不同的线程中处理，因此通过MultitaskManager终止应用程序不会终止您的通知。正如您已经正确调查过的那样，终止应用程序甚至不一定会导致onExit（）回调

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

那么解决方案是什么？

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

你可以从你的活动开始一项服务。一个特殊的服务是：如果应用程序进程由于某种原因被终止，它们会自动重启。因此，您可以通过取消重启时的通知来重用自动重启

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

步骤1创建一个终止服务 简单的一个。它只是在创建时终止了一个通知，并有他的特殊活页夹

public class KillNotificationsService extends Service {

    public class KillBinder extends Binder {
        public final Service service;

        public KillBinder(Service service) {
            this.service = service;
        }

    }

    public static int NOTIFICATION_ID = 666;
    private NotificationManager mNM;
    private final IBinder mBinder = new KillBinder(this);

    @Override
    public IBinder onBind(Intent intent) {
            return mBinder;
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
            return Service.START_STICKY;
    }
    @Override
    public void onCreate() {
            mNM = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
            mNM.cancel(NOTIFICATION_ID);
    }
}

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

步骤2：将其添加到您的清单中： 将其添加到标签之间的某个位置

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

---

重新启动服务可能需要一点时间（1-5秒），但它最终会启动并终止通知。

您应该创建类扩展应用程序并注册活动回调，当您从多任务面板关闭应用程序时，会调用该回调

    public class MyApplication extends Application {



@Override
    public void onCreate() {
        super.onCreate();
        registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
            @Override
            public void onActivityCreated(Activity activity, Bundle bundle) {
            }

        @Override
        public void onActivityStarted(Activity activity) {
        }

        @Override
        public void onActivityResumed(Activity activity) {
        }

        @Override
        public void onActivityPaused(Activity activity) {
        }

        @Override
        public void onActivityStopped(Activity activity) {
        }

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

        @Override
        public void onActivityDestroyed(Activity activity) {
            if (/*check is all your activities onStop state*/) {
                NotificationManager mNM = (NotificationManager)              getSystemService(NOTIFICATION_SERVICE);
                mNM.cancel(R.id.key_notification_id);
            }
        }
    });
}

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

---

}

冰激凌三明治（API-14）中引入了将应用程序从最近的应用程序列表中删除的功能

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

对于相同的Android版本，我们在“Android.app.Service”中收到了一个特殊的方法“onTaskRemoved（）。当应用程序从最近的应用程序列表中删除时，将调用该函数

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

所以，如果您正在运行任何服务，只需重写“onTaskRemoved（）”方法即可满足您的需求

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

例如：

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

---

或者简单地编写并启动特殊服务来管理相同的问题。

我自己也有同样的问题，但我设法解决了它

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

这就是我所做的

 public class Sample extends Activity {

 private static final String APP_NOTIFICATION_TAG = "sample";
 private static final int NOTIFICATION_ID = 24;
 private NotificationManager notificationManager;
 private Notification appNotification;

 private AppFinishedExecutingListener appFinishedExecutingListener;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // set the layout and other stuff goes here
    appFinishedExecutingListener.execute(this);
    new Thread() {
        @Override
        public void run() {
            try {
                appFinishedExecutingListener.get();
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        destroyActivityComponent();
                    }
                });
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }.start();

    setupNotification();
 }

 /*
 * Setup this app 
 */
private void setupNotification() {

    Intent intent = new Intent(getApplicationContext(), MainActivity.class);
    // make sure when the user click the notification, this will make sure it will resume the app
    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);

    // define the action should be performed if the user click the notification i.e. resume our app activity
    PendingIntent pIntent = PendingIntent.getActivity(getApplicationContext(), (int)System.currentTimeMillis(), intent, 0);

    // setup the look for this app on  a notification panel
    appNotification  = new NotificationCompat.Builder(this)
            .setContentTitle(getString(R.string.app_name))
            .setContentText("Currently listening to kiribati radio")
            .setSmallIcon(R.drawable.ic_notification_logo)
            .setContentIntent(pIntent)
            .setAutoCancel(true)
            .setOngoing(true).build()
            ;

    notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);

}

/*
 * Will add app notification when this activity is paused so the user can   
 * quickly access it or resume this activity easily
 */
private void addAppToNotificationP() {
    notificationManager.notify(APP_NOTIFICATION_TAG, NOTIFICATION_ID,   appNotification);
}

/*
 * This will remove the notification if this activity is resumed
 */
private void removeAppFromNotificationP() {
    notificationManager.cancel(APP_NOTIFICATION_TAG,NOTIFICATION_ID);
}

@Override
protected void onPause() {
    super.onPause();
    addAppToNotificationP();
}

@Override
protected void onResume() {
    super.onResume();
    removeAppFromNotificationP();

}

private void destroyActivityCompletely() {
    onResume();
    finish();
}



}

public class AppFinishedExecutingListener extends AsyncTask<MainActivity, Void, Boolean> {

    private MainActivity main_activity;

    @Override
    protected Boolean doInBackground(MainActivity... params) {
        main_activity = params[0];

        while(!main_activity.isFinishing()) {
            try {
                Thread.sleep(100);
                //Log.i(main_activity.TAG,"listening");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //main_activity.finish();


        return true;
    }


}

 var notificationManager = (NotificationManager)GetSystemService(NotificationService);
                notificationManager.Cancel(0);

公共类示例扩展活动{
私有静态最终字符串APP_NOTIFICATION_TAG=“sample”；
私有静态最终整数通知_ID=24；
私人通知经理通知经理；
私人通知；
私有AppFinishedExecutingListener AppFinishedExecutingListener；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
//设置布局和其他东西都在这里
appFinishedExecutingListener.execute（this）；
新线程（）{
@凌驾
公开募捐{
试一试{
appFinishedExecutingListener.get（）；
handler.post（新的Runnable（）{
@凌驾
公开募捐{
销毁活动组件（）；
}
});
}捕捉（中断异常e）{
e、 printStackTrace（）；
}捕获（执行例外）{
e、 printStackTrace（）；
}
}
}.start（）；
setupNotification（）；
}
/*
*安装此应用程序
*/
私有无效设置通知（）{
Intent Intent=新的Intent（getApplicationContext（），MainActivity.class）；
//确保当用户单击通知时，这将确保它将恢复应用程序
intent.setFlags（intent.FLAG_ACTIVITY_CLEAR_TOP | intent.FLAG_ACTIVITY_SINGLE_TOP）；
//定义如果用户单击通知，即恢复我们的应用程序活动，则应执行的操作
PendingEvent pIntent=PendingEvent.getActivity（getApplicationContext（），（int）System.currentTimeMillis（），intent，0）；
//在通知面板上设置此应用的外观
appNotification=new NotificationCompat.Builder（此）
.setContentTitle（getString（R.string.app_name））
.setContentText（“目前正在收听基里巴斯广播”）
.setSmallIcon（R.drawable.ic_通知_徽标）
.setContentIntent（pIntent）
.setAutoCancel（真）
.setContinuous（true）.build（）
;
notificationManager=（notificationManager）getSystemService（通知服务）；
}
/*
*将在暂停此活动时添加应用程序通知，以便用户可以
*快速访问或轻松恢复此活动
*/
私有void addAppToNotificationP（）{
notificationManager.notify（应用程序通知标签、通知ID、应用程序通知）；
}
/*
*如果恢复此活动，将删除通知
*/
私有void removeAppFromNotificationP（）{
notificationManager.cancel（应用程序通知标签、通知ID）；
}
@凌驾
受保护的void onPause（）{
super.onPause（）；
addAppToNotificationP（）；
}
@凌驾
受保护的void onResume（）{
super.onResume（）；
从notificationp（）中删除app；
}
私有无效销毁活动完全（）{
onResume（）；
完成（）；
}
}
公共类AppFinishedExecutingListener扩展异步任务{
私人主要活动主要活动；
@凌驾
受保护的布尔值doInBackground（主活动…参数）{
主_活动=参数[0]；
而（！main_activity.isFinishing（））{
尝试