Android P通知发送源码分析

最新推荐文章于 2024-09-07 17:25:13 发布
最新推荐文章于 2024-09-07 17:25:13 发布
阅读量1.2k 收藏 5
点赞数 1
分类专栏： Android 文章标签： notification
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_33585352/article/details/88061535
版权

Notification源码分析

  • Android 0 以上发送一条消息的示例代码：
 
    @RequiresApi(api = Build.VERSION_CODES.O)
    public void sendNotification(View view) {
        String id = "channel_1";
        String des = "101";
        NotificationChannel channel = new NotificationChannel(id, des, NotificationManager.IMPORTANCE_MIN);
        notificationManager.createNotificationChannel(channel);
        Notification notification = new Notification.Builder(MainActivity.this, id)
                .setContentTitle("Base Notification View")
                .setContentText("您有一条新通知")
                .setSmallIcon(R.drawable.jd_icon)
                .setStyle(new Notification.MediaStyle())
                .setAutoCancel(false)
                .build();
        notificationManager.notify(1, notification);
    }
  • 发送通知的源码

应用调用Notification.notify()接口发送通知，然后会进入system_server进程，调用NotificationManagerService的enqueueNotificationWithTag()。

@UnsupportedAppUsage
    public void notifyAsUser(String tag, int id, Notification notification, UserHandle user)
    {
    	//获取NotificationManagerService
        INotificationManager service = getService();
        String pkg = mContext.getPackageName();
        // Fix the notification as best we can.
        主要是向notification加入应用信息和用户ID
        Notification.addFieldsFromContext(mContext, notification);

        if (notification.sound != null) {
            notification.sound = notification.sound.getCanonicalUri();
            if (StrictMode.vmFileUriExposureEnabled()) {
                notification.sound.checkFileUriExposed("Notification.sound");
            }

        }
        //修复一些icon问题,如果没有就给他指定一个
        fixLegacySmallIcon(notification, pkg);
        if (mContext.getApplicationInfo().targetSdkVersion > Build.VERSION_CODES.LOLLIPOP_MR1) {
            if (notification.getSmallIcon() == null) {
                throw new IllegalArgumentException("Invalid notification (no valid small icon): "
                        + notification);
            }
        }
        if (localLOGV) Log.v(TAG, pkg + ": notify(" + id + ", " + notification + ")");
        notification.reduceImageSizes(mContext);

        ActivityManager am = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);
        boolean isLowRam = am.isLowRamDevice();
        final Notification copy = Builder.maybeCloneStrippedForDelivery(notification, isLowRam,
                mContext);
        try {
        //通知信息发送给NotificationManagerService
            service.enqueueNotificationWithTag(pkg, mContext.getOpPackageName(), tag, id,
                    copy, user.getIdentifier());
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    }
  • enqueueNotificationInternal方法里面执行检查通知的合法性以及与系统设置通知等相关操作，对要加入到状态栏里面的通知做了严格的检查。
