fai scorrere il dito per ignorare l'evento

Sto utilizzando una notifica Android per avvisare l'utente quando un servizio è terminato (successo o fallimento) e desidero eliminare i file locali una volta completato il processo.

Il mio problema è che, in caso di errore, desidero consentire all'utente un'opzione "riprova". e se sceglie di non riprovare e di ignorare la notifica, voglio eliminare i file locali salvati ai fini del processo (immagini ...).

C'è un modo per catturare l'evento di trascinamento della notifica per ignorare?

DeleteIntent : DeleteIntent è un oggetto PendingIntent che può essere associato a una notifica e viene attivato quando la notifica viene eliminata, ether da:

• Azione specifica dell'utente
• Utente Elimina tutte le notifiche.

È possibile impostare l'intenzione in sospeso su un ricevitore di trasmissione e quindi eseguire qualsiasi azione si desideri.

  Intent intent = new Intent(this, MyBroadcastReceiver.class);
  PendingIntent pendingIntent = PendingIntent.getBroadcast(this.getApplicationContext(), 0, intent, 0);
  Builder builder = new Notification.Builder(this):
 ..... code for your notification
  builder.setDeleteIntent(pendingIntent);

MyBroadcastReceiver

public class MyBroadcastReceiver extends BroadcastReceiver {
      @Override
      public void onReceive(Context context, Intent intent) {
             .... code to handle cancel
         }

  }

Una risposta completamente svuotata (con grazie a Mr. Me per la risposta):

1) Crea un ricevitore per gestire l'evento di scorrimento per ignorare:

public class NotificationDismissedReceiver extends BroadcastReceiver {
  @Override
  public void onReceive(Context context, Intent intent) {
      int notificationId = intent.getExtras().getInt("com.my.app.notificationId");
      /* Your code to handle the event here */
  }
}

2) Aggiungi una voce al tuo manifest:

<receiver
    android:name="com.my.app.receiver.NotificationDismissedReceiver"
    android:exported="false" >
</receiver>

3) Crea l'intento in sospeso utilizzando un ID univoco per l'intento in sospeso (l'ID di notifica viene utilizzato qui) poiché senza questo gli stessi extra verranno riutilizzati per ogni evento di licenziamento:

private PendingIntent createOnDismissedIntent(Context context, int notificationId) {
    Intent intent = new Intent(context, NotificationDismissedReceiver.class);
    intent.putExtra("com.my.app.notificationId", notificationId);

    PendingIntent pendingIntent =
           PendingIntent.getBroadcast(context.getApplicationContext(), 
                                      notificationId, intent, 0);
    return pendingIntent;
}

4) Crea la tua notifica:

Notification notification = new NotificationCompat.Builder(context)
              .setContentTitle("My App")
              .setContentText("hello world")
              .setWhen(notificationTime)
              .setDeleteIntent(createOnDismissedIntent(context, notificationId))
              .build();

NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.notify(notificationId, notification);

Un'altra idea:

se crei normalmente una notifica hai bisogno anche delle azioni uno, due o tre di esse. Ho creato un "NotifyManager" che crea tutte le notifiche di cui ho bisogno e riceve anche tutte le chiamate Intent. Quindi posso gestire tutte le azioni E anche la cattura dell'evento di licenziamento in UN posto.

public class NotifyPerformService extends IntentService {

@Inject NotificationManager notificationManager;

public NotifyPerformService() {
    super("NotifyService");
    ...//some Dagger stuff
}

@Override
public void onHandleIntent(Intent intent) {
    notificationManager.performNotifyCall(intent);
}

per creare il deleteIntent usa questo (nel NotificationManager):

private PendingIntent createOnDismissedIntent(Context context) {
    Intent          intent          = new Intent(context, NotifyPerformMailService.class).setAction("ACTION_NOTIFY_DELETED");
    PendingIntent   pendingIntent   = PendingIntent.getService(context, SOME_NOTIFY_DELETED_ID, intent, 0);

    return pendingIntent;
}

e CHE utilizzo per impostare l'intento di eliminazione in questo modo (nel NotificationManager):

private NotificationCompat.Builder setNotificationStandardValues(Context context, long when){
    String                          subText = "some string";
    NotificationCompat.Builder      builder = new NotificationCompat.Builder(context.getApplicationContext());


    builder
            .setLights(ContextUtils.getResourceColor(R.color.primary) , 1800, 3500) //Set the argb value that you would like the LED on the device to blink, as well as the rate
            .setAutoCancel(true)                                                    //Setting this flag will make it so the notification is automatically canceled when the user clicks it in the panel.
            .setWhen(when)                                                          //Set the time that the event occurred. Notifications in the panel are sorted by this time.
            .setVibrate(new long[]{1000, 1000})                                     //Set the vibration pattern to use.

            .setLargeIcon(BitmapFactory.decodeResource(context.getResources(), R.mipmap.ic_launcher))
            .setSmallIcon(R.drawable.ic_white_24dp)
            .setGroup(NOTIFY_GROUP)
            .setContentInfo(subText)
            .setDeleteIntent(createOnDismissedIntent(context))
    ;

    return builder;
}

e infine nello stesso NotificationManager c'è la funzione perform:

public void performNotifyCall(Intent intent) {
    String  action  = intent.getAction();
    boolean success = false;

    if(action.equals(ACTION_DELETE)) {
        success = delete(...);
    }

    if(action.equals(ACTION_SHOW)) {
        success = showDetails(...);
    }

    if(action.equals("ACTION_NOTIFY_DELETED")) {
        success = true;
    }


    if(success == false){
        return;
    }

    //some cleaning stuff
}