Cliquer sur les Actions de Notification Android ne ferme pas le tiroir de Notification

si votre action est sous la forme d'une émission ou d'un service mais que vous avez l'intention que le tiroir de notification s'effondre, vous devez diffuser android.intention.action.CLOSE_SYSTEM_DIALOGS de votre onReceive. Ceci fermera manuellement le tiroir.

j'ai trouvé que lorsque vous utilisez les boutons d'action dans les notifications étendues, vous devez écrire du code supplémentaire et vous êtes plus contraint.

avant d'utiliser les notifications étendues, l'action par défaut dans la notification de téléchargement de mon fichier était de lancer une activité de vue sur le fichier. L'intention de la vue a été enveloppée par une intention de Chooser. Je ne pouvais pas utiliser une intention en attente pour le Chooser intention directement à partir de la notification Parce que le Chooser s'écraserait s'il n'y avait pas d'activité pour afficher le type de fichier. J'avais donc un émetteur qui démarrait le Chooser.

avec des notifications étendues, j'ai décidé de changer la notification de téléchargement de fichier, donc l'action par défaut est d'afficher l'activité de détails de fichier, avec des boutons d'action pour la vue et envoyer. Tel que noté par l'utilisateur 2536953, démarrer un récepteur de radiodiffusion à partir de la notification ne ferme pas le tiroir de notification. Sur la base de son information qu'une activité fermerait le tiroir, j'ai changé mon récepteur de radiodiffusion à une Notificationactivité sans aucune UI.

comme indiqué dans ce post comment rejeter Notification Android après action a été cliqué , un autre problème est que vous devez annuler manuellement votre notification lorsque l'utilisateur clique sur un bouton action. La notification n'est annulée automatiquement pour l'action par défaut. J'ai aussi ajouté du code dans NotificationActivity pour gérer cela.

Construction de la notification étendue avec les boutons view et send:

    NotificationCompat.Builder builder = new NotificationCompat.Builder(m_context).setAutoCancel(true);

    final PendingIntent contentIntent = DownloadedFileIntentUtils.buildPendingItemDetailIntent(m_context, item);
        builder.setContentIntent(contentIntent);

    PendingIntent viewIntent = DownloadedFileIntentUtils.buildNotificationActionIntent(m_context, Intent.ACTION_VIEW,
                m_context.getString(R.string.action_open), uri, MimeTypeUtil.getMimeType(item), id);
    builder.addAction(R.drawable.actionbar_open_with, m_context.getString(R.string.action_open), viewIntent);

    PendingIntent sendIntent = DownloadedFileIntentUtils.buildNotificationActionIntent(m_context, Intent.ACTION_SEND,
                m_context.getString(R.string.action_send), uri, MimeTypeUtil.getMimeType(item), id);
    builder.addAction(R.drawable.actionbar_share, m_context.getString(R.string.action_send), sendIntent);

    builder.setTicker(title)
    .setContentTitle(title)
    .setContentText(text)
    .setSmallIcon(R.drawable.notification_download);
    .setStyle(new NotificationCompat.BigTextStyle().bigText(text));

    getNotificationManager().notify(id, builder.build());

construction de l'intention de commencer une activité à partir des boutons d'action de notification:

    public static PendingIntent buildNotificationActionIntent(Context context, String action, String actionTitle, Uri uri,
        String mimeType, int notificationId) {
    // Build the file action intent (e.g. VIEW or SEND) that we eventually want to start.
    final Intent fileIntent = buildFileActionIntent(action, actionTitle, uri, mimeType);

    // Build the intent to start the NotificationActivity.
    final Intent notificationIntent = new Intent(context, NotificationActivity.class);
    // This flag must be set on activities started from a notification.
    notificationIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    // Pass the file action and notification id to the NotificationActivity.
    notificationIntent.putExtra(Intent.EXTRA_INTENT, fileIntent);
    notificationIntent.putExtra(IIntentCode.INTENT_EXTRA_NOTIFICATION_ID, notificationId);

    // Return a pending intent to pass to the notification manager.
    return PendingIntent.getActivity(context, s_intentCode.getAndIncrement(), notificationIntent, PendingIntent.FLAG_ONE_SHOT);
}

public static Intent buildFileActionIntent(String action, String actionTitle, 
        Uri uri, String mimeType) {
    Intent intent = new Intent(action);
    intent.addCategory(Intent.CATEGORY_DEFAULT);

    if (action.equals(Intent.ACTION_SEND)) {
        intent.putExtra(Intent.EXTRA_STREAM, uri);
        intent.setType(mimeType);
    } else {
        intent.setDataAndType(uri, mimeType);
    }

    intent.putExtra(Intent.EXTRA_TITLE, actionTitle);

    // Grant read permission on the file to other apps without declared permission.
    int flags = Intent.FLAG_GRANT_READ_URI_PERMISSION;
    intent.setFlags(flags);

    return intent;
}

Notification de l'activité sans aucune INTERFACE utilisateur:

public class NotificationActivity extends Activity {
private final static Logger s_logger = LogUtil.getLogger(NotificationActivity.class);

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