void enqueueNotificationInternal(final String pkg, final String opPkg, final int callingUid,
            final int callingPid, final String tag, final int id, final Notification notification,
            int incomingUserId) {
        if (DBG) {
            Slog.v(TAG, "enqueueNotificationInternal: pkg=" + pkg + " id=" + id
                    + " notification=" + notification);
        }
        //检查一下通知是否由系统发送过来的还是同一个通知发送过来的，会获取通知信息提交者的uid,
        //并与PackageManager中获取分配给拥有指定包名的应用程序UID比对
        checkCallerIsSystemOrSameApp(pkg);

        final int userId = ActivityManager.handleIncomingUser(callingPid,
                callingUid, incomingUserId, true, false, "enqueueNotification", pkg);
        final UserHandle user = new UserHandle(userId);

        if (pkg == null || notification == null) {
            throw new IllegalArgumentException("null not allowed: pkg=" + pkg
                    + " id=" + id + " notification=" + notification);
        }

        // The system can post notifications for any package, let us resolve that.
             final int notificationUid = resolveNotificationUid(opPkg, callingUid, userId);

        // Fix the notification as best we can.
        try {
            final ApplicationInfo ai = mPackageManagerClient.getApplicationInfoAsUser(
                    pkg, PackageManager.MATCH_DEBUG_TRIAGED_MISSING,
                    (userId == UserHandle.USER_ALL) ? USER_SYSTEM : userId);
            Notification.addFieldsFromContext(ai, notification);

            int canColorize = mPackageManagerClient.checkPermission(
                    android.Manifest.permission.USE_COLORIZED_NOTIFICATIONS, pkg);
            if (canColorize == PERMISSION_GRANTED) {
                notification.flags |= Notification.FLAG_CAN_COLORIZE;
            } else {
                notification.flags &= ~Notification.FLAG_CAN_COLORIZE;
            }

        } catch (NameNotFoundException e) {
            Slog.e(TAG, "Cannot create a context for sending app", e);
            return;
        }

        mUsageStats.registerEnqueuedByApp(pkg);

        // setup local book-keeping
        String channelId = notification.getChannelId();
        if (mIsTelevision && (new Notification.TvExtender(notification)).getChannelId() != null) {
            channelId = (new Notification.TvExtender(notification)).getChannelId();
        }
        final NotificationChannel channel = mRankingHelper.getNotificationChannel(pkg,
                notificationUid, channelId, false /* includeDeleted */);
        if (channel == null) {
            final String noChannelStr = "No Channel found for "
                    + "pkg=" + pkg
                    + ", channelId=" + channelId
                    + ", id=" + id
                    + ", tag=" + tag
                    + ", opPkg=" + opPkg
                    + ", callingUid=" + callingUid
                    + ", userId=" + userId
                    + ", incomingUserId=" + incomingUserId
                    + ", notificationUid=" + notificationUid
                    + ", notification=" + notification;
            Log.e(TAG, noChannelStr);
            boolean appNotificationsOff = mRankingHelper.getImportance(pkg, notificationUid)
                    == NotificationManager.IMPORTANCE_NONE;

            if (!appNotificationsOff) {
                doChannelWarningToast("Developer warning for package \"" + pkg + "\"\n" +
                        "Failed to post notification on channel \"" + channelId + "\"\n" +
                        "See log for more details");
            }
            return;
        }
		//创建一个StatusBarNotification对象,时间获取的是当前系统时间
        final StatusBarNotification n = new StatusBarNotification(
                pkg, opPkg, id, tag, notificationUid, callingPid, notification,
                user, null, System.currentTimeMillis());
        final NotificationRecord r = new NotificationRecord(getContext(), n, channel);
        r.setIsAppImportanceLocked(mRankingHelper.getIsAppImportanceLocked(pkg, callingUid));

        if ((notification.flags & Notification.FLAG_FOREGROUND_SERVICE) != 0) {
            final boolean fgServiceShown = channel.isFgServiceShown();
            if (((channel.getUserLockedFields() & NotificationChannel.USER_LOCKED_IMPORTANCE) == 0
                        || !fgServiceShown)
                    && (r.getImportance() == IMPORTANCE_MIN
                            || r.getImportance() == IMPORTANCE_NONE)) {
                // Increase the importance of foreground service notifications unless the user had
                // an opinion otherwise (and the channel hasn't yet shown a fg service).
                if (TextUtils.isEmpty(channelId)
                        || NotificationChannel.DEFAULT_CHANNEL_ID.equals(channelId)) {
                    r.setImportance(IMPORTANCE_LOW, "Bumped for foreground service");
                } else {
                    channel.setImportance(IMPORTANCE_LOW);
                    if (!fgServiceShown) {
                        channel.unlockFields(NotificationChannel.USER_LOCKED_IMPORTANCE);
                        channel.setFgServiceShown(true);
                    }
                    mRankingHelper.updateNotificationChannel(pkg, notificationUid, channel, false);
                    r.updateNotificationChannel(channel);
                }
            } else if (!fgServiceShown && !TextUtils.isEmpty(channelId)
                    && !NotificationChannel.DEFAULT_CHANNEL_ID.equals(channelId)) {
                channel.setFgServiceShown(true);
                r.updateNotificationChannel(channel);
            }
        }

        if (!checkDisqualifyingFeatures(userId, notificationUid, id, tag, r,
                r.sbn.getOverrideGroupKey() != null)) {
            return;
        }

        // 白名单待处理的intent
        if (notification.allPendingIntents != null) {
            final int intentCount = notification.allPendingIntents.size();
            if (intentCount > 0) {
                final ActivityManagerInternal am = LocalServices
                        .getService(ActivityManagerInternal.class);
                final long duration = LocalServices.getService(
                        DeviceIdleController.LocalService.class).getNotificationWhitelistDuration();
                for (int i = 0; i < intentCount; i++) {
                    PendingIntent pendingIntent = notification.allPendingIntents.valueAt(i);
                    if (pendingIntent != null) {
                        am.setPendingIntentWhitelistDuration(pendingIntent.getTarget(),
                                WHITELIST_TOKEN, duration);
                    }
                }
            }
        }
         //通过mHandler执行EnqueueNotificationRunnable
        mHandler.post(new EnqueueNotificationRunnable(userId, r));
    }
  • 通知消息具体的权限拦截代码
