services/core/java/com/android/server/notification/RankingHelper.java - platform/frameworks/base - Git at Google

 /**
  * Copyright (c) 2014, 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.server.notification;

 import android.app.Notification;
 import android.content.Context;
 import android.os.Handler;
 import android.os.Message;
 import android.os.UserHandle;
 import android.service.notification.NotificationListenerService;
 import android.text.TextUtils;
 import android.util.ArrayMap;
 import android.util.ArraySet;
 import android.util.Log;
 import android.util.Slog;
 import android.util.SparseIntArray;
 import org.xmlpull.v1.XmlPullParser;
 import org.xmlpull.v1.XmlPullParserException;
 import org.xmlpull.v1.XmlSerializer;

 import java.io.IOException;
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;

 public class RankingHelper implements RankingConfig {
     private static final String TAG = "RankingHelper";
     private static final boolean DEBUG = false;

     private static final int XML_VERSION = 1;

     private static final String TAG_RANKING = "ranking";
     private static final String TAG_PACKAGE = "package";
     private static final String ATT_VERSION = "version";

     private static final String ATT_NAME = "name";
     private static final String ATT_UID = "uid";
     private static final String ATT_PRIORITY = "priority";
     private static final String ATT_VISIBILITY = "visibility";

     private final NotificationSignalExtractor[] mSignalExtractors;
     private final NotificationComparator mPreliminaryComparator = new NotificationComparator();
     private final GlobalSortKeyComparator mFinalComparator = new GlobalSortKeyComparator();

     // Package name to uid, to priority. Would be better as Table<String, Int, Int>
     private final ArrayMap<String, SparseIntArray> mPackagePriorities;
     private final ArrayMap<String, SparseIntArray> mPackageVisibilities;
     private final ArrayMap<String, NotificationRecord> mProxyByGroupTmp;

     private final Context mContext;
     private final Handler mRankingHandler;

     public RankingHelper(Context context, Handler rankingHandler, String[] extractorNames) {
         mContext = context;
         mRankingHandler = rankingHandler;
         mPackagePriorities = new ArrayMap<String, SparseIntArray>();
         mPackageVisibilities = new ArrayMap<String, SparseIntArray>();

         final int N = extractorNames.length;
         mSignalExtractors = new NotificationSignalExtractor[N];
         for (int i = 0; i < N; i++) {
             try {
                 Class<?> extractorClass = mContext.getClassLoader().loadClass(extractorNames[i]);
                 NotificationSignalExtractor extractor =
                         (NotificationSignalExtractor) extractorClass.newInstance();
                 extractor.initialize(mContext);
                 extractor.setConfig(this);
                 mSignalExtractors[i] = extractor;
             } catch (ClassNotFoundException e) {
                 Slog.w(TAG, "Couldn't find extractor " + extractorNames[i] + ".", e);
             } catch (InstantiationException e) {
                 Slog.w(TAG, "Couldn't instantiate extractor " + extractorNames[i] + ".", e);
             } catch (IllegalAccessException e) {
                 Slog.w(TAG, "Problem accessing extractor " + extractorNames[i] + ".", e);
             }
         }
         mProxyByGroupTmp = new ArrayMap<String, NotificationRecord>();
     }

     public <T extends NotificationSignalExtractor> T findExtractor(Class<T> extractorClass) {
         final int N = mSignalExtractors.length;
         for (int i = 0; i < N; i++) {
             final NotificationSignalExtractor extractor = mSignalExtractors[i];
             if (extractorClass.equals(extractor.getClass())) {
                 return (T) extractor;
             }
         }
         return null;
     }

     public void extractSignals(NotificationRecord r) {
         final int N = mSignalExtractors.length;
         for (int i = 0; i < N; i++) {
             NotificationSignalExtractor extractor = mSignalExtractors[i];
             try {
                 RankingReconsideration recon = extractor.process(r);
                 if (recon != null) {
                     Message m = Message.obtain(mRankingHandler,
                             NotificationManagerService.MESSAGE_RECONSIDER_RANKING, recon);
                     long delay = recon.getDelay(TimeUnit.MILLISECONDS);
                     mRankingHandler.sendMessageDelayed(m, delay);
                 }
             } catch (Throwable t) {
                 Slog.w(TAG, "NotificationSignalExtractor failed.", t);
             }
         }
     }

     public void readXml(XmlPullParser parser) throws XmlPullParserException, IOException {
         int type = parser.getEventType();
         if (type != XmlPullParser.START_TAG) return;
         String tag = parser.getName();
         if (!TAG_RANKING.equals(tag)) return;
         mPackagePriorities.clear();
         final int version = safeInt(parser, ATT_VERSION, XML_VERSION);
         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) {
             tag = parser.getName();
             if (type == XmlPullParser.END_TAG && TAG_RANKING.equals(tag)) {
                 return;
             }
             if (type == XmlPullParser.START_TAG) {
                 if (TAG_PACKAGE.equals(tag)) {
                     int uid = safeInt(parser, ATT_UID, UserHandle.USER_ALL);
                     int priority = safeInt(parser, ATT_PRIORITY, Notification.PRIORITY_DEFAULT);
                     int vis = safeInt(parser, ATT_VISIBILITY,
                             NotificationListenerService.Ranking.VISIBILITY_NO_OVERRIDE);
                     String name = parser.getAttributeValue(null, ATT_NAME);

                     if (!TextUtils.isEmpty(name)) {
                         if (priority != Notification.PRIORITY_DEFAULT) {
                             SparseIntArray priorityByUid = mPackagePriorities.get(name);
                             if (priorityByUid == null) {
                                 priorityByUid = new SparseIntArray();
                                 mPackagePriorities.put(name, priorityByUid);
                             }
                             priorityByUid.put(uid, priority);
                         }
                         if (vis != NotificationListenerService.Ranking.VISIBILITY_NO_OVERRIDE) {
                             SparseIntArray visibilityByUid = mPackageVisibilities.get(name);
                             if (visibilityByUid == null) {
                                 visibilityByUid = new SparseIntArray();
                                 mPackageVisibilities.put(name, visibilityByUid);
                             }
                             visibilityByUid.put(uid, vis);
                         }
                     }
                 }
             }
         }
         throw new IllegalStateException("Failed to reach END_DOCUMENT");
     }

     public void writeXml(XmlSerializer out) throws IOException {
         out.startTag(null, TAG_RANKING);
         out.attribute(null, ATT_VERSION, Integer.toString(XML_VERSION));

         final Set<String> packageNames = new ArraySet<>(mPackagePriorities.size()
                 + mPackageVisibilities.size());
         packageNames.addAll(mPackagePriorities.keySet());
         packageNames.addAll(mPackageVisibilities.keySet());
         final Set<Integer> packageUids = new ArraySet<>();
         for (String packageName : packageNames) {
             packageUids.clear();
             SparseIntArray priorityByUid = mPackagePriorities.get(packageName);
             SparseIntArray visibilityByUid = mPackageVisibilities.get(packageName);
             if (priorityByUid != null) {
                 final int M = priorityByUid.size();
                 for (int j = 0; j < M; j++) {
                     packageUids.add(priorityByUid.keyAt(j));
                 }
             }
             if (visibilityByUid != null) {
                 final int M = visibilityByUid.size();
                 for (int j = 0; j < M; j++) {
                     packageUids.add(visibilityByUid.keyAt(j));
                 }
             }
             for (Integer uid : packageUids) {
                 out.startTag(null, TAG_PACKAGE);
                 out.attribute(null, ATT_NAME, packageName);
                 if (priorityByUid != null) {
                     final int priority = priorityByUid.get(uid);
                     if (priority != Notification.PRIORITY_DEFAULT) {
                         out.attribute(null, ATT_PRIORITY, Integer.toString(priority));
                     }
                 }
                 if (visibilityByUid != null) {
                     final int visibility = visibilityByUid.get(uid);
                     if (visibility != NotificationListenerService.Ranking.VISIBILITY_NO_OVERRIDE) {
                         out.attribute(null, ATT_VISIBILITY, Integer.toString(visibility));
                     }
                 }
                 out.attribute(null, ATT_UID, Integer.toString(uid));
                 out.endTag(null, TAG_PACKAGE);
             }
         }
         out.endTag(null, TAG_RANKING);
     }

     private void updateConfig() {
         final int N = mSignalExtractors.length;
         for (int i = 0; i < N; i++) {
             mSignalExtractors[i].setConfig(this);
         }
         mRankingHandler.sendEmptyMessage(NotificationManagerService.MESSAGE_RANKING_CONFIG_CHANGE);
     }

     public void sort(ArrayList<NotificationRecord> notificationList) {
         final int N = notificationList.size();
         // clear global sort keys
         for (int i = N - 1; i >= 0; i--) {
             notificationList.get(i).setGlobalSortKey(null);
         }

         // rank each record individually
         Collections.sort(notificationList, mPreliminaryComparator);

         synchronized (mProxyByGroupTmp) {
             // record individual ranking result and nominate proxies for each group
             for (int i = N - 1; i >= 0; i--) {
                 final NotificationRecord record = notificationList.get(i);
                 record.setAuthoritativeRank(i);
                 final String groupKey = record.getGroupKey();
                 boolean isGroupSummary = record.getNotification().isGroupSummary();
                 if (isGroupSummary || !mProxyByGroupTmp.containsKey(groupKey)) {
                     mProxyByGroupTmp.put(groupKey, record);
                 }
             }
             // assign global sort key:
             //   is_recently_intrusive:group_rank:is_group_summary:group_sort_key:rank
             for (int i = 0; i < N; i++) {
                 final NotificationRecord record = notificationList.get(i);
                 NotificationRecord groupProxy = mProxyByGroupTmp.get(record.getGroupKey());
                 String groupSortKey = record.getNotification().getSortKey();

                 // We need to make sure the developer provided group sort key (gsk) is handled
                 // correctly:
                 //   gsk="" < gsk=non-null-string < gsk=null
                 //
                 // We enforce this by using different prefixes for these three cases.
                 String groupSortKeyPortion;
                 if (groupSortKey == null) {
                     groupSortKeyPortion = "nsk";
                 } else if (groupSortKey.equals("")) {
                     groupSortKeyPortion = "esk";
                 } else {
                     groupSortKeyPortion = "gsk=" + groupSortKey;
                 }

                 boolean isGroupSummary = record.getNotification().isGroupSummary();
                 record.setGlobalSortKey(
                         String.format("intrsv=%c:grnk=0x%04x:gsmry=%c:%s:rnk=0x%04x",
                         record.isRecentlyIntrusive() ? '0' : '1',
                         groupProxy.getAuthoritativeRank(),
                         isGroupSummary ? '0' : '1',
                         groupSortKeyPortion,
                         record.getAuthoritativeRank()));
             }
             mProxyByGroupTmp.clear();
         }

         // Do a second ranking pass, using group proxies
         Collections.sort(notificationList, mFinalComparator);
     }

     public int indexOf(ArrayList<NotificationRecord> notificationList, NotificationRecord target) {
         return Collections.binarySearch(notificationList, target, mFinalComparator);
     }

     private static int safeInt(XmlPullParser parser, String att, int defValue) {
         final String val = parser.getAttributeValue(null, att);
         return tryParseInt(val, defValue);
     }

     private static int tryParseInt(String value, int defValue) {
         if (TextUtils.isEmpty(value)) return defValue;
         try {
             return Integer.valueOf(value);
         } catch (NumberFormatException e) {
             return defValue;
         }
     }

     @Override
     public int getPackagePriority(String packageName, int uid) {
         int priority = Notification.PRIORITY_DEFAULT;
         SparseIntArray priorityByUid = mPackagePriorities.get(packageName);
         if (priorityByUid != null) {
             priority = priorityByUid.get(uid, Notification.PRIORITY_DEFAULT);
         }
         return priority;
     }

     @Override
     public void setPackagePriority(String packageName, int uid, int priority) {
         if (priority == getPackagePriority(packageName, uid)) {
             return;
         }
         SparseIntArray priorityByUid = mPackagePriorities.get(packageName);
         if (priorityByUid == null) {
             priorityByUid = new SparseIntArray();
             mPackagePriorities.put(packageName, priorityByUid);
         }
         priorityByUid.put(uid, priority);
         updateConfig();
     }

     @Override
     public int getPackageVisibilityOverride(String packageName, int uid) {
         int visibility = NotificationListenerService.Ranking.VISIBILITY_NO_OVERRIDE;
         SparseIntArray visibilityByUid = mPackageVisibilities.get(packageName);
         if (visibilityByUid != null) {
             visibility = visibilityByUid.get(uid,
                     NotificationListenerService.Ranking.VISIBILITY_NO_OVERRIDE);
         }
         return visibility;
     }

     @Override
     public void setPackageVisibilityOverride(String packageName, int uid, int visibility) {
         if (visibility == getPackageVisibilityOverride(packageName, uid)) {
             return;
         }
         SparseIntArray visibilityByUid = mPackageVisibilities.get(packageName);
         if (visibilityByUid == null) {
             visibilityByUid = new SparseIntArray();
             mPackageVisibilities.put(packageName, visibilityByUid);
         }
         visibilityByUid.put(uid, visibility);
         updateConfig();
     }

     public void dump(PrintWriter pw, String prefix, NotificationManagerService.DumpFilter filter) {
         if (filter == null) {
             final int N = mSignalExtractors.length;
             pw.print(prefix);
             pw.print("mSignalExtractors.length = ");
             pw.println(N);
             for (int i = 0; i < N; i++) {
                 pw.print(prefix);
                 pw.print("  ");
                 pw.println(mSignalExtractors[i]);
             }
         }
         final int N = mPackagePriorities.size();
         if (filter == null) {
             pw.print(prefix);
             pw.println("package priorities:");
         }
         for (int i = 0; i < N; i++) {
             String name = mPackagePriorities.keyAt(i);
             if (filter == null || filter.matches(name)) {
                 SparseIntArray priorityByUid = mPackagePriorities.get(name);
                 final int M = priorityByUid.size();
                 for (int j = 0; j < M; j++) {
                     int uid = priorityByUid.keyAt(j);
                     int priority = priorityByUid.get(uid);
                     pw.print(prefix);
                     pw.print("  ");
                     pw.print(name);
                     pw.print(" (");
                     pw.print(uid);
                     pw.print(") has priority: ");
                     pw.println(priority);
                 }
             }
         }
     }
 }
	/**
	* Copyright (c) 2014, 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.server.notification;

	import android.app.Notification;
	import android.content.Context;
	import android.os.Handler;
	import android.os.Message;
	import android.os.UserHandle;
	import android.service.notification.NotificationListenerService;
	import android.text.TextUtils;
	import android.util.ArrayMap;
	import android.util.ArraySet;
	import android.util.Log;
	import android.util.Slog;
	import android.util.SparseIntArray;
	import org.xmlpull.v1.XmlPullParser;
	import org.xmlpull.v1.XmlPullParserException;
	import org.xmlpull.v1.XmlSerializer;

	import java.io.IOException;
	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Set;
	import java.util.concurrent.TimeUnit;

	public class RankingHelper implements RankingConfig {
	private static final String TAG = "RankingHelper";
	private static final boolean DEBUG = false;

	private static final int XML_VERSION = 1;

	private static final String TAG_RANKING = "ranking";
	private static final String TAG_PACKAGE = "package";
	private static final String ATT_VERSION = "version";

	private static final String ATT_NAME = "name";
	private static final String ATT_UID = "uid";
	private static final String ATT_PRIORITY = "priority";
	private static final String ATT_VISIBILITY = "visibility";

	private final NotificationSignalExtractor[] mSignalExtractors;
	private final NotificationComparator mPreliminaryComparator = new NotificationComparator();
	private final GlobalSortKeyComparator mFinalComparator = new GlobalSortKeyComparator();

	// Package name to uid, to priority. Would be better as Table<String, Int, Int>
	private final ArrayMap<String, SparseIntArray> mPackagePriorities;
	private final ArrayMap<String, SparseIntArray> mPackageVisibilities;
	private final ArrayMap<String, NotificationRecord> mProxyByGroupTmp;

	private final Context mContext;
	private final Handler mRankingHandler;

	public RankingHelper(Context context, Handler rankingHandler, String[] extractorNames) {
	mContext = context;
	mRankingHandler = rankingHandler;
	mPackagePriorities = new ArrayMap<String, SparseIntArray>();
	mPackageVisibilities = new ArrayMap<String, SparseIntArray>();

	final int N = extractorNames.length;
	mSignalExtractors = new NotificationSignalExtractor[N];
	for (int i = 0; i < N; i++) {
	try {
	Class<?> extractorClass = mContext.getClassLoader().loadClass(extractorNames[i]);
	NotificationSignalExtractor extractor =
	(NotificationSignalExtractor) extractorClass.newInstance();
	extractor.initialize(mContext);
	extractor.setConfig(this);
	mSignalExtractors[i] = extractor;
	} catch (ClassNotFoundException e) {
	Slog.w(TAG, "Couldn't find extractor " + extractorNames[i] + ".", e);
	} catch (InstantiationException e) {
	Slog.w(TAG, "Couldn't instantiate extractor " + extractorNames[i] + ".", e);
	} catch (IllegalAccessException e) {
	Slog.w(TAG, "Problem accessing extractor " + extractorNames[i] + ".", e);
	}
	}
	mProxyByGroupTmp = new ArrayMap<String, NotificationRecord>();
	}

	public <T extends NotificationSignalExtractor> T findExtractor(Class<T> extractorClass) {
	final int N = mSignalExtractors.length;
	for (int i = 0; i < N; i++) {
	final NotificationSignalExtractor extractor = mSignalExtractors[i];
	if (extractorClass.equals(extractor.getClass())) {
	return (T) extractor;
	}
	}
	return null;
	}

	public void extractSignals(NotificationRecord r) {
	final int N = mSignalExtractors.length;
	for (int i = 0; i < N; i++) {
	NotificationSignalExtractor extractor = mSignalExtractors[i];
	try {
	RankingReconsideration recon = extractor.process(r);
	if (recon != null) {
	Message m = Message.obtain(mRankingHandler,
	NotificationManagerService.MESSAGE_RECONSIDER_RANKING, recon);
	long delay = recon.getDelay(TimeUnit.MILLISECONDS);
	mRankingHandler.sendMessageDelayed(m, delay);
	}
	} catch (Throwable t) {
	Slog.w(TAG, "NotificationSignalExtractor failed.", t);
	}
	}
	}

	public void readXml(XmlPullParser parser) throws XmlPullParserException, IOException {
	int type = parser.getEventType();
	if (type != XmlPullParser.START_TAG) return;
	String tag = parser.getName();
	if (!TAG_RANKING.equals(tag)) return;
	mPackagePriorities.clear();
	final int version = safeInt(parser, ATT_VERSION, XML_VERSION);
	while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) {
	tag = parser.getName();
	if (type == XmlPullParser.END_TAG && TAG_RANKING.equals(tag)) {
	return;
	}
	if (type == XmlPullParser.START_TAG) {
	if (TAG_PACKAGE.equals(tag)) {
	int uid = safeInt(parser, ATT_UID, UserHandle.USER_ALL);
	int priority = safeInt(parser, ATT_PRIORITY, Notification.PRIORITY_DEFAULT);
	int vis = safeInt(parser, ATT_VISIBILITY,
	NotificationListenerService.Ranking.VISIBILITY_NO_OVERRIDE);
	String name = parser.getAttributeValue(null, ATT_NAME);

	if (!TextUtils.isEmpty(name)) {
	if (priority != Notification.PRIORITY_DEFAULT) {
	SparseIntArray priorityByUid = mPackagePriorities.get(name);
	if (priorityByUid == null) {
	priorityByUid = new SparseIntArray();
	mPackagePriorities.put(name, priorityByUid);
	}
	priorityByUid.put(uid, priority);
	}
	if (vis != NotificationListenerService.Ranking.VISIBILITY_NO_OVERRIDE) {
	SparseIntArray visibilityByUid = mPackageVisibilities.get(name);
	if (visibilityByUid == null) {
	visibilityByUid = new SparseIntArray();
	mPackageVisibilities.put(name, visibilityByUid);
	}
	visibilityByUid.put(uid, vis);
	}
	}
	}
	}
	}
	throw new IllegalStateException("Failed to reach END_DOCUMENT");
	}

	public void writeXml(XmlSerializer out) throws IOException {
	out.startTag(null, TAG_RANKING);
	out.attribute(null, ATT_VERSION, Integer.toString(XML_VERSION));

	final Set<String> packageNames = new ArraySet<>(mPackagePriorities.size()
	+ mPackageVisibilities.size());
	packageNames.addAll(mPackagePriorities.keySet());
	packageNames.addAll(mPackageVisibilities.keySet());
	final Set<Integer> packageUids = new ArraySet<>();
	for (String packageName : packageNames) {
	packageUids.clear();
	SparseIntArray priorityByUid = mPackagePriorities.get(packageName);
	SparseIntArray visibilityByUid = mPackageVisibilities.get(packageName);
	if (priorityByUid != null) {
	final int M = priorityByUid.size();
	for (int j = 0; j < M; j++) {
	packageUids.add(priorityByUid.keyAt(j));
	}
	}
	if (visibilityByUid != null) {
	final int M = visibilityByUid.size();
	for (int j = 0; j < M; j++) {
	packageUids.add(visibilityByUid.keyAt(j));
	}
	}
	for (Integer uid : packageUids) {
	out.startTag(null, TAG_PACKAGE);
	out.attribute(null, ATT_NAME, packageName);
	if (priorityByUid != null) {
	final int priority = priorityByUid.get(uid);
	if (priority != Notification.PRIORITY_DEFAULT) {
	out.attribute(null, ATT_PRIORITY, Integer.toString(priority));
	}
	}
	if (visibilityByUid != null) {
	final int visibility = visibilityByUid.get(uid);
	if (visibility != NotificationListenerService.Ranking.VISIBILITY_NO_OVERRIDE) {
	out.attribute(null, ATT_VISIBILITY, Integer.toString(visibility));
	}
	}
	out.attribute(null, ATT_UID, Integer.toString(uid));
	out.endTag(null, TAG_PACKAGE);
	}
	}
	out.endTag(null, TAG_RANKING);
	}

	private void updateConfig() {
	final int N = mSignalExtractors.length;
	for (int i = 0; i < N; i++) {
	mSignalExtractors[i].setConfig(this);
	}
	mRankingHandler.sendEmptyMessage(NotificationManagerService.MESSAGE_RANKING_CONFIG_CHANGE);
	}

	public void sort(ArrayList<NotificationRecord> notificationList) {
	final int N = notificationList.size();
	// clear global sort keys
	for (int i = N - 1; i >= 0; i--) {
	notificationList.get(i).setGlobalSortKey(null);
	}

	// rank each record individually
	Collections.sort(notificationList, mPreliminaryComparator);

	synchronized (mProxyByGroupTmp) {
	// record individual ranking result and nominate proxies for each group
	for (int i = N - 1; i >= 0; i--) {
	final NotificationRecord record = notificationList.get(i);
	record.setAuthoritativeRank(i);
	final String groupKey = record.getGroupKey();
	boolean isGroupSummary = record.getNotification().isGroupSummary();
	if (isGroupSummary \|\| !mProxyByGroupTmp.containsKey(groupKey)) {
	mProxyByGroupTmp.put(groupKey, record);
	}
	}
	// assign global sort key:
	// is_recently_intrusive:group_rank:is_group_summary:group_sort_key:rank
	for (int i = 0; i < N; i++) {
	final NotificationRecord record = notificationList.get(i);
	NotificationRecord groupProxy = mProxyByGroupTmp.get(record.getGroupKey());
	String groupSortKey = record.getNotification().getSortKey();

	// We need to make sure the developer provided group sort key (gsk) is handled
	// correctly:
	// gsk="" < gsk=non-null-string < gsk=null
	//
	// We enforce this by using different prefixes for these three cases.
	String groupSortKeyPortion;
	if (groupSortKey == null) {
	groupSortKeyPortion = "nsk";
	} else if (groupSortKey.equals("")) {
	groupSortKeyPortion = "esk";
	} else {
	groupSortKeyPortion = "gsk=" + groupSortKey;
	}

	boolean isGroupSummary = record.getNotification().isGroupSummary();
	record.setGlobalSortKey(
	String.format("intrsv=%c:grnk=0x%04x:gsmry=%c:%s:rnk=0x%04x",
	record.isRecentlyIntrusive() ? '0' : '1',
	groupProxy.getAuthoritativeRank(),
	isGroupSummary ? '0' : '1',
	groupSortKeyPortion,
	record.getAuthoritativeRank()));
	}
	mProxyByGroupTmp.clear();
	}

	// Do a second ranking pass, using group proxies
	Collections.sort(notificationList, mFinalComparator);
	}

	public int indexOf(ArrayList<NotificationRecord> notificationList, NotificationRecord target) {
	return Collections.binarySearch(notificationList, target, mFinalComparator);
	}

	private static int safeInt(XmlPullParser parser, String att, int defValue) {
	final String val = parser.getAttributeValue(null, att);
	return tryParseInt(val, defValue);
	}

	private static int tryParseInt(String value, int defValue) {
	if (TextUtils.isEmpty(value)) return defValue;
	try {
	return Integer.valueOf(value);
	} catch (NumberFormatException e) {
	return defValue;
	}
	}

	@Override
	public int getPackagePriority(String packageName, int uid) {
	int priority = Notification.PRIORITY_DEFAULT;
	SparseIntArray priorityByUid = mPackagePriorities.get(packageName);
	if (priorityByUid != null) {
	priority = priorityByUid.get(uid, Notification.PRIORITY_DEFAULT);
	}
	return priority;
	}

	@Override
	public void setPackagePriority(String packageName, int uid, int priority) {
	if (priority == getPackagePriority(packageName, uid)) {
	return;
	}
	SparseIntArray priorityByUid = mPackagePriorities.get(packageName);
	if (priorityByUid == null) {
	priorityByUid = new SparseIntArray();
	mPackagePriorities.put(packageName, priorityByUid);
	}
	priorityByUid.put(uid, priority);
	updateConfig();
	}

	@Override
	public int getPackageVisibilityOverride(String packageName, int uid) {
	int visibility = NotificationListenerService.Ranking.VISIBILITY_NO_OVERRIDE;
	SparseIntArray visibilityByUid = mPackageVisibilities.get(packageName);
	if (visibilityByUid != null) {
	visibility = visibilityByUid.get(uid,
	NotificationListenerService.Ranking.VISIBILITY_NO_OVERRIDE);
	}
	return visibility;
	}

	@Override
	public void setPackageVisibilityOverride(String packageName, int uid, int visibility) {
	if (visibility == getPackageVisibilityOverride(packageName, uid)) {
	return;
	}
	SparseIntArray visibilityByUid = mPackageVisibilities.get(packageName);
	if (visibilityByUid == null) {
	visibilityByUid = new SparseIntArray();
	mPackageVisibilities.put(packageName, visibilityByUid);
	}
	visibilityByUid.put(uid, visibility);
	updateConfig();
	}

	public void dump(PrintWriter pw, String prefix, NotificationManagerService.DumpFilter filter) {
	if (filter == null) {
	final int N = mSignalExtractors.length;
	pw.print(prefix);
	pw.print("mSignalExtractors.length = ");
	pw.println(N);
	for (int i = 0; i < N; i++) {
	pw.print(prefix);
	pw.print(" ");
	pw.println(mSignalExtractors[i]);
	}
	}
	final int N = mPackagePriorities.size();
	if (filter == null) {
	pw.print(prefix);
	pw.println("package priorities:");
	}
	for (int i = 0; i < N; i++) {
	String name = mPackagePriorities.keyAt(i);
	if (filter == null \|\| filter.matches(name)) {
	SparseIntArray priorityByUid = mPackagePriorities.get(name);
	final int M = priorityByUid.size();
	for (int j = 0; j < M; j++) {
	int uid = priorityByUid.keyAt(j);
	int priority = priorityByUid.get(uid);
	pw.print(prefix);
	pw.print(" ");
	pw.print(name);
	pw.print(" (");
	pw.print(uid);
	pw.print(") has priority: ");
	pw.println(priority);
	}
	}
	}
	}
	}