9c3cb64e08
Bug: 159442644 Test: adb shell am start -n com.android.settings/.Settings\\\$NotificationStationActivity Change-Id: I5c628ed52bfb44af1cc99ec9fd3dc436fe296344
762 lines
30 KiB
Java
762 lines
30 KiB
Java
/*
|
|
* Copyright (C) 2012 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.settings.notification.history;
|
|
|
|
import static android.provider.Settings.EXTRA_APP_PACKAGE;
|
|
import static android.provider.Settings.EXTRA_CHANNEL_ID;
|
|
|
|
import android.app.Activity;
|
|
import android.app.ActivityManager;
|
|
import android.app.INotificationManager;
|
|
import android.app.Notification;
|
|
import android.app.NotificationChannel;
|
|
import android.app.PendingIntent;
|
|
import android.app.settings.SettingsEnums;
|
|
import android.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.IntentSender;
|
|
import android.content.pm.ApplicationInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.graphics.PorterDuff;
|
|
import android.graphics.Typeface;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.os.Bundle;
|
|
import android.os.Parcel;
|
|
import android.os.RemoteException;
|
|
import android.os.ServiceManager;
|
|
import android.os.UserHandle;
|
|
import android.provider.Settings;
|
|
import android.service.notification.NotificationListenerService;
|
|
import android.service.notification.NotificationListenerService.Ranking;
|
|
import android.service.notification.NotificationListenerService.RankingMap;
|
|
import android.service.notification.StatusBarNotification;
|
|
import android.text.SpannableString;
|
|
import android.text.SpannableStringBuilder;
|
|
import android.text.TextUtils;
|
|
import android.text.style.StyleSpan;
|
|
import android.util.Log;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.widget.DateTimeView;
|
|
import android.widget.ImageView;
|
|
import android.widget.TextView;
|
|
|
|
import androidx.preference.Preference;
|
|
import androidx.preference.PreferenceViewHolder;
|
|
import androidx.recyclerview.widget.RecyclerView;
|
|
|
|
import com.android.settings.R;
|
|
import com.android.settings.SettingsPreferenceFragment;
|
|
import com.android.settings.Utils;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Comparator;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
|
|
public class NotificationStation extends SettingsPreferenceFragment {
|
|
private static final String TAG = NotificationStation.class.getSimpleName();
|
|
|
|
private static final boolean DEBUG = false;
|
|
private static final boolean DUMP_EXTRAS = true;
|
|
private static final boolean DUMP_PARCEL = true;
|
|
|
|
private static class HistoricalNotificationInfo {
|
|
public String key;
|
|
public NotificationChannel channel;
|
|
// Historical notifications don't have Ranking information. for most fields that's ok
|
|
// but we need channel id to launch settings.
|
|
public String channelId;
|
|
public String pkg;
|
|
public Drawable pkgicon;
|
|
public CharSequence pkgname;
|
|
public Drawable icon;
|
|
public boolean badged;
|
|
public CharSequence title;
|
|
public CharSequence text;
|
|
public int priority;
|
|
public int user;
|
|
public long timestamp;
|
|
public boolean active;
|
|
public CharSequence notificationExtra;
|
|
public CharSequence rankingExtra;
|
|
public boolean alerted;
|
|
public boolean visuallyInterruptive;
|
|
|
|
public void updateFrom(HistoricalNotificationInfo updatedInfo) {
|
|
this.channel = updatedInfo.channel;
|
|
this.icon = updatedInfo.icon;
|
|
this.title = updatedInfo.title;
|
|
this.text = updatedInfo.text;
|
|
this.priority = updatedInfo.priority;
|
|
this.timestamp = updatedInfo.timestamp;
|
|
this.active = updatedInfo.active;
|
|
this.alerted = updatedInfo.alerted;
|
|
this.visuallyInterruptive = updatedInfo.visuallyInterruptive;
|
|
this.notificationExtra = updatedInfo.notificationExtra;
|
|
this.rankingExtra = updatedInfo.rankingExtra;
|
|
}
|
|
}
|
|
|
|
private PackageManager mPm;
|
|
private INotificationManager mNoMan;
|
|
private RankingMap mRanking;
|
|
private LinkedList<HistoricalNotificationInfo> mNotificationInfos;
|
|
|
|
private final NotificationListenerService mListener = new NotificationListenerService() {
|
|
@Override
|
|
public void onNotificationPosted(StatusBarNotification sbn, RankingMap ranking) {
|
|
logd("onNotificationPosted: %s, with update for %d", sbn.getNotification(),
|
|
ranking == null ? 0 : ranking.getOrderedKeys().length);
|
|
mRanking = ranking;
|
|
if (sbn.getNotification().isGroupSummary()) {
|
|
return;
|
|
}
|
|
addOrUpdateNotification(sbn);
|
|
}
|
|
|
|
@Override
|
|
public void onNotificationRemoved(StatusBarNotification sbn, RankingMap ranking) {
|
|
logd("onNotificationRankingUpdate with update for %d",
|
|
ranking == null ? 0 : ranking.getOrderedKeys().length);
|
|
mRanking = ranking;
|
|
if (sbn.getNotification().isGroupSummary()) {
|
|
return;
|
|
}
|
|
markNotificationAsDismissed(sbn);
|
|
}
|
|
|
|
@Override
|
|
public void onNotificationRankingUpdate(RankingMap ranking) {
|
|
logd("onNotificationRankingUpdate with update for %d",
|
|
ranking == null ? 0 : ranking.getOrderedKeys().length);
|
|
mRanking = ranking;
|
|
updateNotificationsFromRanking();
|
|
}
|
|
|
|
@Override
|
|
public void onListenerConnected() {
|
|
mRanking = getCurrentRanking();
|
|
logd("onListenerConnected with update for %d",
|
|
mRanking == null ? 0 : mRanking.getOrderedKeys().length);
|
|
populateNotifications();
|
|
}
|
|
};
|
|
|
|
private Context mContext;
|
|
|
|
private final Comparator<HistoricalNotificationInfo> mNotificationSorter
|
|
= (lhs, rhs) -> Long.compare(rhs.timestamp, lhs.timestamp);
|
|
|
|
@Override
|
|
public void onAttach(Activity activity) {
|
|
logd("onAttach(%s)", activity.getClass().getSimpleName());
|
|
super.onAttach(activity);
|
|
mContext = activity;
|
|
mPm = mContext.getPackageManager();
|
|
mNoMan = INotificationManager.Stub.asInterface(
|
|
ServiceManager.getService(Context.NOTIFICATION_SERVICE));
|
|
mNotificationInfos = new LinkedList<>();
|
|
}
|
|
|
|
@Override
|
|
public void onDetach() {
|
|
logd("onDetach()");
|
|
super.onDetach();
|
|
}
|
|
|
|
@Override
|
|
public void onPause() {
|
|
try {
|
|
mListener.unregisterAsSystemService();
|
|
} catch (RemoteException e) {
|
|
Log.e(TAG, "Cannot unregister listener", e);
|
|
}
|
|
super.onPause();
|
|
}
|
|
|
|
@Override
|
|
public int getMetricsCategory() {
|
|
return SettingsEnums.NOTIFICATION_STATION;
|
|
}
|
|
|
|
@Override
|
|
public void onActivityCreated(Bundle savedInstanceState) {
|
|
logd("onActivityCreated(%s)", savedInstanceState);
|
|
super.onActivityCreated(savedInstanceState);
|
|
|
|
RecyclerView listView = getListView();
|
|
Utils.forceCustomPadding(listView, false /* non additive padding */);
|
|
}
|
|
|
|
@Override
|
|
public void onResume() {
|
|
logd("onResume()");
|
|
super.onResume();
|
|
try {
|
|
mListener.registerAsSystemService(mContext, new ComponentName(mContext.getPackageName(),
|
|
this.getClass().getCanonicalName()), ActivityManager.getCurrentUser());
|
|
} catch (RemoteException e) {
|
|
Log.e(TAG, "Cannot register listener", e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds all current and historical notifications when the NLS connects.
|
|
*/
|
|
private void populateNotifications() {
|
|
loadNotifications();
|
|
final int N = mNotificationInfos.size();
|
|
logd("adding %d infos", N);
|
|
if (getPreferenceScreen() == null) {
|
|
setPreferenceScreen(getPreferenceManager().createPreferenceScreen(getContext()));
|
|
}
|
|
getPreferenceScreen().removeAll();
|
|
for (int i = 0; i < N; i++) {
|
|
getPreferenceScreen().addPreference(new HistoricalNotificationPreference(
|
|
getPrefContext(), mNotificationInfos.get(i), i));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Finds and dims the given notification in the preferences list.
|
|
*/
|
|
private void markNotificationAsDismissed(StatusBarNotification sbn) {
|
|
final int N = mNotificationInfos.size();
|
|
for (int i = 0; i < N; i++) {
|
|
final HistoricalNotificationInfo info = mNotificationInfos.get(i);
|
|
if (TextUtils.equals(info.key, sbn.getKey())) {
|
|
info.active = false;
|
|
((HistoricalNotificationPreference) getPreferenceScreen().findPreference(
|
|
sbn.getKey())).updatePreference(info);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Either updates a notification with its latest information or (if it's something the user
|
|
* would consider a new notification) adds a new entry at the start of the list.
|
|
*/
|
|
private void addOrUpdateNotification(StatusBarNotification sbn) {
|
|
HistoricalNotificationInfo newInfo = createFromSbn(sbn, true);
|
|
boolean needsAdd = true;
|
|
final int N = mNotificationInfos.size();
|
|
for (int i = 0; i < N; i++) {
|
|
final HistoricalNotificationInfo info = mNotificationInfos.get(i);
|
|
if (TextUtils.equals(info.key, sbn.getKey()) && info.active
|
|
&& !newInfo.alerted && !newInfo.visuallyInterruptive) {
|
|
info.updateFrom(newInfo);
|
|
|
|
((HistoricalNotificationPreference) getPreferenceScreen().findPreference(
|
|
sbn.getKey())).updatePreference(info);
|
|
needsAdd = false;
|
|
break;
|
|
}
|
|
}
|
|
if (needsAdd) {
|
|
mNotificationInfos.addFirst(newInfo);
|
|
getPreferenceScreen().addPreference(new HistoricalNotificationPreference(
|
|
getPrefContext(), mNotificationInfos.peekFirst(),
|
|
-1 * mNotificationInfos.size()));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Updates all notifications in the list based on new information in the ranking.
|
|
*/
|
|
private void updateNotificationsFromRanking() {
|
|
Ranking rank = new Ranking();
|
|
for (int i = 0; i < getPreferenceScreen().getPreferenceCount(); i++) {
|
|
final HistoricalNotificationPreference p =
|
|
(HistoricalNotificationPreference) getPreferenceScreen().getPreference(i);
|
|
final HistoricalNotificationInfo info = mNotificationInfos.get(i);
|
|
mRanking.getRanking(p.getKey(), rank);
|
|
|
|
updateFromRanking(info);
|
|
((HistoricalNotificationPreference) getPreferenceScreen().findPreference(
|
|
info.key)).updatePreference(info);
|
|
}
|
|
}
|
|
|
|
private static void logd(String msg, Object... args) {
|
|
if (DEBUG) {
|
|
Log.d(TAG, args == null || args.length == 0 ? msg : String.format(msg, args));
|
|
}
|
|
}
|
|
|
|
private static CharSequence bold(CharSequence cs) {
|
|
if (cs.length() == 0) return cs;
|
|
SpannableString ss = new SpannableString(cs);
|
|
ss.setSpan(new StyleSpan(Typeface.BOLD), 0, cs.length(), 0);
|
|
return ss;
|
|
}
|
|
|
|
private static String getTitleString(Notification n) {
|
|
CharSequence title = null;
|
|
if (n.extras != null) {
|
|
title = n.extras.getCharSequence(Notification.EXTRA_TITLE);
|
|
}
|
|
return title == null? null : String.valueOf(title);
|
|
}
|
|
|
|
/**
|
|
* Returns the appropriate substring for this notification based on the style of notification.
|
|
*/
|
|
private static String getTextString(Context appContext, Notification n) {
|
|
CharSequence text = null;
|
|
if (n.extras != null) {
|
|
text = n.extras.getCharSequence(Notification.EXTRA_TEXT);
|
|
|
|
Notification.Builder nb = Notification.Builder.recoverBuilder(appContext, n);
|
|
|
|
if (nb.getStyle() instanceof Notification.BigTextStyle) {
|
|
text = ((Notification.BigTextStyle) nb.getStyle()).getBigText();
|
|
} else if (nb.getStyle() instanceof Notification.MessagingStyle) {
|
|
Notification.MessagingStyle ms = (Notification.MessagingStyle) nb.getStyle();
|
|
final List<Notification.MessagingStyle.Message> messages = ms.getMessages();
|
|
if (messages != null && messages.size() > 0) {
|
|
text = messages.get(messages.size() - 1).getText();
|
|
}
|
|
}
|
|
|
|
if (TextUtils.isEmpty(text)) {
|
|
text = n.extras.getCharSequence(Notification.EXTRA_TEXT);
|
|
}
|
|
}
|
|
return text == null ? null : String.valueOf(text);
|
|
}
|
|
|
|
private Drawable loadIcon(HistoricalNotificationInfo info, StatusBarNotification sbn) {
|
|
Drawable draw = sbn.getNotification().getSmallIcon().loadDrawableAsUser(
|
|
sbn.getPackageContext(mContext), info.user);
|
|
if (draw == null) {
|
|
return null;
|
|
}
|
|
draw.mutate();
|
|
draw.setColorFilter(sbn.getNotification().color, PorterDuff.Mode.SRC_ATOP);
|
|
return draw;
|
|
}
|
|
|
|
private static String formatPendingIntent(PendingIntent pi) {
|
|
final StringBuilder sb = new StringBuilder();
|
|
final IntentSender is = pi.getIntentSender();
|
|
sb.append("Intent(pkg=").append(is.getCreatorPackage());
|
|
try {
|
|
final boolean isActivity =
|
|
ActivityManager.getService().isIntentSenderAnActivity(is.getTarget());
|
|
if (isActivity) sb.append(" (activity)");
|
|
} catch (RemoteException ex) {}
|
|
sb.append(")");
|
|
return sb.toString();
|
|
}
|
|
|
|
/**
|
|
* Reads all current and past notifications (up to the system limit, since the device was
|
|
* booted), stores the data we need to present them, and sorts them chronologically for display.
|
|
*/
|
|
private void loadNotifications() {
|
|
try {
|
|
StatusBarNotification[] active = mNoMan.getActiveNotificationsWithAttribution(
|
|
mContext.getPackageName(), mContext.getAttributionTag());
|
|
StatusBarNotification[] dismissed = mNoMan.getHistoricalNotificationsWithAttribution(
|
|
mContext.getPackageName(), mContext.getAttributionTag(), 50, false);
|
|
|
|
List<HistoricalNotificationInfo> list
|
|
= new ArrayList<>(active.length + dismissed.length);
|
|
|
|
for (StatusBarNotification[] resultSet
|
|
: new StatusBarNotification[][] { active, dismissed }) {
|
|
for (StatusBarNotification sbn : resultSet) {
|
|
if (sbn.getNotification().isGroupSummary()) {
|
|
continue;
|
|
}
|
|
final HistoricalNotificationInfo info = createFromSbn(sbn, resultSet == active);
|
|
logd(" [%d] %s: %s", info.timestamp, info.pkg, info.title);
|
|
list.add(info);
|
|
}
|
|
}
|
|
|
|
// notifications are given to us in the same order as the shade; sorted by inferred
|
|
// priority. Resort chronologically for our display.
|
|
list.sort(mNotificationSorter);
|
|
mNotificationInfos = new LinkedList<>(list);
|
|
|
|
} catch (RemoteException e) {
|
|
Log.e(TAG, "Cannot load Notifications: ", e);
|
|
}
|
|
}
|
|
|
|
private HistoricalNotificationInfo createFromSbn(StatusBarNotification sbn, boolean active) {
|
|
final Notification n = sbn.getNotification();
|
|
final HistoricalNotificationInfo info = new HistoricalNotificationInfo();
|
|
info.pkg = sbn.getPackageName();
|
|
info.user = sbn.getUserId() == UserHandle.USER_ALL
|
|
? UserHandle.USER_SYSTEM : sbn.getUserId();
|
|
info.badged = info.user != ActivityManager.getCurrentUser();
|
|
info.icon = loadIcon(info, sbn);
|
|
if (info.icon == null) {
|
|
info.icon = loadPackageIconDrawable(info.pkg, info.user);
|
|
}
|
|
info.pkgname = loadPackageName(info.pkg);
|
|
info.title = getTitleString(n);
|
|
info.text = getTextString(sbn.getPackageContext(mContext), n);
|
|
info.timestamp = sbn.getPostTime();
|
|
info.priority = n.priority;
|
|
info.key = sbn.getKey();
|
|
info.channelId = sbn.getNotification().getChannelId();
|
|
|
|
info.active = active;
|
|
info.notificationExtra = generateExtraText(sbn, info);
|
|
|
|
updateFromRanking(info);
|
|
|
|
return info;
|
|
}
|
|
|
|
private void updateFromRanking(HistoricalNotificationInfo info) {
|
|
Ranking rank = new Ranking();
|
|
if (mRanking == null) {
|
|
return;
|
|
}
|
|
mRanking.getRanking(info.key, rank);
|
|
info.alerted = rank.getLastAudiblyAlertedMillis() > 0;
|
|
info.visuallyInterruptive = rank.visuallyInterruptive();
|
|
info.channel = rank.getChannel();
|
|
info.rankingExtra = generateRankingExtraText(info);
|
|
}
|
|
|
|
/**
|
|
* Generates a string of debug information for this notification based on the RankingMap
|
|
*/
|
|
private CharSequence generateRankingExtraText(HistoricalNotificationInfo info) {
|
|
final SpannableStringBuilder sb = new SpannableStringBuilder();
|
|
final String delim = getString(R.string.notification_log_details_delimiter);
|
|
|
|
Ranking rank = new Ranking();
|
|
if (mRanking != null && mRanking.getRanking(info.key, rank)) {
|
|
if (info.active && info.alerted) {
|
|
sb.append("\n")
|
|
.append(bold(getString(R.string.notification_log_details_alerted)));
|
|
}
|
|
sb.append("\n")
|
|
.append(bold(getString(R.string.notification_log_channel)))
|
|
.append(delim)
|
|
.append(info.channel.toString());
|
|
sb.append("\n")
|
|
.append(bold("getShortcutInfo"))
|
|
.append(delim)
|
|
.append(String.valueOf(rank.getShortcutInfo()));
|
|
sb.append("\n")
|
|
.append(bold("isConversation"))
|
|
.append(delim)
|
|
.append(rank.isConversation() ? "true" : "false");
|
|
sb.append("\n")
|
|
.append(bold("isBubble"))
|
|
.append(delim)
|
|
.append(rank.isBubble() ? "true" : "false");
|
|
if (info.active) {
|
|
sb.append("\n")
|
|
.append(bold(getString(
|
|
R.string.notification_log_details_importance)))
|
|
.append(delim)
|
|
.append(Ranking.importanceToString(rank.getImportance()));
|
|
if (rank.getImportanceExplanation() != null) {
|
|
sb.append("\n")
|
|
.append(bold(getString(
|
|
R.string.notification_log_details_explanation)))
|
|
.append(delim)
|
|
.append(rank.getImportanceExplanation());
|
|
}
|
|
sb.append("\n")
|
|
.append(bold(getString(
|
|
R.string.notification_log_details_badge)))
|
|
.append(delim)
|
|
.append(Boolean.toString(rank.canShowBadge()));
|
|
}
|
|
} else {
|
|
if (mRanking == null) {
|
|
sb.append("\n")
|
|
.append(bold(getString(
|
|
R.string.notification_log_details_ranking_null)));
|
|
} else {
|
|
sb.append("\n")
|
|
.append(bold(getString(
|
|
R.string.notification_log_details_ranking_none)));
|
|
}
|
|
}
|
|
|
|
return sb;
|
|
}
|
|
|
|
/**
|
|
* Generates a string of debug information for this notification
|
|
*/
|
|
private CharSequence generateExtraText(StatusBarNotification sbn,
|
|
HistoricalNotificationInfo info) {
|
|
final Notification n = sbn.getNotification();
|
|
final SpannableStringBuilder sb = new SpannableStringBuilder();
|
|
final String delim = getString(R.string.notification_log_details_delimiter);
|
|
sb.append(bold(getString(R.string.notification_log_details_package)))
|
|
.append(delim)
|
|
.append(info.pkg)
|
|
.append("\n")
|
|
.append(bold(getString(R.string.notification_log_details_key)))
|
|
.append(delim)
|
|
.append(sbn.getKey());
|
|
sb.append("\n")
|
|
.append(bold(getString(R.string.notification_log_details_icon)))
|
|
.append(delim)
|
|
.append(String.valueOf(n.getSmallIcon()));
|
|
sb.append("\n")
|
|
.append(bold("postTime"))
|
|
.append(delim)
|
|
.append(String.valueOf(sbn.getPostTime()));
|
|
if (n.getTimeoutAfter() != 0) {
|
|
sb.append("\n")
|
|
.append(bold("timeoutAfter"))
|
|
.append(delim)
|
|
.append(String.valueOf(n.getTimeoutAfter()));
|
|
}
|
|
if (sbn.isGroup()) {
|
|
sb.append("\n")
|
|
.append(bold(getString(R.string.notification_log_details_group)))
|
|
.append(delim)
|
|
.append(String.valueOf(sbn.getGroupKey()));
|
|
if (n.isGroupSummary()) {
|
|
sb.append(bold(
|
|
getString(R.string.notification_log_details_group_summary)));
|
|
}
|
|
}
|
|
if (n.publicVersion != null) {
|
|
sb.append("\n")
|
|
.append(bold(getString(
|
|
R.string.notification_log_details_public_version)))
|
|
.append(delim)
|
|
.append(getTitleString(n.publicVersion));
|
|
}
|
|
|
|
if (n.contentIntent != null) {
|
|
sb.append("\n")
|
|
.append(bold(getString(
|
|
R.string.notification_log_details_content_intent)))
|
|
.append(delim)
|
|
.append(formatPendingIntent(n.contentIntent));
|
|
}
|
|
if (n.deleteIntent != null) {
|
|
sb.append("\n")
|
|
.append(bold(getString(
|
|
R.string.notification_log_details_delete_intent)))
|
|
.append(delim)
|
|
.append(formatPendingIntent(n.deleteIntent));
|
|
}
|
|
if (n.fullScreenIntent != null) {
|
|
sb.append("\n")
|
|
.append(bold(getString(
|
|
R.string.notification_log_details_full_screen_intent)))
|
|
.append(delim)
|
|
.append(formatPendingIntent(n.fullScreenIntent));
|
|
}
|
|
if (n.actions != null && n.actions.length > 0) {
|
|
sb.append("\n")
|
|
.append(bold(getString(R.string.notification_log_details_actions)));
|
|
for (int ai=0; ai<n.actions.length; ai++) {
|
|
final Notification.Action action = n.actions[ai];
|
|
sb.append("\n ").append(String.valueOf(ai)).append(' ')
|
|
.append(bold(getString(
|
|
R.string.notification_log_details_title)))
|
|
.append(delim)
|
|
.append(action.title);
|
|
if (action.actionIntent != null) {
|
|
sb.append("\n ")
|
|
.append(bold(getString(
|
|
R.string.notification_log_details_content_intent)))
|
|
.append(delim)
|
|
.append(formatPendingIntent(action.actionIntent));
|
|
}
|
|
if (action.getRemoteInputs() != null) {
|
|
sb.append("\n ")
|
|
.append(bold(getString(
|
|
R.string.notification_log_details_remoteinput)))
|
|
.append(delim)
|
|
.append(String.valueOf(action.getRemoteInputs().length));
|
|
}
|
|
}
|
|
}
|
|
if (n.contentView != null) {
|
|
sb.append("\n")
|
|
.append(bold(getString(
|
|
R.string.notification_log_details_content_view)))
|
|
.append(delim)
|
|
.append(n.contentView.toString());
|
|
}
|
|
if (n.getBubbleMetadata() != null) {
|
|
sb.append("\n")
|
|
.append(bold("bubbleMetadata"))
|
|
.append(delim)
|
|
.append(String.valueOf(n.getBubbleMetadata()));
|
|
}
|
|
if (n.getShortcutId() != null) {
|
|
sb.append("\n")
|
|
.append(bold("shortcutId"))
|
|
.append(delim)
|
|
.append(String.valueOf(n.getShortcutId()));
|
|
}
|
|
|
|
if (DUMP_EXTRAS) {
|
|
if (n.extras != null && n.extras.size() > 0) {
|
|
sb.append("\n")
|
|
.append(bold(getString(
|
|
R.string.notification_log_details_extras)));
|
|
for (String extraKey : n.extras.keySet()) {
|
|
String val = String.valueOf(n.extras.get(extraKey));
|
|
if (val.length() > 100) val = val.substring(0, 100) + "...";
|
|
sb.append("\n ").append(extraKey).append(delim).append(val);
|
|
}
|
|
}
|
|
}
|
|
if (DUMP_PARCEL) {
|
|
final Parcel p = Parcel.obtain();
|
|
n.writeToParcel(p, 0);
|
|
sb.append("\n")
|
|
.append(bold(getString(R.string.notification_log_details_parcel)))
|
|
.append(delim)
|
|
.append(String.valueOf(p.dataPosition()))
|
|
.append(' ')
|
|
.append(bold(getString(R.string.notification_log_details_ashmem)))
|
|
.append(delim)
|
|
.append(String.valueOf(p.getBlobAshmemSize()))
|
|
.append("\n");
|
|
}
|
|
return sb;
|
|
}
|
|
|
|
private Drawable loadPackageIconDrawable(String pkg, int userId) {
|
|
Drawable icon = null;
|
|
try {
|
|
icon = mPm.getApplicationIcon(pkg);
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
Log.e(TAG, "Cannot get application icon", e);
|
|
}
|
|
|
|
return icon;
|
|
}
|
|
|
|
private CharSequence loadPackageName(String pkg) {
|
|
try {
|
|
ApplicationInfo info = mPm.getApplicationInfo(pkg,
|
|
PackageManager.MATCH_ANY_USER);
|
|
if (info != null) return mPm.getApplicationLabel(info);
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
Log.e(TAG, "Cannot load package name", e);
|
|
}
|
|
return pkg;
|
|
}
|
|
|
|
private static class HistoricalNotificationPreference extends Preference {
|
|
private final HistoricalNotificationInfo mInfo;
|
|
private static long sLastExpandedTimestamp; // quick hack to keep things from collapsing
|
|
public ViewGroup mItemView; // hack to update prefs fast;
|
|
private Context mContext;
|
|
|
|
public HistoricalNotificationPreference(Context context, HistoricalNotificationInfo info,
|
|
int order) {
|
|
super(context);
|
|
setLayoutResource(R.layout.notification_log_row);
|
|
setOrder(order);
|
|
setKey(info.key);
|
|
mInfo = info;
|
|
mContext = context;
|
|
}
|
|
|
|
@Override
|
|
public void onBindViewHolder(PreferenceViewHolder row) {
|
|
super.onBindViewHolder(row);
|
|
|
|
mItemView = (ViewGroup) row.itemView;
|
|
|
|
updatePreference(mInfo);
|
|
|
|
row.findViewById(R.id.timestamp).setOnLongClickListener(v -> {
|
|
final View extras = row.findViewById(R.id.extra);
|
|
extras.setVisibility(extras.getVisibility() == View.VISIBLE
|
|
? View.GONE : View.VISIBLE);
|
|
sLastExpandedTimestamp = mInfo.timestamp;
|
|
return false;
|
|
});
|
|
}
|
|
|
|
public void updatePreference(HistoricalNotificationInfo info) {
|
|
if (mItemView == null) {
|
|
return;
|
|
}
|
|
if (info.icon != null) {
|
|
((ImageView) mItemView.findViewById(R.id.icon)).setImageDrawable(mInfo.icon);
|
|
}
|
|
((TextView) mItemView.findViewById(R.id.pkgname)).setText(mInfo.pkgname);
|
|
((DateTimeView) mItemView.findViewById(R.id.timestamp)).setTime(info.timestamp);
|
|
if (!TextUtils.isEmpty(info.title)) {
|
|
((TextView) mItemView.findViewById(R.id.title)).setText(info.title);
|
|
mItemView.findViewById(R.id.title).setVisibility(View.VISIBLE);
|
|
} else {
|
|
mItemView.findViewById(R.id.title).setVisibility(View.GONE);
|
|
}
|
|
if (!TextUtils.isEmpty(info.text)) {
|
|
((TextView) mItemView.findViewById(R.id.text)).setText(info.text);
|
|
mItemView.findViewById(R.id.text).setVisibility(View.VISIBLE);
|
|
} else {
|
|
mItemView.findViewById(R.id.text).setVisibility(View.GONE);
|
|
}
|
|
if (info.icon != null) {
|
|
((ImageView) mItemView.findViewById(R.id.icon)).setImageDrawable(info.icon);
|
|
}
|
|
|
|
ImageView profileBadge = mItemView.findViewById(R.id.profile_badge);
|
|
Drawable profile = mContext.getPackageManager().getUserBadgeForDensity(
|
|
UserHandle.of(info.user), -1);
|
|
profileBadge.setImageDrawable(profile);
|
|
profileBadge.setVisibility(info.badged ? View.VISIBLE : View.GONE);
|
|
|
|
((DateTimeView) mItemView.findViewById(R.id.timestamp)).setTime(mInfo.timestamp);
|
|
|
|
((TextView) mItemView.findViewById(R.id.notification_extra))
|
|
.setText(mInfo.notificationExtra);
|
|
((TextView) mItemView.findViewById(R.id.ranking_extra))
|
|
.setText(mInfo.rankingExtra);
|
|
|
|
mItemView.findViewById(R.id.extra).setVisibility(
|
|
mInfo.timestamp == sLastExpandedTimestamp ? View.VISIBLE : View.GONE);
|
|
|
|
mItemView.setAlpha(mInfo.active ? 1.0f : 0.5f);
|
|
|
|
mItemView.findViewById(R.id.alerted_icon).setVisibility(
|
|
mInfo.alerted ? View.VISIBLE : View.GONE);
|
|
}
|
|
|
|
@Override
|
|
public void performClick() {
|
|
Intent intent = new Intent(Settings.ACTION_CHANNEL_NOTIFICATION_SETTINGS)
|
|
.putExtra(EXTRA_APP_PACKAGE, mInfo.pkg)
|
|
.putExtra(EXTRA_CHANNEL_ID,
|
|
mInfo.channel != null ? mInfo.channel.getId() : mInfo.channelId);
|
|
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
|
|
getContext().startActivity(intent);
|
|
}
|
|
}
|
|
}
|