private int resolveNotificationUid(String opPackageName, int callingUid, int userId) {
        // The system can post notifications on behalf of any package it wants
        //系统应用发出的通知不受限制
        if (isCallerSystemOrPhone() && opPackageName != null && !"android".equals(opPackageName)) {
            try {
                return getContext().getPackageManager()
                        .getPackageUidAsUser(opPackageName, userId);
            } catch (NameNotFoundException e) {
                /* ignore */
            }
        }
        return callingUid;
    }

    /*
     * 
     *检查通知的规则
     * Has side effects.
     */
    private boolean checkDisqualifyingFeatures(int userId, int callingUid, int id, String tag,
            NotificationRecord r, boolean isAutogroup) {
        final String pkg = r.sbn.getPackageName();
        final boolean isSystemNotification =
                isUidSystemOrPhone(callingUid) || ("android".equals(pkg));
        final boolean isNotificationFromListener = mListeners.isListenerPackage(pkg);

		//除了系统的通知或者是来自于注册监听的通知, 限制所有的通知数量, 防止DOS攻击和处理泄露
        if (!isSystemNotification && !isNotificationFromListener) {
            synchronized (mNotificationLock) {
                if (mNotificationsByKey.get(r.sbn.getKey()) == null && isCallerInstantApp(pkg)) {
                    
                    throw new SecurityException("Instant app " + pkg
                            + " cannot create notifications");
                }

                // rate limit updates that aren't completed progress notifications
                if (mNotificationsByKey.get(r.sbn.getKey()) != null
                        && !r.getNotification().hasCompletedProgress()
                        && !isAutogroup) {

                    final float appEnqueueRate = mUsageStats.getAppEnqueueRate(pkg);
                    if (appEnqueueRate > mMaxPackageEnqueueRate) {
                        mUsageStats.registerOverRateQuota(pkg);
                        final long now = SystemClock.elapsedRealtime();
                        if ((now - mLastOverRateLogTime) > MIN_PACKAGE_OVERRATE_LOG_INTERVAL) {
                            Slog.e(TAG, "Package enqueue rate is " + appEnqueueRate
                                    + ". Shedding " + r.sbn.getKey() + ". package=" + pkg);
                            mLastOverRateLogTime = now;
                        }
                        return false;
                    }
                }

                // limit the number of outstanding notificationrecords an app can have
                int count = getNotificationCountLocked(pkg, userId, id, tag);
                if (count >= MAX_PACKAGE_NOTIFICATIONS) {
                    mUsageStats.registerOverCountQuota(pkg);
                    Slog.e(TAG, "Package has already posted or enqueued " + count
                            + " notifications.  Not showing more.  package=" + pkg);
                    return false;
                }
            }
        }

        // snoozed apps
        if (mSnoozeHelper.isSnoozed(userId, pkg, r.getKey())) {
            MetricsLogger.action(r.getLogMaker()
                    .setType(MetricsProto.MetricsEvent.TYPE_UPDATE)
                    .setCategory(MetricsProto.MetricsEvent.NOTIFICATION_SNOOZED));
            if (DBG) {
                Slog.d(TAG, "Ignored enqueue for snoozed notification " + r.getKey());
            }
            mSnoozeHelper.update(userId, r);
            savePolicyFile();
            return false;
        }


        // blocked apps
        if (isBlocked(r, mUsageStats)) {
            return false;
        }

        return true;
    }

