src/com/android/car/notification/CarNotificationListener.java - platform/packages/apps/Car/Notification - Git at Google

 /*
  * Copyright (C) 2018 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.android.car.notification;

 import android.annotation.Nullable;
 import android.app.ActivityManager;
 import android.app.NotificationManager;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Binder;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Message;
 import android.os.RemoteException;
 import android.os.UserHandle;
 import android.service.notification.NotificationListenerService;
 import android.service.notification.StatusBarNotification;
 import android.util.Log;

 import com.android.car.notification.headsup.CarHeadsUpNotificationAppContainer;

 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;

 /**
  * NotificationListenerService that fetches all notifications from system.
  */
 public class CarNotificationListener extends NotificationListenerService implements
         CarHeadsUpNotificationManager.OnHeadsUpNotificationStateChange {
     private static final String TAG = "CarNotificationListener";
     static final String ACTION_LOCAL_BINDING = "local_binding";
     static final int NOTIFY_NOTIFICATION_POSTED = 1;
     static final int NOTIFY_NOTIFICATION_REMOVED = 2;
     /** Temporary {@link Ranking} object that serves as a reused value holder */
     final private Ranking mTemporaryRanking = new Ranking();

     private Handler mHandler;
     private RankingMap mRankingMap;
     private CarHeadsUpNotificationManager mHeadsUpManager;
     private NotificationDataManager mNotificationDataManager;

     /**
      * Map that contains all the active notifications that are not currently HUN. These
      * notifications may or may not be visible to the user if they get filtered out. The only time
      * these will be removed from the map is when the {@llink NotificationListenerService} calls the
      * onNotificationRemoved method. New notifications will be added to this map if the notification
      * is posted as a non-HUN or when a HUN's state is changed to non-HUN.
      */
     private Map<String, AlertEntry> mActiveNotifications = new HashMap<>();

     /**
      * Call this if to register this service as a system service and connect to HUN. This is useful
      * if the notification service is being used as a lib instead of a standalone app. The
      * standalone app version has a manifest entry that will have the same effect.
      *
      * @param context Context required for registering the service.
      * @param carUxRestrictionManagerWrapper will have the heads up manager registered with it.
      * @param carHeadsUpNotificationManager HUN controller.
      * @param notificationDataManager used for keeping track of additional notification states.
      */
     public void registerAsSystemService(Context context,
             CarUxRestrictionManagerWrapper carUxRestrictionManagerWrapper,
             CarHeadsUpNotificationManager carHeadsUpNotificationManager,
             NotificationDataManager notificationDataManager) {
         try {
             mNotificationDataManager = notificationDataManager;
             registerAsSystemService(context,
                     new ComponentName(context.getPackageName(), getClass().getCanonicalName()),
                     ActivityManager.getCurrentUser());
             mHeadsUpManager = carHeadsUpNotificationManager;
             mHeadsUpManager.registerHeadsUpNotificationStateChangeListener(this);
             carUxRestrictionManagerWrapper.setCarHeadsUpNotificationManager(
                     carHeadsUpNotificationManager);
         } catch (RemoteException e) {
             Log.e(TAG, "Unable to register notification listener", e);
         }
     }

     @Override
     public void onCreate() {
         super.onCreate();
         mNotificationDataManager = new NotificationDataManager();
         NotificationApplication app = (NotificationApplication) getApplication();

         app.getClickHandlerFactory().setNotificationDataManager(mNotificationDataManager);
         mHeadsUpManager = new CarHeadsUpNotificationManager(/* context= */ this,
                 app.getClickHandlerFactory(), mNotificationDataManager, new CarHeadsUpNotificationAppContainer(this));
         mHeadsUpManager.registerHeadsUpNotificationStateChangeListener(this);
         app.getCarUxRestrictionWrapper().setCarHeadsUpNotificationManager(mHeadsUpManager);
     }

     @Override
     public IBinder onBind(Intent intent) {
         return ACTION_LOCAL_BINDING.equals(intent.getAction())
                 ? new LocalBinder() : super.onBind(intent);
     }

     @Override
     public void onNotificationPosted(StatusBarNotification sbn, RankingMap rankingMap) {
         if (sbn == null) {
             Log.e(TAG, "onNotificationPosted: StatusBarNotification is null");
             return;
         }

         Log.d(TAG, "onNotificationPosted: " + sbn);
         if (!isNotificationForCurrentUser(sbn)) {
             return;
         }
         AlertEntry alertEntry = new AlertEntry(sbn);
         onNotificationRankingUpdate(rankingMap);
         notifyNotificationPosted(alertEntry);
     }

     @Override
     public void onNotificationRemoved(StatusBarNotification sbn) {
         if (sbn == null) {
             Log.e(TAG, "onNotificationRemoved: StatusBarNotification is null");
             return;
         }

         Log.d(TAG, "onNotificationRemoved: " + sbn);
         AlertEntry alertEntry = mActiveNotifications.get(sbn.getKey());

         if (alertEntry != null) {
             mActiveNotifications.remove(alertEntry.getKey());
         } else {
             // HUN notifications are not tracked in mActiveNotifications but still need to be
             // removed
             alertEntry = new AlertEntry(sbn);
         }

         removeNotification(alertEntry);
     }

     @Override
     public void onNotificationRankingUpdate(RankingMap rankingMap) {
         mRankingMap = rankingMap;
         for (AlertEntry alertEntry : mActiveNotifications.values()) {
             if (!mRankingMap.getRanking(alertEntry.getKey(), mTemporaryRanking)) {
                 continue;
             }
             String oldOverrideGroupKey =
                     alertEntry.getStatusBarNotification().getOverrideGroupKey();
             String newOverrideGroupKey = getOverrideGroupKey(alertEntry.getKey());
             if (!Objects.equals(oldOverrideGroupKey, newOverrideGroupKey)) {
                 alertEntry.getStatusBarNotification().setOverrideGroupKey(newOverrideGroupKey);
             }
         }
     }

     /**
      * Get the override group key of a {@link AlertEntry} given its key.
      */
     @Nullable
     private String getOverrideGroupKey(String key) {
         if (mRankingMap != null) {
             mRankingMap.getRanking(key, mTemporaryRanking);
             return mTemporaryRanking.getOverrideGroupKey();
         }
         return null;
     }

     /**
      * Get all active notifications that are not heads-up notifications.
      *
      * @return a map of all active notifications with key being the notification key.
      */
     Map<String, AlertEntry> getNotifications() {
         return mActiveNotifications.entrySet().stream()
                 .filter(x -> (isNotificationForCurrentUser(
                         x.getValue().getStatusBarNotification())))
                 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
     }

     @Override
     public RankingMap getCurrentRanking() {
         return mRankingMap;
     }

     @Override
     public void onListenerConnected() {
         mActiveNotifications = Stream.of(getActiveNotifications()).collect(
                 Collectors.toMap(StatusBarNotification::getKey, sbn -> new AlertEntry(sbn)));
         mRankingMap = super.getCurrentRanking();
     }

     @Override
     public void onListenerDisconnected() {
     }

     public void setHandler(Handler handler) {
         mHandler = handler;
     }

     private void notifyNotificationPosted(AlertEntry alertEntry) {
         if (shouldTrackUnseen(alertEntry)) {
             mNotificationDataManager.addNewMessageNotification(alertEntry);
         } else {
             mNotificationDataManager.untrackUnseenNotification(alertEntry);
         }

         boolean isShowingHeadsUp = mHeadsUpManager.maybeShowHeadsUp(alertEntry, getCurrentRanking(),
                 mActiveNotifications);

         if (!isShowingHeadsUp) {
             postNewNotification(alertEntry);
         }
     }

     private boolean isNotificationForCurrentUser(StatusBarNotification sbn) {
         // Notifications should only be shown for the current user and the the notifications from
         // the system when CarNotification is running as SystemUI component.
         return (sbn.getUser().getIdentifier() == ActivityManager.getCurrentUser()
                 || sbn.getUser().getIdentifier() == UserHandle.USER_ALL);
     }


     @Override
     public void onStateChange(AlertEntry alertEntry, boolean isHeadsUp) {
         // No more a HUN
         if (!isHeadsUp) {
             postNewNotification(alertEntry);
         }
     }

     class LocalBinder extends Binder {
         public CarNotificationListener getService() {
             return CarNotificationListener.this;
         }
     }

     private void postNewNotification(AlertEntry alertEntry) {
         mActiveNotifications.put(alertEntry.getKey(), alertEntry);
         sendNotificationEventToHandler(alertEntry, NOTIFY_NOTIFICATION_POSTED);
     }

     private void removeNotification(AlertEntry alertEntry) {
         mHeadsUpManager.maybeRemoveHeadsUp(alertEntry);
         sendNotificationEventToHandler(alertEntry, NOTIFY_NOTIFICATION_REMOVED);
     }

     private void sendNotificationEventToHandler(AlertEntry alertEntry, int eventType) {
         if (mHandler == null) {
             return;
         }
         Message msg = Message.obtain(mHandler);
         msg.what = eventType;
         msg.obj = alertEntry;
         mHandler.sendMessage(msg);
     }

     // Don't show unseen markers for <= LOW importance notifications to be consistent
     // with how these notifications are handled on phones
     boolean shouldTrackUnseen(AlertEntry alertEntry) {
         Ranking ranking = new NotificationListenerService.Ranking();
         mRankingMap.getRanking(alertEntry.getKey(), ranking);
         return ranking.getImportance() > NotificationManager.IMPORTANCE_LOW;
     }
 }
	/*
	* Copyright (C) 2018 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.android.car.notification;

	import android.annotation.Nullable;
	import android.app.ActivityManager;
	import android.app.NotificationManager;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.Intent;
	import android.os.Binder;
	import android.os.Handler;
	import android.os.IBinder;
	import android.os.Message;
	import android.os.RemoteException;
	import android.os.UserHandle;
	import android.service.notification.NotificationListenerService;
	import android.service.notification.StatusBarNotification;
	import android.util.Log;

	import com.android.car.notification.headsup.CarHeadsUpNotificationAppContainer;

	import java.util.HashMap;
	import java.util.Map;
	import java.util.Objects;
	import java.util.stream.Collectors;
	import java.util.stream.Stream;

	/**
	* NotificationListenerService that fetches all notifications from system.
	*/
	public class CarNotificationListener extends NotificationListenerService implements
	CarHeadsUpNotificationManager.OnHeadsUpNotificationStateChange {
	private static final String TAG = "CarNotificationListener";
	static final String ACTION_LOCAL_BINDING = "local_binding";
	static final int NOTIFY_NOTIFICATION_POSTED = 1;
	static final int NOTIFY_NOTIFICATION_REMOVED = 2;
	/** Temporary {@link Ranking} object that serves as a reused value holder */
	final private Ranking mTemporaryRanking = new Ranking();

	private Handler mHandler;
	private RankingMap mRankingMap;
	private CarHeadsUpNotificationManager mHeadsUpManager;
	private NotificationDataManager mNotificationDataManager;

	/**
	* Map that contains all the active notifications that are not currently HUN. These
	* notifications may or may not be visible to the user if they get filtered out. The only time
	* these will be removed from the map is when the {@llink NotificationListenerService} calls the
	* onNotificationRemoved method. New notifications will be added to this map if the notification
	* is posted as a non-HUN or when a HUN's state is changed to non-HUN.
	*/
	private Map<String, AlertEntry> mActiveNotifications = new HashMap<>();

	/**
	* Call this if to register this service as a system service and connect to HUN. This is useful
	* if the notification service is being used as a lib instead of a standalone app. The
	* standalone app version has a manifest entry that will have the same effect.
	*
	* @param context Context required for registering the service.
	* @param carUxRestrictionManagerWrapper will have the heads up manager registered with it.
	* @param carHeadsUpNotificationManager HUN controller.
	* @param notificationDataManager used for keeping track of additional notification states.
	*/
	public void registerAsSystemService(Context context,
	CarUxRestrictionManagerWrapper carUxRestrictionManagerWrapper,
	CarHeadsUpNotificationManager carHeadsUpNotificationManager,
	NotificationDataManager notificationDataManager) {
	try {
	mNotificationDataManager = notificationDataManager;
	registerAsSystemService(context,
	new ComponentName(context.getPackageName(), getClass().getCanonicalName()),
	ActivityManager.getCurrentUser());
	mHeadsUpManager = carHeadsUpNotificationManager;
	mHeadsUpManager.registerHeadsUpNotificationStateChangeListener(this);
	carUxRestrictionManagerWrapper.setCarHeadsUpNotificationManager(
	carHeadsUpNotificationManager);
	} catch (RemoteException e) {
	Log.e(TAG, "Unable to register notification listener", e);
	}
	}

	@Override
	public void onCreate() {
	super.onCreate();
	mNotificationDataManager = new NotificationDataManager();
	NotificationApplication app = (NotificationApplication) getApplication();

	app.getClickHandlerFactory().setNotificationDataManager(mNotificationDataManager);
	mHeadsUpManager = new CarHeadsUpNotificationManager(/* context= */ this,
	app.getClickHandlerFactory(), mNotificationDataManager, new CarHeadsUpNotificationAppContainer(this));
	mHeadsUpManager.registerHeadsUpNotificationStateChangeListener(this);
	app.getCarUxRestrictionWrapper().setCarHeadsUpNotificationManager(mHeadsUpManager);
	}

	@Override
	public IBinder onBind(Intent intent) {
	return ACTION_LOCAL_BINDING.equals(intent.getAction())
	? new LocalBinder() : super.onBind(intent);
	}

	@Override
	public void onNotificationPosted(StatusBarNotification sbn, RankingMap rankingMap) {
	if (sbn == null) {
	Log.e(TAG, "onNotificationPosted: StatusBarNotification is null");
	return;
	}

	Log.d(TAG, "onNotificationPosted: " + sbn);
	if (!isNotificationForCurrentUser(sbn)) {
	return;
	}
	AlertEntry alertEntry = new AlertEntry(sbn);
	onNotificationRankingUpdate(rankingMap);
	notifyNotificationPosted(alertEntry);
	}

	@Override
	public void onNotificationRemoved(StatusBarNotification sbn) {
	if (sbn == null) {
	Log.e(TAG, "onNotificationRemoved: StatusBarNotification is null");
	return;
	}

	Log.d(TAG, "onNotificationRemoved: " + sbn);
	AlertEntry alertEntry = mActiveNotifications.get(sbn.getKey());

	if (alertEntry != null) {
	mActiveNotifications.remove(alertEntry.getKey());
	} else {
	// HUN notifications are not tracked in mActiveNotifications but still need to be
	// removed
	alertEntry = new AlertEntry(sbn);
	}

	removeNotification(alertEntry);
	}

	@Override
	public void onNotificationRankingUpdate(RankingMap rankingMap) {
	mRankingMap = rankingMap;
	for (AlertEntry alertEntry : mActiveNotifications.values()) {
	if (!mRankingMap.getRanking(alertEntry.getKey(), mTemporaryRanking)) {
	continue;
	}
	String oldOverrideGroupKey =
	alertEntry.getStatusBarNotification().getOverrideGroupKey();
	String newOverrideGroupKey = getOverrideGroupKey(alertEntry.getKey());
	if (!Objects.equals(oldOverrideGroupKey, newOverrideGroupKey)) {
	alertEntry.getStatusBarNotification().setOverrideGroupKey(newOverrideGroupKey);
	}
	}
	}

	/**
	* Get the override group key of a {@link AlertEntry} given its key.
	*/
	@Nullable
	private String getOverrideGroupKey(String key) {
	if (mRankingMap != null) {
	mRankingMap.getRanking(key, mTemporaryRanking);
	return mTemporaryRanking.getOverrideGroupKey();
	}
	return null;
	}

	/**
	* Get all active notifications that are not heads-up notifications.
	*
	* @return a map of all active notifications with key being the notification key.
	*/
	Map<String, AlertEntry> getNotifications() {
	return mActiveNotifications.entrySet().stream()
	.filter(x -> (isNotificationForCurrentUser(
	x.getValue().getStatusBarNotification())))
	.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
	}

	@Override
	public RankingMap getCurrentRanking() {
	return mRankingMap;
	}

	@Override
	public void onListenerConnected() {
	mActiveNotifications = Stream.of(getActiveNotifications()).collect(
	Collectors.toMap(StatusBarNotification::getKey, sbn -> new AlertEntry(sbn)));
	mRankingMap = super.getCurrentRanking();
	}

	@Override
	public void onListenerDisconnected() {
	}

	public void setHandler(Handler handler) {
	mHandler = handler;
	}

	private void notifyNotificationPosted(AlertEntry alertEntry) {
	if (shouldTrackUnseen(alertEntry)) {
	mNotificationDataManager.addNewMessageNotification(alertEntry);
	} else {
	mNotificationDataManager.untrackUnseenNotification(alertEntry);
	}

	boolean isShowingHeadsUp = mHeadsUpManager.maybeShowHeadsUp(alertEntry, getCurrentRanking(),
	mActiveNotifications);

	if (!isShowingHeadsUp) {
	postNewNotification(alertEntry);
	}
	}

	private boolean isNotificationForCurrentUser(StatusBarNotification sbn) {
	// Notifications should only be shown for the current user and the the notifications from
	// the system when CarNotification is running as SystemUI component.
	return (sbn.getUser().getIdentifier() == ActivityManager.getCurrentUser()
	\|\| sbn.getUser().getIdentifier() == UserHandle.USER_ALL);
	}


	@Override
	public void onStateChange(AlertEntry alertEntry, boolean isHeadsUp) {
	// No more a HUN
	if (!isHeadsUp) {
	postNewNotification(alertEntry);
	}
	}

	class LocalBinder extends Binder {
	public CarNotificationListener getService() {
	return CarNotificationListener.this;
	}
	}

	private void postNewNotification(AlertEntry alertEntry) {
	mActiveNotifications.put(alertEntry.getKey(), alertEntry);
	sendNotificationEventToHandler(alertEntry, NOTIFY_NOTIFICATION_POSTED);
	}

	private void removeNotification(AlertEntry alertEntry) {
	mHeadsUpManager.maybeRemoveHeadsUp(alertEntry);
	sendNotificationEventToHandler(alertEntry, NOTIFY_NOTIFICATION_REMOVED);
	}

	private void sendNotificationEventToHandler(AlertEntry alertEntry, int eventType) {
	if (mHandler == null) {
	return;
	}
	Message msg = Message.obtain(mHandler);
	msg.what = eventType;
	msg.obj = alertEntry;
	mHandler.sendMessage(msg);
	}

	// Don't show unseen markers for <= LOW importance notifications to be consistent
	// with how these notifications are handled on phones
	boolean shouldTrackUnseen(AlertEntry alertEntry) {
	Ranking ranking = new NotificationListenerService.Ranking();
	mRankingMap.getRanking(alertEntry.getKey(), ranking);
	return ranking.getImportance() > NotificationManager.IMPORTANCE_LOW;
	}
	}