libraries/BluetoothServices/src/com/google/android/tv/btservices/NotificationCenter.java - device/google/atv - Git at Google

 /*
  * Copyright (C) 2021 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.google.android.tv.btservices;

 import static android.app.NotificationManager.IMPORTANCE_DEFAULT;
 import static android.app.NotificationManager.IMPORTANCE_HIGH;
 import static android.app.NotificationManager.IMPORTANCE_LOW;
 import static android.app.NotificationManager.IMPORTANCE_MAX;

 import android.app.Notification;
 import android.app.Notification.TvExtender;
 import android.app.NotificationChannel;
 import android.app.NotificationManager;
 import android.app.PendingIntent;
 import android.bluetooth.BluetoothDevice;
 import android.content.Context;
 import android.content.Intent;
 import android.graphics.drawable.Icon;
 import android.util.Log;
 import androidx.core.app.NotificationCompat;
 import com.google.android.tv.btservices.settings.RemoteDfuConfirmationActivity;
 import com.google.common.base.Stopwatch;
 import com.google.common.base.Ticker;

 import java.time.Instant;
 import java.time.ZonedDateTime;
 import java.time.ZoneId;
 import java.time.temporal.ChronoUnit;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;

 /**
  * Singleton that manages all notifications posted by BluetoothDeviceService.
  *
  * <p>This singleton class provides static methods for other components within
  * this service to post Android system notifications. This currently includes
  * low battery notification, device connect/disconnect notification, etc.
  */
 public class NotificationCenter {
     private static final String TAG = "Atv.BtServices.NotificationCenter";

     private static final long REMOTE_UPDATE_SNOOZE_PERIOD =
             TimeUnit.MILLISECONDS.convert(12, TimeUnit.HOURS);
     private static final String DFU_NOTIFICATION_CHANNEL = "btservices-remote-dfu-channel";
     private static final String DEFAULT_NOTIFICATION_CHANNEL = "btservices-default-channel";
     private static final String HIGH_PRIORITY_NOTIFICATION_CHANNEL = "btservices-high-channel";
     private static final String CRITICAL_NOTIFICATION_CHANNEL = "btservices-critical-channel";

     private static final int NOTIFICATION_RESET_HOUR_OF_DAY = 3;

     private static class InstanceHolder {
         public static NotificationCenter instance = new NotificationCenter();
     }

     private static NotificationCenter getInstance() {
         return InstanceHolder.instance;
     }

     /**
      * Represents different battery state for battery notification.
      *
      * <p>{@code GOOD} represents good battery level that does not require
      * notification; {@code LOW} represents low battery level, user will be
      * notified to change battery soon; {@code CRITICAL} represents that battery
      * is so low that the device has disconnected and is no longer functional.
      */
     public enum BatteryState {
         GOOD,
         LOW,
         CRITICAL,
         DEPLETED,
     }

     public static synchronized void initialize(Context context) {
         NotificationCenter nc = getInstance();
         nc.mContext = context;
         nc.mNotificationManager = context.getSystemService(NotificationManager.class);
         nc.createNotificationChannel();
     }

     public static synchronized void refreshLowBatteryNotification(
             BluetoothDevice device,
             BatteryState state,
             boolean forceNotification) {
         getInstance().refreshLowBatteryNotificationImpl(device, state, forceNotification);
     }

     public static synchronized void sendDfuNotification(BluetoothDevice device) {
         getInstance().sendDfuNotificationImpl(device);
     }

     public static synchronized void dismissUpdateNotification(BluetoothDevice device) {
         getInstance().dismissUpdateNotificationImpl(device);
     }

     public static synchronized void resetUpdateNotification() {
         getInstance().dfuNotificationSnoozeWatch.clear();
     }

     private void createNotificationChannel() {
         // Create notification channel for firmware update notification
         CharSequence dfuName = mContext.getString(R.string.settings_notif_update_channel_name);
         String dfuDescr = mContext.getString(R.string.settings_notif_update_channel_description);
         ensureNotificationChannel(DFU_NOTIFICATION_CHANNEL, IMPORTANCE_MAX, dfuName, dfuDescr);

         // Create notification channels with different priorities for battery notifications
         CharSequence name = mContext.getString(R.string.settings_notif_battery_channel_name);
         String descr = mContext.getString(R.string.settings_notif_battery_channel_description);
         ensureNotificationChannel(DEFAULT_NOTIFICATION_CHANNEL, IMPORTANCE_LOW, name, descr);
         ensureNotificationChannel(HIGH_PRIORITY_NOTIFICATION_CHANNEL, IMPORTANCE_DEFAULT, name,
                 descr);
         ensureNotificationChannel(CRITICAL_NOTIFICATION_CHANNEL, IMPORTANCE_HIGH, name, descr);
     }

     private void ensureNotificationChannel(String channelId,
             int importance, CharSequence name, String description) {
         if (mNotificationManager.getNotificationChannel(channelId) != null) {
             return;
         }
         NotificationChannel channel = new NotificationChannel(channelId, name, importance);
         channel.setDescription(description);
         mNotificationManager.createNotificationChannel(channel);
     }


     private final Map<BluetoothDevice, Integer> dfuNotifications = new HashMap<>();
     private final Map<BluetoothDevice, Integer> lowBatteryNotifications = new HashMap<>();
     private final Map<BluetoothDevice, Integer> criticalBatteryNotifications = new HashMap<>();
     private final Map<BluetoothDevice, Integer> depletedBatteryNotifications = new HashMap<>();
     private final Map<BluetoothDevice, Stopwatch> dfuNotificationSnoozeWatch = new HashMap<>();
     private Context mContext;
     private NotificationManager mNotificationManager;
     private int notificationIdCounter = 0;
     private ZonedDateTime lastNotificationTime =
             Instant.ofEpochSecond(0).atZone(ZoneId.systemDefault());

     private final Ticker ticker = new Ticker() {
         public long read() {
             return android.os.SystemClock.elapsedRealtimeNanos();
         }
     };

     private NotificationCenter() {}

     private void sendDfuNotificationImpl(BluetoothDevice device) {
         if (device == null) {
             Log.w(TAG, "sendDfuNotification: Bluetooth device null");
             return;
         }

         Stopwatch stopwatch = dfuNotificationSnoozeWatch.get(device);
         if (stopwatch != null &&
                 stopwatch.elapsed(TimeUnit.MILLISECONDS) < REMOTE_UPDATE_SNOOZE_PERIOD) {
             return;
         }

         if (stopwatch == null) {
             stopwatch = Stopwatch.createStarted(ticker);
             dfuNotificationSnoozeWatch.put(device, stopwatch);
         }

         stopwatch.reset();
         stopwatch.start();

         int notificationId;
         if (dfuNotifications.get(device) != null) {
             notificationId = dfuNotifications.get(device);
         } else {
             notificationId = notificationIdCounter++;
             dfuNotifications.put(device, notificationId);
         }
         final String name = BluetoothUtils.getName(device);
         Intent intent = new Intent(mContext, RemoteDfuConfirmationActivity.class);
         intent.putExtra(RemoteDfuConfirmationActivity.EXTRA_BT_ADDRESS, device.getAddress());
         intent.putExtra(RemoteDfuConfirmationActivity.EXTRA_BT_NAME, name);

         PendingIntent updateIntent = PendingIntent.getActivity(mContext,
                 /* requestCode= */ 0, intent,
                 PendingIntent.FLAG_MUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);

         Notification.Action updateAction = new Notification.Action.Builder(/* icon= */ null,
                 mContext.getString(R.string.settings_notif_update_action),
                 updateIntent).build();

         Notification.Action dismissAction = new Notification.Action.Builder(/* icon= */ null,
                 mContext.getString(R.string.settings_notif_update_dismiss), null)
                 .setSemanticAction(Notification.Action.SEMANTIC_ACTION_DELETE)
                 .build();

         Icon icon = Icon.createWithResource(mContext, R.drawable.ic_official_remote);
         Notification notification = new Notification.Builder(mContext, DFU_NOTIFICATION_CHANNEL)
                 .setSmallIcon(icon)
                 .setContentTitle(mContext.getString(R.string.settings_notif_update_title))
                 .setContentText(mContext.getString(R.string.settings_notif_update_text))
                 .setContentIntent(updateIntent)
                 .setPriority(NotificationCompat.PRIORITY_MAX)
                 .addAction(updateAction)
                 .addAction(dismissAction)
                 .extend(new TvExtender())
                 .build();
         mNotificationManager.notify(notificationId, notification);
     }

     private void dismissUpdateNotificationImpl(BluetoothDevice device) {
         if (dfuNotifications.get(device) != null) {
             int notificationId = dfuNotifications.get(device);
             mNotificationManager.cancel(notificationId);
         }
     }

     private void refreshLowBatteryNotificationImpl(BluetoothDevice device, BatteryState state,
             boolean forceNotification) {
         // Dismiss outdated notifications.
         if (state != BatteryState.LOW) {
             if (lowBatteryNotifications.get(device) != null) {
                 int notificationId = lowBatteryNotifications.remove(device);
                 mNotificationManager.cancel(notificationId);
             }
         }

         if (state != BatteryState.CRITICAL) {
             if (criticalBatteryNotifications.get(device) != null) {
                 int notificationId = criticalBatteryNotifications.remove(device);
                 mNotificationManager.cancel(notificationId);
             }
         }

         switch (state) {
             case GOOD:
                 // do nothing
                 break;

             case LOW:
                 postLowBatteryNotification(device, forceNotification);
                 break;

             case CRITICAL:
                 postCriticalBatteryNotification(device, forceNotification);
                 break;

             case DEPLETED:
                 postDepletedBatteryNotification(device);
                 break;

             default:
                 // impossible to reach
                 throw new AssertionError();
         }
     }

     private void postLowBatteryNotification(BluetoothDevice device, boolean forced) {
         if ((!forced && lowBatteryNotifications.get(device) != null) || !isNotificationAllowed()) {
             return;
         }

         int notificationId = lowBatteryNotifications.getOrDefault(device, notificationIdCounter);

         if (notificationId == notificationIdCounter) {
             notificationIdCounter++;
             lowBatteryNotifications.put(device, notificationId);
         }

         Log.w(TAG, "Low battery for remote device: " + device);
         Icon icon = Icon.createWithResource(mContext, R.drawable.ic_official_remote);

         Notification notification = new Notification.Builder(mContext, DEFAULT_NOTIFICATION_CHANNEL)
                 .setSmallIcon(icon)
                 .setContentTitle(mContext.getString(R.string.settings_notif_low_battery_title))
                 .setContentText(mContext.getString(R.string.settings_notif_low_battery_text))
                 .setPriority(NotificationCompat.PRIORITY_DEFAULT)
                 .extend(new TvExtender())
                 .build();
         mNotificationManager.notify(notificationId, notification);
         logLastNotificationTime();
     }

     private void postCriticalBatteryNotification(BluetoothDevice device, boolean forced) {

         if ((!forced && criticalBatteryNotifications.get(device) != null) ||
                 !isNotificationAllowed()) {
             return;
         }

         int notificationId = criticalBatteryNotifications.getOrDefault(device, notificationIdCounter);

         if (notificationId == notificationIdCounter) {
             notificationIdCounter++;
             criticalBatteryNotifications.put(device, notificationId);
         }

         Log.w(TAG, "Critical battery for remote device: " + device);
         Icon icon = Icon.createWithResource(mContext, R.drawable.ic_official_remote);

         Notification notification =
                 new Notification.Builder(mContext, HIGH_PRIORITY_NOTIFICATION_CHANNEL)
                 .setSmallIcon(icon)
                 .setContentTitle(mContext.getString(R.string.settings_notif_critical_battery_title))
                 .setContentText(mContext.getString(R.string.settings_notif_critical_battery_text))
                 .setPriority(NotificationCompat.PRIORITY_DEFAULT)
                 .extend(new TvExtender())
                 .build();
         mNotificationManager.notify(notificationId, notification);
         logLastNotificationTime();
     }

     private void postDepletedBatteryNotification(BluetoothDevice device) {

         if (depletedBatteryNotifications.get(device) != null || !isNotificationAllowed()) {
             return;
         }

         int notificationId = notificationIdCounter++;
         depletedBatteryNotifications.put(device, notificationId);

         Log.w(TAG, "Depleted battery for remote device: " + device);
         Icon icon = Icon.createWithResource(mContext, R.drawable.ic_official_remote);

         Notification notification =
                 new Notification.Builder(mContext, HIGH_PRIORITY_NOTIFICATION_CHANNEL)
                 .setSmallIcon(icon)
                 .setContentTitle(mContext.getString(R.string.settings_notif_depleted_battery_title))
                 .setContentText(mContext.getString(R.string.settings_notif_depleted_battery_text))
                 .setPriority(NotificationCompat.PRIORITY_DEFAULT)
                 .extend(new TvExtender())
                 .build();
         mNotificationManager.notify(notificationId, notification);
         logLastNotificationTime();
     }

     private void logLastNotificationTime() {
         lastNotificationTime = Instant.now().atZone(ZoneId.systemDefault());
     }

     private boolean isNotificationAllowed() {
         final ZonedDateTime currentTime = Instant.now().atZone(ZoneId.systemDefault());
         final ZonedDateTime resetTime =
             lastNotificationTime.plusDays(1).withHour(NOTIFICATION_RESET_HOUR_OF_DAY).withMinute(0);

         // return true if it has passed notification reset time
         return resetTime.until(currentTime, ChronoUnit.MILLIS) > 0;
     }
 }
	/*
	* Copyright (C) 2021 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.google.android.tv.btservices;

	import static android.app.NotificationManager.IMPORTANCE_DEFAULT;
	import static android.app.NotificationManager.IMPORTANCE_HIGH;
	import static android.app.NotificationManager.IMPORTANCE_LOW;
	import static android.app.NotificationManager.IMPORTANCE_MAX;

	import android.app.Notification;
	import android.app.Notification.TvExtender;
	import android.app.NotificationChannel;
	import android.app.NotificationManager;
	import android.app.PendingIntent;
	import android.bluetooth.BluetoothDevice;
	import android.content.Context;
	import android.content.Intent;
	import android.graphics.drawable.Icon;
	import android.util.Log;
	import androidx.core.app.NotificationCompat;
	import com.google.android.tv.btservices.settings.RemoteDfuConfirmationActivity;
	import com.google.common.base.Stopwatch;
	import com.google.common.base.Ticker;

	import java.time.Instant;
	import java.time.ZonedDateTime;
	import java.time.ZoneId;
	import java.time.temporal.ChronoUnit;
	import java.util.HashMap;
	import java.util.Map;
	import java.util.concurrent.TimeUnit;

	/**
	* Singleton that manages all notifications posted by BluetoothDeviceService.
	*
	* <p>This singleton class provides static methods for other components within
	* this service to post Android system notifications. This currently includes
	* low battery notification, device connect/disconnect notification, etc.
	*/
	public class NotificationCenter {
	private static final String TAG = "Atv.BtServices.NotificationCenter";

	private static final long REMOTE_UPDATE_SNOOZE_PERIOD =
	TimeUnit.MILLISECONDS.convert(12, TimeUnit.HOURS);
	private static final String DFU_NOTIFICATION_CHANNEL = "btservices-remote-dfu-channel";
	private static final String DEFAULT_NOTIFICATION_CHANNEL = "btservices-default-channel";
	private static final String HIGH_PRIORITY_NOTIFICATION_CHANNEL = "btservices-high-channel";
	private static final String CRITICAL_NOTIFICATION_CHANNEL = "btservices-critical-channel";

	private static final int NOTIFICATION_RESET_HOUR_OF_DAY = 3;

	private static class InstanceHolder {
	public static NotificationCenter instance = new NotificationCenter();
	}

	private static NotificationCenter getInstance() {
	return InstanceHolder.instance;
	}

	/**
	* Represents different battery state for battery notification.
	*
	* <p>{@code GOOD} represents good battery level that does not require
	* notification; {@code LOW} represents low battery level, user will be
	* notified to change battery soon; {@code CRITICAL} represents that battery
	* is so low that the device has disconnected and is no longer functional.
	*/
	public enum BatteryState {
	GOOD,
	LOW,
	CRITICAL,
	DEPLETED,
	}

	public static synchronized void initialize(Context context) {
	NotificationCenter nc = getInstance();
	nc.mContext = context;
	nc.mNotificationManager = context.getSystemService(NotificationManager.class);
	nc.createNotificationChannel();
	}

	public static synchronized void refreshLowBatteryNotification(
	BluetoothDevice device,
	BatteryState state,
	boolean forceNotification) {
	getInstance().refreshLowBatteryNotificationImpl(device, state, forceNotification);
	}

	public static synchronized void sendDfuNotification(BluetoothDevice device) {
	getInstance().sendDfuNotificationImpl(device);
	}

	public static synchronized void dismissUpdateNotification(BluetoothDevice device) {
	getInstance().dismissUpdateNotificationImpl(device);
	}

	public static synchronized void resetUpdateNotification() {
	getInstance().dfuNotificationSnoozeWatch.clear();
	}

	private void createNotificationChannel() {
	// Create notification channel for firmware update notification
	CharSequence dfuName = mContext.getString(R.string.settings_notif_update_channel_name);
	String dfuDescr = mContext.getString(R.string.settings_notif_update_channel_description);
	ensureNotificationChannel(DFU_NOTIFICATION_CHANNEL, IMPORTANCE_MAX, dfuName, dfuDescr);

	// Create notification channels with different priorities for battery notifications
	CharSequence name = mContext.getString(R.string.settings_notif_battery_channel_name);
	String descr = mContext.getString(R.string.settings_notif_battery_channel_description);
	ensureNotificationChannel(DEFAULT_NOTIFICATION_CHANNEL, IMPORTANCE_LOW, name, descr);
	ensureNotificationChannel(HIGH_PRIORITY_NOTIFICATION_CHANNEL, IMPORTANCE_DEFAULT, name,
	descr);
	ensureNotificationChannel(CRITICAL_NOTIFICATION_CHANNEL, IMPORTANCE_HIGH, name, descr);
	}

	private void ensureNotificationChannel(String channelId,
	int importance, CharSequence name, String description) {
	if (mNotificationManager.getNotificationChannel(channelId) != null) {
	return;
	}
	NotificationChannel channel = new NotificationChannel(channelId, name, importance);
	channel.setDescription(description);
	mNotificationManager.createNotificationChannel(channel);
	}


	private final Map<BluetoothDevice, Integer> dfuNotifications = new HashMap<>();
	private final Map<BluetoothDevice, Integer> lowBatteryNotifications = new HashMap<>();
	private final Map<BluetoothDevice, Integer> criticalBatteryNotifications = new HashMap<>();
	private final Map<BluetoothDevice, Integer> depletedBatteryNotifications = new HashMap<>();
	private final Map<BluetoothDevice, Stopwatch> dfuNotificationSnoozeWatch = new HashMap<>();
	private Context mContext;
	private NotificationManager mNotificationManager;
	private int notificationIdCounter = 0;
	private ZonedDateTime lastNotificationTime =
	Instant.ofEpochSecond(0).atZone(ZoneId.systemDefault());

	private final Ticker ticker = new Ticker() {
	public long read() {
	return android.os.SystemClock.elapsedRealtimeNanos();
	}
	};

	private NotificationCenter() {}

	private void sendDfuNotificationImpl(BluetoothDevice device) {
	if (device == null) {
	Log.w(TAG, "sendDfuNotification: Bluetooth device null");
	return;
	}

	Stopwatch stopwatch = dfuNotificationSnoozeWatch.get(device);
	if (stopwatch != null &&
	stopwatch.elapsed(TimeUnit.MILLISECONDS) < REMOTE_UPDATE_SNOOZE_PERIOD) {
	return;
	}

	if (stopwatch == null) {
	stopwatch = Stopwatch.createStarted(ticker);
	dfuNotificationSnoozeWatch.put(device, stopwatch);
	}

	stopwatch.reset();
	stopwatch.start();

	int notificationId;
	if (dfuNotifications.get(device) != null) {
	notificationId = dfuNotifications.get(device);
	} else {
	notificationId = notificationIdCounter++;
	dfuNotifications.put(device, notificationId);
	}
	final String name = BluetoothUtils.getName(device);
	Intent intent = new Intent(mContext, RemoteDfuConfirmationActivity.class);
	intent.putExtra(RemoteDfuConfirmationActivity.EXTRA_BT_ADDRESS, device.getAddress());
	intent.putExtra(RemoteDfuConfirmationActivity.EXTRA_BT_NAME, name);

	PendingIntent updateIntent = PendingIntent.getActivity(mContext,
	/* requestCode= */ 0, intent,
	PendingIntent.FLAG_MUTABLE \| PendingIntent.FLAG_UPDATE_CURRENT);

	Notification.Action updateAction = new Notification.Action.Builder(/* icon= */ null,
	mContext.getString(R.string.settings_notif_update_action),
	updateIntent).build();

	Notification.Action dismissAction = new Notification.Action.Builder(/* icon= */ null,
	mContext.getString(R.string.settings_notif_update_dismiss), null)
	.setSemanticAction(Notification.Action.SEMANTIC_ACTION_DELETE)
	.build();

	Icon icon = Icon.createWithResource(mContext, R.drawable.ic_official_remote);
	Notification notification = new Notification.Builder(mContext, DFU_NOTIFICATION_CHANNEL)
	.setSmallIcon(icon)
	.setContentTitle(mContext.getString(R.string.settings_notif_update_title))
	.setContentText(mContext.getString(R.string.settings_notif_update_text))
	.setContentIntent(updateIntent)
	.setPriority(NotificationCompat.PRIORITY_MAX)
	.addAction(updateAction)
	.addAction(dismissAction)
	.extend(new TvExtender())
	.build();
	mNotificationManager.notify(notificationId, notification);
	}

	private void dismissUpdateNotificationImpl(BluetoothDevice device) {
	if (dfuNotifications.get(device) != null) {
	int notificationId = dfuNotifications.get(device);
	mNotificationManager.cancel(notificationId);
	}
	}

	private void refreshLowBatteryNotificationImpl(BluetoothDevice device, BatteryState state,
	boolean forceNotification) {
	// Dismiss outdated notifications.
	if (state != BatteryState.LOW) {
	if (lowBatteryNotifications.get(device) != null) {
	int notificationId = lowBatteryNotifications.remove(device);
	mNotificationManager.cancel(notificationId);
	}
	}

	if (state != BatteryState.CRITICAL) {
	if (criticalBatteryNotifications.get(device) != null) {
	int notificationId = criticalBatteryNotifications.remove(device);
	mNotificationManager.cancel(notificationId);
	}
	}

	switch (state) {
	case GOOD:
	// do nothing
	break;

	case LOW:
	postLowBatteryNotification(device, forceNotification);
	break;

	case CRITICAL:
	postCriticalBatteryNotification(device, forceNotification);
	break;

	case DEPLETED:
	postDepletedBatteryNotification(device);
	break;

	default:
	// impossible to reach
	throw new AssertionError();
	}
	}

	private void postLowBatteryNotification(BluetoothDevice device, boolean forced) {
	if ((!forced && lowBatteryNotifications.get(device) != null) \|\| !isNotificationAllowed()) {
	return;
	}

	int notificationId = lowBatteryNotifications.getOrDefault(device, notificationIdCounter);

	if (notificationId == notificationIdCounter) {
	notificationIdCounter++;
	lowBatteryNotifications.put(device, notificationId);
	}

	Log.w(TAG, "Low battery for remote device: " + device);
	Icon icon = Icon.createWithResource(mContext, R.drawable.ic_official_remote);

	Notification notification = new Notification.Builder(mContext, DEFAULT_NOTIFICATION_CHANNEL)
	.setSmallIcon(icon)
	.setContentTitle(mContext.getString(R.string.settings_notif_low_battery_title))
	.setContentText(mContext.getString(R.string.settings_notif_low_battery_text))
	.setPriority(NotificationCompat.PRIORITY_DEFAULT)
	.extend(new TvExtender())
	.build();
	mNotificationManager.notify(notificationId, notification);
	logLastNotificationTime();
	}

	private void postCriticalBatteryNotification(BluetoothDevice device, boolean forced) {

	if ((!forced && criticalBatteryNotifications.get(device) != null) \|\|
	!isNotificationAllowed()) {
	return;
	}

	int notificationId = criticalBatteryNotifications.getOrDefault(device, notificationIdCounter);

	if (notificationId == notificationIdCounter) {
	notificationIdCounter++;
	criticalBatteryNotifications.put(device, notificationId);
	}

	Log.w(TAG, "Critical battery for remote device: " + device);
	Icon icon = Icon.createWithResource(mContext, R.drawable.ic_official_remote);

	Notification notification =
	new Notification.Builder(mContext, HIGH_PRIORITY_NOTIFICATION_CHANNEL)
	.setSmallIcon(icon)
	.setContentTitle(mContext.getString(R.string.settings_notif_critical_battery_title))
	.setContentText(mContext.getString(R.string.settings_notif_critical_battery_text))
	.setPriority(NotificationCompat.PRIORITY_DEFAULT)
	.extend(new TvExtender())
	.build();
	mNotificationManager.notify(notificationId, notification);
	logLastNotificationTime();
	}

	private void postDepletedBatteryNotification(BluetoothDevice device) {

	if (depletedBatteryNotifications.get(device) != null \|\| !isNotificationAllowed()) {
	return;
	}

	int notificationId = notificationIdCounter++;
	depletedBatteryNotifications.put(device, notificationId);

	Log.w(TAG, "Depleted battery for remote device: " + device);
	Icon icon = Icon.createWithResource(mContext, R.drawable.ic_official_remote);

	Notification notification =
	new Notification.Builder(mContext, HIGH_PRIORITY_NOTIFICATION_CHANNEL)
	.setSmallIcon(icon)
	.setContentTitle(mContext.getString(R.string.settings_notif_depleted_battery_title))
	.setContentText(mContext.getString(R.string.settings_notif_depleted_battery_text))
	.setPriority(NotificationCompat.PRIORITY_DEFAULT)
	.extend(new TvExtender())
	.build();
	mNotificationManager.notify(notificationId, notification);
	logLastNotificationTime();
	}

	private void logLastNotificationTime() {
	lastNotificationTime = Instant.now().atZone(ZoneId.systemDefault());
	}

	private boolean isNotificationAllowed() {
	final ZonedDateTime currentTime = Instant.now().atZone(ZoneId.systemDefault());
	final ZonedDateTime resetTime =
	lastNotificationTime.plusDays(1).withHour(NOTIFICATION_RESET_HOUR_OF_DAY).withMinute(0);

	// return true if it has passed notification reset time
	return resetTime.until(currentTime, ChronoUnit.MILLIS) > 0;
	}
	}