ActivityInfo.java revision d02bdaab495641ab50e2123fdfd99a819cc40540
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 * Options that have been set in the activity declaration in the 154 * manifest. 155 * These include: 156 * {@link #FLAG_MULTIPROCESS}, 157 * {@link #FLAG_FINISH_ON_TASK_LAUNCH}, {@link #FLAG_CLEAR_TASK_ON_LAUNCH}, 158 * {@link #FLAG_ALWAYS_RETAIN_TASK_STATE}, 159 * {@link #FLAG_STATE_NOT_NEEDED}, {@link #FLAG_EXCLUDE_FROM_RECENTS}, 160 * {@link #FLAG_ALLOW_TASK_REPARENTING}, {@link #FLAG_NO_HISTORY}, 161 * {@link #FLAG_FINISH_ON_CLOSE_SYSTEM_DIALOGS}, 162 */ 163 public int flags; 164 165 /** 166 * Constant corresponding to <code>unspecified</code> in 167 * the {@link android.R.attr#screenOrientation} attribute. 168 */ 169 public static final int SCREEN_ORIENTATION_UNSPECIFIED = -1; 170 /** 171 * Constant corresponding to <code>landscape</code> in 172 * the {@link android.R.attr#screenOrientation} attribute. 173 */ 174 public static final int SCREEN_ORIENTATION_LANDSCAPE = 0; 175 /** 176 * Constant corresponding to <code>portrait</code> in 177 * the {@link android.R.attr#screenOrientation} attribute. 178 */ 179 public static final int SCREEN_ORIENTATION_PORTRAIT = 1; 180 /** 181 * Constant corresponding to <code>user</code> in 182 * the {@link android.R.attr#screenOrientation} attribute. 183 */ 184 public static final int SCREEN_ORIENTATION_USER = 2; 185 /** 186 * Constant corresponding to <code>behind</code> in 187 * the {@link android.R.attr#screenOrientation} attribute. 188 */ 189 public static final int SCREEN_ORIENTATION_BEHIND = 3; 190 /** 191 * Constant corresponding to <code>sensor</code> in 192 * the {@link android.R.attr#screenOrientation} attribute. 193 */ 194 public static final int SCREEN_ORIENTATION_SENSOR = 4; 195 196 /** 197 * Constant corresponding to <code>sensor</code> in 198 * the {@link android.R.attr#screenOrientation} attribute. 199 */ 200 public static final int SCREEN_ORIENTATION_NOSENSOR = 5; 201 /** 202 * The preferred screen orientation this activity would like to run in. 203 * From the {@link android.R.attr#screenOrientation} attribute, one of 204 * {@link #SCREEN_ORIENTATION_UNSPECIFIED}, 205 * {@link #SCREEN_ORIENTATION_LANDSCAPE}, 206 * {@link #SCREEN_ORIENTATION_PORTRAIT}, 207 * {@link #SCREEN_ORIENTATION_USER}, 208 * {@link #SCREEN_ORIENTATION_BEHIND}, 209 * {@link #SCREEN_ORIENTATION_SENSOR}, 210 * {@link #SCREEN_ORIENTATION_NOSENSOR}. 211 */ 212 public int screenOrientation = SCREEN_ORIENTATION_UNSPECIFIED; 213 214 /** 215 * Bit in {@link #configChanges} that indicates that the activity 216 * can itself handle changes to the IMSI MCC. Set from the 217 * {@link android.R.attr#configChanges} attribute. 218 */ 219 public static final int CONFIG_MCC = 0x0001; 220 /** 221 * Bit in {@link #configChanges} that indicates that the activity 222 * can itself handle changes to the IMSI MNC. Set from the 223 * {@link android.R.attr#configChanges} attribute. 224 */ 225 public static final int CONFIG_MNC = 0x0002; 226 /** 227 * Bit in {@link #configChanges} that indicates that the activity 228 * can itself handle changes to the locale. Set from the 229 * {@link android.R.attr#configChanges} attribute. 230 */ 231 public static final int CONFIG_LOCALE = 0x0004; 232 /** 233 * Bit in {@link #configChanges} that indicates that the activity 234 * can itself handle changes to the touchscreen type. Set from the 235 * {@link android.R.attr#configChanges} attribute. 236 */ 237 public static final int CONFIG_TOUCHSCREEN = 0x0008; 238 /** 239 * Bit in {@link #configChanges} that indicates that the activity 240 * can itself handle changes to the keyboard type. Set from the 241 * {@link android.R.attr#configChanges} attribute. 242 */ 243 public static final int CONFIG_KEYBOARD = 0x0010; 244 /** 245 * Bit in {@link #configChanges} that indicates that the activity 246 * can itself handle changes to the keyboard or navigation being hidden/exposed. 247 * Note that inspite of the name, this applies to the changes to any 248 * hidden states: keyboard or navigation. 249 * Set from the {@link android.R.attr#configChanges} attribute. 250 */ 251 public static final int CONFIG_KEYBOARD_HIDDEN = 0x0020; 252 /** 253 * Bit in {@link #configChanges} that indicates that the activity 254 * can itself handle changes to the navigation type. Set from the 255 * {@link android.R.attr#configChanges} attribute. 256 */ 257 public static final int CONFIG_NAVIGATION = 0x0040; 258 /** 259 * Bit in {@link #configChanges} that indicates that the activity 260 * can itself handle changes to the screen orientation. Set from the 261 * {@link android.R.attr#configChanges} attribute. 262 */ 263 public static final int CONFIG_ORIENTATION = 0x0080; 264 /** 265 * Bit in {@link #configChanges} that indicates that the activity 266 * can itself handle changes to the screen layout. Set from the 267 * {@link android.R.attr#configChanges} attribute. 268 */ 269 public static final int CONFIG_SCREEN_LAYOUT = 0x0100; 270 /** 271 * Bit in {@link #configChanges} that indicates that the activity 272 * can itself handle the ui mode. Set from the 273 * {@link android.R.attr#configChanges} attribute. 274 */ 275 public static final int CONFIG_UI_MODE = 0x0200; 276 /** 277 * Bit in {@link #configChanges} that indicates that the activity 278 * can itself handle changes to the font scaling factor. Set from the 279 * {@link android.R.attr#configChanges} attribute. This is 280 * not a core resource configutation, but a higher-level value, so its 281 * constant starts at the high bits. 282 */ 283 public static final int CONFIG_FONT_SCALE = 0x40000000; 284 285 /** 286 * Bit mask of kinds of configuration changes that this activity 287 * can handle itself (without being restarted by the system). 288 * Contains any combination of {@link #CONFIG_FONT_SCALE}, 289 * {@link #CONFIG_MCC}, {@link #CONFIG_MNC}, 290 * {@link #CONFIG_LOCALE}, {@link #CONFIG_TOUCHSCREEN}, 291 * {@link #CONFIG_KEYBOARD}, {@link #CONFIG_NAVIGATION}, 292 * {@link #CONFIG_ORIENTATION}, and {@link #CONFIG_SCREEN_LAYOUT}. Set from the 293 * {@link android.R.attr#configChanges} attribute. 294 */ 295 public int configChanges; 296 297 /** 298 * The desired soft input mode for this activity's main window. 299 * Set from the {@link android.R.attr#windowSoftInputMode} attribute 300 * in the activity's manifest. May be any of the same values allowed 301 * for {@link android.view.WindowManager.LayoutParams#softInputMode 302 * WindowManager.LayoutParams.softInputMode}. If 0 (unspecified), 303 * the mode from the theme will be used. 304 */ 305 public int softInputMode; 306 307 public ActivityInfo() { 308 } 309 310 public ActivityInfo(ActivityInfo orig) { 311 super(orig); 312 theme = orig.theme; 313 launchMode = orig.launchMode; 314 permission = orig.permission; 315 taskAffinity = orig.taskAffinity; 316 targetActivity = orig.targetActivity; 317 flags = orig.flags; 318 screenOrientation = orig.screenOrientation; 319 configChanges = orig.configChanges; 320 softInputMode = orig.softInputMode; 321 } 322 323 /** 324 * Return the theme resource identifier to use for this activity. If 325 * the activity defines a theme, that is used; else, the application 326 * theme is used. 327 * 328 * @return The theme associated with this activity. 329 */ 330 public final int getThemeResource() { 331 return theme != 0 ? theme : applicationInfo.theme; 332 } 333 334 public void dump(Printer pw, String prefix) { 335 super.dumpFront(pw, prefix); 336 if (permission != null) { 337 pw.println(prefix + "permission=" + permission); 338 } 339 pw.println(prefix + "taskAffinity=" + taskAffinity 340 + " targetActivity=" + targetActivity); 341 if (launchMode != 0 || flags != 0 || theme != 0) { 342 pw.println(prefix + "launchMode=" + launchMode 343 + " flags=0x" + Integer.toHexString(flags) 344 + " theme=0x" + Integer.toHexString(theme)); 345 } 346 if (screenOrientation != SCREEN_ORIENTATION_UNSPECIFIED 347 || configChanges != 0 || softInputMode != 0) { 348 pw.println(prefix + "screenOrientation=" + screenOrientation 349 + " configChanges=0x" + Integer.toHexString(configChanges) 350 + " softInputMode=0x" + Integer.toHexString(softInputMode)); 351 } 352 super.dumpBack(pw, prefix); 353 } 354 355 public String toString() { 356 return "ActivityInfo{" 357 + Integer.toHexString(System.identityHashCode(this)) 358 + " " + name + "}"; 359 } 360 361 public int describeContents() { 362 return 0; 363 } 364 365 public void writeToParcel(Parcel dest, int parcelableFlags) { 366 super.writeToParcel(dest, parcelableFlags); 367 dest.writeInt(theme); 368 dest.writeInt(launchMode); 369 dest.writeString(permission); 370 dest.writeString(taskAffinity); 371 dest.writeString(targetActivity); 372 dest.writeInt(flags); 373 dest.writeInt(screenOrientation); 374 dest.writeInt(configChanges); 375 dest.writeInt(softInputMode); 376 } 377 378 public static final Parcelable.Creator<ActivityInfo> CREATOR 379 = new Parcelable.Creator<ActivityInfo>() { 380 public ActivityInfo createFromParcel(Parcel source) { 381 return new ActivityInfo(source); 382 } 383 public ActivityInfo[] newArray(int size) { 384 return new ActivityInfo[size]; 385 } 386 }; 387 388 private ActivityInfo(Parcel source) { 389 super(source); 390 theme = source.readInt(); 391 launchMode = source.readInt(); 392 permission = source.readString(); 393 taskAffinity = source.readString(); 394 targetActivity = source.readString(); 395 flags = source.readInt(); 396 screenOrientation = source.readInt(); 397 configChanges = source.readInt(); 398 softInputMode = source.readInt(); 399 } 400} 401