无法以编程方式为 Android Oreo 上的通知通道更新声音

Question

I am having some troubles updating notification sound for a channel into Android Oreo. I know that the sound can be set by the user manually by opening App notifications screen, but I want to do this programmatically by using RingtonePreference into a default Settings activity (user to be able to pick up notification sound from an activity inside my app).

Problem is that the first notification fired into application picks up the default sound value from the PreferenceManager.getDefaultSharedPreferences() and after manually changing it to other media (using RingtonePreference screen) it will still play the sound which was created initially on that channel and not the new one selected by the user.

I don't understand why the NotificationChannel sound is not updated according with the new sound value as I am doing something like this NotificationChannel mChannel = new NotificationChannel(id, title, importance); mChannel.setSound(ringtoneUri, audioAttributes); NotificationChannel mChannel = new NotificationChannel(id, title, importance); mChannel.setSound(ringtoneUri, audioAttributes);

Below is the full code:

 public static void sendNotification(Context context, NotificationType notificationType) {
        String id = "channel_1"; // default_channel_id
        String title = "Doppler Channel"; // Default Channel
        Intent intent;
        PendingIntent pendingIntent;
        NotificationCompat.Builder builder;

        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
        Uri ringtoneUri = Uri.parse(preferences.getString("notifications_new_message_ringtone", "DEFAULT_RINGTONE_URI"));
        boolean isNotificationSticky = !Boolean.parseBoolean(preferences.getAll().get("stickyNotification").toString());

        AudioAttributes audioAttributes = new AudioAttributes.Builder()
                .setUsage(AudioAttributes.USAGE_NOTIFICATION)
                .build();

        NotificationManager notifManager = (NotificationManager)context.getSystemService(Context.NOTIFICATION_SERVICE);

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

            int importance = NotificationManager.IMPORTANCE_DEFAULT;

            NotificationChannel mChannel = notifManager.getNotificationChannel(id);

                mChannel = new NotificationChannel(id, title, importance);
                mChannel.setSound(ringtoneUri, audioAttributes);
                notifManager.createNotificationChannel(mChannel);

            builder = new NotificationCompat.Builder(context, id);
            intent = new Intent(context, MainActivity.class);
            intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
            pendingIntent = PendingIntent.getActivity(context, 0, intent, 0);
            builder .setSmallIcon(notificationType.getNotificationIcon())
                    .setContentTitle(notificationType.getNotificationContent())
                    .setSubText(notificationType.getNotificationTitle())
                    .setOnlyAlertOnce(true)
                    .setOngoing(isNotificationSticky)
                    .setAutoCancel(true)
                    .setSound(ringtoneUri)
                    .setColor(notificationType.getNotificationColor())
                    .setContentIntent(pendingIntent);
        }
Notification notification = builder.build();
notifManager.notify(1, notification);

}

The only way I was able to update the sound was to give the channel id a random value UUID.randomUUID().toString() each time a notification is fired but this is causing a lot of garbage when user manually checks the App notification screen.

A hint on this would be much appreciated.

Thanks a lot!

Answer 1

There is a way you can "trick" Android into allowing this. If you use the WhatsApp app you'll see that they allow you to alter the sound of message notifications from within the app. And if you investigate a little you'll notice that they actually delete and create channels.

However, if you delete and recreate the same channel (in other words, the "new" channel has the same channel ID as the "old" one) then your new changes will not apply. Android apparently keeps track of all the deleted ones and prevent updates to those when recreated. So lets say you have your channel (and access to its fields in your app). What you need to do if you want a user to, for example, update the sound of a channel is:

• Delete the old channel
• Create a new one with a different channel ID but with the new updated sound and all other user visible fields identical to the just deleted channel.

So if we assume you have two channels with defined "Base ID":s which we'll base all their channel ID's on. Then, whenever your app launches you can check if the channels already exist, and if so, retreive them, otherwise create them. It requires some manual labor when you add more channels, perhaps there are better ways of doing this. But if you do this you can create a new channel for each change and give it a new incremented ID. Below is a full working example of a class that takes care of all this. And in this example we have the two channels with their baseId's and they are initialized with sound #1 and sound #2 but each time we instantiate the class we update the second channel and give it sound #3.

public class TestNotificationHandler {

    private static TestNotificationHandler instance;
    private NotificationManager mNotificationManager;
    private Context mContext;

    private Uri NOTIFICATION_SOUND_1, NOTIFICATION_SOUND_2, NOTIFICATION_SOUND_3, NOTIFICATION_SOUND_4;

    private static final String TAG = TestNotificationHandler.class.getSimpleName();

    public static TestNotificationHandler getInstance(Context context) {
        if (instance == null) {
            instance = new TestNotificationHandler(context);
        }
        return instance;
    }

    private TestNotificationHandler(Context context) {
        mContext = context;
        mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);

        NOTIFICATION_SOUND_1 = Uri.parse("android.resource://" + mContext.getPackageName() + "/" + R.raw.sound_1);
        NOTIFICATION_SOUND_2 = Uri.parse("android.resource://" + mContext.getPackageName() + "/" + R.raw.sound_2);
        NOTIFICATION_SOUND_3 = Uri.parse("android.resource://" + mContext.getPackageName() + "/" + R.raw.sound_3);
        NOTIFICATION_SOUND_4 = Uri.parse("android.resource://" + mContext.getPackageName() + "/" + R.raw.sound_4);

        getOrCreateChannels();

        // Only added here for testing, this should of course be done when user actually performs a change from within the app
        setNewChannelSound(testChannel2, NOTIFICATION_SOUND_3);

