i_lovefish
i_lovefish

Android中Notification的framework层讲解

android的notificaiton的声音sound也是申请的AudioManager机制来播放声音的。最近让我找恢复出厂设置后，手机刚启动，接受短信没有声音，如果恢复出厂设置后，等一会儿，过个2分钟再接受短信，就有铃声了。下面我把我分析代码的方法写下来，给自己和读者一些启发：

      日历也是用的是Notification，但是恢复出厂设置后，立马设置日历后，日历可以出声音，我看日历的代码，结果发现日历只是用了Notification的闪屏，真正声音是日历自己实现了Mediaplayer来出声音的。所以我又不得不老老实实地研究Notification.sound到底把声音传递到什么地方去了？

       首先，我在短信的com.android.mms.transaction包中的MessagingNotification的573行的java代码：notification.sound = TextUtils.isEmpty(ringtoneStr) ? null : Uri.parse(ringtoneStr);打log查看，发现这个uri确实是存在的，我推测：就是说这个uri传给了framework一层，但是framework一层有没有执行完的动作，所以不响。为了验证是不是短信的错误，我自己单独写了个notification的例子，一个按钮，点击就发出声音。这个例子在正常情况下能正常发声。我就恢复出厂设置后，运行这个例子，结果发现没有声音，这就充分验证了我的猜测。我就去framework去着notificaion.sound = 的声音传递给framework做什么事情了？？

       接着，在Source Insight软件中导入framework整个工程，然后搜索，notificaiton.sounds，结果搜到了，在framework/base/core/java/android/app/Notification.java类。

[java] view plain copy print ?
  1. /*
  2. * Copyright (C) 2007 The Android Open Source Project
  3. *
  4. * Licensed under the Apache License, Version 2.0 (the "License");
  5. * you may not use this file except in compliance with the License.
  6. * You may obtain a copy of the License at
  7. *
  8. *      http://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. * Unless required by applicable law or agreed to in writing, software
  11. * distributed under the License is distributed on an "AS IS" BASIS,
  12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. * See the License for the specific language governing permissions and
  14. * limitations under the License.
  15. */ 
  16.  
  17. package android.app; 
  18.  
  19. import java.util.Date; 
  20.  
  21. import android.app.PendingIntent; 
  22. import android.content.Context; 
  23. import android.content.Intent; 
  24. import android.media.AudioManager; 
  25. import android.net.Uri; 
  26. import android.os.Parcel; 
  27. import android.os.Parcelable; 
  28. import android.text.TextUtils; 
  29. import android.text.format.DateFormat; 
  30. import android.text.format.DateUtils; 
  31. import android.widget.RemoteViews; 
  32.  
  33. /**
  34. * A class that represents how a persistent notification is to be presented to
  35. * the user using the {@link android.app.NotificationManager}.
  36. *
  37. * <p>For a guide to creating notifications, see the
  38. * <a href="{@docRoot}guide/topics/ui/notifiers/notifications.html">Creating Status
  39. * Bar Notifications</a> document in the Dev Guide.</p>
  40. */ 
  41. public class Notificationimplements Parcelable 
  42. { 
  43.     /**
  44.      * Use all default values (where applicable).
  45.      */ 
  46.     public staticfinalint DEFAULT_ALL = ~0; 
  47.      
  48.     /**
  49.      * Use the default notification sound. This will ignore any given
  50.      * {@link #sound}.
  51.      *
  52.      * @see #defaults
  53.      */  
  54.     public staticfinalint DEFAULT_SOUND =1; 
  55.  
  56.     /**
  57.      * Use the default notification vibrate. This will ignore any given
  58.      * {@link #vibrate}. Using phone vibration requires the
  59.      * {@link android.Manifest.permission#VIBRATE VIBRATE} permission.
  60.      *
  61.      * @see #defaults
  62.      */  
  63.     public static finalint DEFAULT_VIBRATE =2; 
  64.      
  65.     /**
  66.      * Use the default notification lights. This will ignore the
  67.      * {@link #FLAG_SHOW_LIGHTS} bit, and {@link #ledARGB}, {@link #ledOffMS}, or
  68.      * {@link #ledOnMS}.
  69.      *
  70.      * @see #defaults
  71.      */  
  72.     public staticfinalint DEFAULT_LIGHTS =4; 
  73.      
  74.     /**
  75.      * The timestamp for the notification.  The icons and expanded views
  76.      * are sorted by this key.
  77.      */ 
  78.     public long when; 
  79.  
  80.     /**
  81.      * The resource id of a drawable to use as the icon in the status bar.
  82.      */ 
  83.     public int icon; 
  84.  
  85.     /**
  86.      * The number of events that this notification represents.  For example, in a new mail
  87.      * notification, this could be the number of unread messages.  This number is superimposed over
  88.      * the icon in the status bar.  If the number is 0 or negative, it is not shown in the status
  89.      * bar.
  90.      */ 
  91.     public int number; 
  92.  
  93.     /**
  94.      * The intent to execute when the expanded status entry is clicked.  If
  95.      * this is an activity, it must include the
  96.      * {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK} flag, which requires
  97.      * that you take care of task management as described in the <em>Activities and Tasks</em>
  98.      * section of the <a href="{@docRoot}guide/topics/fundamentals.html#acttask">Application
  99.      * Fundamentals</a> document.
  100.      */ 
  101.     public PendingIntent contentIntent; 
  102.  
  103.     /**
  104.      * The intent to execute when the status entry is deleted by the user
  105.      * with the "Clear All Notifications" button. This probably shouldn't
  106.      * be launching an activity since several of those will be sent at the
  107.      * same time.
  108.      */ 
  109.     public PendingIntent deleteIntent; 
  110.  
  111.     /**
  112.      * An intent to launch instead of posting the notification to the status bar.
  113.      * Only for use with extremely high-priority notifications demanding the user's
  114.      * <strong>immediate</strong> attention, such as an incoming phone call or
  115.      * alarm clock that the user has explicitly set to a particular time.
  116.      * If this facility is used for something else, please give the user an option
  117.      * to turn it off and use a normal notification, as this can be extremely
  118.      * disruptive.
  119.      */ 
  120.     public PendingIntent fullScreenIntent; 
  121.  
  122.     /**
  123.      * Text to scroll across the screen when this item is added to
  124.      * the status bar.
  125.      */ 
  126.     public CharSequence tickerText; 
  127.  
  128.     /**
  129.      * The view that will represent this notification in the expanded status bar.
  130.      */ 
  131.     public RemoteViews contentView; 
  132.  
  133.     /**
  134.      * If the icon in the status bar is to have more than one level, you can set this.  Otherwise,
  135.      * leave it at its default value of 0.
  136.      *
  137.      * @see android.widget.ImageView#setImageLevel
  138.      * @see android.graphics.drawable#setLevel
  139.      */ 
  140.     public int iconLevel; 
  141.  
  142.     /**
  143.      * The sound to play.
  144.      *
  145.      * <p>
  146.      * To play the default notification sound, see {@link #defaults}.
  147.      * </p>
  148.      */ 
  149.     public Uri sound; 
  150.  
  151.     /**
  152.      * Use this constant as the value for audioStreamType to request that
  153.      * the default stream type for notifications be used.  Currently the
  154.      * default stream type is STREAM_RING.
  155.      */ 
  156.     public staticfinalint STREAM_DEFAULT = -1; 
  157.  
  158.     /**
  159.      * The audio stream type to use when playing the sound.
  160.      * Should be one of the STREAM_ constants from
  161.      * {@link android.media.AudioManager}.
  162.      */ 
  163.     public int audioStreamType = STREAM_DEFAULT; 
  164.  
  165.      
  166.     /**
  167.      * The pattern with which to vibrate.
  168.      *
  169.      * <p>
  170.      * To vibrate the default pattern, see {@link #defaults}.
  171.      * </p>
  172.      *
  173.      * @see android.os.Vibrator#vibrate(long[],int)
  174.      */ 
  175.     public long[] vibrate; 
  176.  
  177.     /**
  178.      * The color of the led.  The hardware will do its best approximation.
  179.      *
  180.      * @see #FLAG_SHOW_LIGHTS
  181.      * @see #flags
  182.      */ 
  183.     public int ledARGB; 
  184.  
  185.     /**
  186.      * The number of milliseconds for the LED to be on while it's flashing.
  187.      * The hardware will do its best approximation.
  188.      *
  189.      * @see #FLAG_SHOW_LIGHTS
  190.      * @see #flags
  191.      */ 
  192.     public int ledOnMS; 
  193.  
  194.     /**
  195.      * The number of milliseconds for the LED to be off while it's flashing.
  196.      * The hardware will do its best approximation.
  197.      *
  198.      * @see #FLAG_SHOW_LIGHTS
  199.      * @see #flags
  200.      */ 
  201.     public int ledOffMS; 
  202.  
  203.     /**
  204.      * Specifies which values should be taken from the defaults.
  205.      * <p>
  206.      * To set, OR the desired from {@link #DEFAULT_SOUND},
  207.      * {@link #DEFAULT_VIBRATE}, {@link #DEFAULT_LIGHTS}. For all default
  208.      * values, use {@link #DEFAULT_ALL}.
  209.      * </p>
  210.      */ 
  211.     public int defaults; 
  212.  
  213.  
  214.     /**
  215.      * Bit to be bitwise-ored into the {@link #flags} field that should be
  216.      * set if you want the LED on for this notification.
  217.      * <ul>
  218.      * <li>To turn the LED off, pass 0 in the alpha channel for colorARGB
  219.      *      or 0 for both ledOnMS and ledOffMS.</li>
  220.      * <li>To turn the LED on, pass 1 for ledOnMS and 0 for ledOffMS.</li>
  221.      * <li>To flash the LED, pass the number of milliseconds that it should
  222.      *      be on and off to ledOnMS and ledOffMS.</li>
  223.      * </ul>
  224.      * <p>
  225.      * Since hardware varies, you are not guaranteed that any of the values
  226.      * you pass are honored exactly.  Use the system defaults (TODO) if possible
  227.      * because they will be set to values that work on any given hardware.
  228.      * <p>
  229.      * The alpha channel must be set for forward compatibility.
  230.      *
  231.      */ 
  232.     public staticfinalint FLAG_SHOW_LIGHTS        =0x00000001; 
  233.  
  234.     /**
  235.      * Bit to be bitwise-ored into the {@link #flags} field that should be
  236.      * set if this notification is in reference to something that is ongoing,
  237.      * like a phone call.  It should not be set if this notification is in
  238.      * reference to something that happened at a particular point in time,
  239.      * like a missed phone call.
  240.      */ 
  241.     public static finalint FLAG_ONGOING_EVENT      =0x00000002; 
  242.  
  243.     /**
  244.      * Bit to be bitwise-ored into the {@link #flags} field that if set,
  245.      * the audio will be repeated until the notification is
  246.      * cancelled or the notification window is opened.
  247.      */ 
  248.     public staticfinalint FLAG_INSISTENT          =0x00000004; 
  249.  
  250.     /**
  251.      * Bit to be bitwise-ored into the {@link #flags} field that should be
  252.      * set if you want the sound and/or vibration play each time the
  253.      * notification is sent, even if it has not been canceled before that.
  254.      */ 
  255.     public static finalint FLAG_ONLY_ALERT_ONCE    =0x00000008; 
  256.  
  257.     /**
  258.      * Bit to be bitwise-ored into the {@link #flags} field that should be
  259.      * set if the notification should be canceled when it is clicked by the
  260.      * user.
  261.      */ 
  262.     public staticfinalint FLAG_AUTO_CANCEL        =0x00000010; 
  263.  
  264.     /**
  265.      * Bit to be bitwise-ored into the {@link #flags} field that should be
  266.      * set if the notification should not be canceled when the user clicks
  267.      * the Clear all button.
  268.      */ 
  269.     public static finalint FLAG_NO_CLEAR           =0x00000020; 
  270.  
  271.     /**
  272.      * Bit to be bitwise-ored into the {@link #flags} field that should be
  273.      * set if this notification represents a currently running service.  This
  274.      * will normally be set for you by {@link Service#startForeground}.
  275.      */ 
  276.     public staticfinalint FLAG_FOREGROUND_SERVICE =0x00000040; 
  277.  
  278.     public int flags; 
  279.  
  280.     /**
  281.      * Constructs a Notification object with everything set to 0.
  282.      */ 
  283.     public Notification() 
  284.     { 
  285.         this.when = System.currentTimeMillis(); 
  286.     } 
  287.  
  288.     /**
  289.      * @deprecated use {@link #Notification(int,CharSequence,long)} and {@link #setLatestEventInfo}.
  290.      * @hide
  291.      */ 
  292.     public Notification(Context context,int icon, CharSequence tickerText,long when, 
  293.             CharSequence contentTitle, CharSequence contentText, Intent contentIntent) 
  294.     { 
  295.         this.when = when; 
  296.         this.icon = icon; 
  297.         this.tickerText = tickerText; 
  298.         setLatestEventInfo(context, contentTitle, contentText, 
  299.                 PendingIntent.getActivity(context, 0, contentIntent,0)); 
  300.     } 
  301.  
  302.     /**
  303.      * Constructs a Notification object with the information needed to
  304.      * have a status bar icon without the standard expanded view.
  305.      *
  306.      * @param icon          The resource id of the icon to put in the status bar.
  307.      * @param tickerText    The text that flows by in the status bar when the notification first
  308.      *                      activates.
  309.      * @param when          The time to show in the time field.  In the System.currentTimeMillis
  310.      *                      timebase.
  311.      */ 
  312.     public Notification(int icon, CharSequence tickerText,long when) 
  313.     { 
  314.         this.icon = icon; 
  315.         this.tickerText = tickerText; 
  316.         this.when = when; 
  317.     } 
  318.  
  319.     /**
  320.      * Unflatten the notification from a parcel.
  321.      */ 
  322.     public Notification(Parcel parcel) 
  323.     { 
  324.         int version = parcel.readInt(); 
  325.  
  326.         when = parcel.readLong(); 
  327.         icon = parcel.readInt(); 
  328.         number = parcel.readInt(); 
  329.         if (parcel.readInt() !=0) { 
  330.             contentIntent = PendingIntent.CREATOR.createFromParcel(parcel); 
  331.         } 
  332.         if (parcel.readInt() !=0) { 
  333.             deleteIntent = PendingIntent.CREATOR.createFromParcel(parcel); 
  334.         } 
  335.         if (parcel.readInt() !=0) { 
  336.             tickerText = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(parcel); 
  337.         } 
  338.         if (parcel.readInt() !=0) { 
  339.             contentView = RemoteViews.CREATOR.createFromParcel(parcel); 
  340.         } 
  341.         defaults = parcel.readInt(); 
  342.         flags = parcel.readInt(); 
  343.         if (parcel.readInt() !=0) { 
  344.             sound = Uri.CREATOR.createFromParcel(parcel); 
  345.         } 
  346.  
  347.         audioStreamType = parcel.readInt(); 
  348.         vibrate = parcel.createLongArray(); 
  349.         ledARGB = parcel.readInt(); 
  350.         ledOnMS = parcel.readInt(); 
  351.         ledOffMS = parcel.readInt(); 
  352.         iconLevel = parcel.readInt(); 
  353.  
  354.         if (parcel.readInt() !=0) { 
  355.             fullScreenIntent = PendingIntent.CREATOR.createFromParcel(parcel); 
  356.         } 
  357.     } 
  358.  
  359.     public Notification clone() { 
  360.         Notification that = new Notification(); 
  361.  
  362.         that.when = this.when; 
  363.         that.icon = this.icon; 
  364.         that.number = this.number; 
  365.  
  366.         // PendingIntents are global, so there's no reason (or way) to clone them. 
  367.         that.contentIntent = this.contentIntent; 
  368.         that.deleteIntent = this.deleteIntent; 
  369.         that.fullScreenIntent = this.fullScreenIntent; 
  370.  
  371.         if (this.tickerText !=null) { 
  372.             that.tickerText = this.tickerText.toString(); 
  373.         } 
  374.         if (this.contentView !=null) { 
  375.             that.contentView = this.contentView.clone(); 
  376.         } 
  377.         that.iconLevel = that.iconLevel; 
  378.         that.sound = this.sound;// android.net.Uri is immutable 
  379.         that.audioStreamType = this.audioStreamType; 
  380.  
  381.         final long[] vibrate = this.vibrate; 
  382.         if (vibrate != null) { 
  383.             finalint N = vibrate.length; 
  384.             final long[] vib = that.vibrate =newlong[N]; 
  385.             System.arraycopy(vibrate, 0, vib,0, N); 
  386.         } 
  387.  
  388.         that.ledARGB = this.ledARGB; 
  389.         that.ledOnMS = this.ledOnMS; 
  390.         that.ledOffMS = this.ledOffMS; 
  391.         that.defaults = this.defaults; 
  392.          
  393.         that.flags = this.flags; 
  394.  
  395.         return that; 
  396.     } 
  397.  
  398.     public int describeContents() { 
  399.         return 0; 
  400.     } 
  401.  
  402.     /**
  403.      * Flatten this notification from a parcel.
  404.      */ 
  405.     public void writeToParcel(Parcel parcel, int flags) 
  406.     { 
  407.         parcel.writeInt(1); 
  408.  
  409.         parcel.writeLong(when); 
  410.         parcel.writeInt(icon); 
  411.         parcel.writeInt(number); 
  412.         if (contentIntent != null) { 
  413.             parcel.writeInt(1); 
  414.             contentIntent.writeToParcel(parcel, 0); 
  415.         } else { 
  416.             parcel.writeInt(0); 
  417.         } 
  418.         if (deleteIntent != null) { 
  419.             parcel.writeInt(1); 
  420.             deleteIntent.writeToParcel(parcel, 0); 
  421.         } else { 
  422.             parcel.writeInt(0); 
  423.         } 
  424.         if (tickerText != null) { 
  425.             parcel.writeInt(1); 
  426.             TextUtils.writeToParcel(tickerText, parcel, flags); 
  427.         } else { 
  428.             parcel.writeInt(0); 
  429.         } 
  430.         if (contentView != null) { 
  431.             parcel.writeInt(1); 
  432.             contentView.writeToParcel(parcel, 0); 
  433.         } else { 
  434.             parcel.writeInt(0); 
  435.         } 
  436.  
  437.         parcel.writeInt(defaults); 
  438.         parcel.writeInt(this.flags); 
  439.  
  440.         if (sound != null) { 
  441.             parcel.writeInt(1); 
  442.             sound.writeToParcel(parcel, 0); 
  443.         } else { 
  444.             parcel.writeInt(0); 
  445.         } 
  446.         parcel.writeInt(audioStreamType); 
  447.         parcel.writeLongArray(vibrate); 
  448.         parcel.writeInt(ledARGB); 
  449.         parcel.writeInt(ledOnMS); 
  450.         parcel.writeInt(ledOffMS); 
  451.         parcel.writeInt(iconLevel); 
  452.  
  453.         if (fullScreenIntent !=null) { 
  454.             parcel.writeInt(1); 
  455.             fullScreenIntent.writeToParcel(parcel, 0); 
  456.         } else { 
  457.             parcel.writeInt(0); 
  458.         } 
  459.     } 
  460.  
  461.     /**
  462.      * Parcelable.Creator that instantiates Notification objects
  463.      */ 
  464.     public staticfinal Parcelable.Creator<Notification> CREATOR 
  465.             = new Parcelable.Creator<Notification>() 
  466.     { 
  467.         public Notification createFromParcel(Parcel parcel) 
  468.         { 
  469.             returnnew Notification(parcel); 
  470.         } 
  471.  
  472.         public Notification[] newArray(int size) 
  473.         { 
  474.             return new Notification[size]; 
  475.         } 
  476.     }; 
  477.  
  478.     /**
  479.      * Sets the {@link #contentView} field to be a view with the standard "Latest Event"
  480.      * layout.
  481.      *
  482.      * <p>Uses the {@link #icon} and {@link #when} fields to set the icon and time fields
  483.      * in the view.</p>
  484.      * @param context       The context for your application / activity.
  485.      * @param contentTitle The title that goes in the expanded entry.
  486.      * @param contentText  The text that goes in the expanded entry.
  487.      * @param contentIntent The intent to launch when the user clicks the expanded notification.
  488.      * If this is an activity, it must include the
  489.      * {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK} flag, which requires
  490.      * that you take care of task management as described in
  491.      * <a href="{@docRoot}guide/topics/fundamentals.html#lcycles">Application Fundamentals: Activities and Tasks</a>.
  492.      */ 
  493.     public void setLatestEventInfo(Context context, 
  494.             CharSequence contentTitle, CharSequence contentText, PendingIntent contentIntent) { 
  495.         RemoteViews contentView = new RemoteViews(context.getPackageName(), 
  496.                 com.android.internal.R.layout.status_bar_latest_event_content); 
  497.         if (this.icon !=0) { 
  498.             contentView.setImageViewResource(com.android.internal.R.id.icon,this.icon); 
  499.         } 
  500.         if (contentTitle != null) { 
  501.             contentView.setTextViewText(com.android.internal.R.id.title, contentTitle); 
  502.         } 
  503.         if (contentText !=null) { 
  504.             contentView.setTextViewText(com.android.internal.R.id.text, contentText); 
  505.         } 
  506.         if (this.when !=0) { 
  507.             contentView.setLong(com.android.internal.R.id.time,"setTime", when); 
  508.         } 
  509.  
  510.         this.contentView = contentView; 
  511.         this.contentIntent = contentIntent; 
  512.     } 
  513.  
  514.     @Override 
  515.     public String toString() { 
  516.         StringBuilder sb = new StringBuilder(); 
  517.         sb.append("Notification(vibrate="); 
  518.         if (this.vibrate !=null) { 
  519.             int N =this.vibrate.length-1; 
  520.             sb.append("["); 
  521.             for (int i=0; i<N; i++) { 
  522.                 sb.append(this.vibrate[i]); 
  523.                 sb.append(','); 
  524.             } 
  525.             if (N != -1) { 
  526.                 sb.append(this.vibrate[N]); 
  527.             } 
  528.             sb.append("]"); 
  529.         } else if ((this.defaults & DEFAULT_VIBRATE) !=0) { 
  530.             sb.append("default"); 
  531.         } else { 
  532.             sb.append("null"); 
  533.         } 
  534.         sb.append(",sound="); 
  535.         if (this.sound !=null) { 
  536.             sb.append(this.sound.toString()); 
  537.         } else if ((this.defaults & DEFAULT_SOUND) !=0) { 
  538.             sb.append("default"); 
  539.         } else { 
  540.             sb.append("null"); 
  541.         } 
  542.         sb.append(",defaults=0x"); 
  543.         sb.append(Integer.toHexString(this.defaults)); 
  544.         sb.append(",flags=0x"); 
  545.         sb.append(Integer.toHexString(this.flags)); 
  546.         sb.append(")"); 
  547.         return sb.toString(); 
  548.     } 
  549. } 