protected boolean isBlocked(NotificationRecord r, NotificationUsageStats usageStats) {
        final String pkg = r.sbn.getPackageName();
        final int callingUid = r.sbn.getUid();
        // blocked apps
        // 这里是blocked的apps，就是你在settings中选择Block all的app，这里就会帮通知都屏蔽了
        final boolean isPackageSuspended = isPackageSuspendedForUser(pkg, callingUid);
        if (isPackageSuspended) {
            Slog.e(TAG, "Suppressing notification from package due to package "
                    + "suspended by administrator.");
            usageStats.registerSuspendedByAdmin(r);
            return isPackageSuspended;
        }
        final boolean isBlocked =
                mRankingHelper.isGroupBlocked(pkg, callingUid, r.getChannel().getGroup())
                || mRankingHelper.getImportance(pkg, callingUid)
                        == NotificationManager.IMPORTANCE_NONE
                || r.getChannel().getImportance() == NotificationManager.IMPORTANCE_NONE;
        if (isBlocked) {
            Slog.e(TAG, "Suppressing notification from package by user request.");
            usageStats.registerBlocked(r);
        }
        return isBlocked;
    }

上面的代码主要是过滤特殊通知处理，创建了StatusBarNotification、NotificationRecord对象，并防止DOS攻击，对单个应用（非系统应用）的通知条数做了未读消息只有50条的限制。

  • PostNotificationRunnable进行最后的推送通知
protected class EnqueueNotificationRunnable implements Runnable {
        private final NotificationRecord r;
        private final int userId;

        EnqueueNotificationRunnable(int userId, NotificationRecord r) {
            this.userId = userId;
            this.r = r;
        };

        @Override
        public void run() {
            synchronized (mNotificationLock) {
                mEnqueuedNotifications.add(r);
                scheduleTimeoutLocked(r);

                final StatusBarNotification n = r.sbn;
                if (DBG) Slog.d(TAG, "EnqueueNotificationRunnable.run for: " + n.getKey());
                //根据key值获取Old NotificationRecord
                NotificationRecord old = mNotificationsByKey.get(n.getKey());
                if (old != null) {
                    // 保留以前记录中的排序信息
                    r.copyRankingInformation(old);
                }

                final int callingUid = n.getUid();
                final int callingPid = n.getInitialPid();
                final Notification notification = n.getNotification();
                final String pkg = n.getPackageName();
                final int id = n.getId();
                final String tag = n.getTag();

                // Handle grouped notifications and bail out early if we
                // can to avoid extracting signals.
                handleGroupedNotificationLocked(r, old, callingUid, callingPid);

                // if this is a group child, unsnooze parent summary
                if (n.isGroup() && notification.isGroupChild()) {
                    mSnoozeHelper.repostGroupSummary(pkg, r.getUserId(), n.getGroupKey());
                }

                // This conditional is a dirty hack to limit the logging done on
                //     behalf of the download manager without affecting other apps.
                if (!pkg.equals("com.android.providers.downloads")
                        || Log.isLoggable("DownloadManager", Log.VERBOSE)) {
                    int enqueueStatus = EVENTLOG_ENQUEUE_STATUS_NEW;
                    if (old != null) {
                        enqueueStatus = EVENTLOG_ENQUEUE_STATUS_UPDATE;
                    }
                    //打印Event Log，可通过该LOG查看当前通知的信息，判断当前通知是否发送成功；
                    EventLogTags.writeNotificationEnqueue(callingUid, callingPid,
                            pkg, id, tag, userId, notification.toString(),
                            enqueueStatus);
                }
	 更新NotificationRecord内容，RankingHelper管理了通知的开关、channel维护，比如横幅通知是否开启，在此处更新；
                mRankingHelper.extractSignals(r);

                // 
                if (mAssistants.isEnabled()) {
                    mAssistants.onNotificationEnqueued(r);
                    mHandler.postDelayed(new PostNotificationRunnable(r.getKey()),
                            DELAY_FOR_ASSISTANT_TIME);
                } else {
                    mHandler.post(new PostNotificationRunnable(r.getKey()));
                }
            }
        }
    }

