/**@class android.service.notification.NotificationListenerService @extends android.app.Service A service that receives calls from the system when new notifications are posted or removed, or their ranking changed. <p>To extend this class, you must declare the service in your manifest file with the {@link android.Manifest.permission#BIND_NOTIFICATION_LISTENER_SERVICE} permission and include an intent filter with the {@link #SERVICE_INTERFACE} action. For example:</p> <pre> <service android:name=".NotificationListener" android:label="@string/service_name" android:permission="android.permission.BIND_NOTIFICATION_LISTENER_SERVICE"> <intent-filter> <action android:name="android.service.notification.NotificationListenerService" /> </intent-filter> </service></pre> <p>The service should wait for the {@link #onListenerConnected}() event before performing any operations. The {@link #requestRebind}(ComponentName) method is the <i>only</i> one that is safe to call before {@link #onListenerConnected}() or after {@link #onListenerDisconnected}(). </p> <p> Notification listeners cannot get notification access or be bound by the system on {@linkplain ActivityManager#isLowRamDevice() low-RAM} devices. The system also ignores notification listeners running in a work profile. A {@link android.app.admin.DevicePolicyManager} might block notifications originating from a work profile.</p> <p> From {@link Build.VERSION_CODES#N} onward all callbacks are called on the main thread. Prior to N, there is no guarantee on what thread the callback will happen. </p> */ var NotificationListenerService = { /** {@link #getCurrentInterruptionFilter() Interruption filter} constant - Normal interruption filter. */ INTERRUPTION_FILTER_ALL : "1", /** {@link #getCurrentInterruptionFilter() Interruption filter} constant - Priority interruption filter. */ INTERRUPTION_FILTER_PRIORITY : "2", /** {@link #getCurrentInterruptionFilter() Interruption filter} constant - No interruptions filter. */ INTERRUPTION_FILTER_NONE : "3", /** {@link #getCurrentInterruptionFilter() Interruption filter} constant - Alarms only interruption filter. */ INTERRUPTION_FILTER_ALARMS : "4", /**{@link #getCurrentInterruptionFilter() Interruption filter} constant - returned when the value is unavailable for any reason. For example, before the notification listener is connected. {@see #onListenerConnected()} */ INTERRUPTION_FILTER_UNKNOWN : "0", /**{@link #getCurrentListenerHints() Listener hints} constant - the primary device UI should disable notification sound, vibrating and other visual or aural effects. This does not change the interruption filter, only the effects. */ HINT_HOST_DISABLE_EFFECTS : "1", /**{@link #getCurrentListenerHints() Listener hints} constant - the primary device UI should disable notification sound, but not phone calls. This does not change the interruption filter, only the effects. */ HINT_HOST_DISABLE_NOTIFICATION_EFFECTS : "2", /**{@link #getCurrentListenerHints() Listener hints} constant - the primary device UI should disable phone call sounds, buyt not notification sound. This does not change the interruption filter, only the effects. */ HINT_HOST_DISABLE_CALL_EFFECTS : "4", /** Whether notification suppressed by DND should not interruption visually when the screen is off. @deprecated Use the more specific visual effects in {@link NotificationManager.Policy}. */ SUPPRESSED_EFFECT_SCREEN_OFF : "1", /** Whether notification suppressed by DND should not interruption visually when the screen is on. @deprecated Use the more specific visual effects in {@link NotificationManager.Policy}. */ SUPPRESSED_EFFECT_SCREEN_ON : "2", /**Notification was canceled by the status bar reporting a notification click. */ REASON_CLICK : "1", /**Notification was canceled by the status bar reporting a user dismissal. */ REASON_CANCEL : "2", /**Notification was canceled by the status bar reporting a user dismiss all. */ REASON_CANCEL_ALL : "3", /**Notification was canceled by the status bar reporting an inflation error. */ REASON_ERROR : "4", /**Notification was canceled by the package manager modifying the package. */ REASON_PACKAGE_CHANGED : "5", /**Notification was canceled by the owning user context being stopped. */ REASON_USER_STOPPED : "6", /**Notification was canceled by the user banning the package. */ REASON_PACKAGE_BANNED : "7", /**Notification was canceled by the app canceling this specific notification. */ REASON_APP_CANCEL : "8", /**Notification was canceled by the app cancelling all its notifications. */ REASON_APP_CANCEL_ALL : "9", /**Notification was canceled by a listener reporting a user dismissal. */ REASON_LISTENER_CANCEL : "10", /**Notification was canceled by a listener reporting a user dismiss all. */ REASON_LISTENER_CANCEL_ALL : "11", /**Notification was canceled because it was a member of a canceled group. */ REASON_GROUP_SUMMARY_CANCELED : "12", /**Notification was canceled because it was an invisible member of a group. */ REASON_GROUP_OPTIMIZATION : "13", /**Notification was canceled by the device administrator suspending the package. */ REASON_PACKAGE_SUSPENDED : "14", /**Notification was canceled by the owning managed profile being turned off. */ REASON_PROFILE_TURNED_OFF : "15", /**Autobundled summary notification was canceled because its group was unbundled */ REASON_UNAUTOBUNDLED : "16", /**Notification was canceled by the user banning the channel. */ REASON_CHANNEL_BANNED : "17", /**Notification was snoozed. */ REASON_SNOOZED : "18", /**Notification was canceled due to timeout */ REASON_TIMEOUT : "19", /** The full trim of the StatusBarNotification including all its features. @hide @removed */ TRIM_FULL : "0", /** A light trim of the StatusBarNotification excluding the following features: <ol> <li>{@link Notification#tickerView tickerView}</li> <li>{@link Notification#contentView contentView}</li> <li>{@link Notification#largeIcon largeIcon}</li> <li>{@link Notification#bigContentView bigContentView}</li> <li>{@link Notification#headsUpContentView headsUpContentView}</li> <li>{@link Notification#EXTRA_LARGE_ICON extras[EXTRA_LARGE_ICON]}</li> <li>{@link Notification#EXTRA_LARGE_ICON_BIG extras[EXTRA_LARGE_ICON_BIG]}</li> <li>{@link Notification#EXTRA_PICTURE extras[EXTRA_PICTURE]}</li> <li>{@link Notification#EXTRA_BIG_TEXT extras[EXTRA_BIG_TEXT]}</li> </ol> @hide @removed */ TRIM_LIGHT : "1", /** Channel or group modification reason provided to {@link #onNotificationChannelModified(String, UserHandle,NotificationChannel, int)} or {@link #onNotificationChannelGroupModified(String, UserHandle, NotificationChannelGroup, int)}- the provided object was created. */ NOTIFICATION_CHANNEL_OR_GROUP_ADDED : "1", /** Channel or group modification reason provided to {@link #onNotificationChannelModified(String, UserHandle, NotificationChannel, int)} or {@link #onNotificationChannelGroupModified(String, UserHandle,NotificationChannelGroup, int)} - the provided object was updated. */ NOTIFICATION_CHANNEL_OR_GROUP_UPDATED : "2", /** Channel or group modification reason provided to {@link #onNotificationChannelModified(String, UserHandle, NotificationChannel, int)} or {@link #onNotificationChannelGroupModified(String, UserHandle, NotificationChannelGroup, int)}- the provided object was deleted. */ NOTIFICATION_CHANNEL_OR_GROUP_DELETED : "3", /** The {@link Intent} that must be declared as handled by the service. */ SERVICE_INTERFACE : "android.service.notification.NotificationListenerService", /**Implement this method to learn about new notifications as they are posted by apps. @param {Object {StatusBarNotification}} sbn A data structure encapsulating the original {@link android.app.Notification} object as well as its identifying information (tag and id) and source (package name). */ onNotificationPosted : function( ) {}, /**Implement this method to learn about new notifications as they are posted by apps. @param {Object {StatusBarNotification}} sbn A data structure encapsulating the original {@link android.app.Notification} object as well as its identifying information (tag and id) and source (package name). @param {Object {NotificationListenerService.RankingMap}} rankingMap The current ranking map that can be used to retrieve ranking information for active notifications, including the newly posted one. */ onNotificationPosted : function( ) {}, /**Implement this method to learn when notifications are removed. <p> This might occur because the user has dismissed the notification using system UI (or another notification listener) or because the app has withdrawn the notification. <p> NOTE: The {@link android.service.notification.StatusBarNotification} object you receive will be "light"; that is, the result from {@link android.service.notification.StatusBarNotification#getNotification} may be missing some heavyweight fields such as {@link android.app.Notification#contentView} and {@link android.app.Notification#largeIcon}. However, all other fields on {@link android.service.notification.StatusBarNotification}, sufficient to match this call with a prior call to {@link #onNotificationPosted}(StatusBarNotification), will be intact. @param {Object {StatusBarNotification}} sbn A data structure encapsulating at least the original information (tag and id) and source (package name) used to post the {@link android.app.Notification} that was just removed. */ onNotificationRemoved : function( ) {}, /**Implement this method to learn when notifications are removed. <p> This might occur because the user has dismissed the notification using system UI (or another notification listener) or because the app has withdrawn the notification. <p> NOTE: The {@link android.service.notification.StatusBarNotification} object you receive will be "light"; that is, the result from {@link android.service.notification.StatusBarNotification#getNotification} may be missing some heavyweight fields such as {@link android.app.Notification#contentView} and {@link android.app.Notification#largeIcon}. However, all other fields on {@link android.service.notification.StatusBarNotification}, sufficient to match this call with a prior call to {@link #onNotificationPosted}(StatusBarNotification), will be intact. @param {Object {StatusBarNotification}} sbn A data structure encapsulating at least the original information (tag and id) and source (package name) used to post the {@link android.app.Notification} that was just removed. @param {Object {NotificationListenerService.RankingMap}} rankingMap The current ranking map that can be used to retrieve ranking information for active notifications. */ onNotificationRemoved : function( ) {}, /**Implement this method to learn when notifications are removed and why. <p> This might occur because the user has dismissed the notification using system UI (or another notification listener) or because the app has withdrawn the notification. <p> NOTE: The {@link android.service.notification.StatusBarNotification} object you receive will be "light"; that is, the result from {@link android.service.notification.StatusBarNotification#getNotification} may be missing some heavyweight fields such as {@link android.app.Notification#contentView} and {@link android.app.Notification#largeIcon}. However, all other fields on {@link android.service.notification.StatusBarNotification}, sufficient to match this call with a prior call to {@link #onNotificationPosted}(StatusBarNotification), will be intact. @param {Object {StatusBarNotification}} sbn A data structure encapsulating at least the original information (tag and id) and source (package name) used to post the {@link android.app.Notification} that was just removed. @param {Object {NotificationListenerService.RankingMap}} rankingMap The current ranking map that can be used to retrieve ranking information for active notifications. @param {Number} reason see {@link #REASON_LISTENER_CANCEL}, etc. */ onNotificationRemoved : function( ) {}, /**NotificationStats are not populated for notification listeners, so fall back to {@link #onNotificationRemoved(StatusBarNotification, android.service.notification.NotificationListenerService.RankingMap, int)}. @hide */ onNotificationRemoved : function( ) {}, /**Implement this method to learn about when the listener is enabled and connected to the notification manager. You are safe to call {@link #getActiveNotifications}() at this time. */ onListenerConnected : function( ) {}, /**Implement this method to learn about when the listener is disconnected from the notification manager.You will not receive any events after this call, and may only call {@link #requestRebind}(ComponentName) at this time. */ onListenerDisconnected : function( ) {}, /**Implement this method to be notified when the notification ranking changes. @param {Object {NotificationListenerService.RankingMap}} rankingMap The current ranking map that can be used to retrieve ranking information for active notifications. */ onNotificationRankingUpdate : function( ) {}, /**Implement this method to be notified when the {@link #getCurrentListenerHints() Listener hints} change. @param {Number} hints The current {@link #getCurrentListenerHints() listener hints}. */ onListenerHintsChanged : function( ) {}, /**Implement this method to be notified when the behavior of silent notifications in the status bar changes. See {@link NotificationManager#shouldHideSilentStatusBarIcons()}. @param {Boolean} hideSilentStatusIcons whether or not status bar icons should be hidden for silent notifications */ onSilentStatusBarIconsVisibilityChanged : function( ) {}, /**Implement this method to learn about notification channel modifications. <p>The caller must have {@link CompanionDeviceManager#getAssociations() an associated device} in order to receive this callback. @param {String} pkg The package the channel belongs to. @param {Object {UserHandle}} user The user on which the change was made. @param {Object {NotificationChannel}} channel The channel that has changed. @param {Number} modificationType One of {@link #NOTIFICATION_CHANNEL_OR_GROUP_ADDED}, {@link #NOTIFICATION_CHANNEL_OR_GROUP_UPDATED}, {@link #NOTIFICATION_CHANNEL_OR_GROUP_DELETED}. */ onNotificationChannelModified : function( ) {}, /**Implement this method to learn about notification channel group modifications. <p>The caller must have {@link CompanionDeviceManager#getAssociations() an associated device} in order to receive this callback. @param {String} pkg The package the group belongs to. @param {Object {UserHandle}} user The user on which the change was made. @param {Object {NotificationChannelGroup}} group The group that has changed. @param {Number} modificationType One of {@link #NOTIFICATION_CHANNEL_OR_GROUP_ADDED}, {@link #NOTIFICATION_CHANNEL_OR_GROUP_UPDATED}, {@link #NOTIFICATION_CHANNEL_OR_GROUP_DELETED}. */ onNotificationChannelGroupModified : function( ) {}, /**Implement this method to be notified when the {@link #getCurrentInterruptionFilter() interruption filter} changed. @param {Number} interruptionFilter The current {@link #getCurrentInterruptionFilter() interruption filter}. */ onInterruptionFilterChanged : function( ) {}, /**Inform the notification manager about dismissal of a single notification. <p> Use this if your listener has a user interface that allows the user to dismiss individual notifications, similar to the behavior of Android's status bar and notification panel. It should be called after the user dismisses a single notification using your UI; upon being informed, the notification manager will actually remove the notification and you will get an {@link #onNotificationRemoved}(StatusBarNotification) callback. <p> <b>Note:</b> If your listener allows the user to fire a notification's {@link android.app.Notification#contentIntent} by tapping/clicking/etc., you should call this method at that time <i>if</i> the Notification in question has the {@link android.app.Notification#FLAG_AUTO_CANCEL} flag set. <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. @param {String} pkg Package of the notifying app. @param {String} tag Tag of the notification as specified by the notifying app in {@link android.app.NotificationManager#notify(String, int, android.app.Notification)}. @param {Number} id ID of the notification as specified by the notifying app in {@link android.app.NotificationManager#notify(String, int, android.app.Notification)}. <p> @deprecated Use {@link #cancelNotification(String key)} instead. Beginning with {@link android.os.Build.VERSION_CODES#LOLLIPOP} this method will no longer cancel the notification. It will continue to cancel the notification for applications whose {@code targetSdkVersion} is earlier than {@link android.os.Build.VERSION_CODES#LOLLIPOP}. */ cancelNotification : function( ) {}, /**Inform the notification manager about dismissal of a single notification. <p> Use this if your listener has a user interface that allows the user to dismiss individual notifications, similar to the behavior of Android's status bar and notification panel. It should be called after the user dismisses a single notification using your UI; upon being informed, the notification manager will actually remove the notification and you will get an {@link #onNotificationRemoved}(StatusBarNotification) callback. <p> <b>Note:</b> If your listener allows the user to fire a notification's {@link android.app.Notification#contentIntent} by tapping/clicking/etc., you should call this method at that time <i>if</i> the Notification in question has the {@link android.app.Notification#FLAG_AUTO_CANCEL} flag set. <p> <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. @param {String} key Notification to dismiss from {@link StatusBarNotification#getKey()}. */ cancelNotification : function( ) {}, /**Inform the notification manager about dismissal of all notifications. <p> Use this if your listener has a user interface that allows the user to dismiss all notifications, similar to the behavior of Android's status bar and notification panel. It should be called after the user invokes the "dismiss all" function of your UI; upon being informed, the notification manager will actually remove all active notifications and you will get multiple {@link #onNotificationRemoved}(StatusBarNotification) callbacks. <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. {@see #cancelNotification(String, String, int)} */ cancelAllNotifications : function( ) {}, /**Inform the notification manager about dismissal of specific notifications. <p> Use this if your listener has a user interface that allows the user to dismiss multiple notifications at once. <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. @param {Object {java.lang.String[]}} keys Notifications to dismiss, or {@code null} to dismiss all. {@see #cancelNotification(String, String, int)} */ cancelNotifications : function( ) {}, /**Inform the notification manager about snoozing a specific notification. <p> Use this if your listener has a user interface that allows the user to snooze a notification until a given {@link android.service.notification.SnoozeCriterion}. It should be called after the user snoozes a single notification using your UI; upon being informed, the notification manager will actually remove the notification and you will get an {@link #onNotificationRemoved}(StatusBarNotification) callback. When the snoozing period expires, you will get a {@link #onNotificationPosted(StatusBarNotification, android.service.notification.NotificationListenerService.RankingMap)} callback for the notification. @param {String} key The key of the notification to snooze @param {String} snoozeCriterionId The{@link SnoozeCriterion#getId()} of a context to snooze the notification until. @hide @removed */ snoozeNotification : function( ) {}, /**Inform the notification manager about snoozing a specific notification. <p> Use this if your listener has a user interface that allows the user to snooze a notification for a time. It should be called after the user snoozes a single notification using your UI; upon being informed, the notification manager will actually remove the notification and you will get an {@link #onNotificationRemoved}(StatusBarNotification) callback. When the snoozing period expires, you will get a {@link #onNotificationPosted(StatusBarNotification, android.service.notification.NotificationListenerService.RankingMap)} callback for the notification. @param {String} key The key of the notification to snooze @param {Number} durationMs A duration to snooze the notification for, in milliseconds. */ snoozeNotification : function( ) {}, /**Inform the notification manager that these notifications have been viewed by the user. This should only be called when there is sufficient confidence that the user is looking at the notifications, such as when the notifications appear on the screen due to an explicit user interaction. <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. @param {Object {java.lang.String[]}} keys Notifications to mark as seen. */ setNotificationsShown : function( ) {}, /**Updates a notification channel for a given package for a given user. This should only be used to reflect changes a user has made to the channel via the listener's user interface. <p>This method will throw a security exception if you don't have access to notifications for the given user.</p> <p>The caller must have {@link CompanionDeviceManager#getAssociations() an associated device} in order to use this method. @param {String} pkg The package the channel belongs to. @param {Object {UserHandle}} user The user the channel belongs to. @param {Object {NotificationChannel}} channel the channel to update. */ updateNotificationChannel : function( ) {}, /**Returns all notification channels belonging to the given package for a given user. <p>This method will throw a security exception if you don't have access to notifications for the given user.</p> <p>The caller must have {@link CompanionDeviceManager#getAssociations() an associated device} or be the {@link android.service.notification.NotificationAssistantService notification assistant} in order to use this method. @param {String} pkg The package to retrieve channels for. */ getNotificationChannels : function( ) {}, /**Returns all notification channel groups belonging to the given package for a given user. <p>This method will throw a security exception if you don't have access to notifications for the given user.</p> <p>The caller must have {@link CompanionDeviceManager#getAssociations() an associated device} or be the {@link android.service.notification.NotificationAssistantService notification assistant} in order to use this method. @param {String} pkg The package to retrieve channel groups for. */ getNotificationChannelGroups : function( ) {}, /**Sets the notification trim that will be received via {@link #onNotificationPosted}. <p> Setting a trim other than {@link #TRIM_FULL} enables listeners that don't need access to the full notification features right away to reduce their memory footprint. Full notifications can be requested on-demand via {@link #getActiveNotifications}(int). <p> Set to {@link #TRIM_FULL} initially. <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. @param {Number} trim trim of the notifications to be passed via {@link #onNotificationPosted}. See <code>TRIM_*</code> constants. @removed @param trim trim of the notifications to be passed via {@link #onNotificationPosted}. See <code>TRIM_*</code> constants. */ setOnNotificationPostedTrim : function( ) {}, /**Request the list of outstanding notifications (that is, those that are visible to the current user). Useful when you don't know what's already been posted. <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. @return {Object {android.service.notification.StatusBarNotification}} An array of active notifications, sorted in natural order. */ getActiveNotifications : function( ) {}, /**Like {@link #getActiveNotifications}(), but returns the list of currently snoozed notifications, for all users this listener has access to. <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. @return {Object {android.service.notification.StatusBarNotification}} An array of snoozed notifications, sorted in natural order. */ getSnoozedNotifications : function( ) {}, /**Request the list of outstanding notifications (that is, those that are visible to the current user). Useful when you don't know what's already been posted. @param {Number} trim trim of the notifications to be returned. See <code>TRIM_*</code> constants. @removed @param trim trim of the notifications to be returned. See <code>TRIM_*</code> constants. @return {Object {android.service.notification.StatusBarNotification}} An array of active notifications, sorted in natural order. */ getActiveNotifications : function( ) {}, /**Request one or more notifications by key. Useful if you have been keeping track of notifications but didn't want to retain the bits, and now need to go back and extract more data out of those notifications. <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. @param {Object {java.lang.String[]}} keys the keys of the notifications to request @return {Object {android.service.notification.StatusBarNotification}} An array of notifications corresponding to the requested keys, in the same order as the key list. */ getActiveNotifications : function( ) {}, /**Request one or more notifications by key. Useful if you have been keeping track of notifications but didn't want to retain the bits, and now need to go back and extract more data out of those notifications. @param {Object {java.lang.String[]}} keys the keys of the notifications to request @param {Number} trim trim of the notifications to be returned. See <code>TRIM_*</code> constants. @param keys the keys of the notifications to request @param trim trim of the notifications to be returned. See <code>TRIM_*</code> constants. @return {Object {android.service.notification.StatusBarNotification}} An array of notifications corresponding to the requested keys, in the same order as the key list. */ getActiveNotifications : function( ) {}, /**Gets the set of hints representing current state. <p> The current state may differ from the requested state if the hint represents state shared across all listeners or a feature the notification host does not support or refuses to grant. <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. @return {Number} Zero or more of the HINT_ constants. */ getCurrentListenerHints : function( ) {}, /**Gets the current notification interruption filter active on the host. <p> The interruption filter defines which notifications are allowed to interrupt the user (e.g. via sound & vibration) and is applied globally. Listeners can find out whether a specific notification matched the interruption filter via {@link android.service.notification.NotificationListenerService.Ranking#matchesInterruptionFilter()}. <p> The current filter may differ from the previously requested filter if the notification host does not support or refuses to apply the requested filter, or if another component changed the filter in the meantime. <p> Listen for updates using {@link #onInterruptionFilterChanged}(int). <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. @return {Number} One of the INTERRUPTION_FILTER_ constants, or INTERRUPTION_FILTER_UNKNOWN when unavailable. */ getCurrentInterruptionFilter : function( ) {}, /**Clears listener hints set via {@link #getCurrentListenerHints}(). <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. */ clearRequestedListenerHints : function( ) {}, /**Sets the desired {@link #getCurrentListenerHints() listener hints}. <p> This is merely a request, the host may or may not choose to take action depending on other listener requests or other global state. <p> Listen for updates using {@link #onListenerHintsChanged}(int). <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. @param {Number} hints One or more of the HINT_ constants. */ requestListenerHints : function( ) {}, /**Sets the desired {@link #getCurrentInterruptionFilter() interruption filter}. <p> This is merely a request, the host may or may not choose to apply the requested interruption filter depending on other listener requests or other global state. <p> Listen for updates using {@link #onInterruptionFilterChanged}(int). <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. @param {Number} interruptionFilter One of the INTERRUPTION_FILTER_ constants. */ requestInterruptionFilter : function( ) {}, /**Returns current ranking information. <p> The returned object represents the current ranking snapshot and only applies for currently active notifications. <p> Generally you should use the RankingMap that is passed with events such as {@link #onNotificationPosted(StatusBarNotification, android.service.notification.NotificationListenerService.RankingMap)}, {@link #onNotificationRemoved(StatusBarNotification, android.service.notification.NotificationListenerService.RankingMap)}, and so on. This method should only be used when needing access outside of such events, for example to retrieve the RankingMap right after initialization. <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. @return {Object {android.service.notification.NotificationListenerService.RankingMap}} A {@link RankingMap} object providing access to ranking information */ getCurrentRanking : function( ) {}, /**This is not the lifecycle event you are looking for. <p>The service should wait for the {@link #onListenerConnected}() event before performing any operations. */ onBind : function( ) {}, /** */ onDestroy : function( ) {}, /**Directly register this service with the Notification Manager. <p>Only system services may use this call. It will fail for non-system callers. Apps should ask the user to add their listener in Settings. @param {Object {Context}} context Context required for accessing resources. Since this service isn't launched as a real Service when using this method, a context has to be passed in. @param {Object {ComponentName}} componentName the component that will consume the notification information @param {Number} currentUser the user to use as the stream filter @hide @removed */ registerAsSystemService : function( ) {}, /**Directly unregister this service from the Notification Manager. <p>This method will fail for listeners that were not registered with (@link registerAsService). @hide @removed */ unregisterAsSystemService : function( ) {}, /**Request that the listener be rebound, after a previous call to {@link #requestUnbind}. <p>This method will fail for listeners that have not been granted the permission by the user. */ requestRebind : function( ) {}, /**Request that the service be unbound. <p>Once this is called, you will no longer receive updates and no method calls are guaranteed to be successful, until you next receive the {@link #onListenerConnected}() event. The service will likely be killed by the system after this call. <p>The service should wait for the {@link #onListenerConnected}() event before performing this operation. I know it's tempting, but you must wait. */ requestUnbind : function( ) {}, /**Convert new-style Icons to legacy representations for pre-M clients. @hide */ createLegacyIconExtras : function( ) {}, /** @hide */ applyUpdateLocked : function( ) {}, };