Notification.java revision f54bfcf5a3594d7d8423391be68d9b982ea6c4fa
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
17package android.app;
18
19import com.android.internal.R;
20
21import android.content.Context;
22import android.content.Intent;
23import android.graphics.Bitmap;
24import android.media.AudioManager;
25import android.net.Uri;
26import android.os.Bundle;
27import android.os.IBinder;
28import android.os.Parcel;
29import android.os.Parcelable;
30import android.os.SystemClock;
31import android.text.TextUtils;
32import android.util.IntProperty;
33import android.util.Log;
34import android.view.View;
35import android.widget.ProgressBar;
36import android.widget.RemoteViews;
37
38import java.text.NumberFormat;
39import java.util.ArrayList;
40
41/**
42 * A class that represents how a persistent notification is to be presented to
43 * the user using the {@link android.app.NotificationManager}.
44 *
45 * <p>The {@link Notification.Builder Notification.Builder} has been added to make it
46 * easier to construct Notifications.</p>
47 *
48 * <div class="special reference">
49 * <h3>Developer Guides</h3>
50 * <p>For a guide to creating notifications, read the
51 * <a href="{@docRoot}guide/topics/ui/notifiers/notifications.html">Status Bar Notifications</a>
52 * developer guide.</p>
53 * </div>
54 */
55public class Notification implements Parcelable
56{
57    /**
58     * Use all default values (where applicable).
59     */
60    public static final int DEFAULT_ALL = ~0;
61
62    /**
63     * Use the default notification sound. This will ignore any given
64     * {@link #sound}.
65     *
66
67     * @see #defaults
68     */
69
70    public static final int DEFAULT_SOUND = 1;
71
72    /**
73     * Use the default notification vibrate. This will ignore any given
74     * {@link #vibrate}. Using phone vibration requires the
75     * {@link android.Manifest.permission#VIBRATE VIBRATE} permission.
76     *
77     * @see #defaults
78     */
79
80    public static final int DEFAULT_VIBRATE = 2;
81
82    /**
83     * Use the default notification lights. This will ignore the
84     * {@link #FLAG_SHOW_LIGHTS} bit, and {@link #ledARGB}, {@link #ledOffMS}, or
85     * {@link #ledOnMS}.
86     *
87     * @see #defaults
88     */
89
90    public static final int DEFAULT_LIGHTS = 4;
91
92    /**
93     * A timestamp related to this notification, in milliseconds since the epoch.
94     *
95     * Default value: {@link System#currentTimeMillis() Now}.
96     *
97     * Choose a timestamp that will be most relevant to the user. For most finite events, this
98     * corresponds to the time the event happened (or will happen, in the case of events that have
99     * yet to occur but about which the user is being informed). Indefinite events should be
100     * timestamped according to when the activity began.
101     *
102     * Some examples:
103     *
104     * <ul>
105     *   <li>Notification of a new chat message should be stamped when the message was received.</li>
106     *   <li>Notification of an ongoing file download (with a progress bar, for example) should be stamped when the download started.</li>
107     *   <li>Notification of a completed file download should be stamped when the download finished.</li>
108     *   <li>Notification of an upcoming meeting should be stamped with the time the meeting will begin (that is, in the future).</li>
109     *   <li>Notification of an ongoing stopwatch (increasing timer) should be stamped with the watch's start time.
110     *   <li>Notification of an ongoing countdown timer should be stamped with the timer's end time.
111     * </ul>
112     *
113     */
114    public long when;
115
116    /**
117     * The resource id of a drawable to use as the icon in the status bar.
118     * This is required; notifications with an invalid icon resource will not be shown.
119     */
120    public int icon;
121
122    /**
123     * If the icon in the status bar is to have more than one level, you can set this.  Otherwise,
124     * leave it at its default value of 0.
125     *
126     * @see android.widget.ImageView#setImageLevel
127     * @see android.graphics.drawable#setLevel
128     */
129    public int iconLevel;
130
131    /**
132     * The number of events that this notification represents. For example, in a new mail
133     * notification, this could be the number of unread messages.
134     *
135     * The system may or may not use this field to modify the appearance of the notification. For
136     * example, before {@link android.os.Build.VERSION_CODES#HONEYCOMB}, this number was
137     * superimposed over the icon in the status bar. Starting with
138     * {@link android.os.Build.VERSION_CODES#HONEYCOMB}, the template used by
139     * {@link Notification.Builder} has displayed the number in the expanded notification view.
140     *
141     * If the number is 0 or negative, it is never shown.
142     */
143    public int number;
144
145    /**
146     * The intent to execute when the expanded status entry is clicked.  If
147     * this is an activity, it must include the
148     * {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK} flag, which requires
149     * that you take care of task management as described in the
150     * <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
151     * Stack</a> document.  In particular, make sure to read the notification section
152     * <a href="{@docRoot}guide/topics/ui/notifiers/notifications.html#HandlingNotifications">Handling
153     * Notifications</a> for the correct ways to launch an application from a
154     * notification.
155     */
156    public PendingIntent contentIntent;
157
158    /**
159     * The intent to execute when the notification is explicitly dismissed by the user, either with
160     * the "Clear All" button or by swiping it away individually.
161     *
162     * This probably shouldn't be launching an activity since several of those will be sent
163     * at the same time.
164     */
165    public PendingIntent deleteIntent;
166
167    /**
168     * An intent to launch instead of posting the notification to the status bar.
169     *
170     * @see Notification.Builder#setFullScreenIntent
171     */
172    public PendingIntent fullScreenIntent;
173
174    /**
175     * Text to scroll across the screen when this item is added to
176     * the status bar on large and smaller devices.
177     *
178     * @see #tickerView
179     */
180    public CharSequence tickerText;
181
182    /**
183     * The view to show as the ticker in the status bar when the notification
184     * is posted.
185     */
186    public RemoteViews tickerView;
187
188    /**
189     * The view that will represent this notification in the expanded status bar.
190     */
191    public RemoteViews contentView;
192
193    /**
194     * A large-format version of {@link #contentView}, giving the Notification an
195     * opportunity to show more detail. The system UI may choose to show this
196     * instead of the normal content view at its discretion.
197     */
198    public RemoteViews bigContentView;
199
200    /**
201     * The bitmap that may escape the bounds of the panel and bar.
202     */
203    public Bitmap largeIcon;
204
205    /**
206     * The sound to play.
207     *
208     * <p>
209     * To play the default notification sound, see {@link #defaults}.
210     * </p>
211     */
212    public Uri sound;
213
214    /**
215     * Use this constant as the value for audioStreamType to request that
216     * the default stream type for notifications be used.  Currently the
217     * default stream type is {@link AudioManager#STREAM_NOTIFICATION}.
218     */
219    public static final int STREAM_DEFAULT = -1;
220
221    /**
222     * The audio stream type to use when playing the sound.
223     * Should be one of the STREAM_ constants from
224     * {@link android.media.AudioManager}.
225     */
226    public int audioStreamType = STREAM_DEFAULT;
227
228    /**
229     * The pattern with which to vibrate.
230     *
231     * <p>
232     * To vibrate the default pattern, see {@link #defaults}.
233     * </p>
234     *
235     * @see android.os.Vibrator#vibrate(long[],int)
236     */
237    public long[] vibrate;
238
239    /**
240     * The color of the led.  The hardware will do its best approximation.
241     *
242     * @see #FLAG_SHOW_LIGHTS
243     * @see #flags
244     */
245    public int ledARGB;
246
247    /**
248     * The number of milliseconds for the LED to be on while it's flashing.
249     * The hardware will do its best approximation.
250     *
251     * @see #FLAG_SHOW_LIGHTS
252     * @see #flags
253     */
254    public int ledOnMS;
255
256    /**
257     * The number of milliseconds for the LED to be off while it's flashing.
258     * The hardware will do its best approximation.
259     *
260     * @see #FLAG_SHOW_LIGHTS
261     * @see #flags
262     */
263    public int ledOffMS;
264
265    /**
266     * Specifies which values should be taken from the defaults.
267     * <p>
268     * To set, OR the desired from {@link #DEFAULT_SOUND},
269     * {@link #DEFAULT_VIBRATE}, {@link #DEFAULT_LIGHTS}. For all default
270     * values, use {@link #DEFAULT_ALL}.
271     * </p>
272     */
273    public int defaults;
274
275    /**
276     * Bit to be bitwise-ored into the {@link #flags} field that should be
277     * set if you want the LED on for this notification.
278     * <ul>
279     * <li>To turn the LED off, pass 0 in the alpha channel for colorARGB
280     *      or 0 for both ledOnMS and ledOffMS.</li>
281     * <li>To turn the LED on, pass 1 for ledOnMS and 0 for ledOffMS.</li>
282     * <li>To flash the LED, pass the number of milliseconds that it should
283     *      be on and off to ledOnMS and ledOffMS.</li>
284     * </ul>
285     * <p>
286     * Since hardware varies, you are not guaranteed that any of the values
287     * you pass are honored exactly.  Use the system defaults (TODO) if possible
288     * because they will be set to values that work on any given hardware.
289     * <p>
290     * The alpha channel must be set for forward compatibility.
291     *
292     */
293    public static final int FLAG_SHOW_LIGHTS        = 0x00000001;
294
295    /**
296     * Bit to be bitwise-ored into the {@link #flags} field that should be
297     * set if this notification is in reference to something that is ongoing,
298     * like a phone call.  It should not be set if this notification is in
299     * reference to something that happened at a particular point in time,
300     * like a missed phone call.
301     */
302    public static final int FLAG_ONGOING_EVENT      = 0x00000002;
303
304    /**
305     * Bit to be bitwise-ored into the {@link #flags} field that if set,
306     * the audio will be repeated until the notification is
307     * cancelled or the notification window is opened.
308     */
309    public static final int FLAG_INSISTENT          = 0x00000004;
310
311    /**
312     * Bit to be bitwise-ored into the {@link #flags} field that should be
313     * set if you want the sound and/or vibration play each time the
314     * notification is sent, even if it has not been canceled before that.
315     */
316    public static final int FLAG_ONLY_ALERT_ONCE    = 0x00000008;
317
318    /**
319     * Bit to be bitwise-ored into the {@link #flags} field that should be
320     * set if the notification should be canceled when it is clicked by the
321     * user.  On tablets, the
322
323     */
324    public static final int FLAG_AUTO_CANCEL        = 0x00000010;
325
326    /**
327     * Bit to be bitwise-ored into the {@link #flags} field that should be
328     * set if the notification should not be canceled when the user clicks
329     * the Clear all button.
330     */
331    public static final int FLAG_NO_CLEAR           = 0x00000020;
332
333    /**
334     * Bit to be bitwise-ored into the {@link #flags} field that should be
335     * set if this notification represents a currently running service.  This
336     * will normally be set for you by {@link Service#startForeground}.
337     */
338    public static final int FLAG_FOREGROUND_SERVICE = 0x00000040;
339
340    /**
341     * Obsolete flag indicating high-priority notifications; use the priority field instead.
342     *
343     * @deprecated Use {@link #priority} with a positive value.
344     */
345    public static final int FLAG_HIGH_PRIORITY      = 0x00000080;
346
347    public int flags;
348
349    /**
350     * Default notification {@link #priority}. If your application does not prioritize its own
351     * notifications, use this value for all notifications.
352     */
353    public static final int PRIORITY_DEFAULT = 0;
354
355    /**
356     * Lower {@link #priority}, for items that are less important. The UI may choose to show these
357     * items smaller, or at a different position in the list, compared with your app's
358     * {@link #PRIORITY_DEFAULT} items.
359     */
360    public static final int PRIORITY_LOW = -1;
361
362    /**
363     * Lowest {@link #priority}; these items might not be shown to the user except under special
364     * circumstances, such as detailed notification logs.
365     */
366    public static final int PRIORITY_MIN = -2;
367
368    /**
369     * Higher {@link #priority}, for more important notifications or alerts. The UI may choose to
370     * show these items larger, or at a different position in notification lists, compared with
371     * your app's {@link #PRIORITY_DEFAULT} items.
372     */
373    public static final int PRIORITY_HIGH = 1;
374
375    /**
376     * Highest {@link #priority}, for your application's most important items that require the
377     * user's prompt attention or input.
378     */
379    public static final int PRIORITY_MAX = 2;
380
381    /**
382     * Relative priority for this notification.
383     *
384     * Priority is an indication of how much of the user's valuable attention should be consumed by
385     * this notification. Low-priority notifications may be hidden from the user in certain
386     * situations, while the user might be interrupted for a higher-priority notification. The
387     * system will make a determination about how to interpret notification priority as described in
388     * MUMBLE MUMBLE.
389     */
390    public int priority;
391
392    /**
393     * @hide
394     * Notification type: incoming call (voice or video) or similar synchronous communication request.
395     */
396    public static final String KIND_CALL = "android.call";
397
398    /**
399     * @hide
400     * Notification type: incoming direct message (SMS, instant message, etc.).
401     */
402    public static final String KIND_MESSAGE = "android.message";
403
404    /**
405     * @hide
406     * Notification type: asynchronous bulk message (email).
407     */
408    public static final String KIND_EMAIL = "android.email";
409
410    /**
411     * @hide
412     * Notification type: calendar event.
413     */
414    public static final String KIND_EVENT = "android.event";
415
416    /**
417     * Notification type: promotion or advertisement.
418     */
419    public static final String KIND_PROMO = "android.promo";
420
421    /**
422     * @hide
423     * If this notification matches of one or more special types (see the <code>KIND_*</code>
424     * constants), add them here, best match first.
425     */
426    public String[] kind;
427
428    /**
429     * Extra key for people values (type TBD).
430     *
431     * @hide
432     */
433    public static final String EXTRA_PEOPLE = "android.people";
434
435    private Bundle extras;
436
437    /**
438     * Structure to encapsulate an "action", including title and icon, that can be attached to a Notification.
439     * @hide
440     */
441    private static class Action implements Parcelable {
442        public int icon;
443        public CharSequence title;
444        public PendingIntent actionIntent;
445        @SuppressWarnings("unused")
446        public Action() { }
447        private Action(Parcel in) {
448            icon = in.readInt();
449            title = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
450            if (in.readInt() == 1) {
451                actionIntent = PendingIntent.CREATOR.createFromParcel(in);
452            }
453        }
454        public Action(int icon_, CharSequence title_, PendingIntent intent_) {
455            this.icon = icon_;
456            this.title = title_;
457            this.actionIntent = intent_;
458        }
459        @Override
460        public Action clone() {
461            return new Action(
462                this.icon,
463                this.title.toString(),
464                this.actionIntent // safe to alias
465            );
466        }
467        @Override
468        public int describeContents() {
469            return 0;
470        }
471        @Override
472        public void writeToParcel(Parcel out, int flags) {
473            out.writeInt(icon);
474            TextUtils.writeToParcel(title, out, flags);
475            if (actionIntent != null) {
476                out.writeInt(1);
477                actionIntent.writeToParcel(out, flags);
478            } else {
479                out.writeInt(0);
480            }
481        }
482        public static final Parcelable.Creator<Action> CREATOR
483        = new Parcelable.Creator<Action>() {
484            public Action createFromParcel(Parcel in) {
485                return new Action(in);
486            }
487            public Action[] newArray(int size) {
488                return new Action[size];
489            }
490        };
491    }
492
493    private Action[] actions;
494
495    /**
496     * Constructs a Notification object with default values.
497     * You might want to consider using {@link Builder} instead.
498     */
499    public Notification()
500    {
501        this.when = System.currentTimeMillis();
502        this.priority = PRIORITY_DEFAULT;
503    }
504
505    /**
506     * @hide
507     */
508    public Notification(Context context, int icon, CharSequence tickerText, long when,
509            CharSequence contentTitle, CharSequence contentText, Intent contentIntent)
510    {
511        this.when = when;
512        this.icon = icon;
513        this.tickerText = tickerText;
514        setLatestEventInfo(context, contentTitle, contentText,
515                PendingIntent.getActivity(context, 0, contentIntent, 0));
516    }
517
518    /**
519     * Constructs a Notification object with the information needed to
520     * have a status bar icon without the standard expanded view.
521     *
522     * @param icon          The resource id of the icon to put in the status bar.
523     * @param tickerText    The text that flows by in the status bar when the notification first
524     *                      activates.
525     * @param when          The time to show in the time field.  In the System.currentTimeMillis
526     *                      timebase.
527     *
528     * @deprecated Use {@link Builder} instead.
529     */
530    @Deprecated
531    public Notification(int icon, CharSequence tickerText, long when)
532    {
533        this.icon = icon;
534        this.tickerText = tickerText;
535        this.when = when;
536    }
537
538    /**
539     * Unflatten the notification from a parcel.
540     */
541    public Notification(Parcel parcel)
542    {
543        int version = parcel.readInt();
544
545        when = parcel.readLong();
546        icon = parcel.readInt();
547        number = parcel.readInt();
548        if (parcel.readInt() != 0) {
549            contentIntent = PendingIntent.CREATOR.createFromParcel(parcel);
550        }
551        if (parcel.readInt() != 0) {
552            deleteIntent = PendingIntent.CREATOR.createFromParcel(parcel);
553        }
554        if (parcel.readInt() != 0) {
555            tickerText = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(parcel);
556        }
557        if (parcel.readInt() != 0) {
558            tickerView = RemoteViews.CREATOR.createFromParcel(parcel);
559        }
560        if (parcel.readInt() != 0) {
561            contentView = RemoteViews.CREATOR.createFromParcel(parcel);
562        }
563        if (parcel.readInt() != 0) {
564            largeIcon = Bitmap.CREATOR.createFromParcel(parcel);
565        }
566        defaults = parcel.readInt();
567        flags = parcel.readInt();
568        if (parcel.readInt() != 0) {
569            sound = Uri.CREATOR.createFromParcel(parcel);
570        }
571
572        audioStreamType = parcel.readInt();
573        vibrate = parcel.createLongArray();
574        ledARGB = parcel.readInt();
575        ledOnMS = parcel.readInt();
576        ledOffMS = parcel.readInt();
577        iconLevel = parcel.readInt();
578
579        if (parcel.readInt() != 0) {
580            fullScreenIntent = PendingIntent.CREATOR.createFromParcel(parcel);
581        }
582
583        priority = parcel.readInt();
584
585        kind = parcel.createStringArray(); // may set kind to null
586
587        if (parcel.readInt() != 0) {
588            extras = parcel.readBundle();
589        }
590
591        actions = parcel.createTypedArray(Action.CREATOR);
592        if (parcel.readInt() != 0) {
593            bigContentView = RemoteViews.CREATOR.createFromParcel(parcel);
594        }
595    }
596
597    @Override
598    public Notification clone() {
599        Notification that = new Notification();
600
601        that.when = this.when;
602        that.icon = this.icon;
603        that.number = this.number;
604
605        // PendingIntents are global, so there's no reason (or way) to clone them.
606        that.contentIntent = this.contentIntent;
607        that.deleteIntent = this.deleteIntent;
608        that.fullScreenIntent = this.fullScreenIntent;
609
610        if (this.tickerText != null) {
611            that.tickerText = this.tickerText.toString();
612        }
613        if (this.tickerView != null) {
614            that.tickerView = this.tickerView.clone();
615        }
616        if (this.contentView != null) {
617            that.contentView = this.contentView.clone();
618        }
619        if (this.largeIcon != null) {
620            that.largeIcon = Bitmap.createBitmap(this.largeIcon);
621        }
622        that.iconLevel = this.iconLevel;
623        that.sound = this.sound; // android.net.Uri is immutable
624        that.audioStreamType = this.audioStreamType;
625
626        final long[] vibrate = this.vibrate;
627        if (vibrate != null) {
628            final int N = vibrate.length;
629            final long[] vib = that.vibrate = new long[N];
630            System.arraycopy(vibrate, 0, vib, 0, N);
631        }
632
633        that.ledARGB = this.ledARGB;
634        that.ledOnMS = this.ledOnMS;
635        that.ledOffMS = this.ledOffMS;
636        that.defaults = this.defaults;
637
638        that.flags = this.flags;
639
640        that.priority = this.priority;
641
642        final String[] thiskind = this.kind;
643        if (thiskind != null) {
644            final int N = thiskind.length;
645            final String[] thatkind = that.kind = new String[N];
646            System.arraycopy(thiskind, 0, thatkind, 0, N);
647        }
648
649        if (this.extras != null) {
650            that.extras = new Bundle(this.extras);
651
652        }
653
654        that.actions = new Action[this.actions.length];
655        for(int i=0; i<this.actions.length; i++) {
656            that.actions[i] = this.actions[i].clone();
657        }
658        if (this.bigContentView != null) {
659            that.bigContentView = this.bigContentView.clone();
660        }
661
662        return that;
663    }
664
665    public int describeContents() {
666        return 0;
667    }
668
669    /**
670     * Flatten this notification from a parcel.
671     */
672    public void writeToParcel(Parcel parcel, int flags)
673    {
674        parcel.writeInt(1);
675
676        parcel.writeLong(when);
677        parcel.writeInt(icon);
678        parcel.writeInt(number);
679        if (contentIntent != null) {
680            parcel.writeInt(1);
681            contentIntent.writeToParcel(parcel, 0);
682        } else {
683            parcel.writeInt(0);
684        }
685        if (deleteIntent != null) {
686            parcel.writeInt(1);
687            deleteIntent.writeToParcel(parcel, 0);
688        } else {
689            parcel.writeInt(0);
690        }
691        if (tickerText != null) {
692            parcel.writeInt(1);
693            TextUtils.writeToParcel(tickerText, parcel, flags);
694        } else {
695            parcel.writeInt(0);
696        }
697        if (tickerView != null) {
698            parcel.writeInt(1);
699            tickerView.writeToParcel(parcel, 0);
700        } else {
701            parcel.writeInt(0);
702        }
703        if (contentView != null) {
704            parcel.writeInt(1);
705            contentView.writeToParcel(parcel, 0);
706        } else {
707            parcel.writeInt(0);
708        }
709        if (largeIcon != null) {
710            parcel.writeInt(1);
711            largeIcon.writeToParcel(parcel, 0);
712        } else {
713            parcel.writeInt(0);
714        }
715
716        parcel.writeInt(defaults);
717        parcel.writeInt(this.flags);
718
719        if (sound != null) {
720            parcel.writeInt(1);
721            sound.writeToParcel(parcel, 0);
722        } else {
723            parcel.writeInt(0);
724        }
725        parcel.writeInt(audioStreamType);
726        parcel.writeLongArray(vibrate);
727        parcel.writeInt(ledARGB);
728        parcel.writeInt(ledOnMS);
729        parcel.writeInt(ledOffMS);
730        parcel.writeInt(iconLevel);
731
732        if (fullScreenIntent != null) {
733            parcel.writeInt(1);
734            fullScreenIntent.writeToParcel(parcel, 0);
735        } else {
736            parcel.writeInt(0);
737        }
738
739        parcel.writeInt(priority);
740
741        parcel.writeStringArray(kind); // ok for null
742
743        if (extras != null) {
744            parcel.writeInt(1);
745            extras.writeToParcel(parcel, 0);
746        } else {
747            parcel.writeInt(0);
748        }
749
750        parcel.writeTypedArray(actions, 0);
751
752        if (bigContentView != null) {
753            parcel.writeInt(1);
754            bigContentView.writeToParcel(parcel, 0);
755        } else {
756            parcel.writeInt(0);
757        }
758    }
759
760    /**
761     * Parcelable.Creator that instantiates Notification objects
762     */
763    public static final Parcelable.Creator<Notification> CREATOR
764            = new Parcelable.Creator<Notification>()
765    {
766        public Notification createFromParcel(Parcel parcel)
767        {
768            return new Notification(parcel);
769        }
770
771        public Notification[] newArray(int size)
772        {
773            return new Notification[size];
774        }
775    };
776
777    /**
778     * Sets the {@link #contentView} field to be a view with the standard "Latest Event"
779     * layout.
780     *
781     * <p>Uses the {@link #icon} and {@link #when} fields to set the icon and time fields
782     * in the view.</p>
783     * @param context       The context for your application / activity.
784     * @param contentTitle The title that goes in the expanded entry.
785     * @param contentText  The text that goes in the expanded entry.
786     * @param contentIntent The intent to launch when the user clicks the expanded notification.
787     * If this is an activity, it must include the
788     * {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK} flag, which requires
789     * that you take care of task management as described in the
790     * <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
791     * Stack</a> document.
792     *
793     * @deprecated Use {@link Builder} instead.
794     */
795    @Deprecated
796    public void setLatestEventInfo(Context context,
797            CharSequence contentTitle, CharSequence contentText, PendingIntent contentIntent) {
798        // TODO: rewrite this to use Builder
799        RemoteViews contentView = new RemoteViews(context.getPackageName(),
800                R.layout.notification_template_base);
801        if (this.icon != 0) {
802            contentView.setImageViewResource(R.id.icon, this.icon);
803        }
804        if (priority < PRIORITY_LOW) {
805            contentView.setInt(R.id.icon,
806                    "setBackgroundResource", R.drawable.notification_template_icon_low_bg);
807            contentView.setInt(R.id.status_bar_latest_event_content,
808                    "setBackgroundResource", R.drawable.notification_bg_low);
809        }
810        if (contentTitle != null) {
811            contentView.setTextViewText(R.id.title, contentTitle);
812        }
813        if (contentText != null) {
814            contentView.setTextViewText(R.id.text, contentText);
815        }
816        if (this.when != 0) {
817            contentView.setViewVisibility(R.id.time, View.VISIBLE);
818            contentView.setLong(R.id.time, "setTime", when);
819        }
820        if (this.number != 0) {
821            NumberFormat f = NumberFormat.getIntegerInstance();
822            contentView.setTextViewText(R.id.info, f.format(this.number));
823        }
824
825        this.contentView = contentView;
826        this.contentIntent = contentIntent;
827    }
828
829    @Override
830    public String toString() {
831        StringBuilder sb = new StringBuilder();
832        sb.append("Notification(pri=");
833        sb.append(priority);
834        sb.append(" contentView=");
835        if (contentView != null) {
836            sb.append(contentView.getPackage());
837            sb.append("/0x");
838            sb.append(Integer.toHexString(contentView.getLayoutId()));
839        } else {
840            sb.append("null");
841        }
842        // TODO(dsandler): defaults take precedence over local values, so reorder the branches below
843        sb.append(" vibrate=");
844        if (this.vibrate != null) {
845            int N = this.vibrate.length-1;
846            sb.append("[");
847            for (int i=0; i<N; i++) {
848                sb.append(this.vibrate[i]);
849                sb.append(',');
850            }
851            if (N != -1) {
852                sb.append(this.vibrate[N]);
853            }
854            sb.append("]");
855        } else if ((this.defaults & DEFAULT_VIBRATE) != 0) {
856            sb.append("default");
857        } else {
858            sb.append("null");
859        }
860        sb.append(" sound=");
861        if (this.sound != null) {
862            sb.append(this.sound.toString());
863        } else if ((this.defaults & DEFAULT_SOUND) != 0) {
864            sb.append("default");
865        } else {
866            sb.append("null");
867        }
868        sb.append(" defaults=0x");
869        sb.append(Integer.toHexString(this.defaults));
870        sb.append(" flags=0x");
871        sb.append(Integer.toHexString(this.flags));
872        sb.append(" kind=[");
873        if (this.kind == null) {
874            sb.append("null");
875        } else {
876            for (int i=0; i<this.kind.length; i++) {
877                if (i>0) sb.append(",");
878                sb.append(this.kind[i]);
879            }
880        }
881        sb.append("]");
882        if (actions != null) {
883            sb.append(" ");
884            sb.append(actions.length);
885            sb.append(" action");
886            if (actions.length > 1) sb.append("s");
887        }
888        sb.append(")");
889        return sb.toString();
890    }
891
892    /**
893     * Builder class for {@link Notification} objects.
894     *
895     * Provides a convenient way to set the various fields of a {@link Notification} and generate
896     * content views using the platform's notification layout template.
897     *
898     * Example:
899     *
900     * <pre class="prettyprint">
901     * Notification noti = new Notification.Builder()
902     *         .setContentTitle(&quot;New mail from &quot; + sender.toString())
903     *         .setContentText(subject)
904     *         .setSmallIcon(R.drawable.new_mail)
905     *         .setLargeIcon(aBitmap)
906     *         .build();
907     * </pre>
908     */
909    public static class Builder {
910        private Context mContext;
911
912        private long mWhen;
913        private int mSmallIcon;
914        private int mSmallIconLevel;
915        private int mNumber;
916        private CharSequence mContentTitle;
917        private CharSequence mContentText;
918        private CharSequence mContentInfo;
919        private CharSequence mSubText;
920        private PendingIntent mContentIntent;
921        private RemoteViews mContentView;
922        private PendingIntent mDeleteIntent;
923        private PendingIntent mFullScreenIntent;
924        private CharSequence mTickerText;
925        private RemoteViews mTickerView;
926        private Bitmap mLargeIcon;
927        private Uri mSound;
928        private int mAudioStreamType;
929        private long[] mVibrate;
930        private int mLedArgb;
931        private int mLedOnMs;
932        private int mLedOffMs;
933        private int mDefaults;
934        private int mFlags;
935        private int mProgressMax;
936        private int mProgress;
937        private boolean mProgressIndeterminate;
938        private ArrayList<String> mKindList = new ArrayList<String>(1);
939        private Bundle mExtras;
940        private int mPriority;
941        private ArrayList<Action> mActions = new ArrayList<Action>(3);
942        private boolean mUseChronometer;
943        private Style mStyle;
944
945        /**
946         * Constructs a new Builder with the defaults:
947         *
948
949         * <table>
950         * <tr><th align=right>priority</th>
951         *     <td>{@link #PRIORITY_DEFAULT}</td></tr>
952         * <tr><th align=right>when</th>
953         *     <td>now ({@link System#currentTimeMillis()})</td></tr>
954         * <tr><th align=right>audio stream</th>
955         *     <td>{@link #STREAM_DEFAULT}</td></tr>
956         * </table>
957         *
958
959         * @param context
960         *            A {@link Context} that will be used by the Builder to construct the
961         *            RemoteViews. The Context will not be held past the lifetime of this Builder
962         *            object.
963         */
964        public Builder(Context context) {
965            mContext = context;
966
967            // Set defaults to match the defaults of a Notification
968            mWhen = System.currentTimeMillis();
969            mAudioStreamType = STREAM_DEFAULT;
970            mPriority = PRIORITY_DEFAULT;
971        }
972
973        /**
974         * Add a timestamp pertaining to the notification (usually the time the event occurred).
975         *
976
977         * @see Notification#when
978         */
979        public Builder setWhen(long when) {
980            mWhen = when;
981            return this;
982        }
983
984        /**
985         * Show the {@link Notification#when} field as a stopwatch.
986         *
987         * Instead of presenting <code>when</code> as a timestamp, the notification will show an
988         * automatically updating display of the minutes and seconds since <code>when</code>.
989         *
990         * Useful when showing an elapsed time (like an ongoing phone call).
991         *
992         * @see android.widget.Chronometer
993         * @see Notification#when
994         */
995        public Builder setUsesChronometer(boolean b) {
996            mUseChronometer = b;
997            return this;
998        }
999
1000        /**
1001         * Set the small icon resource, which will be used to represent the notification in the
1002         * status bar.
1003         *
1004
1005         * The platform template for the expanded view will draw this icon in the left, unless a
1006         * {@link #setLargeIcon(Bitmap) large icon} has also been specified, in which case the small
1007         * icon will be moved to the right-hand side.
1008         *
1009
1010         * @param icon
1011         *            A resource ID in the application's package of the drawable to use.
1012         * @see Notification#icon
1013         */
1014        public Builder setSmallIcon(int icon) {
1015            mSmallIcon = icon;
1016            return this;
1017        }
1018
1019        /**
1020         * A variant of {@link #setSmallIcon(int) setSmallIcon(int)} that takes an additional
1021         * level parameter for when the icon is a {@link android.graphics.drawable.LevelListDrawable
1022         * LevelListDrawable}.
1023         *
1024         * @param icon A resource ID in the application's package of the drawable to use.
1025         * @param level The level to use for the icon.
1026         *
1027         * @see Notification#icon
1028         * @see Notification#iconLevel
1029         */
1030        public Builder setSmallIcon(int icon, int level) {
1031            mSmallIcon = icon;
1032            mSmallIconLevel = level;
1033            return this;
1034        }
1035
1036        /**
1037         * Set the first line of text in the platform notification template.
1038         */
1039        public Builder setContentTitle(CharSequence title) {
1040            mContentTitle = title;
1041            return this;
1042        }
1043
1044        /**
1045         * Set the second line of text in the platform notification template.
1046         */
1047        public Builder setContentText(CharSequence text) {
1048            mContentText = text;
1049            return this;
1050        }
1051
1052        /**
1053         * Set the third line of text in the platform notification template.
1054         * Don't use if you're also using {@link #setProgress(int, int, boolean)}; they occupy the same location in the standard template.
1055         */
1056        public Builder setSubText(CharSequence text) {
1057            mSubText = text;
1058            return this;
1059        }
1060
1061        /**
1062         * Set the large number at the right-hand side of the notification.  This is
1063         * equivalent to setContentInfo, although it might show the number in a different
1064         * font size for readability.
1065         */
1066        public Builder setNumber(int number) {
1067            mNumber = number;
1068            return this;
1069        }
1070
1071        /**
1072         * A small piece of additional information pertaining to this notification.
1073         *
1074         * The platform template will draw this on the last line of the notification, at the far
1075         * right (to the right of a smallIcon if it has been placed there).
1076         */
1077        public Builder setContentInfo(CharSequence info) {
1078            mContentInfo = info;
1079            return this;
1080        }
1081
1082        /**
1083         * Set the progress this notification represents.
1084         *
1085         * The platform template will represent this using a {@link ProgressBar}.
1086         */
1087        public Builder setProgress(int max, int progress, boolean indeterminate) {
1088            mProgressMax = max;
1089            mProgress = progress;
1090            mProgressIndeterminate = indeterminate;
1091            return this;
1092        }
1093
1094        /**
1095         * Supply a custom RemoteViews to use instead of the platform template.
1096         *
1097         * @see Notification#contentView
1098         */
1099        public Builder setContent(RemoteViews views) {
1100            mContentView = views;
1101            return this;
1102        }
1103
1104        /**
1105         * Supply a {@link PendingIntent} to be sent when the notification is clicked.
1106         *
1107         * As of {@link android.os.Build.VERSION_CODES#HONEYCOMB}, if this field is unset and you
1108         * have specified a custom RemoteViews with {@link #setContent(RemoteViews)}, you can use
1109         * {@link RemoteViews#setOnClickPendingIntent RemoteViews.setOnClickPendingIntent(int,PendingIntent)}
1110         * to assign PendingIntents to individual views in that custom layout (i.e., to create
1111         * clickable buttons inside the notification view).
1112         *
1113         * @see Notification#contentIntent Notification.contentIntent
1114         */
1115        public Builder setContentIntent(PendingIntent intent) {
1116            mContentIntent = intent;
1117            return this;
1118        }
1119
1120        /**
1121         * Supply a {@link PendingIntent} to send when the notification is cleared explicitly by the user.
1122         *
1123         * @see Notification#deleteIntent
1124         */
1125        public Builder setDeleteIntent(PendingIntent intent) {
1126            mDeleteIntent = intent;
1127            return this;
1128        }
1129
1130        /**
1131         * An intent to launch instead of posting the notification to the status bar.
1132         * Only for use with extremely high-priority notifications demanding the user's
1133         * <strong>immediate</strong> attention, such as an incoming phone call or
1134         * alarm clock that the user has explicitly set to a particular time.
1135         * If this facility is used for something else, please give the user an option
1136         * to turn it off and use a normal notification, as this can be extremely
1137         * disruptive.
1138         *
1139         * @param intent The pending intent to launch.
1140         * @param highPriority Passing true will cause this notification to be sent
1141         *          even if other notifications are suppressed.
1142         *
1143         * @see Notification#fullScreenIntent
1144         */
1145        public Builder setFullScreenIntent(PendingIntent intent, boolean highPriority) {
1146            mFullScreenIntent = intent;
1147            setFlag(FLAG_HIGH_PRIORITY, highPriority);
1148            return this;
1149        }
1150
1151        /**
1152         * Set the "ticker" text which is displayed in the status bar when the notification first
1153         * arrives.
1154         *
1155         * @see Notification#tickerText
1156         */
1157        public Builder setTicker(CharSequence tickerText) {
1158            mTickerText = tickerText;
1159            return this;
1160        }
1161
1162        /**
1163         * Set the text that is displayed in the status bar when the notification first
1164         * arrives, and also a RemoteViews object that may be displayed instead on some
1165         * devices.
1166         *
1167         * @see Notification#tickerText
1168         * @see Notification#tickerView
1169         */
1170        public Builder setTicker(CharSequence tickerText, RemoteViews views) {
1171            mTickerText = tickerText;
1172            mTickerView = views;
1173            return this;
1174        }
1175
1176        /**
1177         * Add a large icon to the notification (and the ticker on some devices).
1178         *
1179         * In the platform template, this image will be shown on the left of the notification view
1180         * in place of the {@link #setSmallIcon(int) small icon} (which will move to the right side).
1181         *
1182         * @see Notification#largeIcon
1183         */
1184        public Builder setLargeIcon(Bitmap icon) {
1185            mLargeIcon = icon;
1186            return this;
1187        }
1188
1189        /**
1190         * Set the sound to play.
1191         *
1192         * It will be played on the {@link #STREAM_DEFAULT default stream} for notifications.
1193         *
1194         * @see Notification#sound
1195         */
1196        public Builder setSound(Uri sound) {
1197            mSound = sound;
1198            mAudioStreamType = STREAM_DEFAULT;
1199            return this;
1200        }
1201
1202        /**
1203         * Set the sound to play, along with a specific stream on which to play it.
1204         *
1205         * See {@link android.media.AudioManager} for the <code>STREAM_</code> constants.
1206         *
1207         * @see Notification#sound
1208         */
1209        public Builder setSound(Uri sound, int streamType) {
1210            mSound = sound;
1211            mAudioStreamType = streamType;
1212            return this;
1213        }
1214
1215        /**
1216         * Set the vibration pattern to use.
1217         *
1218
1219         * See {@link android.os.Vibrator#vibrate(long[], int)} for a discussion of the
1220         * <code>pattern</code> parameter.
1221         *
1222
1223         * @see Notification#vibrate
1224         */
1225        public Builder setVibrate(long[] pattern) {
1226            mVibrate = pattern;
1227            return this;
1228        }
1229
1230        /**
1231         * Set the desired color for the indicator LED on the device, as well as the
1232         * blink duty cycle (specified in milliseconds).
1233         *
1234
1235         * Not all devices will honor all (or even any) of these values.
1236         *
1237
1238         * @see Notification#ledARGB
1239         * @see Notification#ledOnMS
1240         * @see Notification#ledOffMS
1241         */
1242        public Builder setLights(int argb, int onMs, int offMs) {
1243            mLedArgb = argb;
1244            mLedOnMs = onMs;
1245            mLedOffMs = offMs;
1246            return this;
1247        }
1248
1249        /**
1250         * Set whether this is an "ongoing" notification.
1251         *
1252
1253         * Ongoing notifications cannot be dismissed by the user, so your application or service
1254         * must take care of canceling them.
1255         *
1256
1257         * They are typically used to indicate a background task that the user is actively engaged
1258         * with (e.g., playing music) or is pending in some way and therefore occupying the device
1259         * (e.g., a file download, sync operation, active network connection).
1260         *
1261
1262         * @see Notification#FLAG_ONGOING_EVENT
1263         * @see Service#setForeground(boolean)
1264         */
1265        public Builder setOngoing(boolean ongoing) {
1266            setFlag(FLAG_ONGOING_EVENT, ongoing);
1267            return this;
1268        }
1269
1270        /**
1271         * Set this flag if you would only like the sound, vibrate
1272         * and ticker to be played if the notification is not already showing.
1273         *
1274         * @see Notification#FLAG_ONLY_ALERT_ONCE
1275         */
1276        public Builder setOnlyAlertOnce(boolean onlyAlertOnce) {
1277            setFlag(FLAG_ONLY_ALERT_ONCE, onlyAlertOnce);
1278            return this;
1279        }
1280
1281        /**
1282         * Make this notification automatically dismissed when the user touches it. The
1283         * PendingIntent set with {@link #setDeleteIntent} will be sent when this happens.
1284         *
1285         * @see Notification#FLAG_AUTO_CANCEL
1286         */
1287        public Builder setAutoCancel(boolean autoCancel) {
1288            setFlag(FLAG_AUTO_CANCEL, autoCancel);
1289            return this;
1290        }
1291
1292        /**
1293         * Set which notification properties will be inherited from system defaults.
1294         * <p>
1295         * The value should be one or more of the following fields combined with
1296         * bitwise-or:
1297         * {@link #DEFAULT_SOUND}, {@link #DEFAULT_VIBRATE}, {@link #DEFAULT_LIGHTS}.
1298         * <p>
1299         * For all default values, use {@link #DEFAULT_ALL}.
1300         */
1301        public Builder setDefaults(int defaults) {
1302            mDefaults = defaults;
1303            return this;
1304        }
1305
1306        /**
1307         * Set the priority of this notification.
1308         *
1309         * @see Notification#priority
1310         */
1311        public Builder setPriority(int pri) {
1312            mPriority = pri;
1313            return this;
1314        }
1315
1316        /**
1317         * @hide
1318         *
1319         * Add a kind (category) to this notification. Optional.
1320         *
1321         * @see Notification#kind
1322         */
1323        public Builder addKind(String k) {
1324            mKindList.add(k);
1325            return this;
1326        }
1327
1328        /**
1329         * Add metadata to this notification.
1330         *
1331         * A reference to the Bundle is held for the lifetime of this Builder, and the Bundle's
1332         * current contents are copied into the Notification each time {@link #build()} is
1333         * called.
1334         *
1335         * @see Notification#extras
1336         * @hide
1337         */
1338        public Builder setExtras(Bundle bag) {
1339            mExtras = bag;
1340            return this;
1341        }
1342
1343        /**
1344         * Add an action to this notification. Actions are typically displayed by
1345         * the system as a button adjacent to the notification content.
1346         *
1347         * @param icon Resource ID of a drawable that represents the action.
1348         * @param title Text describing the action.
1349         * @param intent PendingIntent to be fired when the action is invoked.
1350         */
1351        public Builder addAction(int icon, CharSequence title, PendingIntent intent) {
1352            mActions.add(new Action(icon, title, intent));
1353            return this;
1354        }
1355
1356        /**
1357         * Add a rich notification style to be applied at build time.
1358         *
1359         * @param style Object responsible for modifying the notification style.
1360         */
1361        public Builder setStyle(Style style) {
1362            if (mStyle != style) {
1363                mStyle = style;
1364                mStyle.setBuilder(this);
1365            }
1366            return this;
1367        }
1368
1369        private void setFlag(int mask, boolean value) {
1370            if (value) {
1371                mFlags |= mask;
1372            } else {
1373                mFlags &= ~mask;
1374            }
1375        }
1376
1377        private RemoteViews applyStandardTemplate(int resId) {
1378            RemoteViews contentView = new RemoteViews(mContext.getPackageName(), resId);
1379            boolean hasLine3 = false;
1380            boolean hasLine2 = false;
1381            int smallIconImageViewId = R.id.icon;
1382            if (mLargeIcon != null) {
1383                contentView.setImageViewBitmap(R.id.icon, mLargeIcon);
1384                smallIconImageViewId = R.id.right_icon;
1385            }
1386            if (mPriority < PRIORITY_LOW) {
1387                contentView.setInt(R.id.icon,
1388                        "setBackgroundResource", R.drawable.notification_template_icon_low_bg);
1389                contentView.setInt(R.id.status_bar_latest_event_content,
1390                        "setBackgroundResource", R.drawable.notification_bg_low);
1391            }
1392            if (mSmallIcon != 0) {
1393                contentView.setImageViewResource(smallIconImageViewId, mSmallIcon);
1394                contentView.setViewVisibility(smallIconImageViewId, View.VISIBLE);
1395            } else {
1396                contentView.setViewVisibility(smallIconImageViewId, View.GONE);
1397            }
1398            if (mContentTitle != null) {
1399                contentView.setTextViewText(R.id.title, mContentTitle);
1400            }
1401            if (mContentText != null) {
1402                contentView.setTextViewText(
1403                        (mSubText != null) ? R.id.text2 : R.id.text,
1404                        mContentText);
1405                hasLine3 = true;
1406            }
1407            if (mContentInfo != null) {
1408                contentView.setTextViewText(R.id.info, mContentInfo);
1409                contentView.setViewVisibility(R.id.info, View.VISIBLE);
1410                hasLine3 = true;
1411            } else if (mNumber > 0) {
1412                final int tooBig = mContext.getResources().getInteger(
1413                        R.integer.status_bar_notification_info_maxnum);
1414                if (mNumber > tooBig) {
1415                    contentView.setTextViewText(R.id.info, mContext.getResources().getString(
1416                                R.string.status_bar_notification_info_overflow));
1417                } else {
1418                    NumberFormat f = NumberFormat.getIntegerInstance();
1419                    contentView.setTextViewText(R.id.info, f.format(mNumber));
1420                }
1421                contentView.setViewVisibility(R.id.info, View.VISIBLE);
1422                hasLine3 = true;
1423            } else {
1424                contentView.setViewVisibility(R.id.info, View.GONE);
1425            }
1426
1427            if (mSubText != null) {
1428                contentView.setTextViewText(R.id.text, mSubText);
1429                contentView.setViewVisibility(R.id.text2,
1430                        mContentText != null ? View.VISIBLE : View.GONE);
1431            } else {
1432                contentView.setViewVisibility(R.id.text2, View.GONE);
1433                if (mProgressMax != 0 || mProgressIndeterminate) {
1434                    contentView.setProgressBar(
1435                            R.id.progress, mProgressMax, mProgress, mProgressIndeterminate);
1436                    contentView.setViewVisibility(R.id.progress, View.VISIBLE);
1437                } else {
1438                    contentView.setViewVisibility(R.id.progress, View.GONE);
1439                }
1440            }
1441            if (mWhen != 0) {
1442                if (mUseChronometer) {
1443                    contentView.setViewVisibility(R.id.chronometer, View.VISIBLE);
1444                    contentView.setLong(R.id.chronometer, "setBase",
1445                            mWhen + (SystemClock.elapsedRealtime() - System.currentTimeMillis()));
1446                    contentView.setBoolean(R.id.chronometer, "setStarted", true);
1447                } else {
1448                    contentView.setViewVisibility(R.id.time, View.VISIBLE);
1449                    contentView.setLong(R.id.time, "setTime", mWhen);
1450                }
1451            }
1452            contentView.setViewVisibility(R.id.line3, hasLine3 ? View.VISIBLE : View.GONE);
1453            return contentView;
1454        }
1455
1456        private RemoteViews applyStandardTemplateWithActions(int layoutId) {
1457            RemoteViews big = applyStandardTemplate(layoutId);
1458
1459            int N = mActions.size();
1460            if (N > 0) {
1461                // Log.d("Notification", "has actions: " + mContentText);
1462                big.setViewVisibility(R.id.actions, View.VISIBLE);
1463                if (N>3) N=3;
1464                big.removeAllViews(R.id.actions);
1465                for (int i=0; i<N; i++) {
1466                    final RemoteViews button = generateActionButton(mActions.get(i));
1467                    //Log.d("Notification", "adding action " + i + ": " + mActions.get(i).title);
1468                    big.addView(R.id.actions, button);
1469                }
1470            }
1471            return big;
1472        }
1473
1474        private RemoteViews makeContentView() {
1475            if (mContentView != null) {
1476                return mContentView;
1477            } else {
1478                return applyStandardTemplate(R.layout.notification_template_base); // no more special large_icon flavor
1479            }
1480        }
1481
1482        private RemoteViews makeTickerView() {
1483            if (mTickerView != null) {
1484                return mTickerView;
1485            } else {
1486                if (mContentView == null) {
1487                    return applyStandardTemplate(mLargeIcon == null
1488                            ? R.layout.status_bar_latest_event_ticker
1489                            : R.layout.status_bar_latest_event_ticker_large_icon);
1490                } else {
1491                    return null;
1492                }
1493            }
1494        }
1495
1496        private RemoteViews makeBigContentView() {
1497            if (mActions.size() == 0) return null;
1498
1499            return applyStandardTemplateWithActions(R.layout.notification_template_big_base);
1500        }
1501
1502        private RemoteViews generateActionButton(Action action) {
1503            RemoteViews button = new RemoteViews(mContext.getPackageName(), R.layout.notification_action);
1504            button.setTextViewCompoundDrawables(R.id.action0, action.icon, 0, 0, 0);
1505            button.setTextViewText(R.id.action0, action.title);
1506            if (action.actionIntent != null) {
1507                button.setOnClickPendingIntent(R.id.action0, action.actionIntent);
1508                //button.setBoolean(R.id.action0, "setEnabled", true);
1509                button.setFloat(R.id.button0, "setAlpha", 1.0f);
1510                button.setBoolean(R.id.button0, "setClickable", true);
1511            } else {
1512                //button.setBoolean(R.id.action0, "setEnabled", false);
1513                button.setFloat(R.id.button0, "setAlpha", 0.5f);
1514                button.setBoolean(R.id.button0, "setClickable", false);
1515            }
1516            button.setContentDescription(R.id.action0, action.title);
1517            return button;
1518        }
1519
1520        /**
1521         * Apply the unstyled operations and return a new {@link Notification} object.
1522         */
1523        private Notification buildUnstyled() {
1524            Notification n = new Notification();
1525            n.when = mWhen;
1526            n.icon = mSmallIcon;
1527            n.iconLevel = mSmallIconLevel;
1528            n.number = mNumber;
1529            n.contentView = makeContentView();
1530            n.contentIntent = mContentIntent;
1531            n.deleteIntent = mDeleteIntent;
1532            n.fullScreenIntent = mFullScreenIntent;
1533            n.tickerText = mTickerText;
1534            n.tickerView = makeTickerView();
1535            n.largeIcon = mLargeIcon;
1536            n.sound = mSound;
1537            n.audioStreamType = mAudioStreamType;
1538            n.vibrate = mVibrate;
1539            n.ledARGB = mLedArgb;
1540            n.ledOnMS = mLedOnMs;
1541            n.ledOffMS = mLedOffMs;
1542            n.defaults = mDefaults;
1543            n.flags = mFlags;
1544            n.bigContentView = makeBigContentView();
1545            if (mLedOnMs != 0 && mLedOffMs != 0) {
1546                n.flags |= FLAG_SHOW_LIGHTS;
1547            }
1548            if ((mDefaults & DEFAULT_LIGHTS) != 0) {
1549                n.flags |= FLAG_SHOW_LIGHTS;
1550            }
1551            if (mKindList.size() > 0) {
1552                n.kind = new String[mKindList.size()];
1553                mKindList.toArray(n.kind);
1554            } else {
1555                n.kind = null;
1556            }
1557            n.priority = mPriority;
1558            n.extras = mExtras != null ? new Bundle(mExtras) : null;
1559            if (mActions.size() > 0) {
1560                n.actions = new Action[mActions.size()];
1561                mActions.toArray(n.actions);
1562            }
1563            return n;
1564        }
1565
1566        /**
1567         * @deprecated Use {@link #build()} instead.
1568         */
1569        @Deprecated
1570        public Notification getNotification() {
1571            return build();
1572        }
1573
1574        /**
1575         * Combine all of the options that have been set and return a new {@link Notification}
1576         * object.
1577         */
1578        public Notification build() {
1579            if (mStyle != null) {
1580                return mStyle.build();
1581            } else {
1582                return buildUnstyled();
1583            }
1584        }
1585    }
1586
1587
1588    /**
1589     * An object that can apply a rich notification style to a {@link Notification.Builder}
1590     * object.
1591     */
1592    public static abstract class Style
1593    {
1594        private CharSequence mBigContentTitle;
1595        private CharSequence mSummaryText = null;
1596
1597        protected Builder mBuilder;
1598
1599        /**
1600         * Overrides ContentTitle in the big form of the template.
1601         * This defaults to the value passed to setContentTitle().
1602         */
1603        protected void internalSetBigContentTitle(CharSequence title) {
1604            mBigContentTitle = title;
1605        }
1606
1607        /**
1608         * Set the first line of text after the detail section in the big form of the template.
1609         */
1610        protected void internalSetSummaryText(CharSequence cs) {
1611            mSummaryText = cs;
1612        }
1613
1614        public void setBuilder(Builder builder) {
1615            if (mBuilder != builder) {
1616                mBuilder = builder;
1617                mBuilder.setStyle(this);
1618            }
1619        }
1620
1621        protected void checkBuilder() {
1622            if (mBuilder == null) {
1623                throw new IllegalArgumentException("Style requires a valid Builder object");
1624            }
1625        }
1626
1627        protected RemoteViews getStandardView(int layoutId) {
1628            checkBuilder();
1629
1630            if (mBigContentTitle != null) {
1631                mBuilder.setContentTitle(mBigContentTitle);
1632            }
1633
1634            if (mBuilder.mSubText == null) {
1635                mBuilder.setContentText(null);
1636            }
1637
1638            RemoteViews contentView = mBuilder.applyStandardTemplateWithActions(layoutId);
1639
1640            if (mBuilder.mSubText == null) {
1641                contentView.setViewVisibility(R.id.line3, View.GONE);
1642            }
1643
1644            if (mBigContentTitle != null && mBigContentTitle.equals("")) {
1645                contentView.setViewVisibility(R.id.line1, View.GONE);
1646            }
1647
1648            if (mSummaryText != null && !mSummaryText.equals("")) {
1649                contentView.setViewVisibility(R.id.overflow_title, View.VISIBLE);
1650                contentView.setTextViewText(R.id.overflow_title, mSummaryText);
1651            }
1652
1653            return contentView;
1654        }
1655
1656        public abstract Notification build();
1657    }
1658
1659    /**
1660     * Helper class for generating large-format notifications that include a large image attachment.
1661     *
1662     * This class is a "rebuilder": It consumes a Builder object and modifies its behavior, like so:
1663     * <pre class="prettyprint">
1664     * Notification noti = new Notification.BigPictureStyle(
1665     *      new Notification.Builder()
1666     *         .setContentTitle(&quot;New photo from &quot; + sender.toString())
1667     *         .setContentText(subject)
1668     *         .setSmallIcon(R.drawable.new_post)
1669     *         .setLargeIcon(aBitmap))
1670     *      .bigPicture(aBigBitmap)
1671     *      .build();
1672     * </pre>
1673     *
1674     * @see Notification#bigContentView
1675     */
1676    public static class BigPictureStyle extends Style {
1677        private Bitmap mPicture;
1678
1679        public BigPictureStyle() {
1680        }
1681
1682        public BigPictureStyle(Builder builder) {
1683            setBuilder(builder);
1684        }
1685
1686        /**
1687         * Overrides ContentTitle in the big form of the template.
1688         * This defaults to the value passed to setContentTitle().
1689         */
1690        public BigPictureStyle setBigContentTitle(CharSequence title) {
1691            internalSetBigContentTitle(title);
1692            return this;
1693        }
1694
1695        /**
1696         * Set the first line of text after the detail section in the big form of the template.
1697         */
1698        public BigPictureStyle setSummaryText(CharSequence cs) {
1699            internalSetSummaryText(cs);
1700            return this;
1701        }
1702
1703        public BigPictureStyle bigPicture(Bitmap b) {
1704            mPicture = b;
1705            return this;
1706        }
1707
1708        private RemoteViews makeBigContentView() {
1709            RemoteViews contentView = getStandardView(R.layout.notification_template_big_picture);
1710
1711            contentView.setImageViewBitmap(R.id.big_picture, mPicture);
1712
1713            return contentView;
1714        }
1715
1716        @Override
1717        public Notification build() {
1718            checkBuilder();
1719            Notification wip = mBuilder.buildUnstyled();
1720            wip.bigContentView = makeBigContentView();
1721            return wip;
1722        }
1723    }
1724
1725    /**
1726     * Helper class for generating large-format notifications that include a lot of text.
1727     *
1728     * This class is a "rebuilder": It consumes a Builder object and modifies its behavior, like so:
1729     * <pre class="prettyprint">
1730     * Notification noti = new Notification.BigPictureStyle(
1731     *      new Notification.Builder()
1732     *         .setContentTitle(&quot;New mail from &quot; + sender.toString())
1733     *         .setContentText(subject)
1734     *         .setSmallIcon(R.drawable.new_mail)
1735     *         .setLargeIcon(aBitmap))
1736     *      .bigText(aVeryLongString)
1737     *      .build();
1738     * </pre>
1739     *
1740     * @see Notification#bigContentView
1741     */
1742    public static class BigTextStyle extends Style {
1743        private CharSequence mBigText;
1744
1745        public BigTextStyle() {
1746        }
1747
1748        public BigTextStyle(Builder builder) {
1749            setBuilder(builder);
1750        }
1751
1752        /**
1753         * Overrides ContentTitle in the big form of the template.
1754         * This defaults to the value passed to setContentTitle().
1755         */
1756        public BigTextStyle setBigContentTitle(CharSequence title) {
1757            internalSetBigContentTitle(title);
1758            return this;
1759        }
1760
1761        /**
1762         * Set the first line of text after the detail section in the big form of the template.
1763         */
1764        public BigTextStyle setSummaryText(CharSequence cs) {
1765            internalSetSummaryText(cs);
1766            return this;
1767        }
1768
1769        public BigTextStyle bigText(CharSequence cs) {
1770            mBigText = cs;
1771            return this;
1772        }
1773
1774        private RemoteViews makeBigContentView() {
1775            RemoteViews contentView = getStandardView(R.layout.notification_template_big_text);
1776            contentView.setTextViewText(R.id.big_text, mBigText);
1777            contentView.setViewVisibility(R.id.big_text, View.VISIBLE);
1778            contentView.setViewVisibility(R.id.text2, View.GONE);
1779
1780            return contentView;
1781        }
1782
1783        @Override
1784        public Notification build() {
1785            checkBuilder();
1786            Notification wip = mBuilder.buildUnstyled();
1787            wip.bigContentView = makeBigContentView();
1788            return wip;
1789        }
1790    }
1791
1792    /**
1793     * Helper class for generating large-format notifications that include a list of (up to 5) strings.
1794     *
1795     * This class is a "rebuilder": It consumes a Builder object and modifies its behavior, like so:
1796     * <pre class="prettyprint">
1797     * Notification noti = new Notification.InboxStyle(
1798     *      new Notification.Builder()
1799     *         .setContentTitle(&quot;5 New mails from &quot; + sender.toString())
1800     *         .setContentText(subject)
1801     *         .setSmallIcon(R.drawable.new_mail)
1802     *         .setLargeIcon(aBitmap))
1803     *      .addLine(str1)
1804     *      .addLine(str2)
1805     *      .setContentTitle("")
1806     *      .setSummaryText(&quot;+3 more&quot;)
1807     *      .build();
1808     * </pre>
1809     *
1810     * @see Notification#bigContentView
1811     */
1812    public static class InboxStyle extends Style {
1813        private ArrayList<CharSequence> mTexts = new ArrayList<CharSequence>(5);
1814
1815        public InboxStyle() {
1816        }
1817
1818        public InboxStyle(Builder builder) {
1819            setBuilder(builder);
1820        }
1821
1822        /**
1823         * Overrides ContentTitle in the big form of the template.
1824         * This defaults to the value passed to setContentTitle().
1825         */
1826        public InboxStyle setBigContentTitle(CharSequence title) {
1827            internalSetBigContentTitle(title);
1828            return this;
1829        }
1830
1831        /**
1832         * Set the first line of text after the detail section in the big form of the template.
1833         */
1834        public InboxStyle setSummaryText(CharSequence cs) {
1835            internalSetSummaryText(cs);
1836            return this;
1837        }
1838
1839        public InboxStyle addLine(CharSequence cs) {
1840            mTexts.add(cs);
1841            return this;
1842        }
1843
1844        private RemoteViews makeBigContentView() {
1845            RemoteViews contentView = getStandardView(R.layout.notification_template_inbox);
1846            contentView.setViewVisibility(R.id.text2, View.GONE);
1847
1848            int[] rowIds = {R.id.inbox_text0, R.id.inbox_text1, R.id.inbox_text2, R.id.inbox_text3,
1849                    R.id.inbox_text4};
1850
1851            int i=0;
1852            while (i < mTexts.size() && i < rowIds.length) {
1853                CharSequence str = mTexts.get(i);
1854                if (str != null && !str.equals("")) {
1855                    contentView.setViewVisibility(rowIds[i], View.VISIBLE);
1856                    contentView.setTextViewText(rowIds[i], str);
1857                }
1858                i++;
1859            }
1860
1861            return contentView;
1862        }
1863
1864        @Override
1865        public Notification build() {
1866            checkBuilder();
1867            Notification wip = mBuilder.buildUnstyled();
1868            wip.bigContentView = makeBigContentView();
1869            return wip;
1870        }
1871    }
1872}
1873