这里我们需要关注有异步通信。
启动NotificationManagerService的SystemServer的主线程，如下代码。

SystemServer.java

public static void main(String[] args) {
        new SystemServer().run();
    }
 private void run() {
// ......
 // Start services.
        try {
            traceBeginAndSlog("StartServices");
            startBootstrapServices();
            startCoreServices();
            startOtherServices();
            SystemServerInitThreadPool.shutdown();
        } catch (Throwable ex) {
            Slog.e("System", "******************************************");
            Slog.e("System", "************ Failure starting system services", ex);
            throw ex;
        } finally {
            traceEnd();
        }
// ......
}
 private void startOtherServices() {
// .......
  traceBeginAndSlog("StartNotificationManager");
            mSystemServiceManager.startService(NotificationManagerService.class);
            SystemNotificationChannels.createAll(context);
            notification = INotificationManager.Stub.asInterface(
                    ServiceManager.getService(Context.NOTIFICATION_SERVICE));
            traceEnd();
// .......
 }

在NotificationManagerService处理通知消息的时候，使用了子线程。

public class NotificationManagerService extends SystemService {
//.......
private NotificationListeners mListeners;
private WorkerHandler mHandler;
private final HandlerThread mRankingThread = new HandlerThread("ranker",
            Process.THREAD_PRIORITY_BACKGROUND);
void init(.........){
mHandler = new WorkerHandler(looper);
        mRankingThread.start();
}            
//.......
 void enqueueNotificationInternal(......) {
 mHandler.post(new EnqueueNotificationRunnable(userId, r));
 }

protected class EnqueueNotificationRunnable implements Runnable {
// tell the assistant service about the notification
                if (mAssistants.isEnabled()) {
                    mAssistants.onNotificationEnqueued(r);
                    mHandler.postDelayed(new PostNotificationRunnable(r.getKey()),
                            DELAY_FOR_ASSISTANT_TIME);
                } else {
                    mHandler.post(new PostNotificationRunnable(r.getKey()));
                }
}
protected class PostNotificationRunnable implements Runnable {
//......
 if (notification.getSmallIcon() != null) {
  StatusBarNotification oldSbn = (old != null) ? old.sbn : null;
                        mListeners.notifyPostedLocked(r, old);
 }else{
  mListeners.notifyRemovedLocked(r, NotificationListenerService.REASON_ERROR, null);
 }
//....... 
}
 }

NotificationListeners 的notifyPosted中将通知推送至SystemUI中显示，在该方法中listener数据类型是NotificationListenerWrapper的代理对象，NotificationListenerWrapper在SystemUI进程，在此处listener是client, NotificationListenerWrapper是server。

  • 关于android8.0通知通道的代码，首先会创建通道，然后通过RankingHelper来更新Channels的信息，最终由NotificationListeners推送到SystemUI中。

 @Override
 public void createNotificationChannels(String pkg,
             ParceledListSlice channelsList) throws RemoteException {
            checkCallerIsSystemOrSameApp(pkg);
            createNotificationChannelsImpl(pkg, Binder.getCallingUid(), channelsList);
        }