    Intent intent = getIntent();

    // Cancel the notification that initiated this activity.
    // This is required when using the action buttons in expanded notifications.
    // While the default action automatically closes the notification, the
    // actions initiated by buttons do not.
    int notificationId = intent.getIntExtra(IIntentCode.INTENT_EXTRA_NOTIFICATION_ID, -1);
    if (notificationId != -1) {
        NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        manager.cancel(notificationId);
    }

    // If there is an activity to handle the action, start the file action.
    if (DownloadedFileIntentUtils.verifyActivityIsAvailable(this, fileActionIntent, false)) {
            fileActionIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            DownloadedFileIntentUtils.startFileActionActivity(this, fileActionIntent);
    }

    // Finish activity.
    finish();
}

public static void startFileActionActivity(Context context, Intent fileActionIntent) {
    // Start chooser intent.
    Intent chooser = Intent.createChooser(fileActionIntent, fileActionIntent.getStringExtra(Intent.EXTRA_TITLE));

    // Copy the flags from fileActionIntent to chooser intent.
    // FileActionExecutor must set FLAG_ACTIVITY_NEW_TASK on the intent passed to startActivity
    // because the flag is required when starting an activity from a context that is not an activity.
    chooser.addFlags(fileActionIntent.getFlags());

    context.startActivity(chooser);
}

n'oubliez pas d'ajouter la NotificationActivity à AndroidManifest.XML.

bien que je comprenne parfaitement que la réponse de Soumyajyoti devrait être correcte... il est en fait pas...

j'utilise

Intent CR = new Intent(CRCODE); 
PendingIntent.getBroadcast(getApplicationContext(), MY_ID, CR, 0);

dans une mise en page remoteview pour une notification en cours...

je peux vous assurer qu'il ne ferme pas le tiroir, mais il tire l'intention et l'activité derrière le tiroir ouvert, ainsi que l'exécution des autres tâches que j'ai assigné à mon récepteur...

j'ai testé à la fois getActivity, et getService (ni l'un ni l'autre ne fonctionne dans ma situation, je dois tirer plusieurs intentions onRecieve) et les deux fermer le tiroir correctement...

je sais que ce n'est pas une réponse, mais quand et si je trouve j'en ferai part à modifier cette...

pensée folle... peut-être une activité sans vue sur le contenu pourrait-elle être appelée un récepteur de radiodiffusion qui lancerait les intentions appropriées à d'autres classes ou applications selon les besoins...

la folle pensée énumérés ci-dessus fonctionne... commencez une activité avec PendingIntent.getActivity et de l'utiliser pour relayer les émissions de radiodiffusion ou d'autres intentions puis terminer lui-même... l'effet n'est pas direct, mais imperceptible pour l'utilisateur final

le système android effondre le tiroir de notification pour vous chaque fois que vous cliquez sur une notification et de lancer une activité ou une émission. Je ne pense pas qu'il y ait un moyen programmatique de fermer le tiroir de notification par votre code. Je vous suggère de vérifier les intentions que vous transmettez au constructeur de notification et de vous assurer qu'ils sont donnés des intentions de référence correctes. Je pense que quelque chose dans le gestionnaire de notification android est bloqué en raison de l'intention que vous fournissez. Jusqu'à présent, j' n'ont pas vu le tiroir de notification rester ouvert une fois que l'action est déclenchée à partir de la notification. Juste curieux de savoir si votre activité cible a une zone semi-transparente où l'activité précédente est visible, si elle est alors je vous suggère de rendre le fond complètement opaque (n'ayant pas de région transparente/semi-transparente). Peut-être est-ce empêcher le lanceur maison android pour compléter la séquence d'arrêt et donc ne pas laisser lanceur de fermer le tiroir de notification pour vous. J'Espère a été en mesure de vous aider. Le meilleur de tous.

essayez ceci:

    NotificationManager notificationManager = (NotificationManager) getApplicationContext().getSystemService(getApplicationContext().NOTIFICATION_SERVICE);
    Intent notificationIntent = new Intent(this.getBaseContext(), MainActivity.class);
    notificationIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    PendingIntent pendingIntent = PendingIntent.getActivity(getApplicationContext(), 0, notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT);
    NotificationCompat.Builder mNotifyBuilder = (NotificationCompat.Builder) new NotificationCompat.Builder(
            getApplicationContext())
            .setTicker(getApplicationContext().getText(R.string.app_name))
            .setContentTitle(getApplicationContext().getText(R.string.app_name))
            .setContentText(getApplicationContext().getText(R.string.text))
            .setSmallIcon(R.drawable.smallicon)
            .setLargeIcon(BitmapFactory.decodeResource(getApplicationContext().getResources(), R.mipmap.ic_launcher))
            .setContentIntent(pendingIntent)
            .setAutoCancel(true)
            .setVibrate(new long[]{150, 300});
    mNotifyBuilder.build().flags |= Notification.FLAG_AUTO_CANCEL;
    notificationManager.notify(1, mNotifyBuilder.build());