Android 4.1: come controllare che le notifiche siano disabilitate per l'applicazione?

Android 4.1 offre all'utente una casella di controllo per disabilitare le notifiche per un'applicazione specifica.

Tuttavia, come sviluppatore non abbiamo modo di sapere se una chiamata per la notifica è stata efficace o meno.

Ho davvero bisogno di controllare se le notifiche sono disabilitate per l'applicazione corrente ma non riesco a trovare alcuna impostazione per questo nell'API.

C'è mai un modo per controllare questa impostazione nel codice?

Non puoi farlo al 100%.

Viene chiesto in questo video di Google I / O 2012 e il responsabile del progetto per le nuove notifiche dichiara che non è possibile.

modificare

Aggiornamento 2016: ora puoi controllarlo, come detto in questo video di Google I / O 2016 .

Utilizzare NotificationManagerCompat.areNotificationsEnabled(), dalla libreria di supporto, per verificare se le notifiche sono bloccate su API 19+. Le versioni sotto l'API 19 restituiranno true (le notifiche sono abilitate).

In realtà questo è abbastanza facile da fare:

/**
 * Created by desgraci on 5/7/15.
*/
public class NotificationsUtils {

    private static final String CHECK_OP_NO_THROW = "checkOpNoThrow";
    private static final String OP_POST_NOTIFICATION = "OP_POST_NOTIFICATION";

    public static boolean isNotificationEnabled(Context context) {

        AppOpsManager mAppOps = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);

        ApplicationInfo appInfo = context.getApplicationInfo();

        String pkg = context.getApplicationContext().getPackageName();

        int uid = appInfo.uid;

        Class appOpsClass = null; /* Context.APP_OPS_MANAGER */

        try {

            appOpsClass = Class.forName(AppOpsManager.class.getName());

            Method checkOpNoThrowMethod = appOpsClass.getMethod(CHECK_OP_NO_THROW, Integer.TYPE, Integer.TYPE, String.class);

            Field opPostNotificationValue = appOpsClass.getDeclaredField(OP_POST_NOTIFICATION);
            int value = (int)opPostNotificationValue.get(Integer.class);

            return ((int)checkOpNoThrowMethod.invoke(mAppOps,value, uid, pkg) == AppOpsManager.MODE_ALLOWED);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return false;
    }
}

La risposta di @blundell è corretta ma c'è una piccola modifica nelle versioni più recenti.

NotificationManagerCompat.from(context).areNotificationsEnabled()

Se stai usando Xamarin e hai bisogno di questa risposta puoi usare questo codice:

//return true if this option is not supported.
public class NotificationsUtils 
{
    private const String CHECK_OP_NO_THROW = "checkOpNoThrow";
    private const String OP_POST_NOTIFICATION = "OP_POST_NOTIFICATION";

    public static bool IsNotificationEnabled(global::Android.Content.Context context) {

        AppOpsManager mAppOps = (AppOpsManager) context.GetSystemService(global::Android.Content.Context.AppOpsService);

        ApplicationInfo appInfo = context.ApplicationInfo;

        String pkg = context.ApplicationContext.PackageName;

        int uid = appInfo.Uid;

        try {

            var appOpsClass = Java.Lang.Class.ForName("android.app.AppOpsManager");
            var checkOpNoThrowMethod = appOpsClass.GetMethod(CHECK_OP_NO_THROW,Java.Lang.Integer.Type,Java.Lang.Integer.Type,new Java.Lang.String().Class);//need to add String.Type

            var opPostNotificationValue = appOpsClass.GetDeclaredField (OP_POST_NOTIFICATION);
            var value = (int)opPostNotificationValue.GetInt(Java.Lang.Integer.Type);
            var mode = (int)checkOpNoThrowMethod.Invoke(mAppOps,value, uid, pkg);
            return (mode == (int)AppOpsManagerMode.Allowed);

        } catch (Exception) 
        {
            System.Diagnostics.Debug.WriteLine  ("Notification services is off or not supported");
        } 
        return true;
    }
}

Sembra che non sia possibile interrogare lo stato di notifica.

Raccomando questo:

• Progetta la tua applicazione con le notifiche.
• Consenti all'utente di disabilitare le notifiche dalle impostazioni dell'applicazione.
• Controlla se si fa clic sulle notifiche. Se l'utente fa clic sulla notifica, salvalo nelle preferenze.
• Nella tua app, se l'impostazione di notifica è attiva e se l'utente è Android 4.1+ (API 16), ma se l'utente non fa clic sulla notifica per alcuni giorni / settimane, presumi che l'utente abbia disattivato le notifiche.

Non corretto al 100%. Ma questo dà un'opinione.
Ad esempio, se l'utente non fa clic su alcuna notifica dell'app per 10-15 giorni, probabilmente l'ha disabilitata

Uso questo metodo per verificare se le notifiche sono abilitate o meno, i metodi sopra menzionati funzioneranno per verificare se le notifiche sono abilitate o meno. Ma da Android 8 in poi per la creazione delle notifiche dobbiamo prima creare un canale , quindi da Oreo, dobbiamo verificare se il tuo canale di notifica è abilitato o meno .

    /**
     * Checking Whether notifications are enabled or not
     * @return true if notifications are enabled otherwise false
     */
    public static final String CHANNEL_ID = “your_channel_id";

    private boolean isNotificationChannelEnabled(){
        if(NotificationManagerCompat.from(this).areNotificationsEnabled()) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
                NotificationChannel channel = manager.getNotificationChannel(CHANNEL_ID);
                if (channel == null)
                    return true; //channel is not yet created so return boolean
                // by only checking whether notifications enabled or not
                return channel.getImportance() != NotificationManager.IMPORTANCE_NONE;
            }
            return true;
        }
        return false;
    }