private void createNotificationChannelsImpl(String pkg, int uid,
                ParceledListSlice channelsList) {
            List<NotificationChannel> channels = channelsList.getList();
            final int channelsSize = channels.size();
            for (int i = 0; i < channelsSize; i++) {
                final NotificationChannel channel = channels.get(i);
                Preconditions.checkNotNull(channel, "channel in list is null");
                mRankingHelper.createNotificationChannel(pkg, uid, channel,
                        true /* fromTargetApp */, mConditionProviders.isPackageOrComponentAllowed(
                                pkg, UserHandle.getUserId(uid)));
                mListeners.notifyNotificationChannelChanged(pkg,
                        UserHandle.getUserHandleForUid(uid),
                        mRankingHelper.getNotificationChannel(pkg, uid, channel.getId(), false),
                        NOTIFICATION_CHANNEL_OR_GROUP_ADDED);
            }
            //本地存储信息
            savePolicyFile();
        }
	//NotificationManagerService 在init的时候会调用此方法
    private void loadPolicyFile() {
        if (DBG) Slog.d(TAG, "loadPolicyFile");
        synchronized (mPolicyFile) {

            InputStream infile = null;
            try {
                infile = mPolicyFile.openRead();
                readPolicyXml(infile, false /*forRestore*/);
            } catch (FileNotFoundException e) {
                // No data yet
                // Load default managed services approvals
                readDefaultApprovedServices(USER_SYSTEM);
            } catch (IOException e) {
                Log.wtf(TAG, "Unable to read notification policy", e);
            } catch (NumberFormatException e) {
                Log.wtf(TAG, "Unable to parse notification policy", e);
            } catch (XmlPullParserException e) {
                Log.wtf(TAG, "Unable to parse notification policy", e);
            } finally {
                IoUtils.closeQuietly(infile);
            }
        }
    }

    public void savePolicyFile() {
        mHandler.removeMessages(MESSAGE_SAVE_POLICY_FILE);
        mHandler.sendEmptyMessage(MESSAGE_SAVE_POLICY_FILE);
    }

    private void handleSavePolicyFile() {
        if (DBG) Slog.d(TAG, "handleSavePolicyFile");
        synchronized (mPolicyFile) {
            final FileOutputStream stream;
            try {
                stream = mPolicyFile.startWrite();
            } catch (IOException e) {
                Slog.w(TAG, "Failed to save policy file", e);
                return;
            }

            try {
                writePolicyXml(stream, false /*forBackup*/);
                mPolicyFile.finishWrite(stream);
            } catch (IOException e) {
                Slog.w(TAG, "Failed to save policy file, restoring backup", e);
                mPolicyFile.failWrite(stream);
            }
        }
        BackupManager.dataChanged(getContext().getPackageName());
    }

时序图
在这里插入图片描述