       // Remember that we now effectively have deleted testChannel2, so running this will not work, b/c no channel with the id that the testChannel2 object has currently exists so we cannot delete it
        setNewChannelSound(testChannel2, NOTIFICATION_SOUND_4);

      // The easy and ugly way would be to simply do this which will update our objects
       getOrCreateChannels();

      // And this will now work
      setNewChannelSound(testChannel2, NOTIFICATION_SOUND_4);


      // If we changed so that setNewChannelSound and updateChannel actually returned the updated 
      // channel (or the already existing one if could not update), then we could do something like: 
      // testChannel2 = setNewChannelSound(testChannel2, NOTIFICATION_SOUND_3);
    }


    AudioAttributes mAudioAttributes = new AudioAttributes.Builder()
            .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
            .setUsage(AudioAttributes.USAGE_ALARM)
            .build();

    private NotificationChannel testChannel;
    private String baseTestChannelId = "TEST_CHANNEL_ID-";

    private NotificationChannel testChannel2;
    private String baseTest2ChannelId = "TEST_CHANNEL_2_ID-";

    private void getOrCreateChannels() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            for (NotificationChannel channel : mNotificationManager.getNotificationChannels()) {
                // Since we'll incrementally update the ID we'll look for the correct channel with startsWith
                if (channel.getId().startsWith(baseTestChannelId)) {
                    testChannel = channel;
                } else if (channel.getId().startsWith(baseTest2ChannelId)) {
                    testChannel2 = channel;
                }
            }
            if (testChannel == null) {
                // This should only happen the first time the app is launched or if you just added this channel to your app
                // We'll update the ID incrementally so if it doesn't exist will simply create it as number 0

                testChannel = new NotificationChannel(baseTestChannelId + "0", "TEST CHANNEL", NotificationManager.IMPORTANCE_HIGH);
                testChannel.setDescription("First test channel");
                testChannel.setSound(NOTIFICATION_SOUND_1, mAudioAttributes);
                mNotificationManager.createNotificationChannel(testChannel);
            }
            if (testChannel2 == null) {
                // This should only happen the first time the app is launched or if you just added this channel to your app
                // We'll update the ID incrementally so if it doesn't exist will simply create it as number 0
                testChannel2 = new NotificationChannel(baseTest2ChannelId + "0", "TEST CHANNEL 2", NotificationManager.IMPORTANCE_HIGH);
                testChannel2.setDescription("Second test channel");
                testChannel2.setSound(NOTIFICATION_SOUND_2, mAudioAttributes);
                mNotificationManager.createNotificationChannel(testChannel2);
            } 
        }
    }

    private boolean setNewChannelSound(NotificationChannel notificationChannel, Uri newSound) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            notificationChannel.setSound(newSound, mAudioAttributes);
            return updateChannel(notificationChannel);
        }
        return false;
    }


    private boolean updateChannel(NotificationChannel notificationChannel) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            String baseChannelId = getBaseChannelId(notificationChannel);
            if (baseChannelId == null) {
                Log.e(TAG, "Could not find baseChannelId from id: " + notificationChannel.getId());
                return false;
            }
            int oldIndex = getChannelIncrementedIndex(notificationChannel, baseChannelId);
            if (oldIndex == -1) {
                Log.e(TAG, String.format("Could not get old channel index from id: %s and baseChannelId: %d", notificationChannel.getId(), baseChannelId));
                return false;
            }
            NotificationChannel updatedChannel = new NotificationChannel(baseChannelId+(oldIndex+1), notificationChannel.getName(), NotificationManager.IMPORTANCE_HIGH);
            updatedChannel.setDescription(notificationChannel.getDescription());
            updatedChannel.setVibrationPattern(notificationChannel.getVibrationPattern());
            updatedChannel.setSound(notificationChannel.getSound(), mAudioAttributes);
            mNotificationManager.deleteNotificationChannel(notificationChannel.getId());
            mNotificationManager.createNotificationChannel(updatedChannel);
            return true;
        }
        return false;
    }

    /**********************************************************
     Some helper methods
     **********************************************************/
    private String getBaseChannelId(NotificationChannel notificationChannel) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            if (notificationChannel.getId().startsWith(baseTestChannelId)) {
                return baseTestChannelId;
            } else if (notificationChannel.getId().startsWith(baseTest2ChannelId)) {
                return baseTest2ChannelId;
            }
        }
        return null;
    }

    private int getChannelIncrementedIndex(NotificationChannel channel, String baseChannelId) {
        int index = -1;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            String channelIncIdx = channel.getId().substring(baseChannelId.length(), channel.getId().length());

            try {
                index = Integer.parseInt(channelIncIdx);
            } catch (Exception e) {
                Log.e(TAG, String.format("Could not parse channel index %s", channelIncIdx));
            }
        }
        return index;
    }
}

I would say that the only drawbacks are:

• That you actually have to add this extra logic to maintain your channels (instead of simply creating them and letting the user do the changes out in the OS).
• Only works on version >= OREO. So running this example on an older device will not accomplish anything. So we need to add functionality to handle that. In that case we need to store our "updated" notification types in the prefs or database in order to notify the OS with something different then what we've added as default.
• Android will show a counter in the App notification settings which informs the user of how many times a channel has been deleted. I'd say most users would never care about this or even see it but potentially a few could be annoyed by this.

Answer 2

I don't understand why the NotificationChannel sound is not updated according with the new sound value

For the most part, NotificationChannel is a write-once API. You cannot modify most of its characteristics after you create it.

but I want to do this programmatically by using RingtonePreference into a default Settings activity

I recommend removing this feature from your app, or only offering it on Android 7.1 and older devices.