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.content.pm;
18
19import android.os.Parcel;
20import android.os.Parcelable;
21import android.util.Printer;
22
23/**
24 * Information you can retrieve about a particular application
25 * activity or receiver. This corresponds to information collected
26 * from the AndroidManifest.xml's <activity> and
27 * <receiver> tags.
28 */
29public class ActivityInfo extends ComponentInfo
30        implements Parcelable {
31    /**
32     * A style resource identifier (in the package's resources) of this
33     * activity's theme.  From the "theme" attribute or, if not set, 0.
34     */
35    public int theme;
36
37    /**
38     * Constant corresponding to <code>standard</code> in
39     * the {@link android.R.attr#launchMode} attribute.
40     */
41    public static final int LAUNCH_MULTIPLE = 0;
42    /**
43     * Constant corresponding to <code>singleTop</code> in
44     * the {@link android.R.attr#launchMode} attribute.
45     */
46    public static final int LAUNCH_SINGLE_TOP = 1;
47    /**
48     * Constant corresponding to <code>singleTask</code> in
49     * the {@link android.R.attr#launchMode} attribute.
50     */
51    public static final int LAUNCH_SINGLE_TASK = 2;
52    /**
53     * Constant corresponding to <code>singleInstance</code> in
54     * the {@link android.R.attr#launchMode} attribute.
55     */
56    public static final int LAUNCH_SINGLE_INSTANCE = 3;
57    /**
58     * The launch mode style requested by the activity.  From the
59     * {@link android.R.attr#launchMode} attribute, one of
60     * {@link #LAUNCH_MULTIPLE},
61     * {@link #LAUNCH_SINGLE_TOP}, {@link #LAUNCH_SINGLE_TASK}, or
62     * {@link #LAUNCH_SINGLE_INSTANCE}.
63     */
64    public int launchMode;
65
66    /**
67     * Optional name of a permission required to be able to access this
68     * Activity.  From the "permission" attribute.
69     */
70    public String permission;
71
72    /**
73     * The affinity this activity has for another task in the system.  The
74     * string here is the name of the task, often the package name of the
75     * overall package.  If null, the activity has no affinity.  Set from the
76     * {@link android.R.attr#taskAffinity} attribute.
77     */
78    public String taskAffinity;
79
80    /**
81     * If this is an activity alias, this is the real activity class to run
82     * for it.  Otherwise, this is null.
83     */
84    public String targetActivity;
85
86    /**
87     * Bit in {@link #flags} indicating whether this activity is able to
88     * run in multiple processes.  If
89     * true, the system may instantiate it in the some process as the
90     * process starting it in order to conserve resources.  If false, the
91     * default, it always runs in {@link #processName}.  Set from the
92     * {@link android.R.attr#multiprocess} attribute.
93     */
94    public static final int FLAG_MULTIPROCESS = 0x0001;
95    /**
96     * Bit in {@link #flags} indicating that, when the activity's task is
97     * relaunched from home, this activity should be finished.
98     * Set from the
99     * {@link android.R.attr#finishOnTaskLaunch} attribute.
100     */
101    public static final int FLAG_FINISH_ON_TASK_LAUNCH = 0x0002;
102    /**
103     * Bit in {@link #flags} indicating that, when the activity is the root
104     * of a task, that task's stack should be cleared each time the user
105     * re-launches it from home.  As a result, the user will always
106     * return to the original activity at the top of the task.
107     * This flag only applies to activities that
108     * are used to start the root of a new task.  Set from the
109     * {@link android.R.attr#clearTaskOnLaunch} attribute.
110     */
111    public static final int FLAG_CLEAR_TASK_ON_LAUNCH = 0x0004;
112    /**
113     * Bit in {@link #flags} indicating that, when the activity is the root
114     * of a task, that task's stack should never be cleared when it is
115     * relaunched from home.  Set from the
116     * {@link android.R.attr#alwaysRetainTaskState} attribute.
117     */
118    public static final int FLAG_ALWAYS_RETAIN_TASK_STATE = 0x0008;
119    /**
120     * Bit in {@link #flags} indicating that the activity's state
121     * is not required to be saved, so that if there is a failure the
122     * activity will not be removed from the activity stack.  Set from the
123     * {@link android.R.attr#stateNotNeeded} attribute.
124     */
125    public static final int FLAG_STATE_NOT_NEEDED = 0x0010;
126    /**
127     * Bit in {@link #flags} that indicates that the activity should not
128     * appear in the list of recently launched activities.  Set from the
129     * {@link android.R.attr#excludeFromRecents} attribute.
130     */
131    public static final int FLAG_EXCLUDE_FROM_RECENTS = 0x0020;
132    /**
133     * Bit in {@link #flags} that indicates that the activity can be moved
134     * between tasks based on its task affinity.  Set from the
135     * {@link android.R.attr#allowTaskReparenting} attribute.
136     */
137    public static final int FLAG_ALLOW_TASK_REPARENTING = 0x0040;
138    /**
139     * Bit in {@link #flags} indicating that, when the user navigates away
140     * from an activity, it should be finished.
141     * Set from the
142     * {@link android.R.attr#noHistory} attribute.
143     */
144    public static final int FLAG_NO_HISTORY = 0x0080;
145    /**
146     * Bit in {@link #flags} indicating that, when a request to close system
147     * windows happens, this activity is finished.
148     * Set from the
149     * {@link android.R.attr#finishOnCloseSystemDialogs} attribute.
150     */
151    public static final int FLAG_FINISH_ON_CLOSE_SYSTEM_DIALOGS = 0x0100;
152    /**
153     * Value for {@link #flags}: true when the application's rendering should
154     * be hardware accelerated.
155     */
156    public static final int FLAG_HARDWARE_ACCELERATED = 0x0200;
157    /**
158     * @hide
159     * Bit in {@link #flags} corresponding to an immersive activity
160     * that wishes not to be interrupted by notifications.
161     * Applications that hide the system notification bar with
162     * {@link android.view.WindowManager.LayoutParams#FLAG_FULLSCREEN}
163     * may still be interrupted by high-priority notifications; for example, an
164     * incoming phone call may use
165     * {@link android.app.Notification#fullScreenIntent fullScreenIntent}
166     * to present a full-screen in-call activity to the user, pausing the
167     * current activity as a side-effect. An activity with
168     * {@link #FLAG_IMMERSIVE} set, however, will not be interrupted; the
169     * notification may be shown in some other way (such as a small floating
170     * "toast" window).
171     * {@see android.app.Notification#FLAG_HIGH_PRIORITY}
172     */
173    public static final int FLAG_IMMERSIVE = 0x0400;
174    /**
175     * Options that have been set in the activity declaration in the
176     * manifest.
177     * These include:
178     * {@link #FLAG_MULTIPROCESS},
179     * {@link #FLAG_FINISH_ON_TASK_LAUNCH}, {@link #FLAG_CLEAR_TASK_ON_LAUNCH},
180     * {@link #FLAG_ALWAYS_RETAIN_TASK_STATE},
181     * {@link #FLAG_STATE_NOT_NEEDED}, {@link #FLAG_EXCLUDE_FROM_RECENTS},
182     * {@link #FLAG_ALLOW_TASK_REPARENTING}, {@link #FLAG_NO_HISTORY},
183     * {@link #FLAG_FINISH_ON_CLOSE_SYSTEM_DIALOGS},
184     * {@link #FLAG_HARDWARE_ACCELERATED}
185     */
186    public int flags;
187
188    /**
189     * Constant corresponding to <code>unspecified</code> in
190     * the {@link android.R.attr#screenOrientation} attribute.
191     */
192    public static final int SCREEN_ORIENTATION_UNSPECIFIED = -1;
193    /**
194     * Constant corresponding to <code>landscape</code> in
195     * the {@link android.R.attr#screenOrientation} attribute.
196     */
197    public static final int SCREEN_ORIENTATION_LANDSCAPE = 0;
198    /**
199     * Constant corresponding to <code>portrait</code> in
200     * the {@link android.R.attr#screenOrientation} attribute.
201     */
202    public static final int SCREEN_ORIENTATION_PORTRAIT = 1;
203    /**
204     * Constant corresponding to <code>user</code> in
205     * the {@link android.R.attr#screenOrientation} attribute.
206     */
207    public static final int SCREEN_ORIENTATION_USER = 2;
208    /**
209     * Constant corresponding to <code>behind</code> in
210     * the {@link android.R.attr#screenOrientation} attribute.
211     */
212    public static final int SCREEN_ORIENTATION_BEHIND = 3;
213    /**
214     * Constant corresponding to <code>sensor</code> in
215     * the {@link android.R.attr#screenOrientation} attribute.
216     */
217    public static final int SCREEN_ORIENTATION_SENSOR = 4;
218
219    /**
220     * Constant corresponding to <code>nosensor</code> in
221     * the {@link android.R.attr#screenOrientation} attribute.
222     */
223    public static final int SCREEN_ORIENTATION_NOSENSOR = 5;
224
225    /**
226     * Constant corresponding to <code>sensorLandscape</code> in
227     * the {@link android.R.attr#screenOrientation} attribute.
228     */
229    public static final int SCREEN_ORIENTATION_SENSOR_LANDSCAPE = 6;
230
231    /**
232     * Constant corresponding to <code>sensorPortrait</code> in
233     * the {@link android.R.attr#screenOrientation} attribute.
234     */
235    public static final int SCREEN_ORIENTATION_SENSOR_PORTRAIT = 7;
236
237    /**
238     * Constant corresponding to <code>reverseLandscape</code> in
239     * the {@link android.R.attr#screenOrientation} attribute.
240     */
241    public static final int SCREEN_ORIENTATION_REVERSE_LANDSCAPE = 8;
242
243    /**
244     * Constant corresponding to <code>reversePortrait</code> in
245     * the {@link android.R.attr#screenOrientation} attribute.
246     */
247    public static final int SCREEN_ORIENTATION_REVERSE_PORTRAIT = 9;
248
249    /**
250     * Constant corresponding to <code>fullSensor</code> in
251     * the {@link android.R.attr#screenOrientation} attribute.
252     */
253    public static final int SCREEN_ORIENTATION_FULL_SENSOR = 10;
254
255    /**
256     * The preferred screen orientation this activity would like to run in.
257     * From the {@link android.R.attr#screenOrientation} attribute, one of
258     * {@link #SCREEN_ORIENTATION_UNSPECIFIED},
259     * {@link #SCREEN_ORIENTATION_LANDSCAPE},
260     * {@link #SCREEN_ORIENTATION_PORTRAIT},
261     * {@link #SCREEN_ORIENTATION_USER},
262     * {@link #SCREEN_ORIENTATION_BEHIND},
263     * {@link #SCREEN_ORIENTATION_SENSOR},
264     * {@link #SCREEN_ORIENTATION_NOSENSOR},
265     * {@link #SCREEN_ORIENTATION_SENSOR_LANDSCAPE},
266     * {@link #SCREEN_ORIENTATION_SENSOR_PORTRAIT},
267     * {@link #SCREEN_ORIENTATION_REVERSE_LANDSCAPE},
268     * {@link #SCREEN_ORIENTATION_REVERSE_PORTRAIT},
269     * {@link #SCREEN_ORIENTATION_FULL_SENSOR}.
270     */
271    public int screenOrientation = SCREEN_ORIENTATION_UNSPECIFIED;
272
273    /**
274     * Bit in {@link #configChanges} that indicates that the activity
275     * can itself handle changes to the IMSI MCC.  Set from the
276     * {@link android.R.attr#configChanges} attribute.
277     */
278    public static final int CONFIG_MCC = 0x0001;
279    /**
280     * Bit in {@link #configChanges} that indicates that the activity
281     * can itself handle changes to the IMSI MNC.  Set from the
282     * {@link android.R.attr#configChanges} attribute.
283     */
284    public static final int CONFIG_MNC = 0x0002;
285    /**
286     * Bit in {@link #configChanges} that indicates that the activity
287     * can itself handle changes to the locale.  Set from the
288     * {@link android.R.attr#configChanges} attribute.
289     */
290    public static final int CONFIG_LOCALE = 0x0004;
291    /**
292     * Bit in {@link #configChanges} that indicates that the activity
293     * can itself handle changes to the touchscreen type.  Set from the
294     * {@link android.R.attr#configChanges} attribute.
295     */
296    public static final int CONFIG_TOUCHSCREEN = 0x0008;
297    /**
298     * Bit in {@link #configChanges} that indicates that the activity
299     * can itself handle changes to the keyboard type.  Set from the
300     * {@link android.R.attr#configChanges} attribute.
301     */
302    public static final int CONFIG_KEYBOARD = 0x0010;
303    /**
304     * Bit in {@link #configChanges} that indicates that the activity
305     * can itself handle changes to the keyboard or navigation being hidden/exposed.
306     * Note that inspite of the name, this applies to the changes to any
307     * hidden states: keyboard or navigation.
308     * Set from the {@link android.R.attr#configChanges} attribute.
309     */
310    public static final int CONFIG_KEYBOARD_HIDDEN = 0x0020;
311    /**
312     * Bit in {@link #configChanges} that indicates that the activity
313     * can itself handle changes to the navigation type.  Set from the
314     * {@link android.R.attr#configChanges} attribute.
315     */
316    public static final int CONFIG_NAVIGATION = 0x0040;
317    /**
318     * Bit in {@link #configChanges} that indicates that the activity
319     * can itself handle changes to the screen orientation.  Set from the
320     * {@link android.R.attr#configChanges} attribute.
321     */
322    public static final int CONFIG_ORIENTATION = 0x0080;
323    /**
324     * Bit in {@link #configChanges} that indicates that the activity
325     * can itself handle changes to the screen layout.  Set from the
326     * {@link android.R.attr#configChanges} attribute.
327     */
328    public static final int CONFIG_SCREEN_LAYOUT = 0x0100;
329    /**
330     * Bit in {@link #configChanges} that indicates that the activity
331     * can itself handle the ui mode. Set from the
332     * {@link android.R.attr#configChanges} attribute.
333     */
334    public static final int CONFIG_UI_MODE = 0x0200;
335    /**
336     * Bit in {@link #configChanges} that indicates that the activity
337     * can itself handle the screen size. Set from the
338     * {@link android.R.attr#configChanges} attribute.  This will be
339     * set by default for applications that target an earlier version
340     * than {@link android.os.Build.VERSION_CODES#HONEYCOMB_MR2}...
341     * <b>however</b>, you will not see the bit set here becomes some
342     * applications incorrectly compare {@link #configChanges} against
343     * an absolute value rather than correctly masking out the bits
344     * they are interested in.  Please don't do that, thanks.
345     */
346    public static final int CONFIG_SCREEN_SIZE = 0x0400;
347    /**
348     * Bit in {@link #configChanges} that indicates that the activity
349     * can itself handle the smallest screen size. Set from the
350     * {@link android.R.attr#configChanges} attribute.  This will be
351     * set by default for applications that target an earlier version
352     * than {@link android.os.Build.VERSION_CODES#HONEYCOMB_MR2}...
353     * <b>however</b>, you will not see the bit set here becomes some
354     * applications incorrectly compare {@link #configChanges} against
355     * an absolute value rather than correctly masking out the bits
356     * they are interested in.  Please don't do that, thanks.
357     */
358    public static final int CONFIG_SMALLEST_SCREEN_SIZE = 0x0800;
359    /**
360     * Bit in {@link #configChanges} that indicates that the activity
361     * can itself handle changes to the font scaling factor.  Set from the
362     * {@link android.R.attr#configChanges} attribute.  This is
363     * not a core resource configutation, but a higher-level value, so its
364     * constant starts at the high bits.
365     */
366    public static final int CONFIG_FONT_SCALE = 0x40000000;
367
368    /** @hide
369     * Unfortunately the constants for config changes in native code are
370     * different from ActivityInfo. :(  Here are the values we should use for the
371     * native side given the bit we have assigned in ActivityInfo.
372     */
373    public static int[] CONFIG_NATIVE_BITS = new int[] {
374        0x0001, // MNC
375        0x0002, // MCC
376        0x0004, // LOCALE
377        0x0008, // TOUCH SCREEN
378        0x0010, // KEYBOARD
379        0x0020, // KEYBOARD HIDDEN
380        0x0040, // NAVIGATION
381        0x0080, // ORIENTATION
382        0x0800, // SCREEN LAYOUT
383        0x1000, // UI MODE
384        0x0200, // SCREEN SIZE
385        0x2000, // SMALLEST SCREEN SIZE
386    };
387    /** @hide
388     * Convert Java change bits to native.
389     */
390    public static int activityInfoConfigToNative(int input) {
391        int output = 0;
392        for (int i=0; i<CONFIG_NATIVE_BITS.length; i++) {
393            if ((input&(1<<i)) != 0) {
394                output |= CONFIG_NATIVE_BITS[i];
395            }
396        }
397        return output;
398    }
399
400    /**
401     * @hide
402     * Unfortunately some developers (OpenFeint I am looking at you) have
403     * compared the configChanges bit field against absolute values, so if we
404     * introduce a new bit they break.  To deal with that, we will make sure
405     * the public field will not have a value that breaks them, and let the
406     * framework call here to get the real value.
407     */
408    public int getRealConfigChanged() {
409        return applicationInfo.targetSdkVersion < android.os.Build.VERSION_CODES.HONEYCOMB_MR2
410                ? (configChanges | ActivityInfo.CONFIG_SCREEN_SIZE
411                        | ActivityInfo.CONFIG_SMALLEST_SCREEN_SIZE)
412                : configChanges;
413    }
414
415    /**
416     * Bit mask of kinds of configuration changes that this activity
417     * can handle itself (without being restarted by the system).
418     * Contains any combination of {@link #CONFIG_FONT_SCALE},
419     * {@link #CONFIG_MCC}, {@link #CONFIG_MNC},
420     * {@link #CONFIG_LOCALE}, {@link #CONFIG_TOUCHSCREEN},
421     * {@link #CONFIG_KEYBOARD}, {@link #CONFIG_NAVIGATION},
422     * {@link #CONFIG_ORIENTATION}, and {@link #CONFIG_SCREEN_LAYOUT}.  Set from the
423     * {@link android.R.attr#configChanges} attribute.
424     */
425    public int configChanges;
426
427    /**
428     * The desired soft input mode for this activity's main window.
429     * Set from the {@link android.R.attr#windowSoftInputMode} attribute
430     * in the activity's manifest.  May be any of the same values allowed
431     * for {@link android.view.WindowManager.LayoutParams#softInputMode
432     * WindowManager.LayoutParams.softInputMode}.  If 0 (unspecified),
433     * the mode from the theme will be used.
434     */
435    public int softInputMode;
436
437    /**
438     * The desired extra UI options for this activity and its main window.
439     * Set from the {@link android.R.attr#uiOptions} attribute in the
440     * activity's manifest.
441     */
442    public int uiOptions = 0;
443
444    /**
445     * Flag for use with {@link #uiOptions}.
446     * Indicates that the action bar should put all action items in a separate bar when
447     * the screen is narrow.
448     * <p>This value corresponds to "splitActionBarWhenNarrow" for the {@link #uiOptions} XML
449     * attribute.
450     */
451    public static final int UIOPTION_SPLIT_ACTION_BAR_WHEN_NARROW = 1;
452
453    /**
454     * If defined, the activity named here is the logical parent of this activity.
455     */
456    public String parentActivityName;
457
458    public ActivityInfo() {
459    }
460
461    public ActivityInfo(ActivityInfo orig) {
462        super(orig);
463        theme = orig.theme;
464        launchMode = orig.launchMode;
465        permission = orig.permission;
466        taskAffinity = orig.taskAffinity;
467        targetActivity = orig.targetActivity;
468        flags = orig.flags;
469        screenOrientation = orig.screenOrientation;
470        configChanges = orig.configChanges;
471        softInputMode = orig.softInputMode;
472        uiOptions = orig.uiOptions;
473        parentActivityName = orig.parentActivityName;
474    }
475
476    /**
477     * Return the theme resource identifier to use for this activity.  If
478     * the activity defines a theme, that is used; else, the application
479     * theme is used.
480     *
481     * @return The theme associated with this activity.
482     */
483    public final int getThemeResource() {
484        return theme != 0 ? theme : applicationInfo.theme;
485    }
486
487    public void dump(Printer pw, String prefix) {
488        super.dumpFront(pw, prefix);
489        if (permission != null) {
490            pw.println(prefix + "permission=" + permission);
491        }
492        pw.println(prefix + "taskAffinity=" + taskAffinity
493                + " targetActivity=" + targetActivity);
494        if (launchMode != 0 || flags != 0 || theme != 0) {
495            pw.println(prefix + "launchMode=" + launchMode
496                    + " flags=0x" + Integer.toHexString(flags)
497                    + " theme=0x" + Integer.toHexString(theme));
498        }
499        if (screenOrientation != SCREEN_ORIENTATION_UNSPECIFIED
500                || configChanges != 0 || softInputMode != 0) {
501            pw.println(prefix + "screenOrientation=" + screenOrientation
502                    + " configChanges=0x" + Integer.toHexString(configChanges)
503                    + " softInputMode=0x" + Integer.toHexString(softInputMode));
504        }
505        if (uiOptions != 0) {
506            pw.println(prefix + " uiOptions=0x" + Integer.toHexString(uiOptions));
507        }
508        super.dumpBack(pw, prefix);
509    }
510
511    public String toString() {
512        return "ActivityInfo{"
513            + Integer.toHexString(System.identityHashCode(this))
514            + " " + name + "}";
515    }
516
517    public int describeContents() {
518        return 0;
519    }
520
521    public void writeToParcel(Parcel dest, int parcelableFlags) {
522        super.writeToParcel(dest, parcelableFlags);
523        dest.writeInt(theme);
524        dest.writeInt(launchMode);
525        dest.writeString(permission);
526        dest.writeString(taskAffinity);
527        dest.writeString(targetActivity);
528        dest.writeInt(flags);
529        dest.writeInt(screenOrientation);
530        dest.writeInt(configChanges);
531        dest.writeInt(softInputMode);
532        dest.writeInt(uiOptions);
533        dest.writeString(parentActivityName);
534    }
535
536    public static final Parcelable.Creator<ActivityInfo> CREATOR
537            = new Parcelable.Creator<ActivityInfo>() {
538        public ActivityInfo createFromParcel(Parcel source) {
539            return new ActivityInfo(source);
540        }
541        public ActivityInfo[] newArray(int size) {
542            return new ActivityInfo[size];
543        }
544    };
545
546    private ActivityInfo(Parcel source) {
547        super(source);
548        theme = source.readInt();
549        launchMode = source.readInt();
550        permission = source.readString();
551        taskAffinity = source.readString();
552        targetActivity = source.readString();
553        flags = source.readInt();
554        screenOrientation = source.readInt();
555        configChanges = source.readInt();
556        softInputMode = source.readInt();
557        uiOptions = source.readInt();
558        parentActivityName = source.readString();
559    }
560}
561