[java] view plain copy print ?
  1. /*
  2. * Copyright (C) 2007 The Android Open Source Project
  3. *
  4. * Licensed under the Apache License, Version 2.0 (the "License");
  5. * you may not use this file except in compliance with the License.
  6. * You may obtain a copy of the License at
  7. *
  8. *      http://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. * Unless required by applicable law or agreed to in writing, software
  11. * distributed under the License is distributed on an "AS IS" BASIS,
  12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. * See the License for the specific language governing permissions and
  14. * limitations under the License.
  15. */ 
  16.  
  17. package android.app; 
  18.  
  19. import java.util.Date; 
  20.  
  21. import android.app.PendingIntent; 
  22. import android.content.Context; 
  23. import android.content.Intent; 
  24. import android.media.AudioManager; 
  25. import android.net.Uri; 
  26. import android.os.Parcel; 
  27. import android.os.Parcelable; 
  28. import android.text.TextUtils; 
  29. import android.text.format.DateFormat; 
  30. import android.text.format.DateUtils; 
  31. import android.widget.RemoteViews; 
  32.  
  33. /**
  34. * A class that represents how a persistent notification is to be presented to
  35. * the user using the {@link android.app.NotificationManager}.
  36. *
  37. * <p>For a guide to creating notifications, see the
  38. * <a href="{@docRoot}guide/topics/ui/notifiers/notifications.html">Creating Status
  39. * Bar Notifications</a> document in the Dev Guide.</p>
  40. */ 
  41. public class Notificationimplements Parcelable 
  42. { 
  43.     /**
  44.      * Use all default values (where applicable).
  45.      */ 
  46.     public staticfinalint DEFAULT_ALL = ~0; 
  47.      
  48.     /**
  49.      * Use the default notification sound. This will ignore any given
  50.      * {@link #sound}.
  51.      *
  52.      * @see #defaults
  53.      */  
  54.     public staticfinalint DEFAULT_SOUND =1; 
  55.  
  56.     /**
  57.      * Use the default notification vibrate. This will ignore any given
  58.      * {@link #vibrate}. Using phone vibration requires the
  59.      * {@link android.Manifest.permission#VIBRATE VIBRATE} permission.
  60.      *
  61.      * @see #defaults
  62.      */  
  63.     public staticfinalint DEFAULT_VIBRATE =2; 
  64.      
  65.     /**
  66.      * Use the default notification lights. This will ignore the
  67.      * {@link #FLAG_SHOW_LIGHTS} bit, and {@link #ledARGB}, {@link #ledOffMS}, or
  68.      * {@link #ledOnMS}.
  69.      *
  70.      * @see #defaults
  71.      */  
  72.     public staticfinalint DEFAULT_LIGHTS =4; 
  73.      
  74.     /**
  75.      * The timestamp for the notification.  The icons and expanded views
  76.      * are sorted by this key.
  77.      */ 
  78.     public long when; 
  79.  
  80.     /**
  81.      * The resource id of a drawable to use as the icon in the status bar.
  82.      */ 
  83.     public int icon; 
  84.  
  85.     /**
  86.      * The number of events that this notification represents.  For example, in a new mail
  87.      * notification, this could be the number of unread messages.  This number is superimposed over
  88.      * the icon in the status bar.  If the number is 0 or negative, it is not shown in the status
  89.      * bar.
  90.      */ 
  91.     public int number; 
  92.  
  93.     /**
  94.      * The intent to execute when the expanded status entry is clicked.  If
  95.      * this is an activity, it must include the
  96.      * {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK} flag, which requires
  97.      * that you take care of task management as described in the <em>Activities and Tasks</em>
  98.      * section of the <a href="{@docRoot}guide/topics/fundamentals.html#acttask">Application
  99.      * Fundamentals</a> document.
  100.      */ 
  101.     public PendingIntent contentIntent; 
  102.  
  103.     /**
  104.      * The intent to execute when the status entry is deleted by the user
  105.      * with the "Clear All Notifications" button. This probably shouldn't
  106.      * be launching an activity since several of those will be sent at the
  107.      * same time.
  108.      */ 
  109.     public PendingIntent deleteIntent; 
  110.  
  111.     /**
  112.      * An intent to launch instead of posting the notification to the status bar.
  113.      * Only for use with extremely high-priority notifications demanding the user's
  114.      * <strong>immediate</strong> attention, such as an incoming phone call or
  115.      * alarm clock that the user has explicitly set to a particular time.
  116.      * If this facility is used for something else, please give the user an option
  117.      * to turn it off and use a normal notification, as this can be extremely
  118.      * disruptive.
  119.      */ 
  120.     public PendingIntent fullScreenIntent; 
  121.  
  122.     /**
  123.      * Text to scroll across the screen when this item is added to
  124.      * the status bar.
  125.      */ 
  126.     public CharSequence tickerText; 
  127.  
  128.     /**
  129.      * The view that will represent this notification in the expanded status bar.
  130.      */ 
  131.     public RemoteViews contentView; 
  132.  
  133.     /**
  134.      * If the icon in the status bar is to have more than one level, you can set this.  Otherwise,
  135.      * leave it at its default value of 0.
  136.      *
  137.      * @see android.widget.ImageView#setImageLevel
  138.      * @see android.graphics.drawable#setLevel
  139.      */ 
  140.     public int iconLevel; 
  141.  
  142.     /**
  143.      * The sound to play.
  144.      *
  145.      * <p>
  146.      * To play the default notification sound, see {@link #defaults}.
  147.      * </p>
  148.      */ 
  149.     public Uri sound; 
  150.  
  151.     /**
  152.      * Use this constant as the value for audioStreamType to request that
  153.      * the default stream type for notifications be used.  Currently the
  154.      * default stream type is STREAM_RING.
  155.      */ 
  156.     public staticfinalint STREAM_DEFAULT = -1; 
  157.  
  158.     /**
  159.      * The audio stream type to use when playing the sound.
  160.      * Should be one of the STREAM_ constants from
  161.      * {@link android.media.AudioManager}.
  162.      */ 
  163.     public int audioStreamType = STREAM_DEFAULT; 
  164.  
  165.      
  166.     /**
  167.      * The pattern with which to vibrate.
  168.      *
  169.      * <p>
  170.      * To vibrate the default pattern, see {@link #defaults}.
  171.      * </p>
  172.      *
  173.      * @see android.os.Vibrator#vibrate(long[],int)
  174.      */ 
  175.     public long[] vibrate; 
  176.  
  177.     /**
  178.      * The color of the led.  The hardware will do its best approximation.
  179.      *
  180.      * @see #FLAG_SHOW_LIGHTS
  181.      * @see #flags
  182.      */ 
  183.     public int ledARGB; 
  184.  
  185.     /**
  186.      * The number of milliseconds for the LED to be on while it's flashing.
  187.      * The hardware will do its best approximation.
  188.      *
  189.      * @see #FLAG_SHOW_LIGHTS
  190.      * @see #flags
  191.      */ 
  192.     public int ledOnMS; 
  193.  
  194.     /**
  195.      * The number of milliseconds for the LED to be off while it's flashing.
  196.      * The hardware will do its best approximation.
  197.      *
  198.      * @see #FLAG_SHOW_LIGHTS
  199.      * @see #flags
  200.      */ 
  201.     public int ledOffMS; 
  202.  
  203.     /**
  204.      * Specifies which values should be taken from the defaults.
  205.      * <p>
  206.      * To set, OR the desired from {@link #DEFAULT_SOUND},
  207.      * {@link #DEFAULT_VIBRATE}, {@link #DEFAULT_LIGHTS}. For all default
  208.      * values, use {@link #DEFAULT_ALL}.
  209.      * </p>
  210.      */ 
  211.     public int defaults; 
  212.  
  213.  
  214.     /**
  215.      * Bit to be bitwise-ored into the {@link #flags} field that should be
  216.      * set if you want the LED on for this notification.
  217.      * <ul>
  218.      * <li>To turn the LED off, pass 0 in the alpha channel for colorARGB
  219.      *      or 0 for both ledOnMS and ledOffMS.</li>
  220.      * <li>To turn the LED on, pass 1 for ledOnMS and 0 for ledOffMS.</li>
  221.      * <li>To flash the LED, pass the number of milliseconds that it should
  222.      *      be on and off to ledOnMS and ledOffMS.</li>
  223.      * </ul>
  224.      * <p>
  225.      * Since hardware varies, you are not guaranteed that any of the values
  226.      * you pass are honored exactly.  Use the system defaults (TODO) if possible
  227.      * because they will be set to values that work on any given hardware.
  228.      * <p>
  229.      * The alpha channel must be set for forward compatibility.
  230.      *
  231.      */ 
  232.     public staticfinalint FLAG_SHOW_LIGHTS        =0x00000001; 
  233.  
  234.     /**
  235.      * Bit to be bitwise-ored into the {@link #flags} field that should be
  236.      * set if this notification is in reference to something that is ongoing,
  237.      * like a phone call.  It should not be set if this notification is in
  238.      * reference to something that happened at a particular point in time,
  239.      * like a missed phone call.
  240.      */ 
  241.     public staticfinalint FLAG_ONGOING_EVENT      =0x00000002; 
  242.  
  243.     /**
  244.      * Bit to be bitwise-ored into the {@link #flags} field that if set,
  245.      * the audio will be repeated until the notification is
  246.      * cancelled or the notification window is opened.
  247.      */ 
  248.     public staticfinalint FLAG_INSISTENT          =0x00000004; 
  249.  
  250.     /**
  251.      * Bit to be bitwise-ored into the {@link #flags} field that should be
  252.      * set if you want the sound and/or vibration play each time the
  253.      * notification is sent, even if it has not been canceled before that.
  254.      */ 
  255.     public staticfinalint FLAG_ONLY_ALERT_ONCE    =0x00000008; 
  256.  
  257.     /**
  258.      * Bit to be bitwise-ored into the {@link #flags} field that should be
  259.      * set if the notification should be canceled when it is clicked by the
  260.      * user.
  261.      */ 
  262.     public staticfinalint FLAG_AUTO_CANCEL        =0x00000010; 
  263.  
  264.     /**
  265.      * Bit to be bitwise-ored into the {@link #flags} field that should be
  266.      * set if the notification should not be canceled when the user clicks
  267.      * the Clear all button.
  268.      */ 
  269.     public staticfinalint FLAG_NO_CLEAR           =0x00000020; 
  270.  
  271.     /**
  272.      * Bit to be bitwise-ored into the {@link #flags} field that should be
  273.      * set if this notification represents a currently running service.  This
  274.      * will normally be set for you by {@link Service#startForeground}.
  275.      */ 
  276.     public staticfinalint FLAG_FOREGROUND_SERVICE =0x00000040; 
  277.  
  278.     public int flags; 
  279.  
  280.     /**
  281.      * Constructs a Notification object with everything set to 0.
  282.      */ 
  283.     public Notification() 
  284.     { 
  285.         this.when = System.currentTimeMillis(); 
  286.     } 
  287.  
  288.     /**
  289.      * @deprecated use {@link #Notification(int,CharSequence,long)} and {@link #setLatestEventInfo}.
  290.      * @hide
  291.      */ 
  292.     public Notification(Context context,int icon, CharSequence tickerText,long when, 
  293.             CharSequence contentTitle, CharSequence contentText, Intent contentIntent) 
  294.     { 
  295.         this.when = when; 
  296.         this.icon = icon; 
  297.         this.tickerText = tickerText; 
  298.         setLatestEventInfo(context, contentTitle, contentText, 
  299.                 PendingIntent.getActivity(context, 0, contentIntent, 0)); 
  300.     } 
  301.  
  302.     /**
  303.      * Constructs a Notification object with the information needed to
  304.      * have a status bar icon without the standard expanded view.
  305.      *
  306.      * @param icon          The resource id of the icon to put in the status bar.
  307.      * @param tickerText    The text that flows by in the status bar when the notification first
  308.      *                      activates.
  309.      * @param when          The time to show in the time field.  In the System.currentTimeMillis
  310.      *                      timebase.
  311.      */ 
  312.     public Notification(int icon, CharSequence tickerText,long when) 
  313.     { 
  314.         this.icon = icon; 
  315.         this.tickerText = tickerText; 
  316.         this.when = when; 
  317.     } 
  318.  
  319.     /**
  320.      * Unflatten the notification from a parcel.
  321.      */ 
  322.     public Notification(Parcel parcel) 
  323.     { 
  324.         int version = parcel.readInt(); 
  325.  
  326.         when = parcel.readLong(); 
  327.         icon = parcel.readInt(); 
  328.         number = parcel.readInt(); 
  329.         if (parcel.readInt() !=0) { 
  330.             contentIntent = PendingIntent.CREATOR.createFromParcel(parcel); 
  331.         } 
  332.         if (parcel.readInt() != 0) { 
  333.             deleteIntent = PendingIntent.CREATOR.createFromParcel(parcel); 
  334.         } 
  335.         if (parcel.readInt() !=0) { 
  336.             tickerText = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(parcel); 
  337.         } 
  338.         if (parcel.readInt() != 0) { 
  339.             contentView = RemoteViews.CREATOR.createFromParcel(parcel); 
  340.         } 
  341.         defaults = parcel.readInt(); 
  342.         flags = parcel.readInt(); 
  343.         if (parcel.readInt() !=0) { 
  344.             sound = Uri.CREATOR.createFromParcel(parcel); 
  345.         } 
  346.  
  347.         audioStreamType = parcel.readInt(); 
  348.         vibrate = parcel.createLongArray(); 
  349.         ledARGB = parcel.readInt(); 
  350.         ledOnMS = parcel.readInt(); 
  351.         ledOffMS = parcel.readInt(); 
  352.         iconLevel = parcel.readInt(); 
  353.  
  354.         if (parcel.readInt() != 0) { 
  355.             fullScreenIntent = PendingIntent.CREATOR.createFromParcel(parcel); 
  356.         } 
  357.     } 
  358.  
  359.     public Notification clone() { 
  360.         Notification that = new Notification(); 
  361.  
  362.         that.when = this.when; 
  363.         that.icon = this.icon; 
  364.         that.number = this.number; 
  365.  
  366.         // PendingIntents are global, so there's no reason (or way) to clone them. 
  367.         that.contentIntent = this.contentIntent; 
  368.         that.deleteIntent = this.deleteIntent; 
  369.         that.fullScreenIntent = this.fullScreenIntent; 
  370.  
  371.         if (this.tickerText !=null) { 
  372.             that.tickerText = this.tickerText.toString(); 
  373.         } 
  374.         if (this.contentView !=null) { 
  375.             that.contentView = this.contentView.clone(); 
  376.         } 
  377.         that.iconLevel = that.iconLevel; 
  378.         that.sound = this.sound; // android.net.Uri is immutable 
  379.         that.audioStreamType = this.audioStreamType; 
  380.  
  381.         final long[] vibrate =this.vibrate; 
  382.         if (vibrate != null) { 
  383.             final int N = vibrate.length; 
  384.             final long[] vib = that.vibrate =newlong[N]; 
  385.             System.arraycopy(vibrate, 0, vib, 0, N); 
  386.         } 
  387.  
  388.         that.ledARGB = this.ledARGB; 
  389.         that.ledOnMS = this.ledOnMS; 
  390.         that.ledOffMS = this.ledOffMS; 
  391.         that.defaults = this.defaults; 
  392.          
  393.         that.flags = this.flags; 
  394.  
  395.         return that; 
  396.     } 
  397.  
  398.     public int describeContents() { 
  399.         return 0; 
  400.     } 
  401.  
  402.     /**
  403.      * Flatten this notification from a parcel.
  404.      */ 
  405.     public void writeToParcel(Parcel parcel,int flags) 
  406.     { 
  407.         parcel.writeInt(1); 
  408.  
  409.         parcel.writeLong(when); 
  410.         parcel.writeInt(icon); 
  411.         parcel.writeInt(number); 
  412.         if (contentIntent != null) { 
  413.             parcel.writeInt(1); 
  414.             contentIntent.writeToParcel(parcel, 0); 
  415.         } else { 
  416.             parcel.writeInt(0); 
  417.         } 
  418.         if (deleteIntent != null) { 
  419.             parcel.writeInt(1); 
  420.             deleteIntent.writeToParcel(parcel, 0); 
  421.         } else { 
  422.             parcel.writeInt(0); 
  423.         } 
  424.         if (tickerText != null) { 
  425.             parcel.writeInt(1); 
  426.             TextUtils.writeToParcel(tickerText, parcel, flags); 
  427.         } else { 
  428.             parcel.writeInt(0); 
  429.         } 
  430.         if (contentView != null) { 
  431.             parcel.writeInt(1); 
  432.             contentView.writeToParcel(parcel, 0); 
  433.         } else { 
  434.             parcel.writeInt(0); 
  435.         } 
  436.  
  437.         parcel.writeInt(defaults); 
  438.         parcel.writeInt(this.flags); 
  439.  
  440.         if (sound != null) { 
  441.             parcel.writeInt(1); 
  442.             sound.writeToParcel(parcel, 0); 
  443.         } else { 
  444.             parcel.writeInt(0); 
  445.         } 
  446.         parcel.writeInt(audioStreamType); 
  447.         parcel.writeLongArray(vibrate); 
  448.         parcel.writeInt(ledARGB); 
  449.         parcel.writeInt(ledOnMS); 
  450.         parcel.writeInt(ledOffMS); 
  451.         parcel.writeInt(iconLevel); 
  452.  
  453.         if (fullScreenIntent !=null) { 
  454.             parcel.writeInt(1); 
  455.             fullScreenIntent.writeToParcel(parcel, 0); 
  456.         } else { 
  457.             parcel.writeInt(0); 
  458.         } 
  459.     } 
  460.  
  461.     /**
  462.      * Parcelable.Creator that instantiates Notification objects
  463.      */ 
  464.     public staticfinal Parcelable.Creator<Notification> CREATOR 
  465.             = new Parcelable.Creator<Notification>() 
  466.     { 
  467.         public Notification createFromParcel(Parcel parcel) 
  468.         { 
  469.             return new Notification(parcel); 
  470.         } 
  471.  
  472.         public Notification[] newArray(int size) 
  473.         { 
  474.             return new Notification[size]; 
  475.         } 
  476.     }; 
  477.  
  478.     /**
  479.      * Sets the {@link #contentView} field to be a view with the standard "Latest Event"
  480.      * layout.
  481.      *
  482.      * <p>Uses the {@link #icon} and {@link #when} fields to set the icon and time fields
  483.      * in the view.</p>
  484.      * @param context       The context for your application / activity.
  485.      * @param contentTitle The title that goes in the expanded entry.
  486.      * @param contentText  The text that goes in the expanded entry.
  487.      * @param contentIntent The intent to launch when the user clicks the expanded notification.
  488.      * If this is an activity, it must include the
  489.      * {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK} flag, which requires
  490.      * that you take care of task management as described in
  491.      * <a href="{@docRoot}guide/topics/fundamentals.html#lcycles">Application Fundamentals: Activities and Tasks</a>.
  492.      */ 
  493.     public void setLatestEventInfo(Context context, 
  494.             CharSequence contentTitle, CharSequence contentText, PendingIntent contentIntent) { 
  495.         RemoteViews contentView = new RemoteViews(context.getPackageName(), 
  496.                 com.android.internal.R.layout.status_bar_latest_event_content); 
  497.         if (this.icon !=0) { 
  498.             contentView.setImageViewResource(com.android.internal.R.id.icon,this.icon); 
  499.         } 
  500.         if (contentTitle != null) { 
  501.             contentView.setTextViewText(com.android.internal.R.id.title, contentTitle); 
  502.         } 
  503.         if (contentText !=null) { 
  504.             contentView.setTextViewText(com.android.internal.R.id.text, contentText); 
  505.         } 
  506.         if (this.when !=0) { 
  507.             contentView.setLong(com.android.internal.R.id.time,"setTime", when); 
  508.         } 
  509.  
  510.         this.contentView = contentView; 
  511.         this.contentIntent = contentIntent; 
  512.     } 
  513.  
  514.     @Override 
  515.     public String toString() { 
  516.         StringBuilder sb = new StringBuilder(); 
  517.         sb.append("Notification(vibrate="); 
  518.         if (this.vibrate !=null) { 
  519.             int N = this.vibrate.length-1; 
  520.             sb.append("["); 
  521.             for (int i=0; i<N; i++) { 
  522.                 sb.append(this.vibrate[i]); 
  523.                 sb.append(','); 
  524.             } 
  525.             if (N != -1) { 
  526.                 sb.append(this.vibrate[N]); 
  527.             } 
  528.             sb.append("]"); 
  529.         } else if ((this.defaults & DEFAULT_VIBRATE) !=0) { 
  530.             sb.append("default"); 
  531.         } else { 
  532.             sb.append("null"); 
  533.         } 
  534.         sb.append(",sound="); 
  535.         if (this.sound !=null) { 
  536.             sb.append(this.sound.toString()); 
  537.         } else if ((this.defaults & DEFAULT_SOUND) !=0) { 
  538.             sb.append("default"); 
  539.         } else { 
  540.             sb.append("null"); 
  541.         } 
  542.         sb.append(",defaults=0x"); 
  543.         sb.append(Integer.toHexString(this.defaults)); 
  544.         sb.append(",flags=0x"); 
  545.         sb.append(Integer.toHexString(this.flags)); 
  546.         sb.append(")"); 
  547.         return sb.toString(); 
  548.     } 
  549. } 