Android Wifi——WLAN源码（十四）
小旭的专栏
04-06 1125
上一篇文章主要介绍了 WLAN 直连的 API 及应用开发流程，这一篇主要来看一看源码的实现。
Android通知的实现源码
05-28
Android中的通过，比较简单实用，适合初学者学习，欢迎下载学习。
Android通知系统源码解析
PPLLiang的博客
11-28 4351
Android通知系统源码解析1. 概述2. 流程图2.1. 发送通知流程图3. 源码解析3.1. 使用通知--APP进程3.1.1. 创建通知：3.1.2. 发送（更新）通知：3.1.3. 取消通知：3.1.4. 创建通知源码解析：3.2. 管理通知--SystemServer进程3.2.1. 发送通知：3.2.2. Service处理和推送通知：3.3. 展示--SystemUI进程 1. 概...
Android 12.0 通知发送过程源码分析-Framework
Smile_729day的博客
06-28 1326
一下 NotificationManagerService简称 NMS。
Android通知之NotificationManagerService 源码分析
qq_28284547的博客
09-12 902
NotificationManagerService 是在系统启动时在SystemService.startOtherServicess的时候通过mSystemServiceManager.startService(NotificationManagerService.class)方式启动的，并且加入到了系统服务的列表当中，在Android系统中可以通过ServiceManager.getService("notification")拿到这个服务，后面统称为NMS。这里只是说明一下，后面会展开详细介绍。
Android 发送通知
学无止境~
04-17 529
实现代码如下，代码中有详细注释： [java] view plaincopyprint? public class MainActivity extends Activity {       private TextView tvTitle;       private TextView tvContent;       private B
Android connectGatt流程及源码分析
最新发布
byte轻骑兵的博客
09-07 1113
BluetoothDevice.connectGatt(Context context, boolean autoConnect, BluetoothGattCallback callback)源码刨析
Wifi模块—源码分析获取IP地址（Android P）
风雨与阳光
10-20 3216
一 前言         上一篇分析了连接AP的过程，当底层完成wifi连接，便会事件通知WifiMonitor,WifiMonitor监听到该事件后发送消息NETWORK_CONNECTION_EVENT。                                         二 代码具体流程  1 frameworks/opt/net/wifi/service/java/co...
Android Bluetooth | 蓝牙配对源码分析
ezsxrtghjmk的博客
06-25 3811
基于Android10源码的蓝牙建立配对流程分析，文章较长~
Android readCharacteristic源码分析
byte轻骑兵的博客
08-31 2350
ATT协议定义了BLE设备间数据交换的基本规则，包括数据的读写、通知和指示等操作。它基于客户端-服务器（Client-Server）架构，其中服务端设备存储数据，客户端设备通过发送请求来访问这些数据。
Android 通知栏Notification的全面整合学习（完整项目源码）附配套博文
05-15
这个是通知栏框架（Notificaiton）的全面学习，里面把大概所有的情况都列了出来，通过一个DEMO让你了解它的大致所有使用过程。 可以通过以下博文进行配套了解（有效果图）： http://blog.csdn.net/vipzjyno1/article/details/25248021
android 通知 和 通知的声音 (附源码)
03-20
NULL 博文链接：https://leequer.iteye.com/blog/849364
Android发送通知Notification
02-03
发送通知在ActionBar上显示，Notification
Android-Notification:Android通知库（布局中，浮动和状态栏通知）
05-15
Android通知库 Android应用程序的通知库。 通过使用此库，您可以轻松管理通知。 在后台运行应用程序时发送远程/全局通知。 当应用程序处于前台时发送本地/全局通知。 注册一个NotificationListener以更新通知计数的标志编号。 显示NotificationBoard当前通知的列表。 ... 概述 有3个主要组成部分： 本地通知（管理布局通知） 全局通知（管理浮动通知） 通知远程（管理状态栏通知） 和2个次要组件： 公告板（保存公告列表） 通知效果（管理铃声，振动等） 每个通知可以具有自己的布局和背景。 如果未指定，将使用默认布局和背景。 如果将通知发送到多个组件，则它们的状态将在这些组件之间同步。 因此，取消一个组件中的通知将触发其他组件中的取消事件。 演示版 此存储库中也提供了示例代码。 本地通知 全局通知 公告板 通知远端 编程指南
安卓通知实例
09-25
Android Notification sample. Let you learn how to push notification to Android system and remove them automatically.
android 发送通知
叶上初阳_285557的博客
03-17 452
import android.app.Notification; import android.app.NotificationChannel; import android.app.NotificationManager; import android.app.PendingIntent; import android.content.Context; import android.content.Intent; import android.graphics.BitmapFactory; impor..
android发送通知
chujingwei的专栏
07-05 141
/* 获取Notification对象 *//* 获得NotificationManager对象 */ n = new Notification(); nm = (NotificationManager) getSystemService(NOTIFICATION_SERVICE); /* 设置显示图标，该图标会在状态栏显示 */ n.icon = R.drawab...
Android发送通知
热门推荐
欢乐斗佛的博客
11-17 8万+
安卓使用通知和用户交互是一个非常不错的选择，也是我们项目中经常用到的一个功能，所以今天有必要对这块做一下归纳。安卓发送的通知效果就是在状态栏显示一个通知的小图标，当下拉通知栏的时候可以看到整个消息的内容，同时在接收到消息的时候可以带声音、提示灯闪烁、震动、进度条等等，单用户点击通知的内容时也可以使用Intent干任何你想做的事，比如打开一个app，打开指定的网页，拨打电话等等，通知的一般样式如下图
深入解析Android下拉通知效果实现源码
开发者可以通过分析这些文件，了解在不同Android版本上实现下拉通知效果的差异以及背后的设计原理。源码文件可能包括Notification类的实现、NotificationBuilder类的使用方法、以及Material Design风格的通知外观和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值