/* * Copyright (C) 2007 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 android.app; import java.util.Date; import android.app.PendingIntent; import android.content.Context; import android.content.Intent; import android.media.AudioManager; import android.net.Uri; import android.os.Parcel; import android.os.Parcelable; import android.text.TextUtils; import android.text.format.DateFormat; import android.text.format.DateUtils; import android.widget.RemoteViews; /** * A class that represents how a persistent notification is to be presented to * the user using the {@link android.app.NotificationManager}. * * <p>For a guide to creating notifications, see the * <a href="{@docRoot}guide/topics/ui/notifiers/notifications.html">Creating Status * Bar Notifications</a> document in the Dev Guide.</p> */ public class Notification implements Parcelable { /** * Use all default values (where applicable). */ public static final int DEFAULT_ALL = ~0; /** * Use the default notification sound. This will ignore any given * {@link #sound}. * * @see #defaults */ public static final int DEFAULT_SOUND = 1; /** * Use the default notification vibrate. This will ignore any given * {@link #vibrate}. Using phone vibration requires the * {@link android.Manifest.permission#VIBRATE VIBRATE} permission. * * @see #defaults */ public static final int DEFAULT_VIBRATE = 2; /** * Use the default notification lights. This will ignore the * {@link #FLAG_SHOW_LIGHTS} bit, and {@link #ledARGB}, {@link #ledOffMS}, or * {@link #ledOnMS}. * * @see #defaults */ public static final int DEFAULT_LIGHTS = 4; /** * The timestamp for the notification. The icons and expanded views * are sorted by this key. */ public long when; /** * The resource id of a drawable to use as the icon in the status bar. */ public int icon; /** * The number of events that this notification represents. For example, in a new mail * notification, this could be the number of unread messages. This number is superimposed over * the icon in the status bar. If the number is 0 or negative, it is not shown in the status * bar. */ public int number; /** * The intent to execute when the expanded status entry is clicked. If * this is an activity, it must include the * {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK} flag, which requires * that you take care of task management as described in the <em>Activities and Tasks</em> * section of the <a href="{@docRoot}guide/topics/fundamentals.html#acttask">Application * Fundamentals</a> document. */ public PendingIntent contentIntent; /** * The intent to execute when the status entry is deleted by the user * with the "Clear All Notifications" button. This probably shouldn't * be launching an activity since several of those will be sent at the * same time. */ public PendingIntent deleteIntent; /** * An intent to launch instead of posting the notification to the status bar. * Only for use with extremely high-priority notifications demanding the user's * <strong>immediate</strong> attention, such as an incoming phone call or * alarm clock that the user has explicitly set to a particular time. * If this facility is used for something else, please give the user an option * to turn it off and use a normal notification, as this can be extremely * disruptive. */ public PendingIntent fullScreenIntent; /** * Text to scroll across the screen when this item is added to * the status bar. */ public CharSequence tickerText; /** * The view that will represent this notification in the expanded status bar. */ public RemoteViews contentView; /** * If the icon in the status bar is to have more than one level, you can set this. Otherwise, * leave it at its default value of 0. * * @see android.widget.ImageView#setImageLevel * @see android.graphics.drawable#setLevel */ public int iconLevel; /** * The sound to play. * * <p> * To play the default notification sound, see {@link #defaults}. * </p> */ public Uri sound; /** * Use this constant as the value for audioStreamType to request that * the default stream type for notifications be used. Currently the * default stream type is STREAM_RING. */ public static final int STREAM_DEFAULT = -1; /** * The audio stream type to use when playing the sound. * Should be one of the STREAM_ constants from * {@link android.media.AudioManager}. */ public int audioStreamType = STREAM_DEFAULT; /** * The pattern with which to vibrate. * * <p> * To vibrate the default pattern, see {@link #defaults}. * </p> * * @see android.os.Vibrator#vibrate(long[],int) */ public long[] vibrate; /** * The color of the led. The hardware will do its best approximation. * * @see #FLAG_SHOW_LIGHTS * @see #flags */ public int ledARGB; /** * The number of milliseconds for the LED to be on while it's flashing. * The hardware will do its best approximation. * * @see #FLAG_SHOW_LIGHTS * @see #flags */ public int ledOnMS; /** * The number of milliseconds for the LED to be off while it's flashing. * The hardware will do its best approximation. * * @see #FLAG_SHOW_LIGHTS * @see #flags */ public int ledOffMS; /** * Specifies which values should be taken from the defaults. * <p> * To set, OR the desired from {@link #DEFAULT_SOUND}, * {@link #DEFAULT_VIBRATE}, {@link #DEFAULT_LIGHTS}. For all default * values, use {@link #DEFAULT_ALL}. * </p> */ public int defaults; /** * Bit to be bitwise-ored into the {@link #flags} field that should be * set if you want the LED on for this notification. * <ul> * <li>To turn the LED off, pass 0 in the alpha channel for colorARGB * or 0 for both ledOnMS and ledOffMS.</li> * <li>To turn the LED on, pass 1 for ledOnMS and 0 for ledOffMS.</li> * <li>To flash the LED, pass the number of milliseconds that it should * be on and off to ledOnMS and ledOffMS.</li> * </ul> * <p> * Since hardware varies, you are not guaranteed that any of the values * you pass are honored exactly. Use the system defaults (TODO) if possible * because they will be set to values that work on any given hardware. * <p> * The alpha channel must be set for forward compatibility. * */ public static final int FLAG_SHOW_LIGHTS = 0x00000001; /** * Bit to be bitwise-ored into the {@link #flags} field that should be * set if this notification is in reference to something that is ongoing, * like a phone call. It should not be set if this notification is in * reference to something that happened at a particular point in time, * like a missed phone call. */ public static final int FLAG_ONGOING_EVENT = 0x00000002; /** * Bit to be bitwise-ored into the {@link #flags} field that if set, * the audio will be repeated until the notification is * cancelled or the notification window is opened. */ public static final int FLAG_INSISTENT = 0x00000004; /** * Bit to be bitwise-ored into the {@link #flags} field that should be * set if you want the sound and/or vibration play each time the * notification is sent, even if it has not been canceled before that. */ public static final int FLAG_ONLY_ALERT_ONCE = 0x00000008; /** * Bit to be bitwise-ored into the {@link #flags} field that should be * set if the notification should be canceled when it is clicked by the * user. */ public static final int FLAG_AUTO_CANCEL = 0x00000010; /** * Bit to be bitwise-ored into the {@link #flags} field that should be * set if the notification should not be canceled when the user clicks * the Clear all button. */ public static final int FLAG_NO_CLEAR = 0x00000020; /** * Bit to be bitwise-ored into the {@link #flags} field that should be * set if this notification represents a currently running service. This * will normally be set for you by {@link Service#startForeground}. */ public static final int FLAG_FOREGROUND_SERVICE = 0x00000040; public int flags; /** * Constructs a Notification object with everything set to 0. */ public Notification() { this.when = System.currentTimeMillis(); } /** * @deprecated use {@link #Notification(int,CharSequence,long)} and {@link #setLatestEventInfo}. * @hide */ public Notification(Context context, int icon, CharSequence tickerText, long when, CharSequence contentTitle, CharSequence contentText, Intent contentIntent) { this.when = when; this.icon = icon; this.tickerText = tickerText; setLatestEventInfo(context, contentTitle, contentText, PendingIntent.getActivity(context, 0, contentIntent, 0)); } /** * Constructs a Notification object with the information needed to * have a status bar icon without the standard expanded view. * * @param icon The resource id of the icon to put in the status bar. * @param tickerText The text that flows by in the status bar when the notification first * activates. * @param when The time to show in the time field. In the System.currentTimeMillis * timebase. */ public Notification(int icon, CharSequence tickerText, long when) { this.icon = icon; this.tickerText = tickerText; this.when = when; } /** * Unflatten the notification from a parcel. */ public Notification(Parcel parcel) { int version = parcel.readInt(); when = parcel.readLong(); icon = parcel.readInt(); number = parcel.readInt(); if (parcel.readInt() != 0) { contentIntent = PendingIntent.CREATOR.createFromParcel(parcel); } if (parcel.readInt() != 0) { deleteIntent = PendingIntent.CREATOR.createFromParcel(parcel); } if (parcel.readInt() != 0) { tickerText = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(parcel); } if (parcel.readInt() != 0) { contentView = RemoteViews.CREATOR.createFromParcel(parcel); } defaults = parcel.readInt(); flags = parcel.readInt(); if (parcel.readInt() != 0) { sound = Uri.CREATOR.createFromParcel(parcel); } audioStreamType = parcel.readInt(); vibrate = parcel.createLongArray(); ledARGB = parcel.readInt(); ledOnMS = parcel.readInt(); ledOffMS = parcel.readInt(); iconLevel = parcel.readInt(); if (parcel.readInt() != 0) { fullScreenIntent = PendingIntent.CREATOR.createFromParcel(parcel); } } public Notification clone() { Notification that = new Notification(); that.when = this.when; that.icon = this.icon; that.number = this.number; // PendingIntents are global, so there's no reason (or way) to clone them. that.contentIntent = this.contentIntent; that.deleteIntent = this.deleteIntent; that.fullScreenIntent = this.fullScreenIntent; if (this.tickerText != null) { that.tickerText = this.tickerText.toString(); } if (this.contentView != null) { that.contentView = this.contentView.clone(); } that.iconLevel = that.iconLevel; that.sound = this.sound; // android.net.Uri is immutable that.audioStreamType = this.audioStreamType; final long[] vibrate = this.vibrate; if (vibrate != null) { final int N = vibrate.length; final long[] vib = that.vibrate = new long[N]; System.arraycopy(vibrate, 0, vib, 0, N); } that.ledARGB = this.ledARGB; that.ledOnMS = this.ledOnMS; that.ledOffMS = this.ledOffMS; that.defaults = this.defaults; that.flags = this.flags; return that; } public int describeContents() { return 0; } /** * Flatten this notification from a parcel. */ public void writeToParcel(Parcel parcel, int flags) { parcel.writeInt(1); parcel.writeLong(when); parcel.writeInt(icon); parcel.writeInt(number); if (contentIntent != null) { parcel.writeInt(1); contentIntent.writeToParcel(parcel, 0); } else { parcel.writeInt(0); } if (deleteIntent != null) { parcel.writeInt(1); deleteIntent.writeToParcel(parcel, 0); } else { parcel.writeInt(0); } if (tickerText != null) { parcel.writeInt(1); TextUtils.writeToParcel(tickerText, parcel, flags); } else { parcel.writeInt(0); } if (contentView != null) { parcel.writeInt(1); contentView.writeToParcel(parcel, 0); } else { parcel.writeInt(0); } parcel.writeInt(defaults); parcel.writeInt(this.flags); if (sound != null) { parcel.writeInt(1); sound.writeToParcel(parcel, 0); } else { parcel.writeInt(0); } parcel.writeInt(audioStreamType); parcel.writeLongArray(vibrate); parcel.writeInt(ledARGB); parcel.writeInt(ledOnMS); parcel.writeInt(ledOffMS); parcel.writeInt(iconLevel); if (fullScreenIntent != null) { parcel.writeInt(1); fullScreenIntent.writeToParcel(parcel, 0); } else { parcel.writeInt(0); } } /** * Parcelable.Creator that instantiates Notification objects */ public static final Parcelable.Creator<Notification> CREATOR = new Parcelable.Creator<Notification>() { public Notification createFromParcel(Parcel parcel) { return new Notification(parcel); } public Notification[] newArray(int size) { return new Notification[size]; } }; /** * Sets the {@link #contentView} field to be a view with the standard "Latest Event" * layout. * * <p>Uses the {@link #icon} and {@link #when} fields to set the icon and time fields * in the view.</p> * @param context The context for your application / activity. * @param contentTitle The title that goes in the expanded entry. * @param contentText The text that goes in the expanded entry. * @param contentIntent The intent to launch when the user clicks the expanded notification. * If this is an activity, it must include the * {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK} flag, which requires * that you take care of task management as described in * <a href="{@docRoot}guide/topics/fundamentals.html#lcycles">Application Fundamentals: Activities and Tasks</a>. */ public void setLatestEventInfo(Context context, CharSequence contentTitle, CharSequence contentText, PendingIntent contentIntent) { RemoteViews contentView = new RemoteViews(context.getPackageName(), com.android.internal.R.layout.status_bar_latest_event_content); if (this.icon != 0) { contentView.setImageViewResource(com.android.internal.R.id.icon, this.icon); } if (contentTitle != null) { contentView.setTextViewText(com.android.internal.R.id.title, contentTitle); } if (contentText != null) { contentView.setTextViewText(com.android.internal.R.id.text, contentText); } if (this.when != 0) { contentView.setLong(com.android.internal.R.id.time, "setTime", when); } this.contentView = contentView; this.contentIntent = contentIntent; } @Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append("Notification(vibrate="); if (this.vibrate != null) { int N = this.vibrate.length-1; sb.append("["); for (int i=0; i<N; i++) { sb.append(this.vibrate[i]); sb.append(','); } if (N != -1) { sb.append(this.vibrate[N]); } sb.append("]"); } else if ((this.defaults & DEFAULT_VIBRATE) != 0) { sb.append("default"); } else { sb.append("null"); } sb.append(",sound="); if (this.sound != null) { sb.append(this.sound.toString()); } else if ((this.defaults & DEFAULT_SOUND) != 0) { sb.append("default"); } else { sb.append("null"); } sb.append(",defaults=0x"); sb.append(Integer.toHexString(this.defaults)); sb.append(",flags=0x"); sb.append(Integer.toHexString(this.flags)); sb.append(")"); return sb.toString(); } }


在344行， sound = Uri.CREATOR.createFromParcel(parcel);回来经过打log发现，问题的关键不再这个类中。

          再次，改变方向，换条思路走，找notification的服务类，看有什么新的发现，在framework/base/services/java/com/android/server/NotificationManagerService.java类中，真的找到了我需要的，

[java] view plain copy print ?
  1. /*
  2. * Copyright (C) 2007 The Android Open Source Project
  3. *
  4. * Licensed under the Apache License, Version 2.0 (the "License");
  5. * you may not use this file except in compliance with the License.
  6. * You may obtain a copy of the License at
  7. *
  8. *      http://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. * Unless required by applicable law or agreed to in writing, software
  11. * distributed under the License is distributed on an "AS IS" BASIS,
  12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. * See the License for the specific language governing permissions and
  14. * limitations under the License.
  15. */ 
  16.  
  17. package com.android.server; 
  18.  
  19. import com.android.internal.statusbar.StatusBarNotification; 
  20. import com.android.server.StatusBarManagerService; 
  21.  
  22. import android.app.ActivityManagerNative; 
  23. import android.app.IActivityManager; 
  24. import android.app.INotificationManager; 
  25. import android.app.ITransientNotification; 
  26. import android.app.Notification; 
  27. import android.app.NotificationManager; 
  28. import android.app.PendingIntent; 
  29. import android.app.StatusBarManager; 
  30. import android.content.BroadcastReceiver; 
  31. import android.content.ComponentName; 
  32. import android.content.ContentResolver; 
  33. import android.content.Context; 
  34. import android.content.Intent; 
  35. import android.content.IntentFilter; 
  36. import android.content.pm.ApplicationInfo; 
  37. import android.content.pm.PackageManager; 
  38. import android.content.pm.PackageManager.NameNotFoundException; 
  39. import android.content.res.Resources; 
  40. import android.database.ContentObserver; 
  41. import android.hardware.usb.UsbManager; 
  42. import android.media.AudioManager; 
  43. import android.net.Uri; 
  44. import android.os.BatteryManager; 
  45. import android.os.Bundle; 
  46. import android.os.Binder; 
  47. import android.os.Handler; 
  48. import android.os.IBinder; 
  49. import android.os.Message; 
  50. import android.os.Power; 
  51. import android.os.Process; 
  52. import android.os.RemoteException; 
  53. import android.os.SystemProperties; 
  54. import android.os.Vibrator; 
  55. import android.os.SystemClock; 
  56. import android.provider.Settings; 
  57. import android.telephony.TelephonyManager; 
  58. import android.text.TextUtils; 
  59. import android.util.EventLog; 
  60. import android.util.Slog; 
  61. import android.util.Log; 
  62. import android.view.accessibility.AccessibilityEvent; 
  63. import android.view.accessibility.AccessibilityManager; 
  64. import android.widget.Toast; 
  65.  
  66. import java.io.FileDescriptor; 
  67. import java.io.PrintWriter; 
  68. import java.util.ArrayList; 
  69. import java.util.Arrays; 
  70. import java.util.HashMap; 
  71.  
  72. /** {@hide} */ 
  73. public class NotificationManagerServiceextends INotificationManager.Stub 
  74. { 
  75.     private staticfinal String TAG ="NotificationService"; 
  76.     private staticfinalboolean DBG =false; 
  77.  
  78.     private staticfinalint MAX_PACKAGE_NOTIFICATIONS =50; 
  79.     private staticfinalint NOTIFICATION_REQUEST_INTERVAL =30000;// 30 seconds 
  80.     private staticfinalint MAX_PACKAGE_NOTIFICATION_REQUESTS =500; 
  81.  
  82.     // message codes 
  83.     private staticfinalint MESSAGE_TIMEOUT =2; 
  84.  
  85.     private staticfinalint LONG_DELAY =3500;// 3.5 seconds 
  86.     private staticfinalint SHORT_DELAY =2000;// 2 seconds 
  87.  
  88.     private staticfinallong[] DEFAULT_VIBRATE_PATTERN = {0,250,250,250}; 
  89.  
  90.     private staticfinalint DEFAULT_STREAM_TYPE = AudioManager.STREAM_NOTIFICATION; 
  91.  
  92.     final Context mContext; 
  93.     final IActivityManager mAm; 
  94.     final IBinder mForegroundToken =new Binder(); 
  95.  
  96.     private WorkerHandler mHandler; 
  97.     private StatusBarManagerService mStatusBar; 
  98.     private LightsService mLightsService; 
  99.     private LightsService.Light mBatteryLight; 
  100.     private LightsService.Light mNotificationLight; 
  101.     private LightsService.Light mAttentionLight; 
  102.  
  103.     private int mDefaultNotificationColor; 
  104.     private int mDefaultNotificationLedOn; 
  105.     private int mDefaultNotificationLedOff; 
  106.  
  107.     private NotificationRecord mSoundNotification; 
  108.     private NotificationPlayer mSound; 
  109.     private boolean mSystemReady; 
  110.     private int mDisabledNotifications; 
  111.  
  112.     private NotificationRecord mVibrateNotification; 
  113.     private Vibrator mVibrator =new Vibrator(); 
  114.  
  115.     // for enabling and disabling notification pulse behavior 
  116.     private boolean mScreenOn =true; 
  117.     private boolean mInCall =false; 
  118.     private boolean mNotificationPulseEnabled; 
  119.     // This is true if we have received a new notification while the screen is off 
  120.     // (that is, if mLedNotification was set while the screen was off) 
  121.     // This is reset to false when the screen is turned on. 
  122.     private boolean mPendingPulseNotification; 
  123.  
  124.     // for adb connected notifications 
  125.     private boolean mAdbNotificationShown =false; 
  126.     private Notification mAdbNotification; 
  127.  
  128.     private final ArrayList<NotificationRecord> mNotificationList = 
  129.             new ArrayList<NotificationRecord>(); 
  130.  
  131.     private class PackageRequestInfo { 
  132.         int requestCount; 
  133.         long lastPostTime; 
  134.     } 
  135.  
  136.     private final HashMap<String, PackageRequestInfo> mPackageInfo = 
  137.             new HashMap<String, PackageRequestInfo>(); 
  138.  
  139.     private ArrayList<ToastRecord> mToastQueue; 
  140.  
  141.     private ArrayList<NotificationRecord> mLights =new ArrayList<NotificationRecord>(); 
  142.  
  143.     private boolean mBatteryCharging; 
  144.     private boolean mBatteryLow; 
  145.     private boolean mBatteryFull; 
  146.     private NotificationRecord mLedNotification; 
  147.  
  148.     private staticfinalint BATTERY_LOW_ARGB =0xFFFF0000;// Charging Low - red solid on 
  149.     private staticfinalint BATTERY_MEDIUM_ARGB =0xFFFFFF00;   // Charging - orange solid on 
  150.     private staticfinalint BATTERY_FULL_ARGB =0xFF00FF00;// Charging Full - green solid on 
  151.     private staticfinalint BATTERY_BLINK_ON =125; 
  152.     private staticfinalint BATTERY_BLINK_OFF =2875; 
  153.  
  154.     private static String idDebugString(Context baseContext, String packageName,int id) { 
  155.         Context c = null; 
  156.  
  157.         if (packageName !=null) { 
  158.             try { 
  159.                 c = baseContext.createPackageContext(packageName,0); 
  160.             } catch (NameNotFoundException e) { 
  161.                 c = baseContext; 
  162.             } 
  163.         } else { 
  164.             c = baseContext; 
  165.         } 
  166.  
  167.         String pkg; 
  168.         String type; 
  169.         String name; 
  170.  
  171.         Resources r = c.getResources(); 
  172.         try { 
  173.             return r.getResourceName(id); 
  174.         } catch (Resources.NotFoundException e) { 
  175.             return "<name unknown>"; 
  176.         } 
  177.     } 
  178.  
  179.     private staticfinalclass NotificationRecord 
  180.     { 
  181.         final String pkg; 
  182.         final String tag; 
  183.         final int id; 
  184.         final int uid; 
  185.         final int initialPid; 
  186.         ITransientNotification callback; 
  187.         int duration; 
  188.         final Notification notification; 
  189.         IBinder statusBarKey; 
  190.  
  191.         NotificationRecord(String pkg, String tag, int id, int uid, int initialPid, 
  192.                 Notification notification) 
  193.         { 
  194.             this.pkg = pkg; 
  195.             this.tag = tag; 
  196.             this.id = id; 
  197.             this.uid = uid; 
  198.             this.initialPid = initialPid; 
  199.             this.notification = notification; 
  200.         } 
  201.  
  202.         void dump(PrintWriter pw, String prefix, Context baseContext) { 
  203.             pw.println(prefix + this); 
  204.             pw.println(prefix + "  icon=0x" + Integer.toHexString(notification.icon) 
  205.                     + " / " + idDebugString(baseContext,this.pkg, notification.icon)); 
  206.             pw.println(prefix + "  contentIntent=" + notification.contentIntent); 
  207.             pw.println(prefix + "  deleteIntent=" + notification.deleteIntent); 
  208.             pw.println(prefix + "  tickerText=" + notification.tickerText); 
  209.             pw.println(prefix + "  contentView=" + notification.contentView); 
  210.             pw.println(prefix + "  defaults=0x" + Integer.toHexString(notification.defaults)); 
  211.             pw.println(prefix + "  flags=0x" + Integer.toHexString(notification.flags)); 
  212.             pw.println(prefix + "  sound=" + notification.sound); 
  213.             pw.println(prefix + "  vibrate=" + Arrays.toString(notification.vibrate)); 
  214.             pw.println(prefix + "  ledARGB=0x" + Integer.toHexString(notification.ledARGB) 
  215.                     + " ledOnMS=" + notification.ledOnMS 
  216.                     + " ledOffMS=" + notification.ledOffMS); 
  217.         } 
  218.  
  219.         @Override 
  220.         public final String toString() 
  221.         { 
  222.             return "NotificationRecord{" 
  223.                 + Integer.toHexString(System.identityHashCode(this)) 
  224.                 + " pkg=" + pkg 
  225.                 + " id=" + Integer.toHexString(id) 
  226.                 + " tag=" + tag + "}"; 
  227.         } 
  228.     } 
  229.  
  230.     private staticfinalclass ToastRecord 
  231.     { 
  232.         final int pid; 
  233.         final String pkg; 
  234.         final ITransientNotification callback; 
  235.         int duration; 
  236.  
  237.         ToastRecord(int pid, String pkg, ITransientNotification callback,int duration) 
  238.         { 
  239.             this.pid = pid; 
  240.             this.pkg = pkg; 
  241.             this.callback = callback; 
  242.             this.duration = duration; 
  243.         } 
  244.  
  245.         void update(int duration) { 
  246.             this.duration = duration; 
  247.         } 
  248.  
  249.         void dump(PrintWriter pw, String prefix) { 
  250.             pw.println(prefix + this); 
  251.         } 
  252.  
  253.         @Override 
  254.         public final String toString() 
  255.         { 
  256.             return "ToastRecord{" 
  257.                 + Integer.toHexString(System.identityHashCode(this)) 
  258.                 + " pkg=" + pkg 
  259.                 + " callback=" + callback 
  260.                 + " duration=" + duration; 
  261.         } 
  262.     } 
  263.  
  264.     private StatusBarManagerService.NotificationCallbacks mNotificationCallbacks 
  265.             = new StatusBarManagerService.NotificationCallbacks() { 
  266.  
  267.         public void onSetDisabled(int status) { 
  268.             synchronized (mNotificationList) { 
  269.                 mDisabledNotifications = status; 
  270.                 if ((mDisabledNotifications & StatusBarManager.DISABLE_NOTIFICATION_ALERTS) !=0) { 
  271.                     // cancel whatever's going on 
  272.                     long identity = Binder.clearCallingIdentity(); 
  273.                     try { 
  274.                         mSound.stop(); 
  275.                     } 
  276.                     finally { 
  277.                         Binder.restoreCallingIdentity(identity); 
  278.                     } 
  279.  
  280.                     identity = Binder.clearCallingIdentity(); 
  281.                     try { 
  282.                         mVibrator.cancel(); 
  283.                     } 
  284.                     finally { 
  285.                         Binder.restoreCallingIdentity(identity); 
  286.                     } 
  287.                 } 
  288.             } 
  289.         } 
  290.  
  291.         public void onClearAll() { 
  292.             cancelAll(); 
  293.         } 
  294.  
  295.         public void onNotificationClick(String pkg, String tag,int id) { 
  296.             cancelNotification(pkg, tag, id, Notification.FLAG_AUTO_CANCEL, 
  297.                     Notification.FLAG_FOREGROUND_SERVICE); 
  298.         } 
  299.  
  300.         public void onPanelRevealed() { 
  301.             synchronized (mNotificationList) { 
  302.                 // sound 
  303.                 mSoundNotification = null; 
  304.                 long identity = Binder.clearCallingIdentity(); 
  305.                 try { 
  306.                     mSound.stop(); 
  307.                 } 
  308.                 finally { 
  309.                     Binder.restoreCallingIdentity(identity); 
  310.                 } 
  311.  
  312.                 // vibrate 
  313.                 mVibrateNotification = null; 
  314.                 identity = Binder.clearCallingIdentity(); 
  315.                 try { 
  316.                     mVibrator.cancel(); 
  317.                 } 
  318.                 finally { 
  319.                     Binder.restoreCallingIdentity(identity); 
  320.                 } 
  321.  
  322.                 // light 
  323.                 mLights.clear(); 
  324.                 mLedNotification = null; 
  325.                 updateLightsLocked(); 
  326.             } 
  327.         } 
  328.  
  329.         public void onNotificationError(String pkg, String tag,int id, 
  330.                 int uid, int initialPid, String message) { 
  331.             Slog.d(TAG, "onNotification error pkg=" + pkg +" tag=" + tag +" id=" + id 
  332.                     + "; will crashApplication(uid=" + uid +", pid=" + initialPid +")"); 
  333.             cancelNotification(pkg, tag, id, 0, 0); 
  334.             long ident = Binder.clearCallingIdentity(); 
  335.             try { 
  336.                 ActivityManagerNative.getDefault().crashApplication(uid, initialPid, pkg, 
  337.                         "Bad notification posted from package " + pkg 
  338.                         + ": " + message); 
  339.             } catch (RemoteException e) { 
  340.             } 
  341.             Binder.restoreCallingIdentity(ident); 
  342.         } 
  343.     }; 
  344.  
  345.     private BroadcastReceiver mIntentReceiver =new BroadcastReceiver() { 
  346.         @Override 
  347.         public void onReceive(Context context, Intent intent) { 
  348.             String action = intent.getAction(); 
  349.  
  350.             boolean queryRestart = false; 
  351.              
  352.             if (action.equals(Intent.ACTION_BATTERY_CHANGED)) { 
  353.                 boolean batteryCharging = (intent.getIntExtra("plugged",0) !=0); 
  354.                 int level = intent.getIntExtra("level", -1); 
  355.                 boolean batteryLow = (level >=0 && level <= Power.LOW_BATTERY_THRESHOLD); 
  356.                 int status = intent.getIntExtra("status", BatteryManager.BATTERY_STATUS_UNKNOWN); 
  357.                 boolean batteryFull = (status == BatteryManager.BATTERY_STATUS_FULL || level >=90); 
  358.  
  359.                 if (batteryCharging != mBatteryCharging || 
  360.                         batteryLow != mBatteryLow || 
  361.                         batteryFull != mBatteryFull) { 
  362.                     mBatteryCharging = batteryCharging; 
  363.                     mBatteryLow = batteryLow; 
  364.                     mBatteryFull = batteryFull; 
  365.                     updateLights(); 
  366.                 } 
  367.             } else if (action.equals(UsbManager.ACTION_USB_STATE)) { 
  368.                 Bundle extras = intent.getExtras(); 
  369.                 boolean usbConnected = extras.getBoolean(UsbManager.USB_CONNECTED); 
  370.                 boolean adbEnabled = (UsbManager.USB_FUNCTION_ENABLED.equals( 
  371.                                     extras.getString(UsbManager.USB_FUNCTION_ADB))); 
  372.                 updateAdbNotification(usbConnected && adbEnabled); 
  373.             } else if (action.equals(Intent.ACTION_PACKAGE_REMOVED) 
  374.                     || action.equals(Intent.ACTION_PACKAGE_RESTARTED) 
  375.                     || (queryRestart=action.equals(Intent.ACTION_QUERY_PACKAGE_RESTART)) 
  376.                     || action.equals(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE)) { 
  377.                 String pkgList[] = null; 
  378.                 if (action.equals(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE)) { 
  379.                     pkgList = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST); 
  380.                 } else if (queryRestart) { 
  381.                     pkgList = intent.getStringArrayExtra(Intent.EXTRA_PACKAGES); 
  382.                 } else { 
  383.                     Uri uri = intent.getData(); 
  384.                     if (uri == null) { 
  385.                         return; 
  386.                     } 
  387.                     String pkgName = uri.getSchemeSpecificPart(); 
  388.                     if (pkgName == null) { 
  389.                         return; 
  390.                     } 
  391.                     pkgList = new String[]{pkgName}; 
  392.                 } 
  393.                 if (pkgList !=null && (pkgList.length >0)) { 
  394.                     for (String pkgName : pkgList) { 
  395.                         cancelAllNotificationsInt(pkgName, 0, 0, !queryRestart); 
  396.                     } 
  397.                 } 
  398.             } else if (action.equals(Intent.ACTION_SCREEN_ON)) { 
  399.                 mScreenOn = true; 
  400.                 updateNotificationPulse(); 
  401.             } else if (action.equals(Intent.ACTION_SCREEN_OFF)) { 
  402.                 mScreenOn = false; 
  403.                 updateNotificationPulse(); 
  404.             } else if (action.equals(TelephonyManager.ACTION_PHONE_STATE_CHANGED)) { 
  405.                 mInCall = (intent.getStringExtra(TelephonyManager.EXTRA_STATE).equals(TelephonyManager.EXTRA_STATE_OFFHOOK)); 
  406.                 updateNotificationPulse(); 
  407.             } 
  408.         } 
  409.     }; 
  410.  
  411.     class SettingsObserverextends ContentObserver { 
  412.         SettingsObserver(Handler handler) { 
  413.             super(handler); 
  414.         } 
  415.  
  416.         void observe() { 
  417.             ContentResolver resolver = mContext.getContentResolver(); 
  418.             resolver.registerContentObserver(Settings.System.getUriFor( 
  419.                     Settings.System.NOTIFICATION_LIGHT_PULSE),false,this); 
  420.             update(); 
  421.         } 
  422.  
  423.         @Override public void onChange(boolean selfChange) { 
  424.             update(); 
  425.         } 
  426.  
  427.         public void update() { 
  428.             ContentResolver resolver = mContext.getContentResolver(); 
  429.             boolean pulseEnabled = Settings.System.getInt(resolver, 
  430.                         Settings.System.NOTIFICATION_LIGHT_PULSE, 0) != 0; 
  431.             if (mNotificationPulseEnabled != pulseEnabled) { 
  432.                 mNotificationPulseEnabled = pulseEnabled; 
  433.                 updateNotificationPulse(); 
  434.             } 
  435.         } 
  436.     } 
  437.  
  438.     NotificationManagerService(Context context, StatusBarManagerService statusBar, 
  439.             LightsService lights) 
  440.     { 
  441.         super(); 
  442.         mContext = context; 
  443.         mLightsService = lights; 
  444.         mAm = ActivityManagerNative.getDefault(); 
  445.         mSound = new NotificationPlayer(TAG); 
  446.         mSound.setUsesWakeLock(context); 
  447.         mToastQueue = new ArrayList<ToastRecord>(); 
  448.         mHandler = new WorkerHandler(); 
  449.  
  450.         mStatusBar = statusBar; 
  451.         statusBar.setNotificationCallbacks(mNotificationCallbacks); 
  452.  
  453.         mBatteryLight = lights.getLight(LightsService.LIGHT_ID_BATTERY); 
  454.         mNotificationLight = lights.getLight(LightsService.LIGHT_ID_NOTIFICATIONS); 
  455.         mAttentionLight = lights.getLight(LightsService.LIGHT_ID_ATTENTION); 
  456.  
  457.         Resources resources = mContext.getResources(); 
  458.         mDefaultNotificationColor = resources.getColor( 
  459.                 com.android.internal.R.color.config_defaultNotificationColor); 
  460.         mDefaultNotificationLedOn = resources.getInteger( 
  461.                 com.android.internal.R.integer.config_defaultNotificationLedOn); 
  462.         mDefaultNotificationLedOff = resources.getInteger( 
  463.                 com.android.internal.R.integer.config_defaultNotificationLedOff); 
  464.  
  465.         // Don't start allowing notifications until the setup wizard has run once. 
  466.         // After that, including subsequent boots, init with notifications turned on. 
  467.         // This works on the first boot because the setup wizard will toggle this 
  468.         // flag at least once and we'll go back to 0 after that. 
  469.         if (0 == Settings.Secure.getInt(mContext.getContentResolver(), 
  470.                     Settings.Secure.DEVICE_PROVISIONED, 0)) { 
  471.             mDisabledNotifications = StatusBarManager.DISABLE_NOTIFICATION_ALERTS; 
  472.         } 
  473.  
  474.         // register for battery changed notifications 
  475.         IntentFilter filter = new IntentFilter(); 
  476.         filter.addAction(Intent.ACTION_BATTERY_CHANGED); 
  477.         filter.addAction(UsbManager.ACTION_USB_STATE); 
  478.         filter.addAction(Intent.ACTION_SCREEN_ON); 
  479.         filter.addAction(Intent.ACTION_SCREEN_OFF); 
  480.         filter.addAction(TelephonyManager.ACTION_PHONE_STATE_CHANGED); 
  481.         mContext.registerReceiver(mIntentReceiver, filter); 
  482.         IntentFilter pkgFilter = new IntentFilter(); 
  483.         pkgFilter.addAction(Intent.ACTION_PACKAGE_REMOVED); 
  484.         pkgFilter.addAction(Intent.ACTION_PACKAGE_RESTARTED); 
  485.         pkgFilter.addAction(Intent.ACTION_QUERY_PACKAGE_RESTART); 
  486.         pkgFilter.addDataScheme("package"); 
  487.         mContext.registerReceiver(mIntentReceiver, pkgFilter); 
  488.         IntentFilter sdFilter = new IntentFilter(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE); 
  489.         mContext.registerReceiver(mIntentReceiver, sdFilter); 
  490.  
  491.         SettingsObserver observer = new SettingsObserver(mHandler); 
  492.         observer.observe(); 
  493.     } 
  494.  
  495.     void systemReady() { 
  496.         // no beeping until we're basically done booting 
  497.         mSystemReady = true; 
  498.     } 
  499.  
  500.     // Toasts 
  501.     // ============================================================================ 
  502.     public void enqueueToast(String pkg, ITransientNotification callback,int duration) 
  503.     { 
  504.         if (DBG) Slog.i(TAG, "enqueueToast pkg=" + pkg + " callback=" + callback +" duration=" + duration); 
  505.  
  506.         if (pkg == null || callback ==null) { 
  507.             Slog.e(TAG, "Not doing toast. pkg=" + pkg +" callback=" + callback); 
  508.             return ; 
  509.         } 
  510.  
  511.         synchronized (mToastQueue) { 
  512.             int callingPid = Binder.getCallingPid(); 
  513.             long callingId = Binder.clearCallingIdentity(); 
  514.             try { 
  515.                 ToastRecord record; 
  516.                 int index = indexOfToastLocked(pkg, callback); 
  517.                 // If it's already in the queue, we update it in place, we don't 
  518.                 // move it to the end of the queue. 
  519.                 if (index >=0) { 
  520.                     record = mToastQueue.get(index); 
  521.                     record.update(duration); 
  522.                 } else { 
  523.                     // Limit the number of toasts that any given package except the android 
  524.                     // package can enqueue.  Prevents DOS attacks and deals with leaks. 
  525.                     if (!"android".equals(pkg)) { 
  526.                         int count = 0; 
  527.                         finalint N = mToastQueue.size(); 
  528.                         for (int i=0; i<N; i++) { 
  529.                              final ToastRecord r = mToastQueue.get(i); 
  530.                              if (r.pkg.equals(pkg)) { 
  531.                                  count++; 
  532.                                  if (count >= MAX_PACKAGE_NOTIFICATIONS) { 
  533.                                      Slog.e(TAG, "Package has already posted " + count 
  534.                                             + " toasts. Not showing more. Package=" + pkg); 
  535.                                      return; 
  536.                                  } 
  537.                              } 
  538.                         } 
  539.                     } 
  540.  
  541.                     record = new ToastRecord(callingPid, pkg, callback, duration); 
  542.                     mToastQueue.add(record); 
  543.                     index = mToastQueue.size() - 1; 
  544.                     keepProcessAliveLocked(callingPid); 
  545.                 } 
  546.                 // If it's at index 0, it's the current toast.  It doesn't matter if it's 
  547.                 // new or just been updated.  Call back and tell it to show itself. 
  548.                 // If the callback fails, this will remove it from the list, so don't 
  549.                 // assume that it's valid after this. 
  550.                 if (index == 0) { 
  551.                     showNextToastLocked(); 
  552.                 } 
  553.             } finally { 
  554.                 Binder.restoreCallingIdentity(callingId); 
  555.             } 
  556.         } 
  557.     } 
  558.  
  559.     public void cancelToast(String pkg, ITransientNotification callback) { 
  560.         Slog.i(TAG, "cancelToast pkg=" + pkg +" callback=" + callback); 
  561.  
  562.         if (pkg == null || callback ==null) { 
  563.             Slog.e(TAG, "Not cancelling notification. pkg=" + pkg +" callback=" + callback); 
  564.             return ; 
  565.         } 
  566.  
  567.         synchronized (mToastQueue) { 
  568.             long callingId = Binder.clearCallingIdentity(); 
  569.             try { 
  570.                 int index = indexOfToastLocked(pkg, callback); 
  571.                 if (index >=0) { 
  572.                     cancelToastLocked(index); 
  573.                 } else { 
  574.                     Slog.w(TAG, "Toast already cancelled. pkg=" + pkg +" callback=" + callback); 
  575.                 } 
  576.             } finally { 
  577.                 Binder.restoreCallingIdentity(callingId); 
  578.             } 
  579.         } 
  580.     } 
  581.  
  582.     private void showNextToastLocked() { 
  583.         ToastRecord record = mToastQueue.get(0); 
  584.         while (record != null) { 
  585.             if (DBG) Slog.d(TAG,"Show pkg=" + record.pkg +" callback=" + record.callback); 
  586.             try { 
  587.                 record.callback.show(); 
  588.                 scheduleTimeoutLocked(record, false); 
  589.                 return; 
  590.             } catch (RemoteException e) { 
  591.                 Slog.w(TAG, "Object died trying to show notification " + record.callback 
  592.                         + " in package " + record.pkg); 
  593.                 // remove it from the list and let the process die 
  594.                 int index = mToastQueue.indexOf(record); 
  595.                 if (index >=0) { 
  596.                     mToastQueue.remove(index); 
  597.                 } 
  598.                 keepProcessAliveLocked(record.pid); 
  599.                 if (mToastQueue.size() >0) { 
  600.                     record = mToastQueue.get(0); 
  601.                 } else { 
  602.                     record = null; 
  603.                 } 
  604.             } 
  605.         } 
  606.     } 
  607.  
  608.     private void cancelToastLocked(int index) { 
  609.         ToastRecord record = mToastQueue.get(index); 
  610.         try { 
  611.             record.callback.hide(); 
  612.         } catch (RemoteException e) { 
  613.             Slog.w(TAG, "Object died trying to hide notification " + record.callback 
  614.                     + " in package " + record.pkg); 
  615.             // don't worry about this, we're about to remove it from 
  616.             // the list anyway 
  617.         } 
  618.         mToastQueue.remove(index); 
  619.         keepProcessAliveLocked(record.pid); 
  620.         if (mToastQueue.size() > 0) { 
  621.             // Show the next one. If the callback fails, this will remove 
  622.             // it from the list, so don't assume that the list hasn't changed 
  623.             // after this point. 
  624.             showNextToastLocked(); 
  625.         } 
  626.     } 
  627.  
  628.     private void scheduleTimeoutLocked(ToastRecord r,boolean immediate) 
  629.     { 
  630.         Message m = Message.obtain(mHandler, MESSAGE_TIMEOUT, r); 
  631.         long delay = immediate ?0 : (r.duration == Toast.LENGTH_LONG ? LONG_DELAY : SHORT_DELAY); 
  632.         mHandler.removeCallbacksAndMessages(r); 
  633.         mHandler.sendMessageDelayed(m, delay); 
  634.     } 
  635.  
  636.     private void handleTimeout(ToastRecord record) 
  637.     { 
  638.         if (DBG) Slog.d(TAG, "Timeout pkg=" + record.pkg + " callback=" + record.callback); 
  639.         synchronized (mToastQueue) { 
  640.             int index = indexOfToastLocked(record.pkg, record.callback); 
  641.             if (index >=0) { 
  642.                 cancelToastLocked(index); 
  643.             } 
  644.         } 
  645.     } 
  646.  
  647.     // lock on mToastQueue 
  648.     private int indexOfToastLocked(String pkg, ITransientNotification callback) 
  649.     { 
  650.         IBinder cbak = callback.asBinder(); 
  651.         ArrayList<ToastRecord> list = mToastQueue; 
  652.         int len = list.size(); 
  653.         for (int i=0; i<len; i++) { 
  654.             ToastRecord r = list.get(i); 
  655.             if (r.pkg.equals(pkg) && r.callback.asBinder() == cbak) { 
  656.                 return i; 
  657.             } 
  658.         } 
  659.         return -1; 
  660.     } 
  661.  
  662.     // lock on mToastQueue 
  663.     private void keepProcessAliveLocked(int pid) 
  664.     { 
  665.         int toastCount =0;// toasts from this pid 
  666.         ArrayList<ToastRecord> list = mToastQueue; 
  667.         int N = list.size(); 
  668.         for (int i=0; i<N; i++) { 
  669.             ToastRecord r = list.get(i); 
  670.             if (r.pid == pid) { 
  671.                 toastCount++; 
  672.             } 
  673.         } 
  674.         try { 
  675.             mAm.setProcessForeground(mForegroundToken, pid, toastCount >0); 
  676.         } catch (RemoteException e) { 
  677.             // Shouldn't happen. 
  678.         } 
  679.     } 
  680.  
  681.     private finalclass WorkerHandlerextends Handler 
  682.     { 
  683.         @Override 
  684.         public void handleMessage(Message msg) 
  685.         { 
  686.             switch (msg.what) 
  687.             { 
  688.                 case MESSAGE_TIMEOUT: 
  689.                     handleTimeout((ToastRecord)msg.obj); 
  690.                     break; 
  691.             } 
  692.         } 
  693.     } 
  694.  
  695.  
  696.     // Notifications 
  697.     // ============================================================================ 
  698.     public void enqueueNotification(String pkg,int id, Notification notification,int[] idOut) 
  699.     { 
  700.         enqueueNotificationWithTag(pkg, null/* tag */, id, notification, idOut); 
  701.     } 
  702.  
  703.     public void enqueueNotificationWithTag(String pkg, String tag,int id, Notification notification, 
  704.             int[] idOut) 
  705.     { 
  706.         enqueueNotificationInternal(pkg, Binder.getCallingUid(), Binder.getCallingPid(), 
  707.                 tag, id, notification, idOut); 
  708.     } 
  709.  
  710.     // Not exposed via Binder; for system use only (otherwise malicious apps could spoof the 
  711.     // uid/pid of another application) 
  712.     public void enqueueNotificationInternal(String pkg,int callingUid,int callingPid, 
  713.             String tag, int id, Notification notification,int[] idOut) 
  714.     { 
  715.         checkIncomingCall(pkg); 
  716.  
  717.         // Limit the number of notifications that any given package except the android 
  718.         // package can enqueue.  Prevents DOS attacks and deals with leaks. 
  719.         if (!"android".equals(pkg)) { 
  720.             synchronized (mNotificationList) { 
  721.                 int count =0; 
  722.                 final int N = mNotificationList.size(); 
  723.                 for (int i=0; i<N; i++) { 
  724.                     final NotificationRecord r = mNotificationList.get(i); 
  725.                     if (r.pkg.equals(pkg)) { 
  726.                         count++; 
  727.                         if (count >= MAX_PACKAGE_NOTIFICATIONS) { 
  728.                             Slog.e(TAG, "Package has already posted " + count 
  729.                                     + " notifications.  Not showing more.  package=" + pkg); 
  730.                             return; 
  731.                         } 
  732.                     } 
  733.                 } 
  734.             } 
  735.         } 
  736.  
  737.         // Limit the number of notification requests, notify and cancel that 
  738.         // a package can post. The MAX_PACKAGE_NOTIFICATIONS doesn't work for 
  739.         // packages which notify and quickly cancel it and do this in an 
  740.         // iteration 
  741.         if (!"android".equals(pkg)) { 
  742.             synchronized (mPackageInfo) { 
  743.                 if (!mPackageInfo.containsKey(pkg)) { 
  744.                     final PackageRequestInfo pInfo =new PackageRequestInfo(); 
  745.                     pInfo.requestCount = 1; 
  746.                     pInfo.lastPostTime = SystemClock.elapsedRealtime(); 
  747.                     mPackageInfo.put(pkg,pInfo); 
  748.                 } 
  749.                 else { 
  750.                     final PackageRequestInfo pInfo = mPackageInfo.get(pkg); 
  751.                     finallong currentTime = SystemClock.elapsedRealtime(); 
  752.                     if ((currentTime - pInfo.lastPostTime) <= NOTIFICATION_REQUEST_INTERVAL) { 
  753.                          // Keep track of requests posted within last 30 seconds 
  754.                          pInfo.requestCount++; 
  755.                     } 
  756.                     else { 
  757.                          pInfo.requestCount = 1; 
  758.                          pInfo.lastPostTime = SystemClock.elapsedRealtime(); 
  759.                     } 
  760.  
  761.                     if (pInfo.requestCount >= MAX_PACKAGE_NOTIFICATION_REQUESTS) { 
  762.                         // 500 requests within a span of 30 seconds is high 
  763.                         if (pInfo.requestCount%MAX_PACKAGE_NOTIFICATION_REQUESTS ==0) { 
  764.                             Slog.e(TAG, "Package has already posted too many notifications. " 
  765.                                     + "Not showing more.  package=" + pkg); 
  766.                         } 
  767.                         return; 
  768.                     } 
  769.                 } 
  770.             } 
  771.         } 
  772.  
  773.         // This conditional is a dirty hack to limit the logging done on 
  774.         //     behalf of the download manager without affecting other apps. 
  775.         if (!pkg.equals("com.android.providers.downloads") 
  776.                 || Log.isLoggable("DownloadManager", Log.VERBOSE)) { 
  777.             EventLog.writeEvent(EventLogTags.NOTIFICATION_ENQUEUE, pkg, id, notification.toString()); 
  778.         } 
  779.  
  780.         if (pkg == null || notification ==null) { 
  781.             throw new IllegalArgumentException("null not allowed: pkg=" + pkg 
  782.                     + " id=" + id + " notification=" + notification); 
  783.         } 
  784.         if (notification.icon != 0) { 
  785.             if (notification.contentView ==null) { 
  786.                 throw new IllegalArgumentException("contentView required: pkg=" + pkg 
  787.                         + " id=" + id +" notification=" + notification); 
  788.             } 
  789.             if (notification.contentIntent ==null) { 
  790.                 throw new IllegalArgumentException("contentIntent required: pkg=" + pkg 
  791.                         + " id=" + id +" notification=" + notification); 
  792.             } 
  793.         } 
  794.  
  795.         synchronized (mNotificationList) { 
  796.             NotificationRecord r = new NotificationRecord(pkg, tag, id, 
  797.                     callingUid, callingPid, notification); 
  798.             NotificationRecord old = null; 
  799.  
  800.             int index = indexOfNotificationLocked(pkg, tag, id); 
  801.             if (index < 0) { 
  802.                 mNotificationList.add(r); 
  803.             } else { 
  804.                 old = mNotificationList.remove(index); 
  805.                 mNotificationList.add(index, r); 
  806.                 // Make sure we don't lose the foreground service state. 
  807.                 if (old !=null) { 
  808.                     notification.flags |= 
  809.                         old.notification.flags&Notification.FLAG_FOREGROUND_SERVICE; 
  810.                 } 
  811.             } 
  812.  
  813.             // Ensure if this is a foreground service that the proper additional 
  814.             // flags are set. 
  815.             if ((notification.flags&Notification.FLAG_FOREGROUND_SERVICE) !=0) { 
  816.                 notification.flags |= Notification.FLAG_ONGOING_EVENT 
  817.                         | Notification.FLAG_NO_CLEAR; 
  818.             } 
  819.  
  820.             if (notification.icon !=0) { 
  821.                 StatusBarNotification n = new StatusBarNotification(pkg, id, tag, 
  822.                         r.uid, r.initialPid, notification); 
  823.                 if (old !=null && old.statusBarKey !=null) { 
  824.                     r.statusBarKey = old.statusBarKey; 
  825.                     long identity = Binder.clearCallingIdentity(); 
  826.                     try { 
  827.                         mStatusBar.updateNotification(r.statusBarKey, n); 
  828.                     } 
  829.                     finally { 
  830.                         Binder.restoreCallingIdentity(identity); 
  831.                     } 
  832.                 } else { 
  833.                     long identity = Binder.clearCallingIdentity(); 
  834.                     try { 
  835.                         r.statusBarKey = mStatusBar.addNotification(n); 
  836.                         mAttentionLight.pulse(); 
  837.                     } 
  838.                     finally { 
  839.                         Binder.restoreCallingIdentity(identity); 
  840.                     } 
  841.                 } 
  842.                 sendAccessibilityEvent(notification, pkg); 
  843.             } else { 
  844.                 if (old != null && old.statusBarKey !=null) { 
  845.                     long identity = Binder.clearCallingIdentity(); 
  846.                     try { 
  847.                         mStatusBar.removeNotification(old.statusBarKey); 
  848.                     } 
  849.                     finally { 
  850.                         Binder.restoreCallingIdentity(identity); 
  851.                     } 
  852.                 } 
  853.             } 
  854.  
  855.             // If we're not supposed to beep, vibrate, etc. then don't. 
  856.             if (((mDisabledNotifications & StatusBarManager.DISABLE_NOTIFICATION_ALERTS) ==0) 
  857.                     && (!(old != null 
  858.                         && (notification.flags & Notification.FLAG_ONLY_ALERT_ONCE) !=0 )) 
  859.                     && mSystemReady) { 
  860.  
  861.                 final AudioManager audioManager = (AudioManager) mContext 
  862.                 .getSystemService(Context.AUDIO_SERVICE); 
  863.                 // sound 
  864.                 final boolean useDefaultSound = 
  865.                     (notification.defaults & Notification.DEFAULT_SOUND) !=0; 
  866.                 if (useDefaultSound || notification.sound !=null) { 
  867.                     Uri uri; 
  868.                     if (useDefaultSound) { 
  869.                         uri = Settings.System.DEFAULT_NOTIFICATION_URI; 
  870.                     } else { 
  871.                         uri = notification.sound; 
  872.                     } 
  873.                     boolean looping = (notification.flags & Notification.FLAG_INSISTENT) !=0; 
  874.                     int audioStreamType; 
  875.                     if (notification.audioStreamType >=0) { 
  876.                         audioStreamType = notification.audioStreamType; 
  877.                     } else { 
  878.                         audioStreamType = DEFAULT_STREAM_TYPE; 
  879.                     } 
  880.                     mSoundNotification = r; 
  881.                     // do not play notifications if stream volume is 0 
  882.                     // (typically because ringer mode is silent). 
  883.                     if (audioManager.getStreamVolume(audioStreamType) !=0) { 
  884.                         long identity = Binder.clearCallingIdentity(); 
  885.                         try { 
  886.                             mSound.play(mContext, uri, looping, audioStreamType); 
  887.                         } 
  888.                         finally { 
  889.                             Binder.restoreCallingIdentity(identity); 
  890.                         } 
  891.                     } 
  892.                 } 
  893.  
  894.                 // vibrate 
  895.                 final boolean useDefaultVibrate = 
  896.                     (notification.defaults & Notification.DEFAULT_VIBRATE) !=0; 
  897.                 if ((useDefaultVibrate || notification.vibrate !=null) 
  898.                         && audioManager.shouldVibrate(AudioManager.VIBRATE_TYPE_NOTIFICATION)) { 
  899.                     mVibrateNotification = r; 
  900.  
  901.                     mVibrator.vibrate(useDefaultVibrate ? DEFAULT_VIBRATE_PATTERN 
  902.                                                         : notification.vibrate, 
  903.                               ((notification.flags & Notification.FLAG_INSISTENT) !=0) ?0: -1); 
  904.                 } 
  905.             } 
  906.  
  907.             // this option doesn't shut off the lights 
  908.  
  909.             // light 
  910.             // the most recent thing gets the light 
  911.             mLights.remove(old); 
  912.             if (mLedNotification == old) { 
  913.                 mLedNotification = null; 
  914.             } 
  915.             //Slog.i(TAG, "notification.lights=" 
  916.             //        + ((old.notification.lights.flags & Notification.FLAG_SHOW_LIGHTS) != 0)); 
  917.             if ((notification.flags & Notification.FLAG_SHOW_LIGHTS) !=0) { 
  918.                 mLights.add(r); 
  919.                 updateLightsLocked(); 
  920.             } else { 
  921.                 if (old !=null 
  922.                         && ((old.notification.flags & Notification.FLAG_SHOW_LIGHTS) !=0)) { 
  923.                     updateLightsLocked(); 
  924.                 } 
  925.             } 
  926.         } 
  927.  
  928.         idOut[0] = id; 
  929.     } 
  930.  
  931.     private void sendAccessibilityEvent(Notification notification, CharSequence packageName) { 
  932.         AccessibilityManager manager = AccessibilityManager.getInstance(mContext); 
  933.         if (!manager.isEnabled()) { 
  934.             return; 
  935.         } 
  936.  
  937.         AccessibilityEvent event = 
  938.             AccessibilityEvent.obtain(AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED); 
  939.         event.setPackageName(packageName); 
  940.         event.setClassName(Notification.class.getName()); 
  941.         event.setParcelableData(notification); 
  942.         CharSequence tickerText = notification.tickerText; 
  943.         if (!TextUtils.isEmpty(tickerText)) { 
  944.             event.getText().add(tickerText); 
  945.         } 
  946.  
  947.         manager.sendAccessibilityEvent(event); 
  948.     } 
  949.  
  950.     private void cancelNotificationLocked(NotificationRecord r) { 
  951.         // status bar 
  952.         if (r.notification.icon != 0) { 
  953.             long identity = Binder.clearCallingIdentity(); 
  954.             try { 
  955.                 mStatusBar.removeNotification(r.statusBarKey); 
  956.             } 
  957.             finally { 
  958.                 Binder.restoreCallingIdentity(identity); 
  959.             } 
  960.             r.statusBarKey = null; 
  961.         } 
  962.  
  963.         // sound 
  964.         if (mSoundNotification == r) { 
  965.             mSoundNotification = null; 
  966.             long identity = Binder.clearCallingIdentity(); 
  967.             try { 
  968.                 mSound.stop(); 
  969.             } 
  970.             finally { 
  971.                 Binder.restoreCallingIdentity(identity); 
  972.             } 
  973.         } 
  974.  
  975.         // vibrate 
  976.         if (mVibrateNotification == r) { 
  977.             mVibrateNotification = null; 
  978.             long identity = Binder.clearCallingIdentity(); 
  979.             try { 
  980.                 mVibrator.cancel(); 
  981.             } 
  982.             finally { 
  983.                 Binder.restoreCallingIdentity(identity); 
  984.             } 
  985.         } 
  986.  
  987.         // light 
  988.         mLights.remove(r); 
  989.         if (mLedNotification == r) { 
  990.             mLedNotification = null; 
  991.         } 
  992.     } 
  993.  
  994.     /**
  995.      * Cancels a notification ONLY if it has all of the {@code mustHaveFlags}
  996.      * and none of the {@code mustNotHaveFlags}.
  997.      */ 
  998.     private void cancelNotification(String pkg, String tag,int id,int mustHaveFlags, 
  999.             int mustNotHaveFlags) { 
  1000.         EventLog.writeEvent(EventLogTags.NOTIFICATION_CANCEL, pkg, id, mustHaveFlags); 
  1001.  
  1002.         synchronized (mNotificationList) { 
  1003.             int index = indexOfNotificationLocked(pkg, tag, id); 
  1004.             if (index >= 0) { 
  1005.                 NotificationRecord r = mNotificationList.get(index); 
  1006.  
  1007.                 if ((r.notification.flags & mustHaveFlags) != mustHaveFlags) { 
  1008.                     return; 
  1009.                 } 
  1010.                 if ((r.notification.flags & mustNotHaveFlags) !=0) { 
  1011.                     return; 
  1012.                 } 
  1013.  
  1014.                 mNotificationList.remove(index); 
  1015.  
  1016.                 cancelNotificationLocked(r); 
  1017.                 updateLightsLocked(); 
  1018.             } 
  1019.         } 
  1020.     } 
  1021.  
  1022.     /**
  1023.      * Cancels all notifications from a given package that have all of the
  1024.      * {@code mustHaveFlags}.
  1025.      */ 
  1026.     boolean cancelAllNotificationsInt(String pkg,int mustHaveFlags, 
  1027.             int mustNotHaveFlags,boolean doit) { 
  1028.         EventLog.writeEvent(EventLogTags.NOTIFICATION_CANCEL_ALL, pkg, mustHaveFlags); 
  1029.  
  1030.         synchronized (mNotificationList) { 
  1031.             final int N = mNotificationList.size(); 
  1032.             boolean canceledSomething =false; 
  1033.             for (int i = N-1; i >=0; --i) { 
  1034.                 NotificationRecord r = mNotificationList.get(i); 
  1035.                 if ((r.notification.flags & mustHaveFlags) != mustHaveFlags) { 
  1036.                     continue; 
  1037.                 } 
  1038.                 if ((r.notification.flags & mustNotHaveFlags) !=0) { 
  1039.                     continue; 
  1040.                 } 
  1041.                 if (!r.pkg.equals(pkg)) { 
  1042.                     continue; 
  1043.                 } 
  1044.                 canceledSomething = true; 
  1045.                 if (!doit) { 
  1046.                     return true; 
  1047.                 } 
  1048.                 mNotificationList.remove(i); 
  1049.                 cancelNotificationLocked(r); 
  1050.             } 
  1051.             if (canceledSomething) { 
  1052.                 updateLightsLocked(); 
  1053.             } 
  1054.             return canceledSomething; 
  1055.         } 
  1056.     } 
  1057.  
  1058.  
  1059.     public void cancelNotification(String pkg,int id) { 
  1060.         cancelNotificationWithTag(pkg, null/* tag */, id); 
  1061.     } 
  1062.  
  1063.     public void cancelNotificationWithTag(String pkg, String tag,int id) { 
  1064.         checkIncomingCall(pkg); 
  1065.  
  1066.         // Limit the number of notification requests, notify and cancel that 
  1067.         // a package can post. The MAX_PACKAGE_NOTIFICATIONS doesn't work for 
  1068.         // packages which notify and quickly cancel it and do this in an 
  1069.         // iteration 
  1070.         synchronized (mPackageInfo) { 
  1071.             if (!"android".equals(pkg) && mPackageInfo.containsKey(pkg)) { 
  1072.                 final PackageRequestInfo pInfo = mPackageInfo.get(pkg); 
  1073.                 final long currentTime = SystemClock.elapsedRealtime(); 
  1074.                 if ((currentTime - pInfo.lastPostTime) <= NOTIFICATION_REQUEST_INTERVAL) { 
  1075.                     // Keep track of requests posted within last 30 seconds 
  1076.                     pInfo.requestCount++; 
  1077.                 } 
  1078.                 else { 
  1079.                     pInfo.requestCount = 1; 
  1080.                     pInfo.lastPostTime = SystemClock.elapsedRealtime(); 
  1081.                 } 
  1082.             } 
  1083.         } 
  1084.  
  1085.         // Don't allow client applications to cancel foreground service notis. 
  1086.         cancelNotification(pkg, tag, id, 0, 
  1087.                 Binder.getCallingUid() == Process.SYSTEM_UID 
  1088.                 ? 0 : Notification.FLAG_FOREGROUND_SERVICE); 
  1089.     } 
  1090.  
  1091.     public void cancelAllNotifications(String pkg) { 
  1092.         checkIncomingCall(pkg); 
  1093.  
  1094.         // Calling from user space, don't allow the canceling of actively 
  1095.         // running foreground services. 
  1096.         cancelAllNotificationsInt(pkg, 0, Notification.FLAG_FOREGROUND_SERVICE,true); 
  1097.     } 
  1098.  
  1099.     void checkIncomingCall(String pkg) { 
  1100.         int uid = Binder.getCallingUid(); 
  1101.         if (uid == Process.SYSTEM_UID || uid ==0) { 
  1102.             return; 
  1103.         } 
  1104.         try { 
  1105.             ApplicationInfo ai = mContext.getPackageManager().getApplicationInfo( 
  1106.                     pkg, 0); 
  1107.             if (ai.uid != uid) { 
  1108.                 throw new SecurityException("Calling uid " + uid +" gave package" 
  1109.                         + pkg + " which is owned by uid " + ai.uid); 
  1110.             } 
  1111.         } catch (PackageManager.NameNotFoundException e) { 
  1112.             throw new SecurityException("Unknown package " + pkg); 
  1113.         } 
  1114.     } 
  1115.  
  1116.     void cancelAll() { 
  1117.         synchronized (mNotificationList) { 
  1118.             final int N = mNotificationList.size(); 
  1119.             for (int i=N-1; i>=0; i--) { 
  1120.                 NotificationRecord r = mNotificationList.get(i); 
  1121.  
  1122.                 if ((r.notification.flags & (Notification.FLAG_ONGOING_EVENT 
  1123.                                 | Notification.FLAG_NO_CLEAR)) ==0) { 
  1124.                     if (r.notification.deleteIntent !=null) { 
  1125.                         try { 
  1126.                             r.notification.deleteIntent.send(); 
  1127.                         } catch (PendingIntent.CanceledException ex) { 
  1128.                             // do nothing - there's no relevant way to recover, and 
  1129.                             //     no reason to let this propagate 
  1130.                             Slog.w(TAG, "canceled PendingIntent for " + r.pkg, ex); 
  1131.                         } 
  1132.                     } 
  1133.                     mNotificationList.remove(i); 
  1134.                     cancelNotificationLocked(r); 
  1135.                 } 
  1136.             } 
  1137.  
  1138.             updateLightsLocked(); 
  1139.         } 
  1140.     } 
  1141.  
  1142.     private void updateLights() { 
  1143.         synchronized (mNotificationList) { 
  1144.             updateLightsLocked(); 
  1145.         } 
  1146.     } 
  1147.  
  1148.     // lock on mNotificationList 
  1149.     private void updateLightsLocked() 
  1150.     { 
  1151.         // Battery low always shows, other states only show if charging. 
  1152.         if (mBatteryLow) { 
  1153.             if (mBatteryCharging) { 
  1154.                 mBatteryLight.setColor(BATTERY_LOW_ARGB); 
  1155.             } else { 
  1156.                 // Flash when battery is low and not charging 
  1157.                 mBatteryLight.setFlashing(BATTERY_LOW_ARGB, LightsService.LIGHT_FLASH_TIMED, 
  1158.                         BATTERY_BLINK_ON, BATTERY_BLINK_OFF); 
  1159.             } 
  1160.         } else if (mBatteryCharging) { 
  1161.             if (mBatteryFull) { 
  1162.                 mBatteryLight.setColor(BATTERY_FULL_ARGB); 
  1163.             } else { 
  1164.                 mBatteryLight.setColor(BATTERY_MEDIUM_ARGB); 
  1165.             } 
  1166.         } else { 
  1167.             mBatteryLight.turnOff(); 
  1168.         } 
  1169.  
  1170.         // clear pending pulse notification if screen is on 
  1171.         if (mScreenOn || mLedNotification ==null) { 
  1172.             mPendingPulseNotification = false; 
  1173.         } 
  1174.  
  1175.         // handle notification lights 
  1176.         if (mLedNotification == null) { 
  1177.             // get next notification, if any 
  1178.             int n = mLights.size(); 
  1179.             if (n > 0) { 
  1180.                 mLedNotification = mLights.get(n-1); 
  1181.             } 
  1182.             if (mLedNotification != null && !mScreenOn) { 
  1183.                 mPendingPulseNotification = true; 
  1184.             } 
  1185.         } 
  1186.  
  1187.         // we only flash if screen is off and persistent pulsing is enabled 
  1188.         // and we are not currently in a call 
  1189.         if (!mPendingPulseNotification || mScreenOn || mInCall) { 
  1190.             mNotificationLight.turnOff(); 
  1191.         } else { 
  1192.             int ledARGB = mLedNotification.notification.ledARGB; 
  1193.             int ledOnMS = mLedNotification.notification.ledOnMS; 
  1194.             int ledOffMS = mLedNotification.notification.ledOffMS; 
  1195.             if ((mLedNotification.notification.defaults & Notification.DEFAULT_LIGHTS) !=0) { 
  1196.                 ledARGB = mDefaultNotificationColor; 
  1197.                 ledOnMS = mDefaultNotificationLedOn; 
  1198.                 ledOffMS = mDefaultNotificationLedOff; 
  1199.             } 
  1200.             if (mNotificationPulseEnabled) { 
  1201.                 // pulse repeatedly 
  1202.                 mNotificationLight.setFlashing(ledARGB, LightsService.LIGHT_FLASH_TIMED, 
  1203.                         ledOnMS, ledOffMS); 
  1204.             } else { 
  1205.                 // pulse only once 
  1206.                 mNotificationLight.pulse(ledARGB, ledOnMS); 
  1207.             } 
  1208.         } 
  1209.     } 
  1210.  
  1211.     // lock on mNotificationList 
  1212.     private int indexOfNotificationLocked(String pkg, String tag,int id) 
  1213.     { 
  1214.         ArrayList<NotificationRecord> list = mNotificationList; 
  1215.         final int len = list.size(); 
  1216.         for (int i=0; i<len; i++) { 
  1217.             NotificationRecord r = list.get(i); 
  1218.             if (tag == null) { 
  1219.                 if (r.tag !=null) { 
  1220.                     continue; 
  1221.                 } 
  1222.             } else { 
  1223.                 if (!tag.equals(r.tag)) { 
  1224.                     continue; 
  1225.                 } 
  1226.             } 
  1227.             if (r.id == id && r.pkg.equals(pkg)) { 
  1228.                 return i; 
  1229.             } 
  1230.         } 
  1231.         return -1; 
  1232.     } 
  1233.  
  1234.     // This is here instead of StatusBarPolicy because it is an important 
  1235.     // security feature that we don't want people customizing the platform 
  1236.     // to accidentally lose. 
  1237.     private void updateAdbNotification(boolean adbEnabled) { 
  1238.         if (adbEnabled) { 
  1239.             if ("0".equals(SystemProperties.get("persist.adb.notify"))) { 
  1240.                 return; 
  1241.             } 
  1242.             if (!mAdbNotificationShown) { 
  1243.                 NotificationManager notificationManager = (NotificationManager) mContext 
  1244.                         .getSystemService(Context.NOTIFICATION_SERVICE); 
  1245.                 if (notificationManager !=null) { 
  1246.                     Resources r = mContext.getResources(); 
  1247.                     CharSequence title = r.getText( 
  1248.                             com.android.internal.R.string.adb_active_notification_title); 
  1249.                     CharSequence message = r.getText( 
  1250.                             com.android.internal.R.string.adb_active_notification_message); 
  1251.  
  1252.                     if (mAdbNotification ==null) { 
  1253.                         mAdbNotification = new Notification(); 
  1254.                         mAdbNotification.icon = com.android.internal.R.drawable.stat_sys_adb; 
  1255.                         mAdbNotification.when = 0; 
  1256.                         mAdbNotification.flags = Notification.FLAG_ONGOING_EVENT; 
  1257.                         mAdbNotification.tickerText = title; 
  1258.                         mAdbNotification.defaults = 0; // please be quiet 
  1259.                         mAdbNotification.sound = null; 
  1260.                         mAdbNotification.vibrate = null; 
  1261.                     } 
  1262.  
  1263.                     Intent intent = new Intent( 
  1264.                             Settings.ACTION_APPLICATION_DEVELOPMENT_SETTINGS); 
  1265.                     intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | 
  1266.                             Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED); 
  1267.                     // Note: we are hard-coding the component because this is 
  1268.                     // an important security UI that we don't want anyone 
  1269.                     // intercepting. 
  1270.                     intent.setComponent(new ComponentName("com.android.settings", 
  1271.                             "com.android.settings.DevelopmentSettings")); 
  1272.                     PendingIntent pi = PendingIntent.getActivity(mContext,0, 
  1273.                             intent, 0); 
  1274.  
  1275.                     mAdbNotification.setLatestEventInfo(mContext, title, message, pi); 
  1276.  
  1277.                     mAdbNotificationShown = true; 
  1278.                     notificationManager.notify( 
  1279.                             com.android.internal.R.string.adb_active_notification_title, 
  1280.                             mAdbNotification); 
  1281.                 } 
  1282.             } 
  1283.  
  1284.         } else if (mAdbNotificationShown) { 
  1285.             NotificationManager notificationManager = (NotificationManager) mContext 
  1286.                     .getSystemService(Context.NOTIFICATION_SERVICE); 
  1287.             if (notificationManager !=null) { 
  1288.                 mAdbNotificationShown = false; 
  1289.                 notificationManager.cancel( 
  1290.                         com.android.internal.R.string.adb_active_notification_title); 
  1291.             } 
  1292.         } 
  1293.     } 
  1294.  
  1295.     private void updateNotificationPulse() { 
  1296.         synchronized (mNotificationList) { 
  1297.             updateLightsLocked(); 
  1298.         } 
  1299.     } 
  1300.  
  1301.     // ====================================================================== 
  1302.     @Override 
  1303.     protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 
  1304.         if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) 
  1305.                 != PackageManager.PERMISSION_GRANTED) { 
  1306.             pw.println("Permission Denial: can't dump NotificationManager from from pid=" 
  1307.                     + Binder.getCallingPid() 
  1308.                     + ", uid=" + Binder.getCallingUid()); 
  1309.             return; 
  1310.         } 
  1311.  
  1312.         pw.println("Current Notification Manager state:"); 
  1313.  
  1314.         int N; 
  1315.  
  1316.         synchronized (mToastQueue) { 
  1317.             N = mToastQueue.size(); 
  1318.             if (N > 0) { 
  1319.                 pw.println("  Toast Queue:"); 
  1320.                 for (int i=0; i<N; i++) { 
  1321.                     mToastQueue.get(i).dump(pw, "    "); 
  1322.                 } 
  1323.                 pw.println("  "); 
  1324.             } 
  1325.  
  1326.         } 
  1327.  
  1328.         synchronized (mNotificationList) { 
  1329.             N = mNotificationList.size(); 
  1330.             if (N > 0) { 
  1331.                 pw.println("  Notification List:"); 
  1332.                 for (int i=0; i<N; i++) { 
  1333.                     mNotificationList.get(i).dump(pw, "    ", mContext); 
  1334.                 } 
  1335.                 pw.println("  "); 
  1336.             } 
  1337.  
  1338.             N = mLights.size(); 
  1339.             if (N > 0) { 
  1340.                 pw.println("  Lights List:"); 
  1341.                 for (int i=0; i<N; i++) { 
  1342.                     mLights.get(i).dump(pw, "    ", mContext); 
  1343.                 } 
  1344.                 pw.println("  "); 
  1345.             } 
  1346.  
  1347.             pw.println("  mSoundNotification=" + mSoundNotification); 
  1348.             pw.println("  mSound=" + mSound); 
  1349.             pw.println("  mVibrateNotification=" + mVibrateNotification); 
  1350.             pw.println("  mDisabledNotifications=0x" + Integer.toHexString(mDisabledNotifications)); 
  1351.             pw.println("  mSystemReady=" + mSystemReady); 
  1352.         } 
  1353.     } 
  1354. } 
/* * Copyright (C) 2007 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; import com.android.internal.statusbar.StatusBarNotification; import com.android.server.StatusBarManagerService; import android.app.ActivityManagerNative; import android.app.IActivityManager; import android.app.INotificationManager; import android.app.ITransientNotification; import android.app.Notification; import android.app.NotificationManager; import android.app.PendingIntent; import android.app.StatusBarManager; import android.content.BroadcastReceiver; import android.content.ComponentName; import android.content.ContentResolver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.content.pm.ApplicationInfo; import android.content.pm.PackageManager; import android.content.pm.PackageManager.NameNotFoundException; import android.content.res.Resources; import android.database.ContentObserver; import android.hardware.usb.UsbManager; import android.media.AudioManager; import android.net.Uri; import android.os.BatteryManager; import android.os.Bundle; import android.os.Binder; import android.os.Handler; import android.os.IBinder; import android.os.Message; import android.os.Power; import android.os.Process; import android.os.RemoteException; import android.os.SystemProperties; import android.os.Vibrator; import android.os.SystemClock; import android.provider.Settings; import android.telephony.TelephonyManager; import android.text.TextUtils; import android.util.EventLog; import android.util.Slog; import android.util.Log; import android.view.accessibility.AccessibilityEvent; import android.view.accessibility.AccessibilityManager; import android.widget.Toast; import java.io.FileDescriptor; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; /** {@hide} */ public class NotificationManagerService extends INotificationManager.Stub { private static final String TAG = "NotificationService"; private static final boolean DBG = false; private static final int MAX_PACKAGE_NOTIFICATIONS = 50; private static final int NOTIFICATION_REQUEST_INTERVAL = 30000; // 30 seconds private static final int MAX_PACKAGE_NOTIFICATION_REQUESTS = 500; // message codes private static final int MESSAGE_TIMEOUT = 2; private static final int LONG_DELAY = 3500; // 3.5 seconds private static final int SHORT_DELAY = 2000; // 2 seconds private static final long[] DEFAULT_VIBRATE_PATTERN = {0, 250, 250, 250}; private static final int DEFAULT_STREAM_TYPE = AudioManager.STREAM_NOTIFICATION; final Context mContext; final IActivityManager mAm; final IBinder mForegroundToken = new Binder(); private WorkerHandler mHandler; private StatusBarManagerService mStatusBar; private LightsService mLightsService; private LightsService.Light mBatteryLight; private LightsService.Light mNotificationLight; private LightsService.Light mAttentionLight; private int mDefaultNotificationColor; private int mDefaultNotificationLedOn; private int mDefaultNotificationLedOff; private NotificationRecord mSoundNotification; private NotificationPlayer mSound; private boolean mSystemReady; private int mDisabledNotifications; private NotificationRecord mVibrateNotification; private Vibrator mVibrator = new Vibrator(); // for enabling and disabling notification pulse behavior private boolean mScreenOn = true; private boolean mInCall = false; private boolean mNotificationPulseEnabled; // This is true if we have received a new notification while the screen is off // (that is, if mLedNotification was set while the screen was off) // This is reset to false when the screen is turned on. private boolean mPendingPulseNotification; // for adb connected notifications private boolean mAdbNotificationShown = false; private Notification mAdbNotification; private final ArrayList<NotificationRecord> mNotificationList = new ArrayList<NotificationRecord>(); private class PackageRequestInfo { int requestCount; long lastPostTime; } private final HashMap<String, PackageRequestInfo> mPackageInfo = new HashMap<String, PackageRequestInfo>(); private ArrayList<ToastRecord> mToastQueue; private ArrayList<NotificationRecord> mLights = new ArrayList<NotificationRecord>(); private boolean mBatteryCharging; private boolean mBatteryLow; private boolean mBatteryFull; private NotificationRecord mLedNotification; private static final int BATTERY_LOW_ARGB = 0xFFFF0000; // Charging Low - red solid on private static final int BATTERY_MEDIUM_ARGB = 0xFFFFFF00; // Charging - orange solid on private static final int BATTERY_FULL_ARGB = 0xFF00FF00; // Charging Full - green solid on private static final int BATTERY_BLINK_ON = 125; private static final int BATTERY_BLINK_OFF = 2875; private static String idDebugString(Context baseContext, String packageName, int id) { Context c = null; if (packageName != null) { try { c = baseContext.createPackageContext(packageName, 0); } catch (NameNotFoundException e) { c = baseContext; } } else { c = baseContext; } String pkg; String type; String name; Resources r = c.getResources(); try { return r.getResourceName(id); } catch (Resources.NotFoundException e) { return "<name unknown>"; } } private static final class NotificationRecord { final String pkg; final String tag; final int id; final int uid; final int initialPid; ITransientNotification callback; int duration; final Notification notification; IBinder statusBarKey; NotificationRecord(String pkg, String tag, int id, int uid, int initialPid, Notification notification) { this.pkg = pkg; this.tag = tag; this.id = id; this.uid = uid; this.initialPid = initialPid; this.notification = notification; } void dump(PrintWriter pw, String prefix, Context baseContext) { pw.println(prefix + this); pw.println(prefix + " icon=0x" + Integer.toHexString(notification.icon) + " / " + idDebugString(baseContext, this.pkg, notification.icon)); pw.println(prefix + " contentIntent=" + notification.contentIntent); pw.println(prefix + " deleteIntent=" + notification.deleteIntent); pw.println(prefix + " tickerText=" + notification.tickerText); pw.println(prefix + " contentView=" + notification.contentView); pw.println(prefix + " defaults=0x" + Integer.toHexString(notification.defaults)); pw.println(prefix + " flags=0x" + Integer.toHexString(notification.flags)); pw.println(prefix + " sound=" + notification.sound); pw.println(prefix + " vibrate=" + Arrays.toString(notification.vibrate)); pw.println(prefix + " ledARGB=0x" + Integer.toHexString(notification.ledARGB) + " ledOnMS=" + notification.ledOnMS + " ledOffMS=" + notification.ledOffMS); } @Override public final String toString() { return "NotificationRecord{" + Integer.toHexString(System.identityHashCode(this)) + " pkg=" + pkg + " id=" + Integer.toHexString(id) + " tag=" + tag + "}"; } } private static final class ToastRecord { final int pid; final String pkg; final ITransientNotification callback; int duration; ToastRecord(int pid, String pkg, ITransientNotification callback, int duration) { this.pid = pid; this.pkg = pkg; this.callback = callback; this.duration = duration; } void update(int duration) { this.duration = duration; } void dump(PrintWriter pw, String prefix) { pw.println(prefix + this); } @Override public final String toString() { return "ToastRecord{" + Integer.toHexString(System.identityHashCode(this)) + " pkg=" + pkg + " callback=" + callback + " duration=" + duration; } } private StatusBarManagerService.NotificationCallbacks mNotificationCallbacks = new StatusBarManagerService.NotificationCallbacks() { public void onSetDisabled(int status) { synchronized (mNotificationList) { mDisabledNotifications = status; if ((mDisabledNotifications & StatusBarManager.DISABLE_NOTIFICATION_ALERTS) != 0) { // cancel whatever's going on long identity = Binder.clearCallingIdentity(); try { mSound.stop(); } finally { Binder.restoreCallingIdentity(identity); } identity = Binder.clearCallingIdentity(); try { mVibrator.cancel(); } finally { Binder.restoreCallingIdentity(identity); } } } } public void onClearAll() { cancelAll(); } public void onNotificationClick(String pkg, String tag, int id) { cancelNotification(pkg, tag, id, Notification.FLAG_AUTO_CANCEL, Notification.FLAG_FOREGROUND_SERVICE); } public void onPanelRevealed() { synchronized (mNotificationList) { // sound mSoundNotification = null; long identity = Binder.clearCallingIdentity(); try { mSound.stop(); } finally { Binder.restoreCallingIdentity(identity); } // vibrate mVibrateNotification = null; identity = Binder.clearCallingIdentity(); try { mVibrator.cancel(); } finally { Binder.restoreCallingIdentity(identity); } // light mLights.clear(); mLedNotification = null; updateLightsLocked(); } } public void onNotificationError(String pkg, String tag, int id, int uid, int initialPid, String message) { Slog.d(TAG, "onNotification error pkg=" + pkg + " tag=" + tag + " id=" + id + "; will crashApplication(uid=" + uid + ", pid=" + initialPid + ")"); cancelNotification(pkg, tag, id, 0, 0); long ident = Binder.clearCallingIdentity(); try { ActivityManagerNative.getDefault().crashApplication(uid, initialPid, pkg, "Bad notification posted from package " + pkg + ": " + message); } catch (RemoteException e) { } Binder.restoreCallingIdentity(ident); } }; private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); boolean queryRestart = false; if (action.equals(Intent.ACTION_BATTERY_CHANGED)) { boolean batteryCharging = (intent.getIntExtra("plugged", 0) != 0); int level = intent.getIntExtra("level", -1); boolean batteryLow = (level >= 0 && level <= Power.LOW_BATTERY_THRESHOLD); int status = intent.getIntExtra("status", BatteryManager.BATTERY_STATUS_UNKNOWN); boolean batteryFull = (status == BatteryManager.BATTERY_STATUS_FULL || level >= 90); if (batteryCharging != mBatteryCharging || batteryLow != mBatteryLow || batteryFull != mBatteryFull) { mBatteryCharging = batteryCharging; mBatteryLow = batteryLow; mBatteryFull = batteryFull; updateLights(); } } else if (action.equals(UsbManager.ACTION_USB_STATE)) { Bundle extras = intent.getExtras(); boolean usbConnected = extras.getBoolean(UsbManager.USB_CONNECTED); boolean adbEnabled = (UsbManager.USB_FUNCTION_ENABLED.equals( extras.getString(UsbManager.USB_FUNCTION_ADB))); updateAdbNotification(usbConnected && adbEnabled); } else if (action.equals(Intent.ACTION_PACKAGE_REMOVED) || action.equals(Intent.ACTION_PACKAGE_RESTARTED) || (queryRestart=action.equals(Intent.ACTION_QUERY_PACKAGE_RESTART)) || action.equals(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE)) { String pkgList[] = null; if (action.equals(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE)) { pkgList = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST); } else if (queryRestart) { pkgList = intent.getStringArrayExtra(Intent.EXTRA_PACKAGES); } else { Uri uri = intent.getData(); if (uri == null) { return; } String pkgName = uri.getSchemeSpecificPart(); if (pkgName == null) { return; } pkgList = new String[]{pkgName}; } if (pkgList != null && (pkgList.length > 0)) { for (String pkgName : pkgList) { cancelAllNotificationsInt(pkgName, 0, 0, !queryRestart); } } } else if (action.equals(Intent.ACTION_SCREEN_ON)) { mScreenOn = true; updateNotificationPulse(); } else if (action.equals(Intent.ACTION_SCREEN_OFF)) { mScreenOn = false; updateNotificationPulse(); } else if (action.equals(TelephonyManager.ACTION_PHONE_STATE_CHANGED)) { mInCall = (intent.getStringExtra(TelephonyManager.EXTRA_STATE).equals(TelephonyManager.EXTRA_STATE_OFFHOOK)); updateNotificationPulse(); } } }; class SettingsObserver extends ContentObserver { SettingsObserver(Handler handler) { super(handler); } void observe() { ContentResolver resolver = mContext.getContentResolver(); resolver.registerContentObserver(Settings.System.getUriFor( Settings.System.NOTIFICATION_LIGHT_PULSE), false, this); update(); } @Override public void onChange(boolean selfChange) { update(); } public void update() { ContentResolver resolver = mContext.getContentResolver(); boolean pulseEnabled = Settings.System.getInt(resolver, Settings.System.NOTIFICATION_LIGHT_PULSE, 0) != 0; if (mNotificationPulseEnabled != pulseEnabled) { mNotificationPulseEnabled = pulseEnabled; updateNotificationPulse(); } } } NotificationManagerService(Context context, StatusBarManagerService statusBar, LightsService lights) { super(); mContext = context; mLightsService = lights; mAm = ActivityManagerNative.getDefault(); mSound = new NotificationPlayer(TAG); mSound.setUsesWakeLock(context); mToastQueue = new ArrayList<ToastRecord>(); mHandler = new WorkerHandler(); mStatusBar = statusBar; statusBar.setNotificationCallbacks(mNotificationCallbacks); mBatteryLight = lights.getLight(LightsService.LIGHT_ID_BATTERY); mNotificationLight = lights.getLight(LightsService.LIGHT_ID_NOTIFICATIONS); mAttentionLight = lights.getLight(LightsService.LIGHT_ID_ATTENTION); Resources resources = mContext.getResources(); mDefaultNotificationColor = resources.getColor( com.android.internal.R.color.config_defaultNotificationColor); mDefaultNotificationLedOn = resources.getInteger( com.android.internal.R.integer.config_defaultNotificationLedOn); mDefaultNotificationLedOff = resources.getInteger( com.android.internal.R.integer.config_defaultNotificationLedOff); // Don't start allowing notifications until the setup wizard has run once. // After that, including subsequent boots, init with notifications turned on. // This works on the first boot because the setup wizard will toggle this // flag at least once and we'll go back to 0 after that. if (0 == Settings.Secure.getInt(mContext.getContentResolver(), Settings.Secure.DEVICE_PROVISIONED, 0)) { mDisabledNotifications = StatusBarManager.DISABLE_NOTIFICATION_ALERTS; } // register for battery changed notifications IntentFilter filter = new IntentFilter(); filter.addAction(Intent.ACTION_BATTERY_CHANGED); filter.addAction(UsbManager.ACTION_USB_STATE); filter.addAction(Intent.ACTION_SCREEN_ON); filter.addAction(Intent.ACTION_SCREEN_OFF); filter.addAction(TelephonyManager.ACTION_PHONE_STATE_CHANGED); mContext.registerReceiver(mIntentReceiver, filter); IntentFilter pkgFilter = new IntentFilter(); pkgFilter.addAction(Intent.ACTION_PACKAGE_REMOVED); pkgFilter.addAction(Intent.ACTION_PACKAGE_RESTARTED); pkgFilter.addAction(Intent.ACTION_QUERY_PACKAGE_RESTART); pkgFilter.addDataScheme("package"); mContext.registerReceiver(mIntentReceiver, pkgFilter); IntentFilter sdFilter = new IntentFilter(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE); mContext.registerReceiver(mIntentReceiver, sdFilter); SettingsObserver observer = new SettingsObserver(mHandler); observer.observe(); } void systemReady() { // no beeping until we're basically done booting mSystemReady = true; } // Toasts // ============================================================================ public void enqueueToast(String pkg, ITransientNotification callback, int duration) { if (DBG) Slog.i(TAG, "enqueueToast pkg=" + pkg + " callback=" + callback + " duration=" + duration); if (pkg == null || callback == null) { Slog.e(TAG, "Not doing toast. pkg=" + pkg + " callback=" + callback); return ; } synchronized (mToastQueue) { int callingPid = Binder.getCallingPid(); long callingId = Binder.clearCallingIdentity(); try { ToastRecord record; int index = indexOfToastLocked(pkg, callback); // If it's already in the queue, we update it in place, we don't // move it to the end of the queue. if (index >= 0) { record = mToastQueue.get(index); record.update(duration); } else { // Limit the number of toasts that any given package except the android // package can enqueue. Prevents DOS attacks and deals with leaks. if (!"android".equals(pkg)) { int count = 0; final int N = mToastQueue.size(); for (int i=0; i<N; i++) { final ToastRecord r = mToastQueue.get(i); if (r.pkg.equals(pkg)) { count++; if (count >= MAX_PACKAGE_NOTIFICATIONS) { Slog.e(TAG, "Package has already posted " + count + " toasts. Not showing more. Package=" + pkg); return; } } } } record = new ToastRecord(callingPid, pkg, callback, duration); mToastQueue.add(record); index = mToastQueue.size() - 1; keepProcessAliveLocked(callingPid); } // If it's at index 0, it's the current toast. It doesn't matter if it's // new or just been updated. Call back and tell it to show itself. // If the callback fails, this will remove it from the list, so don't // assume that it's valid after this. if (index == 0) { showNextToastLocked(); } } finally { Binder.restoreCallingIdentity(callingId); } } } public void cancelToast(String pkg, ITransientNotification callback) { Slog.i(TAG, "cancelToast pkg=" + pkg + " callback=" + callback); if (pkg == null || callback == null) { Slog.e(TAG, "Not cancelling notification. pkg=" + pkg + " callback=" + callback); return ; } synchronized (mToastQueue) { long callingId = Binder.clearCallingIdentity(); try { int index = indexOfToastLocked(pkg, callback); if (index >= 0) { cancelToastLocked(index); } else { Slog.w(TAG, "Toast already cancelled. pkg=" + pkg + " callback=" + callback); } } finally { Binder.restoreCallingIdentity(callingId); } } } private void showNextToastLocked() { ToastRecord record = mToastQueue.get(0); while (record != null) { if (DBG) Slog.d(TAG, "Show pkg=" + record.pkg + " callback=" + record.callback); try { record.callback.show(); scheduleTimeoutLocked(record, false); return; } catch (RemoteException e) { Slog.w(TAG, "Object died trying to show notification " + record.callback + " in package " + record.pkg); // remove it from the list and let the process die int index = mToastQueue.indexOf(record); if (index >= 0) { mToastQueue.remove(index); } keepProcessAliveLocked(record.pid); if (mToastQueue.size() > 0) { record = mToastQueue.get(0); } else { record = null; } } } } private void cancelToastLocked(int index) { ToastRecord record = mToastQueue.get(index); try { record.callback.hide(); } catch (RemoteException e) { Slog.w(TAG, "Object died trying to hide notification " + record.callback + " in package " + record.pkg); // don't worry about this, we're about to remove it from // the list anyway } mToastQueue.remove(index); keepProcessAliveLocked(record.pid); if (mToastQueue.size() > 0) { // Show the next one. If the callback fails, this will remove // it from the list, so don't assume that the list hasn't changed // after this point. showNextToastLocked(); } } private void scheduleTimeoutLocked(ToastRecord r, boolean immediate) { Message m = Message.obtain(mHandler, MESSAGE_TIMEOUT, r); long delay = immediate ? 0 : (r.duration == Toast.LENGTH_LONG ? LONG_DELAY : SHORT_DELAY); mHandler.removeCallbacksAndMessages(r); mHandler.sendMessageDelayed(m, delay); } private void handleTimeout(ToastRecord record) { if (DBG) Slog.d(TAG, "Timeout pkg=" + record.pkg + " callback=" + record.callback); synchronized (mToastQueue) { int index = indexOfToastLocked(record.pkg, record.callback); if (index >= 0) { cancelToastLocked(index); } } } // lock on mToastQueue private int indexOfToastLocked(String pkg, ITransientNotification callback) { IBinder cbak = callback.asBinder(); ArrayList<ToastRecord> list = mToastQueue; int len = list.size(); for (int i=0; i<len; i++) { ToastRecord r = list.get(i); if (r.pkg.equals(pkg) && r.callback.asBinder() == cbak) { return i; } } return -1; } // lock on mToastQueue private void keepProcessAliveLocked(int pid) { int toastCount = 0; // toasts from this pid ArrayList<ToastRecord> list = mToastQueue; int N = list.size(); for (int i=0; i<N; i++) { ToastRecord r = list.get(i); if (r.pid == pid) { toastCount++; } } try { mAm.setProcessForeground(mForegroundToken, pid, toastCount > 0); } catch (RemoteException e) { // Shouldn't happen. } } private final class WorkerHandler extends Handler { @Override public void handleMessage(Message msg) { switch (msg.what) { case MESSAGE_TIMEOUT: handleTimeout((ToastRecord)msg.obj); break; } } } // Notifications // ============================================================================ public void enqueueNotification(String pkg, int id, Notification notification, int[] idOut) { enqueueNotificationWithTag(pkg, null /* tag */, id, notification, idOut); } public void enqueueNotificationWithTag(String pkg, String tag, int id, Notification notification, int[] idOut) { enqueueNotificationInternal(pkg, Binder.getCallingUid(), Binder.getCallingPid(), tag, id, notification, idOut); } // Not exposed via Binder; for system use only (otherwise malicious apps could spoof the // uid/pid of another application) public void enqueueNotificationInternal(String pkg, int callingUid, int callingPid, String tag, int id, Notification notification, int[] idOut) { checkIncomingCall(pkg); // Limit the number of notifications that any given package except the android // package can enqueue. Prevents DOS attacks and deals with leaks. if (!"android".equals(pkg)) { synchronized (mNotificationList) { int count = 0; final int N = mNotificationList.size(); for (int i=0; i<N; i++) { final NotificationRecord r = mNotificationList.get(i); if (r.pkg.equals(pkg)) { count++; if (count >= MAX_PACKAGE_NOTIFICATIONS) { Slog.e(TAG, "Package has already posted " + count + " notifications. Not showing more. package=" + pkg); return; } } } } } // Limit the number of notification requests, notify and cancel that // a package can post. The MAX_PACKAGE_NOTIFICATIONS doesn't work for // packages which notify and quickly cancel it and do this in an // iteration if (!"android".equals(pkg)) { synchronized (mPackageInfo) { if (!mPackageInfo.containsKey(pkg)) { final PackageRequestInfo pInfo = new PackageRequestInfo(); pInfo.requestCount = 1; pInfo.lastPostTime = SystemClock.elapsedRealtime(); mPackageInfo.put(pkg,pInfo); } else { final PackageRequestInfo pInfo = mPackageInfo.get(pkg); final long currentTime = SystemClock.elapsedRealtime(); if ((currentTime - pInfo.lastPostTime) <= NOTIFICATION_REQUEST_INTERVAL) { // Keep track of requests posted within last 30 seconds pInfo.requestCount++; } else { pInfo.requestCount = 1; pInfo.lastPostTime = SystemClock.elapsedRealtime(); } if (pInfo.requestCount >= MAX_PACKAGE_NOTIFICATION_REQUESTS) { // 500 requests within a span of 30 seconds is high if (pInfo.requestCount%MAX_PACKAGE_NOTIFICATION_REQUESTS == 0) { Slog.e(TAG, "Package has already posted too many notifications. " + "Not showing more. package=" + pkg); } return; } } } } // 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)) { EventLog.writeEvent(EventLogTags.NOTIFICATION_ENQUEUE, pkg, id, notification.toString()); } if (pkg == null || notification == null) { throw new IllegalArgumentException("null not allowed: pkg=" + pkg + " id=" + id + " notification=" + notification); } if (notification.icon != 0) { if (notification.contentView == null) { throw new IllegalArgumentException("contentView required: pkg=" + pkg + " id=" + id + " notification=" + notification); } if (notification.contentIntent == null) { throw new IllegalArgumentException("contentIntent required: pkg=" + pkg + " id=" + id + " notification=" + notification); } } synchronized (mNotificationList) { NotificationRecord r = new NotificationRecord(pkg, tag, id, callingUid, callingPid, notification); NotificationRecord old = null; int index = indexOfNotificationLocked(pkg, tag, id); if (index < 0) { mNotificationList.add(r); } else { old = mNotificationList.remove(index); mNotificationList.add(index, r); // Make sure we don't lose the foreground service state. if (old != null) { notification.flags |= old.notification.flags&Notification.FLAG_FOREGROUND_SERVICE; } } // Ensure if this is a foreground service that the proper additional // flags are set. if ((notification.flags&Notification.FLAG_FOREGROUND_SERVICE) != 0) { notification.flags |= Notification.FLAG_ONGOING_EVENT | Notification.FLAG_NO_CLEAR; } if (notification.icon != 0) { StatusBarNotification n = new StatusBarNotification(pkg, id, tag, r.uid, r.initialPid, notification); if (old != null && old.statusBarKey != null) { r.statusBarKey = old.statusBarKey; long identity = Binder.clearCallingIdentity(); try { mStatusBar.updateNotification(r.statusBarKey, n); } finally { Binder.restoreCallingIdentity(identity); } } else { long identity = Binder.clearCallingIdentity(); try { r.statusBarKey = mStatusBar.addNotification(n); mAttentionLight.pulse(); } finally { Binder.restoreCallingIdentity(identity); } } sendAccessibilityEvent(notification, pkg); } else { if (old != null && old.statusBarKey != null) { long identity = Binder.clearCallingIdentity(); try { mStatusBar.removeNotification(old.statusBarKey); } finally { Binder.restoreCallingIdentity(identity); } } } // If we're not supposed to beep, vibrate, etc. then don't. if (((mDisabledNotifications & StatusBarManager.DISABLE_NOTIFICATION_ALERTS) == 0) && (!(old != null && (notification.flags & Notification.FLAG_ONLY_ALERT_ONCE) != 0 )) && mSystemReady) { final AudioManager audioManager = (AudioManager) mContext .getSystemService(Context.AUDIO_SERVICE); // sound final boolean useDefaultSound = (notification.defaults & Notification.DEFAULT_SOUND) != 0; if (useDefaultSound || notification.sound != null) { Uri uri; if (useDefaultSound) { uri = Settings.System.DEFAULT_NOTIFICATION_URI; } else { uri = notification.sound; } boolean looping = (notification.flags & Notification.FLAG_INSISTENT) != 0; int audioStreamType; if (notification.audioStreamType >= 0) { audioStreamType = notification.audioStreamType; } else { audioStreamType = DEFAULT_STREAM_TYPE; } mSoundNotification = r; // do not play notifications if stream volume is 0 // (typically because ringer mode is silent). if (audioManager.getStreamVolume(audioStreamType) != 0) { long identity = Binder.clearCallingIdentity(); try { mSound.play(mContext, uri, looping, audioStreamType); } finally { Binder.restoreCallingIdentity(identity); } } } // vibrate final boolean useDefaultVibrate = (notification.defaults & Notification.DEFAULT_VIBRATE) != 0; if ((useDefaultVibrate || notification.vibrate != null) && audioManager.shouldVibrate(AudioManager.VIBRATE_TYPE_NOTIFICATION)) { mVibrateNotification = r; mVibrator.vibrate(useDefaultVibrate ? DEFAULT_VIBRATE_PATTERN : notification.vibrate, ((notification.flags & Notification.FLAG_INSISTENT) != 0) ? 0: -1); } } // this option doesn't shut off the lights // light // the most recent thing gets the light mLights.remove(old); if (mLedNotification == old) { mLedNotification = null; } //Slog.i(TAG, "notification.lights=" // + ((old.notification.lights.flags & Notification.FLAG_SHOW_LIGHTS) != 0)); if ((notification.flags & Notification.FLAG_SHOW_LIGHTS) != 0) { mLights.add(r); updateLightsLocked(); } else { if (old != null && ((old.notification.flags & Notification.FLAG_SHOW_LIGHTS) != 0)) { updateLightsLocked(); } } } idOut[0] = id; } private void sendAccessibilityEvent(Notification notification, CharSequence packageName) { AccessibilityManager manager = AccessibilityManager.getInstance(mContext); if (!manager.isEnabled()) { return; } AccessibilityEvent event = AccessibilityEvent.obtain(AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED); event.setPackageName(packageName); event.setClassName(Notification.class.getName()); event.setParcelableData(notification); CharSequence tickerText = notification.tickerText; if (!TextUtils.isEmpty(tickerText)) { event.getText().add(tickerText); } manager.sendAccessibilityEvent(event); } private void cancelNotificationLocked(NotificationRecord r) { // status bar if (r.notification.icon != 0) { long identity = Binder.clearCallingIdentity(); try { mStatusBar.removeNotification(r.statusBarKey); } finally { Binder.restoreCallingIdentity(identity); } r.statusBarKey = null; } // sound if (mSoundNotification == r) { mSoundNotification = null; long identity = Binder.clearCallingIdentity(); try { mSound.stop(); } finally { Binder.restoreCallingIdentity(identity); } } // vibrate if (mVibrateNotification == r) { mVibrateNotification = null; long identity = Binder.clearCallingIdentity(); try { mVibrator.cancel(); } finally { Binder.restoreCallingIdentity(identity); } } // light mLights.remove(r); if (mLedNotification == r) { mLedNotification = null; } } /** * Cancels a notification ONLY if it has all of the {@code mustHaveFlags} * and none of the {@code mustNotHaveFlags}. */ private void cancelNotification(String pkg, String tag, int id, int mustHaveFlags, int mustNotHaveFlags) { EventLog.writeEvent(EventLogTags.NOTIFICATION_CANCEL, pkg, id, mustHaveFlags); synchronized (mNotificationList) { int index = indexOfNotificationLocked(pkg, tag, id); if (index >= 0) { NotificationRecord r = mNotificationList.get(index); if ((r.notification.flags & mustHaveFlags) != mustHaveFlags) { return; } if ((r.notification.flags & mustNotHaveFlags) != 0) { return; } mNotificationList.remove(index); cancelNotificationLocked(r); updateLightsLocked(); } } } /** * Cancels all notifications from a given package that have all of the * {@code mustHaveFlags}. */ boolean cancelAllNotificationsInt(String pkg, int mustHaveFlags, int mustNotHaveFlags, boolean doit) { EventLog.writeEvent(EventLogTags.NOTIFICATION_CANCEL_ALL, pkg, mustHaveFlags); synchronized (mNotificationList) { final int N = mNotificationList.size(); boolean canceledSomething = false; for (int i = N-1; i >= 0; --i) { NotificationRecord r = mNotificationList.get(i); if ((r.notification.flags & mustHaveFlags) != mustHaveFlags) { continue; } if ((r.notification.flags & mustNotHaveFlags) != 0) { continue; } if (!r.pkg.equals(pkg)) { continue; } canceledSomething = true; if (!doit) { return true; } mNotificationList.remove(i); cancelNotificationLocked(r); } if (canceledSomething) { updateLightsLocked(); } return canceledSomething; } } public void cancelNotification(String pkg, int id) { cancelNotificationWithTag(pkg, null /* tag */, id); } public void cancelNotificationWithTag(String pkg, String tag, int id) { checkIncomingCall(pkg); // Limit the number of notification requests, notify and cancel that // a package can post. The MAX_PACKAGE_NOTIFICATIONS doesn't work for // packages which notify and quickly cancel it and do this in an // iteration synchronized (mPackageInfo) { if (!"android".equals(pkg) && mPackageInfo.containsKey(pkg)) { final PackageRequestInfo pInfo = mPackageInfo.get(pkg); final long currentTime = SystemClock.elapsedRealtime(); if ((currentTime - pInfo.lastPostTime) <= NOTIFICATION_REQUEST_INTERVAL) { // Keep track of requests posted within last 30 seconds pInfo.requestCount++; } else { pInfo.requestCount = 1; pInfo.lastPostTime = SystemClock.elapsedRealtime(); } } } // Don't allow client applications to cancel foreground service notis. cancelNotification(pkg, tag, id, 0, Binder.getCallingUid() == Process.SYSTEM_UID ? 0 : Notification.FLAG_FOREGROUND_SERVICE); } public void cancelAllNotifications(String pkg) { checkIncomingCall(pkg); // Calling from user space, don't allow the canceling of actively // running foreground services. cancelAllNotificationsInt(pkg, 0, Notification.FLAG_FOREGROUND_SERVICE, true); } void checkIncomingCall(String pkg) { int uid = Binder.getCallingUid(); if (uid == Process.SYSTEM_UID || uid == 0) { return; } try { ApplicationInfo ai = mContext.getPackageManager().getApplicationInfo( pkg, 0); if (ai.uid != uid) { throw new SecurityException("Calling uid " + uid + " gave package" + pkg + " which is owned by uid " + ai.uid); } } catch (PackageManager.NameNotFoundException e) { throw new SecurityException("Unknown package " + pkg); } } void cancelAll() { synchronized (mNotificationList) { final int N = mNotificationList.size(); for (int i=N-1; i>=0; i--) { NotificationRecord r = mNotificationList.get(i); if ((r.notification.flags & (Notification.FLAG_ONGOING_EVENT | Notification.FLAG_NO_CLEAR)) == 0) { if (r.notification.deleteIntent != null) { try { r.notification.deleteIntent.send(); } catch (PendingIntent.CanceledException ex) { // do nothing - there's no relevant way to recover, and // no reason to let this propagate Slog.w(TAG, "canceled PendingIntent for " + r.pkg, ex); } } mNotificationList.remove(i); cancelNotificationLocked(r); } } updateLightsLocked(); } } private void updateLights() { synchronized (mNotificationList) { updateLightsLocked(); } } // lock on mNotificationList private void updateLightsLocked() { // Battery low always shows, other states only show if charging. if (mBatteryLow) { if (mBatteryCharging) { mBatteryLight.setColor(BATTERY_LOW_ARGB); } else { // Flash when battery is low and not charging mBatteryLight.setFlashing(BATTERY_LOW_ARGB, LightsService.LIGHT_FLASH_TIMED, BATTERY_BLINK_ON, BATTERY_BLINK_OFF); } } else if (mBatteryCharging) { if (mBatteryFull) { mBatteryLight.setColor(BATTERY_FULL_ARGB); } else { mBatteryLight.setColor(BATTERY_MEDIUM_ARGB); } } else { mBatteryLight.turnOff(); } // clear pending pulse notification if screen is on if (mScreenOn || mLedNotification == null) { mPendingPulseNotification = false; } // handle notification lights if (mLedNotification == null) { // get next notification, if any int n = mLights.size(); if (n > 0) { mLedNotification = mLights.get(n-1); } if (mLedNotification != null && !mScreenOn) { mPendingPulseNotification = true; } } // we only flash if screen is off and persistent pulsing is enabled // and we are not currently in a call if (!mPendingPulseNotification || mScreenOn || mInCall) { mNotificationLight.turnOff(); } else { int ledARGB = mLedNotification.notification.ledARGB; int ledOnMS = mLedNotification.notification.ledOnMS; int ledOffMS = mLedNotification.notification.ledOffMS; if ((mLedNotification.notification.defaults & Notification.DEFAULT_LIGHTS) != 0) { ledARGB = mDefaultNotificationColor; ledOnMS = mDefaultNotificationLedOn; ledOffMS = mDefaultNotificationLedOff; } if (mNotificationPulseEnabled) { // pulse repeatedly mNotificationLight.setFlashing(ledARGB, LightsService.LIGHT_FLASH_TIMED, ledOnMS, ledOffMS); } else { // pulse only once mNotificationLight.pulse(ledARGB, ledOnMS); } } } // lock on mNotificationList private int indexOfNotificationLocked(String pkg, String tag, int id) { ArrayList<NotificationRecord> list = mNotificationList; final int len = list.size(); for (int i=0; i<len; i++) { NotificationRecord r = list.get(i); if (tag == null) { if (r.tag != null) { continue; } } else { if (!tag.equals(r.tag)) { continue; } } if (r.id == id && r.pkg.equals(pkg)) { return i; } } return -1; } // This is here instead of StatusBarPolicy because it is an important // security feature that we don't want people customizing the platform // to accidentally lose. private void updateAdbNotification(boolean adbEnabled) { if (adbEnabled) { if ("0".equals(SystemProperties.get("persist.adb.notify"))) { return; } if (!mAdbNotificationShown) { NotificationManager notificationManager = (NotificationManager) mContext .getSystemService(Context.NOTIFICATION_SERVICE); if (notificationManager != null) { Resources r = mContext.getResources(); CharSequence title = r.getText( com.android.internal.R.string.adb_active_notification_title); CharSequence message = r.getText( com.android.internal.R.string.adb_active_notification_message); if (mAdbNotification == null) { mAdbNotification = new Notification(); mAdbNotification.icon = com.android.internal.R.drawable.stat_sys_adb; mAdbNotification.when = 0; mAdbNotification.flags = Notification.FLAG_ONGOING_EVENT; mAdbNotification.tickerText = title; mAdbNotification.defaults = 0; // please be quiet mAdbNotification.sound = null; mAdbNotification.vibrate = null; } Intent intent = new Intent( Settings.ACTION_APPLICATION_DEVELOPMENT_SETTINGS); intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED); // Note: we are hard-coding the component because this is // an important security UI that we don't want anyone // intercepting. intent.setComponent(new ComponentName("com.android.settings", "com.android.settings.DevelopmentSettings")); PendingIntent pi = PendingIntent.getActivity(mContext, 0, intent, 0); mAdbNotification.setLatestEventInfo(mContext, title, message, pi); mAdbNotificationShown = true; notificationManager.notify( com.android.internal.R.string.adb_active_notification_title, mAdbNotification); } } } else if (mAdbNotificationShown) { NotificationManager notificationManager = (NotificationManager) mContext .getSystemService(Context.NOTIFICATION_SERVICE); if (notificationManager != null) { mAdbNotificationShown = false; notificationManager.cancel( com.android.internal.R.string.adb_active_notification_title); } } } private void updateNotificationPulse() { synchronized (mNotificationList) { updateLightsLocked(); } } // ====================================================================== @Override protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) != PackageManager.PERMISSION_GRANTED) { pw.println("Permission Denial: can't dump NotificationManager from from pid=" + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid()); return; } pw.println("Current Notification Manager state:"); int N; synchronized (mToastQueue) { N = mToastQueue.size(); if (N > 0) { pw.println(" Toast Queue:"); for (int i=0; i<N; i++) { mToastQueue.get(i).dump(pw, " "); } pw.println(" "); } } synchronized (mNotificationList) { N = mNotificationList.size(); if (N > 0) { pw.println(" Notification List:"); for (int i=0; i<N; i++) { mNotificationList.get(i).dump(pw, " ", mContext); } pw.println(" "); } N = mLights.size(); if (N > 0) { pw.println(" Lights List:"); for (int i=0; i<N; i++) { mLights.get(i).dump(pw, " ", mContext); } pw.println(" "); } pw.println(" mSoundNotification=" + mSoundNotification); pw.println(" mSound=" + mSound); pw.println(" mVibrateNotification=" + mVibrateNotification); pw.println(" mDisabledNotifications=0x" + Integer.toHexString(mDisabledNotifications)); pw.println(" mSystemReady=" + mSystemReady); } } }


在871行有这句代码：uri = notification.sound;在886行有这句代码：mSound.play(mContext, uri, looping, audioStreamType);当时我就有点兴奋了，感觉这就是问题的关键，然后打log，发现这就是问题的关键，当notification正常发声音的时候，这个886行的代码走进来了，不发声音的时候这个代码没有走进来，所以我离问题的根源又进了一步。最后发现是包着这段代码的if语句中的判断引起的，所以我把if语句中的代码都打印出来，发现是mDisabledNotifications这个变量引起的，我就追踪这个mDisabledNotifications变量值的变化的地方。发现在467行有这段代码：

[java] view plain copy print ?
  1. // Don't start allowing notifications until the setup wizard has run once. 
  2.      // After that, including subsequent boots, init with notifications turned on. 
  3.      // This works on the first boot because the setup wizard will toggle this 
  4.      // flag at least once and we'll go back to 0 after that. 
  5.      if (0 == Settings.Secure.getInt(mContext.getContentResolver(), 
  6.                  Settings.Secure.DEVICE_PROVISIONED, 0)) { 
  7.          mDisabledNotifications = StatusBarManager.DISABLE_NOTIFICATION_ALERTS; 
  8.      } 
// Don't start allowing notifications until the setup wizard has run once. // After that, including subsequent boots, init with notifications turned on. // This works on the first boot because the setup wizard will toggle this // flag at least once and we'll go back to 0 after that. if (0 == Settings.Secure.getInt(mContext.getContentResolver(), Settings.Secure.DEVICE_PROVISIONED, 0)) { mDisabledNotifications = StatusBarManager.DISABLE_NOTIFICATION_ALERTS; }

研究以上的注释，发现原来google故意这么设置的，至于google为什么要这么设置，我没有深究，暂时没有想明白，但是这个这个初始化的时候必须要tsetup wizard （设置向导）运行一次，所以导致了值不对，所以这个notification就不响了。


在264行有这段代码对mDisabledNotification进行改变的：

[java] view plain copy print ?
  1. private StatusBarManagerService.NotificationCallbacks mNotificationCallbacks 
  2.         = new StatusBarManagerService.NotificationCallbacks() { 
  3.  
  4.     public void onSetDisabled(int status) { 
  5.         synchronized (mNotificationList) { 
  6.             mDisabledNotifications = status; 
  7.             if ((mDisabledNotifications & StatusBarManager.DISABLE_NOTIFICATION_ALERTS) !=0) { 
  8.                 // cancel whatever's going on 
  9.                 long identity = Binder.clearCallingIdentity(); 
  10.                 try { 
  11.                     mSound.stop(); 
  12.                 } 
  13.                 finally { 
  14.                     Binder.restoreCallingIdentity(identity); 
  15.                 } 
  16.  
  17.                 identity = Binder.clearCallingIdentity(); 
  18.                 try { 
  19.                     mVibrator.cancel(); 
  20.                 } 
  21.                 finally { 
  22.                     Binder.restoreCallingIdentity(identity); 
  23.                 } 
  24.             } 
  25.         } 
  26.     } 
private StatusBarManagerService.NotificationCallbacks mNotificationCallbacks = new StatusBarManagerService.NotificationCallbacks() { public void onSetDisabled(int status) { synchronized (mNotificationList) { mDisabledNotifications = status; if ((mDisabledNotifications & StatusBarManager.DISABLE_NOTIFICATION_ALERTS) != 0) { // cancel whatever's going on long identity = Binder.clearCallingIdentity(); try { mSound.stop(); } finally { Binder.restoreCallingIdentity(identity); } identity = Binder.clearCallingIdentity(); try { mVibrator.cancel(); } finally { Binder.restoreCallingIdentity(identity); } } } }

找到问题的根源了，太兴奋了，这个问题断断续续困扰了我3周，终于经过我3天地认真分析，把问题的根源找到了，要想解决就很简单了，可以在初始化的时候直接赋值为0就ok了！

       最后、886行mSound.play(mContext, uri, looping, audioStreamType);是NotificationPlayer类中的一个方法，在play（）方法中有一个线程，  mThread = new CmdThread();   mThread.start();线程中的run方法中有：case   PLAY：startSound(cmd);在startSound（）方法中又有一个线程：  mCompletionThread = new CreationAndCompletionThread(cmd);

[java] view plain copy print ?
  1. mCompletionThread = new CreationAndCompletionThread(cmd); 
  2.                 synchronized(mCompletionThread) { 
  3.                     mCompletionThread.start(); 
  4.                     mCompletionThread.wait(); 
  5.                 } 
mCompletionThread = new CreationAndCompletionThread(cmd); synchronized(mCompletionThread) { mCompletionThread.start(); mCompletionThread.wait(); }

在这个线程类中的run方法中：在这个线程中进行播放音乐的 ，真正的发声音也是通过Mediapaly来实现的：

[java] view plain copy print ?
  1. <span style="font-size:13px;">publicvoid run() { 
  2.             Looper.prepare(); 
  3.             mLooper = Looper.myLooper(); 
  4.             synchronized(this) { 
  5.                 AudioManager audioManager = 
  6.                     (AudioManager) mCmd.context.getSystemService(Context.AUDIO_SERVICE); 
  7.                 try { 
  8.                     MediaPlayer player = new MediaPlayer(); 
  9.                     player.setAudioStreamType(mCmd.stream); 
  10.                     player.setDataSource(mCmd.context, mCmd.uri); 
  11.                     player.setLooping(mCmd.looping); 
  12.                     player.prepare(); 
  13.                     if ((mCmd.uri !=null) && (mCmd.uri.getEncodedPath() !=null) 
  14.                             && (mCmd.uri.getEncodedPath().length() > 0)) { 
  15.                         if (mCmd.looping) { 
  16.                             audioManager.requestAudioFocus(null, mCmd.stream, 
  17.                                     AudioManager.AUDIOFOCUS_GAIN); 
  18.                         } else { 
  19.                             audioManager.requestAudioFocus(null, mCmd.stream, 
  20.                                     AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK); 
  21.                         } 
  22.                     } 
  23.                     player.setOnCompletionListener(NotificationPlayer.this); 
  24.                     player.start(); 
  25.                     if (mPlayer !=null) { 
  26.                         mPlayer.release(); 
  27.                     } 
  28.                     mPlayer = player; 
  29.                 } 
  30.                 catch (Exception e) { 
  31.                     Log.w(mTag, "error loading sound for " + mCmd.uri, e); 
  32.                 } 
  33.                 mAudioManager = audioManager; 
  34.                 this.notify(); 
  35.             } 
  36.             Looper.loop(); 
  37.         }</span> 
<span style="font-size:13px;"> public void run() { Looper.prepare(); mLooper = Looper.myLooper(); synchronized(this) { AudioManager audioManager = (AudioManager) mCmd.context.getSystemService(Context.AUDIO_SERVICE); try { MediaPlayer player = new MediaPlayer(); player.setAudioStreamType(mCmd.stream); player.setDataSource(mCmd.context, mCmd.uri); player.setLooping(mCmd.looping); player.prepare(); if ((mCmd.uri != null) && (mCmd.uri.getEncodedPath() != null) && (mCmd.uri.getEncodedPath().length() > 0)) { if (mCmd.looping) { audioManager.requestAudioFocus(null, mCmd.stream, AudioManager.AUDIOFOCUS_GAIN); } else { audioManager.requestAudioFocus(null, mCmd.stream, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK); } } player.setOnCompletionListener(NotificationPlayer.this); player.start(); if (mPlayer != null) { mPlayer.release(); } mPlayer = player; } catch (Exception e) { Log.w(mTag, "error loading sound for " + mCmd.uri, e); } mAudioManager = audioManager; this.notify(); } Looper.loop(); }</span>

  出处：http://blog.csdn.net/wdaming1986/article/details/7081787

你可能感兴趣的:(android,String,Stream,null,callback,notifications)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 每日一题——第九十题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 2024.9.6 Python，华为笔试题总结，字符串格式化，字符串操作，广度优先搜索解决公司组织绩效互评问题，无向图 RaidenQ python华为leetcode算法力扣广度优先无向图
    1.字符串格式化name="Alice"age=30formatted_string="Name:{},Age:{}".format(name,age)print(formatted_string)或者name="Alice"age=30formatted_string=f"Name:{name},Age:{age}"print(formatted_string)2.网络健康检查第一行有两个整数m
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • 非对称加密算法原理与应用2——RSA私钥加密文件 私语茶馆 云部署与开发架构及产品灵感记录RSA2048私钥加密
    作者：私语茶馆1.相关章节（1）非对称加密算法原理与应用1——秘钥的生成-CSDN博客第一章节讲述的是创建秘钥对，并将公钥和私钥导出为文件格式存储。本章节继续讲如何利用私钥加密内容，包括从密钥库或文件中读取私钥，并用RSA算法加密文件和String。2.私钥加密的概述本文主要基于第一章节的RSA2048bit的非对称加密算法讲述如何利用私钥加密文件。这种加密后的文件，只能由该私钥对应的公钥来解密。
  • leetcode-617. 合并二叉树 manba_ leetcodehot100leetcode算法
    题目描述给你两棵二叉树：root1和root2。想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为null的节点将直接作为新二叉树的节点。返回合并后的二叉树。注意:合并过程必须从两个树的根节点开始。示例1：输入：root1=[1,3,2,
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • Golang语言基础知识点总结 最帅猪猪侠 golang开发语言后端
    Golang语言基础知识点小总结1.go语言有两大类型：值类型：数值类型，bool，string，数组，struct结构体变量直接存储值，内存通常在栈中分配,修改值,不会对源对象产生影响引用类型：指针，slice切片，管道chan，map，interface变量存储的是一个地址，这个地址对应的空间才真正存储数据值，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾
  • string trim的实现 JamesSawyer
    if(typeofString.prototype.trim!=='function'){String.prototype.trim=function(){//这个正则的意思是//'^''$'表示结束和开始//'^\s*'表示任意以空格开头的空格//'\s*$'表示任意以空格结尾的空格//'\S*'表示任意非空字符//'$1'表示'(\S*(\s*\S*)*)'returnthis.replace
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • [Swift]LeetCode943. 最短超级串 | Find the Shortest Superstring 黄小二哥 swift
    ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★➤微信公众号：山青咏芝（shanqingyongzhi）➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）➤GitHub地址：https://github.com/strengthen/LeetCode➤原文地址：https://www.cnblogs.com/streng
  • [Swift]LeetCode767. 重构字符串 | Reorganize String weixin_30591551 swiftruntime
    ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★➤微信公众号：山青咏芝（shanqingyongzhi）➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）➤GitHub地址：https://github.com/strengthen/LeetCode➤原文地址：https://www.cnblogs.com/streng
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • golang获取用户输入的几种方式 余生逆风飞翔 golang开发语言后端
    一、定义结构体typeUserInfostruct{Namestring`json:"name"`Ageint`json:"age"`Addstring`json:"add"`}typeReturnDatastruct{Messagestring`json:"message"`Statusstring`json:"status"`DataUserInfo`json:"data"`}二、get请求的
  • ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your †徐先森® Oracle数据库Web相关错误集
    createtablestudents(idintunsignedprimarykeyauto_increment,namevarchar(50)notnull,ageintunsigned,highdecimal(3,2),genderenum('男','女','中性','保密','妖')default'保密',cls_idintunsigned);在对数据库插入如上带有中文带有默认值的字段的时
  • metaRTC5.0 API编程指南(一) metaRTC metaRTCc++c语言webrtc
    概述metaRTC5.0版本API进行了重构，本篇文章将介绍webrtc传输调用流程和例子。metaRTC5.0版本提供了C++和纯C两种接口。纯C接口YangPeerConnection头文件:include/yangrtc/YangPeerConnection.htypedefstruct{void*conn;YangAVInfo*avinfo;YangStreamConfigstreamco
  • Shell脚本中sed使用 jcrhl321 linux
    目录一、sed编辑器1、sed概述2、sed的工作流程3、sed命令的常见格式4、sed命令常用操作二、sed常用命令使用1、sed打印2、sed删除3、sed替换4、sed插入与增加4、sed剪切粘贴与复制粘贴一、sed编辑器sed（StreamEDitor）是一个强大而简单的文本解析转换工具，可以读取文本，并根据指定的条件对文本内容进行编辑（删除、替换、添加、移动等），最后输出所有行或者仅输出
  • java封装继承多态等 麦田的设计者 javaeclipsejvmcencapsulatopn
           最近一段时间看了很多的视频却忘记总结了，现在只能想到什么写什么了，希望能起到一个回忆巩固的作用。     1、final关键字       译为：最终的        &
  • F5与集群的区别 bijian1013 weblogic集群F5
            http请求配置不是通过集群，而是F5；集群是weblogic容器的，如果是ejb接口是通过集群。         F5同集群的差别，主要还是会话复制的问题，F5一把是分发http请求用的，因为http都是无状态的服务，无需关注会话问题，类似
  • LeetCode[Math] - #7 Reverse Integer Cwind java题解MathLeetCodeAlgorithm
    原题链接：#7 Reverse Integer   要求： 按位反转输入的数字 例1： 输入 x = 123, 返回 321 例2： 输入 x = -123, 返回 -321   难度：简单   分析： 对于一般情况，首先保存输入数字的符号，然后每次取输入的末位（x%10）作为输出的高位（result = result*10 + x%10）即可。但
  • BufferedOutputStream 周凡杨
         首先说一下这个大批量，是指有上千万的数据量。      例子：      有一张短信历史表，其数据有上千万条数据，要进行数据备份到文本文件，就是执行如下SQL然后将结果集写入到文件中！      select t.msisd
  • linux下模拟按键输入和鼠标 被触发 linux
    查看/dev/input/eventX是什么类型的事件， cat /proc/bus/input/devices 设备有着自己特殊的按键键码，我需要将一些标准的按键，比如0－9，X－Z等模拟成标准按键，比如KEY_0,KEY-Z等，所以需要用到按键 模拟，具体方法就是操作/dev/input/event1文件，向它写入个input_event结构体就可以模拟按键的输入了。 linux/in
  • ContentProvider初体验 肆无忌惮_ ContentProvider
    ContentProvider在安卓开发中非常重要。与Activity，Service，BroadcastReceiver并称安卓组件四大天王。 在android中的作用是用来对外共享数据。因为安卓程序的数据库文件存放在data/data/packagename里面，这里面的文件默认都是私有的，别的程序无法访问。 如果QQ游戏想访问手机QQ的帐号信息一键登录，那么就需要使用内容提供者COnte
  • 关于Spring MVC项目（maven）中通过fileupload上传文件 843977358 mybatisspring mvc修改头像上传文件upload
    Spring MVC 中通过fileupload上传文件，其中项目使用maven管理。   1.上传文件首先需要的是导入相关支持jar包：commons-fileupload.jar,commons-io.jar 因为我是用的maven管理项目，所以要在pom文件中配置（每个人的jar包位置根据实际情况定） <!-- 文件上传 start by zhangyd-c --&g
  • 使用svnkit api，纯java操作svn，实现svn提交，更新等操作 aigo svnkit
     原文：http://blog.csdn.net/hardwin/article/details/7963318   import java.io.File; import org.apache.log4j.Logger; import org.tmatesoft.svn.core.SVNCommitInfo; import org.tmateso
  • 对比浏览器，casperjs，httpclient的Header信息 alleni123 爬虫crawlerheader
    @Override protected void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException { String type=req.getParameter("type"); Enumeration es=re
  • java.io操作 DataInputStream和DataOutputStream基本数据流 百合不是茶 java流
    1，java中如果不保存整个对象，只保存类中的属性，那么我们可以使用本篇文章中的方法，如果要保存整个对象  先将类实例化  后面的文章将详细写到     2，DataInputStream 是java.io包中一个数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。
  • 车辆保险理赔案例 bijian1013 车险
    理赔案例： 一货运车，运输公司为车辆购买了机动车商业险和交强险，也买了安全生产责任险，运输一车烟花爆竹，在行驶途中发生爆炸，出现车毁、货损、司机亡、炸死一路人、炸毁一间民宅等惨剧，针对这几种情况，该如何赔付。 赔付建议和方案： 客户所买交强险在这里不起作用，因为交强险的赔付前提是：“机动车发生道路交通意外事故”； 如果是交通意外事故引发的爆炸，则优先适用交强险条款进行赔付，不足的部分由商业
  • 学习Spring必学的Java基础知识(5)—注解 bijian1013 javaspring
            文章来源：http://www.iteye.com/topic/1123823，整理在我的博客有两个目的：一个是原文确实很不错，通俗易懂，督促自已将博主的这一系列关于Spring文章都学完；另一个原因是为免原文被博主删除，在此记录，方便以后查找阅读。           有必要对
  • 【Struts2一】Struts2 Hello World bit1129 Hello world
    Struts2 Hello World应用的基本步骤 创建Struts2的Hello World应用，包括如下几步： 1.配置web.xml 2.创建Action 3.创建struts.xml，配置Action 4.启动web server，通过浏览器访问   配置web.xml <?xml version="1.0" encoding="
  • 【Avro二】Avro RPC框架 bit1129 rpc
    1. Avro RPC简介 1.1. RPC RPC逻辑上分为二层，一是传输层，负责网络通信；二是协议层，将数据按照一定协议格式打包和解包 从序列化方式来看，Apache Thrift 和Google的Protocol Buffers和Avro应该是属于同一个级别的框架，都能跨语言，性能优秀，数据精简，但是Avro的动态模式（不用生成代码，而且性能很好）这个特点让人非常喜欢，比较适合R
  • lua　set get cookie ronin47 lua cookie
    lua: local access_token = ngx.var.cookie_SGAccessToken if access_token then ngx.header["Set-Cookie"] = "SGAccessToken="..access_token.."; path=/;Max-Age=3000" end
  • java-打印不大于N的质数 bylijinnan java
    public class PrimeNumber { /** * 寻找不大于N的质数 */ public static void main(String[] args) { int n=100; PrimeNumber pn=new PrimeNumber(); pn.printPrimeNumber(n); System.out.print
  • Spring源码学习-PropertyPlaceholderHelper bylijinnan javaspring
    今天在看Spring 3.0.0.RELEASE的源码，发现PropertyPlaceholderHelper的一个bug 当时觉得奇怪，上网一搜，果然是个bug，不过早就有人发现了，且已经修复： 详见： http://forum.spring.io/forum/spring-projects/container/88107-propertyplaceholderhelper-bug
  • [逻辑与拓扑]布尔逻辑与拓扑结构的结合会产生什么? comsci 拓扑
       如果我们已经在一个工作流的节点中嵌入了可以进行逻辑推理的代码,那么成百上千个这样的节点如果组成一个拓扑网络,而这个网络是可以自动遍历的,非线性的拓扑计算模型和节点内部的布尔逻辑处理的结合,会产生什么样的结果呢?    是否可以形成一种新的模糊语言识别和处理模型呢?  大家有兴趣可以试试,用软件搞这些有个好处,就是花钱比较少,就算不成
  • ITEYE 都换百度推广了 cuisuqiang GoogleAdSense百度推广广告外快
    以前ITEYE的广告都是谷歌的Google AdSense，现在都换成百度推广了。   为什么个人博客设置里面还是Google AdSense呢？   都知道Google AdSense不好申请，这在ITEYE上也不是讨论了一两天了，强烈建议ITEYE换掉Google AdSense。至少，用一个好申请的吧。   什么时候能从ITEYE上来点外快，哪怕少点
  • 新浪微博技术架构分析 dalan_123 新浪微博架构
    新浪微博在短短一年时间内从零发展到五千万用户，我们的基层架构也发展了几个版本。第一版就是是非常快的，我们可以非常快的实现我们的模块。我们看一下技术特点，微博这个产品从架构上来分析，它需要解决的是发表和订阅的问题。我们第一版采用的是推的消息模式，假如说我们一个明星用户他有10万个粉丝，那就是说用户发表一条微博的时候，我们把这个微博消息攒成10万份，这样就是很简单了，第一版的架构实际上就是这两行字。第
  • 玩转ARP攻击 dcj3sjt126com r
    我写这片文章只是想让你明白深刻理解某一协议的好处。高手免看。如果有人利用这片文章所做的一切事情，盖不负责。 网上关于ARP的资料已经很多了，就不用我都说了。 用某一位高手的话来说，“我们能做的事情很多，唯一受限制的是我们的创造力和想象力”。 ARP也是如此。 以下讨论的机子有 一个要攻击的机子：10.5.4.178 硬件地址：52:54:4C:98
  • PHP编码规范 dcj3sjt126com 编码规范
    一、文件格式 1. 对于只含有 php 代码的文件，我们将在文件结尾处忽略掉 "?>" 。这是为了防止多余的空格或者其它字符影响到代码。例如：<?php$foo = 'foo';2. 缩进应该能够反映出代码的逻辑结果，尽量使用四个空格，禁止使用制表符TAB，因为这样能够保证有跨客户端编程器软件的灵活性。例
  • linux 脱机管理（nohup） eksliang linux nohupnohup
    脱机管理 nohup 转载请出自出处：http://eksliang.iteye.com/blog/2166699 nohup可以让你在脱机或者注销系统后，还能够让工作继续进行。他的语法如下 nohup [命令与参数] --在终端机前台工作 nohup [命令与参数] & --在终端机后台工作   但是这个命令需要注意的是，nohup并不支持bash的内置命令，所
  • BusinessObjects Enterprise Java SDK greemranqq javaBOSAPCrystal Reports
    最近项目用到oracle_ADF  从SAP/BO 上调用 水晶报表，资料比较少，我做一个简单的分享，给和我一样的新手 提供更多的便利。   首先，我是尝试用JAVA JSP 去访问的。   官方API：http://devlibrary.businessobjects.com/BusinessObjectsxi/en/en/BOE_SDK/boesdk_ja
  • 系统负载剧变下的管控策略 iamzhongyong 高并发
    假如目前的系统有100台机器，能够支撑每天1亿的点击量（这个就简单比喻一下），然后系统流量剧变了要，我如何应对，系统有那些策略可以处理，这里总结了一下之前的一些做法。 1、水平扩展 这个最容易理解，加机器，这样的话对于系统刚刚开始的伸缩性设计要求比较高，能够非常灵活的添加机器，来应对流量的变化。 2、系统分组 假如系统服务的业务不同，有优先级高的，有优先级低的，那就让不同的业务调用提前分组
  • BitTorrent DHT 协议中文翻译 justjavac bit
    前言 做了一个磁力链接和BT种子的搜索引擎 {Magnet & Torrent}，因此把 DHT 协议重新看了一遍。 BEP: 5Title: DHT ProtocolVersion: 3dec52cb3ae103ce22358e3894b31cad47a6f22bLast-Modified: Tue Apr 2 16:51:45 2013 -070
  • Ubuntu下Java环境的搭建 macroli java工作ubuntu
    配置命令： 　　$sudo apt-get install ubuntu-restricted-extras 　　再运行如下命令： 　　$sudo apt-get install sun-java6-jdk 　　待安装完毕后选择默认Java. 　　$sudo update- alternatives --config java 　　安装过程提示选择，输入“2”即可，然后按回车键确定。
  • js字符串转日期（兼容IE所有版本） qiaolevip TODateStringIE
    /** * 字符串转时间（yyyy-MM-dd HH:mm:ss） * result （分钟） */ stringToDate : function(fDate){ var fullDate = fDate.split(" ")[0].split("-"); var fullTime = fDate.split("
  • 【数据挖掘学习】关联规则算法Apriori的学习与SQL简单实现购物篮分析 superlxw1234 sql数据挖掘关联规则
    关联规则挖掘用于寻找给定数据集中项之间的有趣的关联或相关关系。 关联规则揭示了数据项间的未知的依赖关系，根据所挖掘的关联关系，可以从一个数据对象的信息来推断另一个数据对象的信息。 例如购物篮分析。牛奶 ⇒ 面包 [支持度：3%，置信度：40%] 支持度3%：意味3%顾客同时购买牛奶和面包。 置信度40%：意味购买牛奶的顾客40%也购买面包。 规则的支持度和置信度是两个规则兴
  • Spring 5.0 的系统需求，期待你的反馈 wiselyman spring
                   Spring 5.0将在2016年发布。Spring5.0将支持JDK 9。          Spring 5.0的特性计划还在工作中，请保持关注，所以作者希望从使用者得到关于Spring 5.0系统需求方面的反馈。  
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他