1<?xml version="1.0" encoding="utf-8"?> 2<!-- 3/* Copyright 2006, The Android Open Source Project 4** 5** Licensed under the Apache License, Version 2.0 (the "License"); 6** you may not use this file except in compliance with the License. 7** You may obtain a copy of the License at 8** 9** http://www.apache.org/licenses/LICENSE-2.0 10** 11** Unless required by applicable law or agreed to in writing, software 12** distributed under the License is distributed on an "AS IS" BASIS, 13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14** See the License for the specific language governing permissions and 15** limitations under the License. 16*/ 17--> 18<resources> 19 <!-- **************************************************************** --> 20 <!-- These are the attributes used in AndroidManifest.xml. --> 21 <!-- **************************************************************** --> 22 <eat-comment /> 23 24 <!-- The overall theme to use for an activity. Use with either the 25 application tag (to supply a default theme for all activities) or 26 the activity tag (to supply a specific theme for that activity). 27 28 <p>This automatically sets 29 your activity's Context to use this theme, and may also be used 30 for "starting" animations prior to the activity being launched (to 31 better match what the activity actually looks like). It is a reference 32 to a style resource defining the theme. If not set, the default 33 system theme will be used. --> 34 <attr name="theme" format="reference" /> 35 36 <!-- A user-legible name for the given item. Use with the 37 application tag (to supply a default label for all application 38 components), or with the activity, receiver, service, or instrumentation 39 tag (to supply a specific label for that component). It may also be 40 used with the intent-filter tag to supply a label to show to the 41 user when an activity is being selected based on a particular Intent. 42 43 <p>The given label will be used wherever the user sees information 44 about its associated component; for example, as the name of a 45 main activity that is displayed in the launcher. You should 46 generally set this to a reference to a string resource, so that 47 it can be localized, however it is also allowed to supply a plain 48 string for quick and dirty programming. --> 49 <attr name="label" format="reference|string" /> 50 51 <!-- A Drawable resource providing a graphical representation of its 52 associated item. Use with the 53 application tag (to supply a default icon for all application 54 components), or with the activity, receiver, service, or instrumentation 55 tag (to supply a specific icon for that component). It may also be 56 used with the intent-filter tag to supply an icon to show to the 57 user when an activity is being selected based on a particular Intent. 58 59 <p>The given icon will be used to display to the user a graphical 60 representation of its associated component; for example, as the icon 61 for main activity that is displayed in the launcher. This must be 62 a reference to a Drawable resource containing the image definition. --> 63 <attr name="icon" format="reference" /> 64 65 <!-- A Drawable resource providing an extended graphical logo for its 66 associated item. Use with the application tag (to supply a default 67 logo for all application components), or with the activity, receiver, 68 service, or instrumentation tag (to supply a specific logo for that 69 component). It may also be used with the intent-filter tag to supply 70 a logo to show to the user when an activity is being selected based 71 on a particular Intent. 72 73 <p>The given logo will be used to display to the user a graphical 74 representation of its associated component; for example as the 75 header in the Action Bar. The primary differences between an icon 76 and a logo are that logos are often wider and more detailed, and are 77 used without an accompanying text caption. This must be a reference 78 to a Drawable resource containing the image definition. --> 79 <attr name="logo" format="reference" /> 80 81 <!-- Name of the activity to be launched to manage application's space on 82 device. The specified activity gets automatically launched when the 83 application's space needs to be managed and is usually invoked 84 through user actions. Applications can thus provide their own custom 85 behavior for managing space for various scenarios like out of memory 86 conditions. This is an optional attribute and 87 applications can choose not to specify a default activity to 88 manage space. --> 89 <attr name="manageSpaceActivity" format="string" /> 90 91 <!-- Option to let applications specify that user data can/cannot be 92 cleared. This flag is turned on by default. 93 <em>This attribute is usable only by applications 94 included in the system image. Third-party apps cannot use it.</em> --> 95 <attr name="allowClearUserData" format="boolean" /> 96 97 <!-- Option to let applications specify that user data should 98 never be encrypted if an Encrypted File System solution 99 is enabled. Specifically, this is an "opt-out" feature, meaning 100 that, by default, user data will be encrypted if the EFS feature 101 is enabled. --> 102 <attr name="neverEncrypt" format="boolean" /> 103 104 <!-- Option to indicate this application is only for testing purposes. 105 For example, it may expose functionality or data outside of itself 106 that would cause a security hole, but is useful for testing. This 107 kind of application can not be installed without the 108 INSTALL_ALLOW_TEST flag, which means only through adb install. --> 109 <attr name="testOnly" format="boolean" /> 110 111 <!-- A unique name for the given item. This must use a Java-style naming 112 convention to ensure the name is unique, for example 113 "com.mycompany.MyName". --> 114 <attr name="name" format="string" /> 115 116 <!-- Specify a permission that a client is required to have in order to 117 use the associated object. If the client does not hold the named 118 permission, its request will fail. See the 119 <a href="{@docRoot}guide/topics/security/security.html">Security and Permissions</a> 120 document for more information on permissions. --> 121 <attr name="permission" format="string" /> 122 123 <!-- A specific {@link android.R.attr#permission} name for read-only 124 access to a {@link android.content.ContentProvider}. See the 125 <a href="{@docRoot}guide/topics/security/security.html">Security and Permissions</a> 126 document for more information on permissions. --> 127 <attr name="readPermission" format="string" /> 128 129 <!-- A specific {@link android.R.attr#permission} name for write 130 access to a {@link android.content.ContentProvider}. See the 131 <a href="{@docRoot}guide/topics/security/security.html">Security and Permissions</a> 132 document for more information on permissions. --> 133 <attr name="writePermission" format="string" /> 134 135 <!-- If true, the {@link android.content.Context#grantUriPermission 136 Context.grantUriPermission} or corresponding Intent flags can 137 be used to allow others to access specific URIs in the content 138 provider, even if they do not have an explicit read or write 139 permission. If you are supporting this feature, you must be 140 sure to call {@link android.content.Context#revokeUriPermission 141 Context.revokeUriPermission} when URIs are deleted from your 142 provider.--> 143 <attr name="grantUriPermissions" format="boolean" /> 144 145 <!-- Characterizes the potential risk implied in a permission and 146 indicates the procedure the system should follow when determining 147 whether to grant the permission to an application requesting it. {@link 148 android.Manifest.permission Standard permissions} have a predefined and 149 permanent protectionLevel. If you are creating a custom permission in an 150 application, you can define a protectionLevel attribute with one of the 151 values listed below. If no protectionLevel is defined for a custom 152 permission, the system assigns the default ("normal"). --> 153 <attr name="protectionLevel"> 154 <!-- A lower-risk permission that gives an application access to isolated 155 application-level features, with minimal risk to other applications, 156 the system, or the user. The system automatically grants this type 157 of permission to a requesting application at installation, without 158 asking for the user's explicit approval (though the user always 159 has the option to review these permissions before installing). --> 160 <flag name="normal" value="0" /> 161 <!-- A higher-risk permission that would give a requesting application 162 access to private user data or control over the device that can 163 negatively impact the user. Because this type of permission 164 introduces potential risk, the system may not automatically 165 grant it to the requesting application. For example, any dangerous 166 permissions requested by an application may be displayed to the 167 user and require confirmation before proceeding, or some other 168 approach may be taken to avoid the user automatically allowing 169 the use of such facilities. --> 170 <flag name="dangerous" value="1" /> 171 <!-- A permission that the system is to grant only if the requesting 172 application is signed with the same certificate as the application 173 that declared the permission. If the certificates match, the system 174 automatically grants the permission without notifying the user or 175 asking for the user's explicit approval. --> 176 <flag name="signature" value="2" /> 177 <!-- A permission that the system is to grant only to packages in the 178 Android system image <em>or</em> that are signed with the same 179 certificates. Please avoid using this option, as the 180 signature protection level should be sufficient for most needs and 181 works regardless of exactly where applications are installed. This 182 permission is used for certain special situations where multiple 183 vendors have applications built in to a system image which need 184 to share specific features explicitly because they are being built 185 together. --> 186 <flag name="signatureOrSystem" value="3" /> 187 <!-- Additional flag from base permission type: this permission can also 188 be granted to any applications installed on the system image. 189 Please avoid using this option, as the 190 signature protection level should be sufficient for most needs and 191 works regardless of exactly where applications are installed. This 192 permission flag is used for certain special situations where multiple 193 vendors have applications built in to a system image which need 194 to share specific features explicitly because they are being built 195 together. --> 196 <flag name="system" value="0x10" /> 197 <!-- Additional flag from base permission type: this permission can also 198 (optionally) be granted to development applications. --> 199 <flag name="development" value="0x20" /> 200 </attr> 201 202 <!-- Flags indicating more context for a permission group. --> 203 <attr name="permissionGroupFlags"> 204 <!-- Set to indicate that this permission group contains permissions 205 protecting access to some information that is considered 206 personal to the user (such as contacts, e-mails, etc). --> 207 <flag name="personalInfo" value="0x0001" /> 208 </attr> 209 210 <!-- Flags indicating more context for a permission. --> 211 <attr name="permissionFlags"> 212 <!-- Set to indicate that this permission allows an operation that 213 may cost the user money. Such permissions may be highlighted 214 when shown to the user with this additional information. --> 215 <flag name="costsMoney" value="0x0001" /> 216 </attr> 217 218 <!-- Specified the name of a group that this permission is associated 219 with. The group must have been defined with the 220 {@link android.R.styleable#AndroidManifestPermissionGroup permission-group} tag. --> 221 <attr name="permissionGroup" format="string" /> 222 223 <!-- Specify the name of a user ID that will be shared between multiple 224 packages. By default, each package gets its own unique user-id. 225 By setting this value on two or more packages, each of these packages 226 will be given a single shared user ID, so they can for example run 227 in the same process. Note that for them to actually get the same 228 user ID, they must also be signed with the same signature. --> 229 <attr name="sharedUserId" format="string" /> 230 231 <!-- Specify a label for the shared user UID of this package. This is 232 only used if you have also used android:sharedUserId. This must 233 be a reference to a string resource; it can not be an explicit 234 string. --> 235 <attr name="sharedUserLabel" format="reference" /> 236 237 <!-- Internal version code. This is the number used to determine whether 238 one version is more recent than another: it has no other meaning than 239 that higher numbers are more recent. You could use this number to 240 encode a "x.y" in the lower and upper 16 bits, make it a build 241 number, simply increase it by one each time a new version is 242 released, or define it however else you want, as long as each 243 successive version has a higher number. This is not a version 244 number generally shown to the user, that is usually supplied 245 with {@link android.R.attr#versionName}. --> 246 <attr name="versionCode" format="integer" /> 247 248 <!-- The text shown to the user to indicate the version they have. This 249 is used for no other purpose than display to the user; the actual 250 significant version number is given by {@link android.R.attr#versionCode}. --> 251 <attr name="versionName" format="string" /> 252 253 <!-- Flag to control special persistent mode of an application. This should 254 not normally be used by applications; it requires that the system keep 255 your application running at all times. --> 256 <attr name="persistent" format="boolean" /> 257 258 <!-- Flag indicating whether the application can be debugged, even when 259 running on a device that is running in user mode. --> 260 <attr name="debuggable" format="boolean" /> 261 262 <!-- Flag indicating whether the application requests the VM to operate in 263 the safe mode. --> 264 <attr name="vmSafeMode" format="boolean" /> 265 266 <!-- <p>Flag indicating whether the application's rendering should be hardware 267 accelerated if possible. This flag is turned on by default for applications 268 that are targeting {@link android.os.Build.VERSION_CODES#ICE_CREAM_SANDWICH} 269 or later.</p> 270 <p>This flag can be set on the application and any activity declared 271 in the manifest. When enabled for the application, each activity is 272 automatically assumed to be hardware accelerated. This flag can be 273 overridden in the activity tags, either turning it off (if on for the 274 application) or on (if off for the application.)</p> 275 <p>When this flag is turned on for an activity (either directly or via 276 the application tag), every window created from the activity, including 277 the activity's own window, will be hardware accelerated, if possible.</p> 278 <p>Please refer to the documentation of 279 {@link android.view.WindowManager.LayoutParams#FLAG_HARDWARE_ACCELERATED} 280 for more information on how to control this flag programmatically.</p> --> 281 <attr name="hardwareAccelerated" format="boolean" /> 282 283 <!-- Flag indicating whether the given application component is available 284 to other applications. If false, it can only be accessed by 285 applications with its same user id (which usually means only by 286 code in its own package). If true, it can be invoked by external 287 entities, though which ones can do so may be controlled through 288 permissions. The default value is false for activity, receiver, 289 and service components that do not specify any intent filters; it 290 is true for activity, receiver, and service components that do 291 have intent filters (implying they expect to be invoked by others 292 who do not know their particular component name) and for all 293 content providers. --> 294 <attr name="exported" format="boolean" /> 295 296 <!-- If set to true, a single instance of this component will run for 297 all users. That instance will run as user 0, the default/primary 298 user. When the app running is in processes for other users and interacts 299 with this component (by binding to a service for example) those processes will 300 always interact with the instance running for user 0. Enabling 301 single user mode forces "exported" of the component to be false, to 302 help avoid introducing multi-user security bugs. This feature is only 303 available to applications built in to the system image; you must hold the 304 permission INTERACT_ACROSS_USERS in order 305 to use this feature. This flag can only be used with services, 306 receivers, and providers; it can not be used with activities. --> 307 <attr name="singleUser" format="boolean" /> 308 309 <!-- Specify a specific process that the associated code is to run in. 310 Use with the application tag (to supply a default process for all 311 application components), or with the activity, receiver, service, 312 or provider tag (to supply a specific icon for that component). 313 314 <p>Application components are normally run in a single process that 315 is created for the entire application. You can use this tag to modify 316 where they run. If the process name begins with a ':' character, 317 a new process private to that application will be created when needed 318 to run that component (allowing you to spread your application across 319 multiple processes). If the process name begins with a lower-case 320 character, the component will be run in a global process of that name, 321 provided that you have permission to do so, allowing multiple 322 applications to share one process to reduce resource usage. --> 323 <attr name="process" format="string" /> 324 325 <!-- Specify a task name that activities have an "affinity" to. 326 Use with the application tag (to supply a default affinity for all 327 activities in the application), or with the activity tag (to supply 328 a specific affinity for that component). 329 330 <p>The default value for this attribute is the same as the package 331 name, indicating that all activities in the manifest should generally 332 be considered a single "application" to the user. You can use this 333 attribute to modify that behavior: either giving them an affinity 334 for another task, if the activities are intended to be part of that 335 task from the user's perspective, or using an empty string for 336 activities that have no affinity to a task. --> 337 <attr name="taskAffinity" format="string" /> 338 339 <!-- Specify that an activity can be moved out of a task it is in to 340 the task it has an affinity for when appropriate. Use with the 341 application tag (to supply a default for all activities in the 342 application), or with an activity tag (to supply a specific 343 setting for that component). 344 345 <p>Normally when an application is started, it is associated with 346 the task of the activity that started it and stays there for its 347 entire lifetime. You can use the allowTaskReparenting feature to force an 348 activity to be re-parented to a different task when the task it is 349 in goes to the background. Typically this is used to cause the 350 activities of an application to move back to the main task associated 351 with that application. The activity is re-parented to the task 352 with the same {@link android.R.attr#taskAffinity} as it has. --> 353 <attr name="allowTaskReparenting" format="boolean" /> 354 355 <!-- Specify whether a component is allowed to have multiple instances 356 of itself running in different processes. Use with the activity 357 and provider tags. 358 359 <p>Normally the system will ensure that all instances of a particular 360 component are only running in a single process. You can use this 361 attribute to disable that behavior, allowing the system to create 362 instances wherever they are used (provided permissions allow it). 363 This is most often used with content providers, so that instances 364 of a provider can be created in each client process, allowing them 365 to be used without performing IPC. --> 366 <attr name="multiprocess" format="boolean" /> 367 368 <!-- Specify whether an activity should be finished when its task is 369 brought to the foreground by relaunching from the home screen. 370 371 <p>If both this option and {@link android.R.attr#allowTaskReparenting} are 372 specified, the finish trumps the affinity: the affinity will be 373 ignored and the activity simply finished. --> 374 <attr name="finishOnTaskLaunch" format="boolean" /> 375 376 <!-- Specify whether an activity should be finished when a "close system 377 windows" request has been made. This happens, for example, when 378 the home key is pressed, when the device is locked, when a system 379 dialog showing recent applications is displayed, etc. --> 380 <attr name="finishOnCloseSystemDialogs" format="boolean" /> 381 382 <!-- Specify whether an activity's task should be cleared when it 383 is re-launched from the home screen. As a result, every time the 384 user starts the task, they will be brought to its root activity, 385 regardless of whether they used BACK or HOME to last leave it. 386 This flag only applies to activities that 387 are used to start the root of a new task. 388 389 <p>An example of the use of this flag would be for the case where 390 a user launches activity A from home, and from there goes to 391 activity B. They now press home, and then return to activity A. 392 Normally they would see activity B, since that is what they were 393 last doing in A's task. However, if A has set this flag to true, 394 then upon going to the background all of the tasks on top of it (B 395 in this case) are removed, so when the user next returns to A they 396 will restart at its original activity. 397 398 <p>When this option is used in conjunction with 399 {@link android.R.attr#allowTaskReparenting}, the allowTaskReparenting trumps the 400 clear. That is, all activities above the root activity of the 401 task will be removed: those that have an affinity will be moved 402 to the task they are associated with, otherwise they will simply 403 be dropped as described here. --> 404 <attr name="clearTaskOnLaunch" format="boolean" /> 405 406 <!-- Specify whether an activity should be kept in its history stack. 407 If this attribute is set, then as soon as the user navigates away 408 from the activity it will be finished and they will no longer be 409 able to return to it. --> 410 <attr name="noHistory" format="boolean" /> 411 412 <!-- Specify whether an acitivty's task state should always be maintained 413 by the system, or if it is allowed to reset the task to its initial 414 state in certain situations. 415 416 <p>Normally the system will reset a task (remove all activities from 417 the stack and reset the root activity) in certain situations when 418 the user re-selects that task from the home screen. Typically this 419 will be done if the user hasn't visited that task for a certain 420 amount of time, such as 30 minutes. 421 422 <p>By setting this attribute, the user will always return to your 423 task in its last state, regardless of how they get there. This is 424 useful, for example, in an application like the web browser where there 425 is a lot of state (such as multiple open tabs) that the application 426 would not like to lose. --> 427 <attr name="alwaysRetainTaskState" format="boolean" /> 428 429 <!-- Indicates that an Activity does not need to have its freeze state 430 (as returned by {@link android.app.Activity#onSaveInstanceState} 431 retained in order to be restarted. Generally you use this for activities 432 that do not store any state. When this flag is set, if for some reason 433 the activity is killed before it has a chance to save its state, 434 then the system will not remove it from the activity stack like 435 it normally would. Instead, the next time the user navigates to 436 it its {@link android.app.Activity#onCreate} method will be called 437 with a null icicle, just like it was starting for the first time. 438 439 <p>This is used by the Home activity to make sure it does not get 440 removed if it crashes for some reason. --> 441 <attr name="stateNotNeeded" format="boolean" /> 442 443 <!-- Indicates that an Activity should be excluded from the list of 444 recently launched activities. --> 445 <attr name="excludeFromRecents" format="boolean" /> 446 447 <!-- Specify that an Activity should be shown over the lock screen and, 448 in a multiuser environment, across all users' windows --> 449 <attr name="showOnLockScreen" format="boolean" /> 450 451 <!-- Specify the authorities under which this content provider can be 452 found. Multiple authorities may be supplied by separating them 453 with a semicolon. Authority names should use a Java-style naming 454 convention (such as <code>com.google.provider.MyProvider</code>) 455 in order to avoid conflicts. Typically this name is the same 456 as the class implementation describing the provider's data structure. --> 457 <attr name="authorities" format="string" /> 458 459 <!-- Flag indicating whether this content provider would like to 460 participate in data synchronization. --> 461 <attr name="syncable" format="boolean" /> 462 463 <!-- Flag declaring this activity to be 'immersive'; immersive activities 464 should not be interrupted with other activities or notifications. --> 465 <attr name="immersive" format="boolean" /> 466 467 <!-- Specify the order in which content providers hosted by a process 468 are instantiated when that process is created. Not needed unless 469 you have providers with dependencies between each other, to make 470 sure that they are created in the order needed by those dependencies. 471 The value is a simple integer, with higher numbers being 472 initialized first. --> 473 <attr name="initOrder" format="integer" /> 474 475 <!-- Specify the relative importance or ability in handling a particular 476 Intent. For receivers, this controls the order in which they are 477 executed to receive a broadcast (note that for 478 asynchronous broadcasts, this order is ignored). For activities, 479 this provides information about how good an activity is handling an 480 Intent; when multiple activities match an intent and have different 481 priorities, only those with the higher priority value will be 482 considered a match. 483 484 <p>Only use if you really need to impose some specific 485 order in which the broadcasts are received, or want to forcibly 486 place an activity to always be preferred over others. The value is a 487 single integer, with higher numbers considered to be better. --> 488 <attr name="priority" format="integer" /> 489 490 <!-- Specify how an activity should be launched. See the 491 <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back 492 Stack</a> document for important information on how these options impact 493 the behavior of your application. 494 495 <p>If this attribute is not specified, <code>standard</code> launch 496 mode will be used. Note that the particular launch behavior can 497 be changed in some ways at runtime through the 498 {@link android.content.Intent} flags 499 {@link android.content.Intent#FLAG_ACTIVITY_SINGLE_TOP}, 500 {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK}, and 501 {@link android.content.Intent#FLAG_ACTIVITY_MULTIPLE_TASK}. --> 502 <attr name="launchMode"> 503 <!-- The default mode, which will usually create a new instance of 504 the activity when it is started, though this behavior may change 505 with the introduction of other options such as 506 {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK 507 Intent.FLAG_ACTIVITY_NEW_TASK}. --> 508 <enum name="standard" value="0" /> 509 <!-- If, when starting the activity, there is already an 510 instance of the same activity class in the foreground that is 511 interacting with the user, then 512 re-use that instance. This existing instance will receive a call to 513 {@link android.app.Activity#onNewIntent Activity.onNewIntent()} with 514 the new Intent that is being started. --> 515 <enum name="singleTop" value="1" /> 516 <!-- If, when starting the activity, there is already a task running 517 that starts with this activity, then instead of starting a new 518 instance the current task is brought to the front. The existing 519 instance will receive a call to {@link android.app.Activity#onNewIntent 520 Activity.onNewIntent()} 521 with the new Intent that is being started, and with the 522 {@link android.content.Intent#FLAG_ACTIVITY_BROUGHT_TO_FRONT 523 Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT} flag set. This is a superset 524 of the singleTop mode, where if there is already an instance 525 of the activity being started at the top of the stack, it will 526 receive the Intent as described there (without the 527 FLAG_ACTIVITY_BROUGHT_TO_FRONT flag set). See the 528 <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back 529 Stack</a> document for more details about tasks.--> 530 <enum name="singleTask" value="2" /> 531 <!-- Only allow one instance of this activity to ever be 532 running. This activity gets a unique task with only itself running 533 in it; if it is ever launched again with the same Intent, then that 534 task will be brought forward and its 535 {@link android.app.Activity#onNewIntent Activity.onNewIntent()} 536 method called. If this 537 activity tries to start a new activity, that new activity will be 538 launched in a separate task. See the 539 <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back 540 Stack</a> document for more details about tasks.--> 541 <enum name="singleInstance" value="3" /> 542 </attr> 543 544 <!-- Specify the orientation an activity should be run in. If not 545 specified, it will run in the current preferred orientation 546 of the screen. --> 547 <attr name="screenOrientation"> 548 <!-- No preference specified: let the system decide the best 549 orientation. This will either be the orientation selected 550 by the activity below, or the user's preferred orientation 551 if this activity is the bottom of a task. If the user 552 explicitly turned off sensor based orientation through settings 553 sensor based device rotation will be ignored. If not by default 554 sensor based orientation will be taken into account and the 555 orientation will changed based on how the user rotates the device --> 556 <enum name="unspecified" value="-1" /> 557 <!-- Would like to have the screen in a landscape orientation: that 558 is, with the display wider than it is tall, ignoring sensor data. --> 559 <enum name="landscape" value="0" /> 560 <!-- Would like to have the screen in a portrait orientation: that 561 is, with the display taller than it is wide, ignoring sensor data. --> 562 <enum name="portrait" value="1" /> 563 <!-- Use the user's current preferred orientation of the handset. --> 564 <enum name="user" value="2" /> 565 <!-- Keep the screen in the same orientation as whatever is behind 566 this activity. --> 567 <enum name="behind" value="3" /> 568 <!-- Orientation is determined by a physical orientation sensor: 569 the display will rotate based on how the user moves the device. --> 570 <enum name="sensor" value="4" /> 571 <!-- Always ignore orientation determined by orientation sensor: 572 the display will not rotate when the user moves the device. --> 573 <enum name="nosensor" value="5" /> 574 <!-- Would like to have the screen in landscape orientation, but can 575 use the sensor to change which direction the screen is facing. --> 576 <enum name="sensorLandscape" value="6" /> 577 <!-- Would like to have the screen in portrait orientation, but can 578 use the sensor to change which direction the screen is facing. --> 579 <enum name="sensorPortrait" value="7" /> 580 <!-- Would like to have the screen in landscape orientation, turned in 581 the opposite direction from normal landscape. --> 582 <enum name="reverseLandscape" value="8" /> 583 <!-- Would like to have the screen in portrait orientation, turned in 584 the opposite direction from normal portrait. --> 585 <enum name="reversePortrait" value="9" /> 586 <!-- Orientation is determined by a physical orientation sensor: 587 the display will rotate based on how the user moves the device. 588 This allows any of the 4 possible rotations, regardless of what 589 the device will normally do (for example some devices won't 590 normally use 180 degree rotation). --> 591 <enum name="fullSensor" value="10" /> 592 </attr> 593 594 <!-- Specify one or more configuration changes that the activity will 595 handle itself. If not specified, the activity will be restarted 596 if any of these configuration changes happen in the system. Otherwise, 597 the activity will remain running and its 598 {@link android.app.Activity#onConfigurationChanged Activity.onConfigurationChanged} 599 method called with the new configuration. 600 601 <p>Note that all of these configuration changes can impact the 602 resource values seen by the application, so you will generally need 603 to re-retrieve all resources (including view layouts, drawables, etc) 604 to correctly handle any configuration change. 605 606 <p>These values must be kept in sync with those in 607 {@link android.content.pm.ActivityInfo} and 608 include/utils/ResourceTypes.h. --> 609 <attr name="configChanges"> 610 <!-- The IMSI MCC has changed, that is a SIM has been detected and 611 updated the Mobile Country Code. --> 612 <flag name="mcc" value="0x0001" /> 613 <!-- The IMSI MNC has changed, that is a SIM has been detected and 614 updated the Mobile Network Code. --> 615 <flag name="mnc" value="0x0002" /> 616 <!-- The locale has changed, that is the user has selected a new 617 language that text should be displayed in. --> 618 <flag name="locale" value="0x0004" /> 619 <!-- The touchscreen has changed. Should never normally happen. --> 620 <flag name="touchscreen" value="0x0008" /> 621 <!-- The keyboard type has changed, for example the user has plugged 622 in an external keyboard. --> 623 <flag name="keyboard" value="0x0010" /> 624 <!-- The keyboard or navigation accessibility has changed, for example 625 the user has slid the keyboard out to expose it. Note that 626 despite its name, this applied to any accessibility: keyboard 627 or navigation. --> 628 <flag name="keyboardHidden" value="0x0020" /> 629 <!-- The navigation type has changed. Should never normally happen. --> 630 <flag name="navigation" value="0x0040" /> 631 <!-- The screen orientation has changed, that is the user has 632 rotated the device. --> 633 <flag name="orientation" value="0x0080" /> 634 <!-- The screen layout has changed. This might be caused by a 635 different display being activated. --> 636 <flag name="screenLayout" value="0x0100" /> 637 <!-- The global user interface mode has changed. For example, 638 going in or out of car mode, night mode changing, etc. --> 639 <flag name="uiMode" value="0x0200" /> 640 <!-- The current available screen size has changed. If applications don't 641 target at least {@link android.os.Build.VERSION_CODES#HONEYCOMB_MR2} 642 then the activity will always handle this itself (the change 643 will not result in a restart). This represents a change in the 644 currently available size, so will change when the user switches 645 between landscape and portrait. --> 646 <flag name="screenSize" value="0x0400" /> 647 <!-- The physical screen size has changed. If applications don't 648 target at least {@link android.os.Build.VERSION_CODES#HONEYCOMB_MR2} 649 then the activity will always handle this itself (the change 650 will not result in a restart). This represents a change in size 651 regardless of orientation, so will only change when the actual 652 physical screen size has changed such as switching to an external 653 display. --> 654 <flag name="smallestScreenSize" value="0x0800" /> 655 <!-- The layout direction has changed. For example going from LTR to RTL. --> 656 <flag name="layoutDirection" value="0x2000" /> 657 <!-- The font scaling factor has changed, that is the user has 658 selected a new global font size. --> 659 <flag name="fontScale" value="0x40000000" /> 660 </attr> 661 662 <!-- Descriptive text for the associated data. --> 663 <attr name="description" format="reference" /> 664 665 <!-- The name of the application package that an Instrumentation object 666 will run against. --> 667 <attr name="targetPackage" format="string" /> 668 669 <!-- Flag indicating that an Instrumentation class wants to take care 670 of starting/stopping profiling itself, rather than relying on 671 the default behavior of profiling the complete time it is running. 672 This allows it to target profiling data at a specific set of 673 operations. --> 674 <attr name="handleProfiling" format="boolean" /> 675 676 <!-- Flag indicating that an Instrumentation class should be run as a 677 functional test. --> 678 <attr name="functionalTest" format="boolean" /> 679 680 <!-- The touch screen type used by an application. --> 681 <attr name="reqTouchScreen"> 682 <enum name="undefined" value="0" /> 683 <enum name="notouch" value="1" /> 684 <enum name="stylus" value="2" /> 685 <enum name="finger" value="3" /> 686 </attr> 687 688 <!-- The input method preferred by an application. --> 689 <attr name="reqKeyboardType"> 690 <enum name="undefined" value="0" /> 691 <enum name="nokeys" value="1" /> 692 <enum name="qwerty" value="2" /> 693 <enum name="twelvekey" value="3" /> 694 </attr> 695 696 <!-- Application's requirement for a hard keyboard --> 697 <attr name="reqHardKeyboard" format="boolean" /> 698 699 <!-- The navigation device preferred by an application. --> 700 <attr name="reqNavigation"> 701 <enum name="undefined" value="0" /> 702 <enum name="nonav" value="1" /> 703 <enum name="dpad" value="2" /> 704 <enum name="trackball" value="3" /> 705 <enum name="wheel" value="4" /> 706 </attr> 707 708 <!-- Application's requirement for five way navigation --> 709 <attr name="reqFiveWayNav" format="boolean" /> 710 711 <!-- The name of the class subclassing <code>BackupAgent</code> to manage 712 backup and restore of the application's data on external storage. --> 713 <attr name="backupAgent" format="string" /> 714 715 <!-- Whether to allow the application to participate in the backup 716 and restore infrastructure. If this attribute is set to <code>false</code>, 717 no backup or restore of the application will ever be performed, even by a 718 full-system backup that would otherwise cause all application data to be saved 719 via adb. The default value of this attribute is <code>true</code>. --> 720 <attr name="allowBackup" format="boolean" /> 721 722 <!-- Whether the application in question should be terminated after its 723 settings have been restored during a full-system restore operation. 724 Single-package restore operations will never cause the application to 725 be shut down. Full-system restore operations typically only occur once, 726 when the phone is first set up. Third-party applications will not usually 727 need to use this attribute. 728 729 <p>The default is <code>true</code>, which means that after the application 730 has finished processing its data during a full-system restore, it will be 731 terminated. --> 732 <attr name="killAfterRestore" format="boolean" /> 733 734 <!-- @deprecated This attribute is not used by the Android operating system. --> 735 <attr name="restoreNeedsApplication" format="boolean" /> 736 737 <!-- Indicate that the application is prepared to attempt a restore of any 738 backed-up dataset, even if the backup is apparently from a newer version 739 of the application than is currently installed on the device. Setting 740 this attribute to <code>true</code> will permit the Backup Manager to 741 attempt restore even when a version mismatch suggests that the data are 742 incompatible. <em>Use with caution!</em> 743 744 <p>The default value of this attribute is <code>false</code>. --> 745 <attr name="restoreAnyVersion" format="boolean" /> 746 747 <!-- The default install location defined by an application. --> 748 <attr name="installLocation"> 749 <!-- Let the system decide ideal install location --> 750 <enum name="auto" value="0" /> 751 <!-- Explicitly request to be installed on internal phone storage 752 only. --> 753 <enum name="internalOnly" value="1" /> 754 <!-- Prefer to be installed on SD card. There is no guarantee that 755 the system will honor this request. The application might end 756 up being installed on internal storage if external media 757 is unavailable or too full. --> 758 <enum name="preferExternal" value="2" /> 759 </attr> 760 761 <!-- Extra options for an activity's UI. Applies to either the {@code <activity>} or 762 {@code <application>} tag. If specified on the {@code <application>} 763 tag these will be considered defaults for all activities in the 764 application. --> 765 <attr name="uiOptions"> 766 <!-- No extra UI options. This is the default. --> 767 <flag name="none" value="0" /> 768 <!-- Split the options menu into a separate bar at the bottom of 769 the screen when severely constrained for horizontal space. 770 (e.g. portrait mode on a phone.) Instead of a small number 771 of action buttons appearing in the action bar at the top 772 of the screen, the action bar will split into the top navigation 773 section and the bottom menu section. Menu items will not be 774 split across the two bars; they will always appear together. --> 775 <flag name="splitActionBarWhenNarrow" value="1" /> 776 </attr> 777 778 <!-- The name of the logical parent of the activity as it appears in the manifest. --> 779 <attr name="parentActivityName" format="string" /> 780 781 <!-- The <code>manifest</code> tag is the root of an 782 <code>AndroidManifest.xml</code> file, 783 describing the contents of an Android package (.apk) file. One 784 attribute must always be supplied: <code>package</code> gives a 785 unique name for the package, using a Java-style naming convention 786 to avoid name collisions. For example, applications published 787 by Google could have names of the form 788 <code>com.google.app.<em>appname</em></code> 789 790 <p>Inside of the manifest tag, may appear the following tags 791 in any order: {@link #AndroidManifestPermission permission}, 792 {@link #AndroidManifestPermissionGroup permission-group}, 793 {@link #AndroidManifestPermissionTree permission-tree}, 794 {@link #AndroidManifestUsesSdk uses-sdk}, 795 {@link #AndroidManifestUsesPermission uses-permission}, 796 {@link #AndroidManifestUsesConfiguration uses-configuration}, 797 {@link #AndroidManifestApplication application}, 798 {@link #AndroidManifestInstrumentation instrumentation}, 799 {@link #AndroidManifestUsesFeature uses-feature}. --> 800 <declare-styleable name="AndroidManifest"> 801 <attr name="versionCode" /> 802 <attr name="versionName" /> 803 <attr name="sharedUserId" /> 804 <attr name="sharedUserLabel" /> 805 <attr name="installLocation" /> 806 </declare-styleable> 807 808 <!-- The <code>application</code> tag describes application-level components 809 contained in the package, as well as general application 810 attributes. Many of the attributes you can supply here (such 811 as theme, label, icon, permission, process, taskAffinity, 812 and allowTaskReparenting) serve 813 as default values for the corresponding attributes of components 814 declared inside of the application. 815 816 <p>Inside of this element you specify what the application contains, 817 using the elements {@link #AndroidManifestProvider provider}, 818 {@link #AndroidManifestService service}, 819 {@link #AndroidManifestReceiver receiver}, 820 {@link #AndroidManifestActivity activity}, 821 {@link #AndroidManifestActivityAlias activity-alias}, and 822 {@link #AndroidManifestUsesLibrary uses-library}. The application tag 823 appears as a child of the root {@link #AndroidManifest manifest} tag. --> 824 <declare-styleable name="AndroidManifestApplication" parent="AndroidManifest"> 825 <!-- An optional name of a class implementing the overall 826 {@link android.app.Application} for this package. When the 827 process for your package is started, this class is instantiated 828 before any of the other application components. Note that this 829 is not required, and in fact most applications will probably 830 not need it. --> 831 <attr name="name" /> 832 <attr name="theme" /> 833 <attr name="label" /> 834 <attr name="icon" /> 835 <attr name="logo" /> 836 <attr name="description" /> 837 <attr name="permission" /> 838 <attr name="process" /> 839 <attr name="taskAffinity" /> 840 <attr name="allowTaskReparenting" /> 841 <!-- Indicate whether this application contains code. If set to false, 842 there is no code associated with it and thus the system will not 843 try to load its code when launching components. The default is true 844 for normal behavior. --> 845 <attr name="hasCode" format="boolean" /> 846 <attr name="persistent" /> 847 <!-- Specify whether the components in this application are enabled or not (that is, can be 848 instantiated by the system). 849 If "false", it overrides any component specific values (a value of "true" will not 850 override the component specific values). --> 851 <attr name="enabled" /> 852 <attr name="debuggable" /> 853 <attr name="vmSafeMode" /> 854 <attr name="hardwareAccelerated" /> 855 <!-- Name of activity to be launched for managing the application's space on the device. --> 856 <attr name="manageSpaceActivity" /> 857 <attr name="allowClearUserData" /> 858 <attr name="testOnly" /> 859 <attr name="backupAgent" /> 860 <attr name="allowBackup" /> 861 <attr name="killAfterRestore" /> 862 <attr name="restoreNeedsApplication" /> 863 <attr name="restoreAnyVersion" /> 864 <attr name="neverEncrypt" /> 865 <!-- Request that your application's processes be created with 866 a large Dalvik heap. This applies to <em>all</em> processes 867 created for the application. It only applies to the first 868 application loaded into a process; if using a sharedUserId 869 to allow multiple applications to use a process, they all must 870 use this option consistently or will get unpredictable results. --> 871 <attr name="largeHeap" format="boolean" /> 872 <!-- Declare that this application can't participate in the normal 873 state save/restore mechanism. Since it is not able to save and 874 restore its state on demand, 875 it can not participate in the normal activity lifecycle. It will 876 not be killed while in the background; the user must explicitly 877 quit it. Only one such app can be running at a time; if the user 878 tries to launch a second such app, they will be prompted 879 to quit the first before doing so. While the 880 application is running, the user will be informed of this. 881 @hide --> 882 <attr name="cantSaveState" format="boolean" /> 883 <attr name="uiOptions" /> 884 <!-- Declare that your application will be able to deal with RTL (right to left) layouts. 885 If set to false (default value), your application will not care about RTL layouts. --> 886 <attr name="supportsRtl" format="boolean" /> 887 </declare-styleable> 888 889 <!-- The <code>permission</code> tag declares a security permission that can be 890 used to control access from other packages to specific components or 891 features in your package (or other packages). See the 892 <a href="{@docRoot}guide/topics/security/security.html">Security and Permissions</a> 893 document for more information on permissions. 894 895 <p>This appears as a child tag of the root 896 {@link #AndroidManifest manifest} tag. --> 897 <declare-styleable name="AndroidManifestPermission" parent="AndroidManifest"> 898 <!-- Required public name of the permission, which other components and 899 packages will use when referring to this permission. This is a string using 900 Java-style scoping to ensure it is unique. The prefix will often 901 be the same as our overall package name, for example 902 "com.mycompany.android.myapp.SomePermission". --> 903 <attr name="name" /> 904 <attr name="label" /> 905 <attr name="icon" /> 906 <attr name="logo" /> 907 <attr name="permissionGroup" /> 908 <attr name="description" /> 909 <attr name="protectionLevel" /> 910 <attr name="permissionFlags" /> 911 </declare-styleable> 912 913 <!-- The <code>permission-group</code> tag declares a logical grouping of 914 related permissions. 915 916 <p>Note that this tag does not declare a permission itself, only 917 a namespace in which further permissions can be placed. See 918 the {@link #AndroidManifestPermission <permission>} tag for 919 more information. 920 921 <p>This appears as a child tag of the root 922 {@link #AndroidManifest manifest} tag. --> 923 <declare-styleable name="AndroidManifestPermissionGroup" parent="AndroidManifest"> 924 <!-- Required public name of the permission group, permissions will use 925 to specify the group they are in. This is a string using 926 Java-style scoping to ensure it is unique. The prefix will often 927 be the same as our overall package name, for example 928 "com.mycompany.android.myapp.SomePermission". --> 929 <attr name="name" /> 930 <attr name="label" /> 931 <attr name="icon" /> 932 <attr name="logo" /> 933 <attr name="description" /> 934 <attr name="permissionGroupFlags" /> 935 <attr name="priority" /> 936 </declare-styleable> 937 938 <!-- The <code>permission-tree</code> tag declares the base of a tree of 939 permission values: it declares that this package has ownership of 940 the given permission name, as well as all names underneath it 941 (separated by '.'). This allows you to use the 942 {@link android.content.pm.PackageManager#addPermission 943 PackageManager.addPermission()} method to dynamically add new 944 permissions under this tree. 945 946 <p>Note that this tag does not declare a permission itself, only 947 a namespace in which further permissions can be placed. See 948 the {@link #AndroidManifestPermission <permission>} tag for 949 more information. 950 951 <p>This appears as a child tag of the root 952 {@link #AndroidManifest manifest} tag. --> 953 <declare-styleable name="AndroidManifestPermissionTree" parent="AndroidManifest"> 954 <!-- Required public name of the permission tree, which is the base name 955 of all permissions under it. This is a string using 956 Java-style scoping to ensure it is unique. The prefix will often 957 be the same as our overall package name, for example 958 "com.mycompany.android.myapp.SomePermission". A permission tree name 959 must have more than two segments in its path; that is, 960 "com.me.foo" is okay, but not "com.me" or "com". --> 961 <attr name="name" /> 962 <attr name="label" /> 963 <attr name="icon" /> 964 <attr name="logo" /> 965 </declare-styleable> 966 967 <!-- The <code>uses-permission</code> tag requests a 968 {@link #AndroidManifestPermission <permission>} that the containing 969 package must be granted in order for it to operate correctly. 970 See the <a href="{@docRoot}guide/topics/security/security.html">Security and Permissions</a> 971 document for more information on permissions. Also available is a 972 {@link android.Manifest.permission list of permissions} included 973 with the base platform. 974 975 <p>This appears as a child tag of the root 976 {@link #AndroidManifest manifest} tag. --> 977 <declare-styleable name="AndroidManifestUsesPermission" parent="AndroidManifest"> 978 <!-- Required name of the permission you use, as published with the 979 corresponding name attribute of a 980 {@link android.R.styleable#AndroidManifestPermission <permission>} 981 tag; often this is one of the {@link android.Manifest.permission standard 982 system permissions}. --> 983 <attr name="name" /> 984 <!-- Specify whether this permission is required for the application. 985 The default is true, meaning the application requires the 986 permission, and it must always be granted when it is installed. 987 If you set this to false, then in some cases the application may 988 be installed with it being granted the permission, and it will 989 need to request the permission later if it needs it. 990 <attr name="required" format="boolean" /> 991 --> 992 </declare-styleable> 993 994 <!-- The <code>uses-configuration</code> tag specifies 995 a specific hardware configuration value used by the application. 996 For example an application might specify that it requires 997 a physical keyboard or a particular navigation method like 998 trackball. Multiple such attribute values can be specified by the 999 application. 1000 1001 <p>This appears as a child tag of the root 1002 {@link #AndroidManifest manifest} tag. --> 1003 <declare-styleable name="AndroidManifestUsesConfiguration" parent="AndroidManifest"> 1004 <!-- The type of touch screen used by an application. --> 1005 <attr name="reqTouchScreen" /> 1006 <attr name="reqKeyboardType" /> 1007 <attr name="reqHardKeyboard" /> 1008 <attr name="reqNavigation" /> 1009 <attr name="reqFiveWayNav" /> 1010 </declare-styleable> 1011 1012 <!-- The <code>uses-feature</code> tag specifies 1013 a specific feature used by the application. 1014 For example an application might specify that it requires 1015 specific version of OpenGL. Multiple such attribute 1016 values can be specified by the application. 1017 1018 <p>This appears as a child tag of the root 1019 {@link #AndroidManifest manifest} tag. --> 1020 <declare-styleable name="AndroidManifestUsesFeature" parent="AndroidManifest"> 1021 <!-- The GLES driver version number needed by an application. 1022 The higher 16 bits represent the major number and the lower 16 bits 1023 represent the minor number. For example for GL 1.2 referring to 1024 0x00000102, the actual value should be set as 0x00010002. --> 1025 <attr name="glEsVersion" format="integer"/> 1026 <!-- The name of the feature that is being used. --> 1027 <attr name="name" /> 1028 <!-- Specify whether this feature is required for the application. 1029 The default is true, meaning the application requires the 1030 feature, and does not want to be installed on devices that 1031 don't support it. If you set this to false, then this will 1032 not impose a restriction on where the application can be 1033 installed. --> 1034 <attr name="required" format="boolean" /> 1035 </declare-styleable> 1036 1037 <!-- The <code>uses-sdk</code> tag describes the SDK features that the 1038 containing package must be running on to operate correctly. 1039 1040 <p>This appears as a child tag of the root 1041 {@link #AndroidManifest manifest} tag. --> 1042 <declare-styleable name="AndroidManifestUsesSdk" parent="AndroidManifest"> 1043 <!-- This is the minimum SDK version number that the application 1044 requires. This number is an abstract integer, from the list 1045 in {@link android.os.Build.VERSION_CODES} If 1046 not supplied, the application will work on any SDK. This 1047 may also be string (such as "Donut") if the application was built 1048 against a development branch, in which case it will only work against 1049 the development builds. --> 1050 <attr name="minSdkVersion" format="integer|string" /> 1051 <!-- This is the SDK version number that the application is targeting. 1052 It is able to run on older versions (down to minSdkVersion), but 1053 was explicitly tested to work with the version specified here. 1054 Specifying this version allows the platform to disable compatibility 1055 code that are not required or enable newer features that are not 1056 available to older applications. This may also be a string 1057 (such as "Donut") if this is built against a development 1058 branch, in which case minSdkVersion is also forced to be that 1059 string. --> 1060 <attr name="targetSdkVersion" format="integer|string" /> 1061 <!-- This is the maximum SDK version number that an application works 1062 on. You can use this to ensure your application is filtered out 1063 of later versions of the platform when you know you have 1064 incompatibility with them. --> 1065 <attr name="maxSdkVersion" format="integer" /> 1066 </declare-styleable> 1067 1068 <!-- The <code>uses-libraries</code> specifies a shared library that this 1069 package requires to be linked against. Specifying this flag tells the 1070 system to include this library's code in your class loader. 1071 1072 <p>This appears as a child tag of the 1073 {@link #AndroidManifestApplication application} tag. --> 1074 <declare-styleable name="AndroidManifestUsesLibrary" parent="AndroidManifestApplication"> 1075 <!-- Required name of the library you use. --> 1076 <attr name="name" /> 1077 <!-- Specify whether this library is required for the application. 1078 The default is true, meaning the application requires the 1079 library, and does not want to be installed on devices that 1080 don't support it. If you set this to false, then this will 1081 allow the application to be installed even if the library 1082 doesn't exist, and you will need to check for its presence 1083 dynamically at runtime. --> 1084 <attr name="required" /> 1085 </declare-styleable> 1086 1087 <!-- The <code>supports-screens</code> specifies the screen dimensions an 1088 application supports. By default a modern application supports all 1089 screen sizes and must explicitly disable certain screen sizes here; 1090 older applications are assumed to only support the traditional normal 1091 (HVGA) screen size. Note that screen size is a separate axis from 1092 density, and is determined as the available pixels to an application 1093 after density scaling has been applied. 1094 1095 <p>This appears as a child tag of the 1096 {@link #AndroidManifest manifest} tag. --> 1097 <declare-styleable name="AndroidManifestSupportsScreens" parent="AndroidManifest"> 1098 <!-- Starting with {@link android.os.Build.VERSION_CODES#HONEYCOMB_MR2}, 1099 this is the new way to specify the minimum screen size an application is 1100 compatible with. This attribute provides the required minimum 1101 "smallest screen width" (as per the -swNNNdp resource configuration) 1102 that the application can run on. For example, a typical phone 1103 screen is 320, a 7" tablet 600, and a 10" tablet 720. If the 1104 smallest screen width of the device is below the value supplied here, 1105 then the application is considered incompatible with that device. 1106 If not supplied, then any old smallScreens, normalScreens, largeScreens, 1107 or xlargeScreens attributes will be used instead. --> 1108 <attr name="requiresSmallestWidthDp" format="integer" /> 1109 <!-- Starting with {@link android.os.Build.VERSION_CODES#HONEYCOMB_MR2}, 1110 this is the new way to specify the largest screens an application is 1111 compatible with. This attribute provides the maximum 1112 "smallest screen width" (as per the -swNNNdp resource configuration) 1113 that the application is designed for. If this value is smaller than 1114 the "smallest screen width" of the device it is running on, the user 1115 is offered to run it in a compatibility mode that emulates a 1116 smaller screen and zooms it to fit the screen. Currently the compatibility mode only 1117 emulates phone screens with a 320dp width, so compatibility mode is not applied if the 1118 value for compatibleWidthLimitDp is larger than 320. --> 1119 <attr name="compatibleWidthLimitDp" format="integer" /> 1120 <!-- Starting with {@link android.os.Build.VERSION_CODES#HONEYCOMB_MR2}, 1121 this is the new way to specify the screens an application is 1122 compatible with. This attribute provides the maximum 1123 "smallest screen width" (as per the -swNNNdp resource configuration) 1124 that the application can work well on. If this value is smaller than 1125 the "smallest screen width" of the device it is running on, the 1126 application will be forced in to screen compatibility mode with 1127 no way for the user to turn it off. Currently the compatibility mode only 1128 emulates phone screens with a 320dp width, so compatibility mode is not applied if the 1129 value for largestWidthLimitDp is larger than 320. --> 1130 <attr name="largestWidthLimitDp" format="integer" /> 1131 <!-- Indicates whether the application supports smaller screen form-factors. 1132 A small screen is defined as one with a smaller aspect ratio than 1133 the traditional HVGA screen; that is, for a portrait screen, less 1134 tall than an HVGA screen. In practice, this means a QVGA low 1135 density or VGA high density screen. An application that does 1136 not support small screens <em>will not be available</em> for 1137 small screen devices, since there is little the platform can do 1138 to make such an application work on a smaller screen. --> 1139 <attr name="smallScreens" format="boolean" /> 1140 <!-- Indicates whether an application supports the normal screen 1141 form-factors. Traditionally this is an HVGA normal density 1142 screen, but WQVGA low density and WVGA high density are also 1143 considered to be normal. This attribute is true by default, 1144 and applications currently should leave it that way. --> 1145 <attr name="normalScreens" format="boolean" /> 1146 <!-- Indicates whether the application supports larger screen form-factors. 1147 A large screen is defined as a screen that is significantly larger 1148 than a normal phone screen, and thus may require some special care 1149 on the application's part to make good use of it. An example would 1150 be a VGA <em>normal density</em> screen, though even larger screens 1151 are certainly possible. An application that does not support 1152 large screens will be placed as a postage stamp on such a 1153 screen, so that it retains the dimensions it was originally 1154 designed for. --> 1155 <attr name="largeScreens" format="boolean" /> 1156 <!-- Indicates whether the application supports extra large screen form-factors. --> 1157 <attr name="xlargeScreens" format="boolean" /> 1158 <!-- Indicates whether the application can resize itself to newer 1159 screen sizes. This is mostly used to distinguish between old 1160 applications that may not be compatible with newly introduced 1161 screen sizes and newer applications that should be; it will be 1162 set for you automatically based on whether you are targeting 1163 a newer platform that supports more screens. --> 1164 <attr name="resizeable" format="boolean" /> 1165 <!-- Indicates whether the application can accommodate any screen 1166 density. Older applications are assumed to not be able to, 1167 new ones able to. You can explicitly supply your abilities 1168 here. --> 1169 <attr name="anyDensity" format="boolean" /> 1170 </declare-styleable> 1171 1172 <!-- Private tag to declare system protected broadcast actions. 1173 1174 <p>This appears as a child tag of the root 1175 {@link #AndroidManifest manifest} tag. --> 1176 <declare-styleable name="AndroidManifestProtectedBroadcast" parent="AndroidManifest"> 1177 <attr name="name" /> 1178 </declare-styleable> 1179 1180 <!-- Private tag to declare the original package name that this package is 1181 based on. Only used for packages installed in the system image. If 1182 given, and different than the actual package name, and the given 1183 original package was previously installed on the device but the new 1184 one was not, then the data for the old one will be renamed to be 1185 for the new package. 1186 1187 <p>This appears as a child tag of the root 1188 {@link #AndroidManifest manifest} tag. --> 1189 <declare-styleable name="AndroidManifestOriginalPackage" parent="AndroidManifest"> 1190 <attr name="name" /> 1191 </declare-styleable> 1192 1193 <!-- The <code>provider</code> tag declares a 1194 {@link android.content.ContentProvider} class that is available 1195 as part of the package's application components, supplying structured 1196 access to data managed by the application. 1197 1198 <p>This appears as a child tag of the 1199 {@link #AndroidManifestApplication application} tag. --> 1200 <declare-styleable name="AndroidManifestProvider" parent="AndroidManifestApplication"> 1201 <!-- Required name of the class implementing the provider, deriving from 1202 {@link android.content.ContentProvider}. This is a fully 1203 qualified class name (for example, com.mycompany.myapp.MyProvider); as a 1204 short-hand if the first character of the class 1205 is a period then it is appended to your package name. --> 1206 <attr name="name" /> 1207 <attr name="label" /> 1208 <attr name="description" /> 1209 <attr name="icon" /> 1210 <attr name="logo" /> 1211 <attr name="process" /> 1212 <attr name="authorities" /> 1213 <attr name="syncable" /> 1214 <attr name="readPermission" /> 1215 <attr name="writePermission" /> 1216 <attr name="grantUriPermissions" /> 1217 <attr name="permission" /> 1218 <attr name="multiprocess" /> 1219 <attr name="initOrder" /> 1220 <!-- Specify whether this provider is enabled or not (that is, can be instantiated by the system). 1221 It can also be specified for an application as a whole, in which case a value of "false" 1222 will override any component specific values (a value of "true" will not override the 1223 component specific values). --> 1224 <attr name="enabled" /> 1225 <attr name="exported" /> 1226 <attr name="singleUser" /> 1227 </declare-styleable> 1228 1229 <!-- Attributes that can be supplied in an AndroidManifest.xml 1230 <code>grant-uri-permission</code> tag, a child of the 1231 {@link #AndroidManifestProvider provider} tag, describing a specific 1232 URI path that can be granted as a permission. This tag can be 1233 specified multiple time to supply multiple paths. --> 1234 <declare-styleable name="AndroidManifestGrantUriPermission" parent="AndroidManifestProvider"> 1235 <!-- Specify a URI path that must exactly match, as per 1236 {@link android.os.PatternMatcher} with 1237 {@link android.os.PatternMatcher#PATTERN_LITERAL}. --> 1238 <attr name="path" format="string" /> 1239 <!-- Specify a URI path that must be a prefix to match, as per 1240 {@link android.os.PatternMatcher} with 1241 {@link android.os.PatternMatcher#PATTERN_PREFIX}. --> 1242 <attr name="pathPrefix" format="string" /> 1243 <!-- Specify a URI path that matches a simple pattern, as per 1244 {@link android.os.PatternMatcher} with 1245 {@link android.os.PatternMatcher#PATTERN_SIMPLE_GLOB}. 1246 Note that because '\' is used as an escape character when 1247 reading the string from XML (before it is parsed as a pattern), 1248 you will need to double-escape: for example a literal "*" would 1249 be written as "\\*" and a literal "\" would be written as 1250 "\\\\". This is basically the same as what you would need to 1251 write if constructing the string in Java code. --> 1252 <attr name="pathPattern" format="string" /> 1253 </declare-styleable> 1254 1255 <!-- Attributes that can be supplied in an AndroidManifest.xml 1256 <code>path-permission</code> tag, a child of the 1257 {@link #AndroidManifestProvider provider} tag, describing a permission 1258 that allows access to a specific path in the provider. This tag can be 1259 specified multiple time to supply multiple paths. --> 1260 <declare-styleable name="AndroidManifestPathPermission" parent="AndroidManifestProvider"> 1261 <attr name="path" /> 1262 <attr name="pathPrefix" /> 1263 <attr name="pathPattern" /> 1264 <attr name="permission" /> 1265 <attr name="readPermission" /> 1266 <attr name="writePermission" /> 1267 </declare-styleable> 1268 1269 <!-- The <code>service</code> tag declares a 1270 {@link android.app.Service} class that is available 1271 as part of the package's application components, implementing 1272 long-running background operations or a rich communication API 1273 that can be called by other packages. 1274 1275 <p>Zero or more {@link #AndroidManifestIntentFilter intent-filter} 1276 tags can be included inside of a service, to specify the Intents 1277 that can connect with it. If none are specified, the service can 1278 only be accessed by direct specification of its class name. 1279 The service tag appears as a child tag of the 1280 {@link #AndroidManifestApplication application} tag. --> 1281 <declare-styleable name="AndroidManifestService" parent="AndroidManifestApplication"> 1282 <!-- Required name of the class implementing the service, deriving from 1283 {@link android.app.Service}. This is a fully 1284 qualified class name (for example, com.mycompany.myapp.MyService); as a 1285 short-hand if the first character of the class 1286 is a period then it is appended to your package name. --> 1287 <attr name="name" /> 1288 <attr name="label" /> 1289 <attr name="description" /> 1290 <attr name="icon" /> 1291 <attr name="logo" /> 1292 <attr name="permission" /> 1293 <attr name="process" /> 1294 <!-- Specify whether the service is enabled or not (that is, can be instantiated by the system). 1295 It can also be specified for an application as a whole, in which case a value of "false" 1296 will override any component specific values (a value of "true" will not override the 1297 component specific values). --> 1298 <attr name="enabled" /> 1299 <attr name="exported" /> 1300 <!-- If set to true, this service with be automatically stopped 1301 when the user remove a task rooted in an activity owned by 1302 the application. The default is false. --> 1303 <attr name="stopWithTask" format="boolean" /> 1304 <!-- If set to true, this service will run under a special process 1305 that is isolated from the rest of the system. The only communication 1306 with it is through the Service API (binding and starting). --> 1307 <attr name="isolatedProcess" format="boolean" /> 1308 <attr name="singleUser" /> 1309 </declare-styleable> 1310 1311 <!-- The <code>receiver</code> tag declares an 1312 {@link android.content.BroadcastReceiver} class that is available 1313 as part of the package's application components, allowing the 1314 application to receive actions or data broadcast by other 1315 applications even if it is not currently running. 1316 1317 <p>Zero or more {@link #AndroidManifestIntentFilter intent-filter} 1318 tags can be included inside of a receiver, to specify the Intents 1319 it will receive. If none are specified, the receiver will only 1320 be run when an Intent is broadcast that is directed at its specific 1321 class name. The receiver tag appears as a child tag of the 1322 {@link #AndroidManifestApplication application} tag. --> 1323 <declare-styleable name="AndroidManifestReceiver" parent="AndroidManifestApplication"> 1324 <!-- Required name of the class implementing the receiver, deriving from 1325 {@link android.content.BroadcastReceiver}. This is a fully 1326 qualified class name (for example, com.mycompany.myapp.MyReceiver); as a 1327 short-hand if the first character of the class 1328 is a period then it is appended to your package name. --> 1329 <attr name="name" /> 1330 <attr name="label" /> 1331 <attr name="description" /> 1332 <attr name="icon" /> 1333 <attr name="logo" /> 1334 <attr name="permission" /> 1335 <attr name="process" /> 1336 <!-- Specify whether the receiver is enabled or not (that is, can be instantiated by the system). 1337 It can also be specified for an application as a whole, in which case a value of "false" 1338 will override any component specific values (a value of "true" will not override the 1339 component specific values). --> 1340 <attr name="enabled" /> 1341 <attr name="exported" /> 1342 <attr name="singleUser" /> 1343 </declare-styleable> 1344 1345 <!-- The <code>activity</code> tag declares an 1346 {@link android.app.Activity} class that is available 1347 as part of the package's application components, implementing 1348 a part of the application's user interface. 1349 1350 <p>Zero or more {@link #AndroidManifestIntentFilter intent-filter} 1351 tags can be included inside of an activity, to specify the Intents 1352 that it can handle. If none are specified, the activity can 1353 only be started through direct specification of its class name. 1354 The activity tag appears as a child tag of the 1355 {@link #AndroidManifestApplication application} tag. --> 1356 <declare-styleable name="AndroidManifestActivity" parent="AndroidManifestApplication"> 1357 <!-- Required name of the class implementing the activity, deriving from 1358 {@link android.app.Activity}. This is a fully 1359 qualified class name (for example, com.mycompany.myapp.MyActivity); as a 1360 short-hand if the first character of the class 1361 is a period then it is appended to your package name. --> 1362 <attr name="name" /> 1363 <attr name="theme" /> 1364 <attr name="label" /> 1365 <attr name="description" /> 1366 <attr name="icon" /> 1367 <attr name="logo" /> 1368 <attr name="launchMode" /> 1369 <attr name="screenOrientation" /> 1370 <attr name="configChanges" /> 1371 <attr name="permission" /> 1372 <attr name="multiprocess" /> 1373 <attr name="process" /> 1374 <attr name="taskAffinity" /> 1375 <attr name="allowTaskReparenting" /> 1376 <attr name="finishOnTaskLaunch" /> 1377 <attr name="finishOnCloseSystemDialogs" /> 1378 <attr name="clearTaskOnLaunch" /> 1379 <attr name="noHistory" /> 1380 <attr name="alwaysRetainTaskState" /> 1381 <attr name="stateNotNeeded" /> 1382 <attr name="excludeFromRecents" /> 1383 <attr name="showOnLockScreen" /> 1384 <!-- Specify whether the activity is enabled or not (that is, can be instantiated by the system). 1385 It can also be specified for an application as a whole, in which case a value of "false" 1386 will override any component specific values (a value of "true" will not override the 1387 component specific values). --> 1388 <attr name="enabled" /> 1389 <attr name="exported" /> 1390 <!-- Specify the default soft-input mode for the main window of 1391 this activity. A value besides "unspecified" here overrides 1392 any value in the theme. --> 1393 <attr name="windowSoftInputMode" /> 1394 <attr name="immersive" /> 1395 <attr name="hardwareAccelerated" /> 1396 <attr name="uiOptions" /> 1397 <attr name="parentActivityName" /> 1398 <attr name="singleUser" /> 1399 <!-- @hide This broacast receiver will only receive broadcasts for the 1400 primary user. Can only be used with receivers. --> 1401 <attr name="primaryUserOnly" format="boolean" /> 1402 </declare-styleable> 1403 1404 <!-- The <code>activity-alias</code> tag declares a new 1405 name for an existing {@link #AndroidManifestActivity activity} 1406 tag. 1407 1408 <p>Zero or more {@link #AndroidManifestIntentFilter intent-filter} 1409 tags can be included inside of an activity-alias, to specify the Intents 1410 that it can handle. If none are specified, the activity can 1411 only be started through direct specification of its class name. 1412 The activity-alias tag appears as a child tag of the 1413 {@link #AndroidManifestApplication application} tag. --> 1414 <declare-styleable name="AndroidManifestActivityAlias" parent="AndroidManifestApplication"> 1415 <!-- Required name of the class implementing the activity, deriving from 1416 {@link android.app.Activity}. This is a fully 1417 qualified class name (for example, com.mycompany.myapp.MyActivity); as a 1418 short-hand if the first character of the class 1419 is a period then it is appended to your package name. --> 1420 <attr name="name" /> 1421 <!-- The name of the activity this alias should launch. The activity 1422 must be in the same manifest as the alias, and have been defined 1423 in that manifest before the alias here. This must use a Java-style 1424 naming convention to ensure the name is unique, for example 1425 "com.mycompany.MyName". --> 1426 <attr name="targetActivity" format="string" /> 1427 <attr name="label" /> 1428 <attr name="description" /> 1429 <attr name="icon" /> 1430 <attr name="logo" /> 1431 <attr name="permission" /> 1432 <!-- Specify whether the activity-alias is enabled or not (that is, can be instantiated by the system). 1433 It can also be specified for an application as a whole, in which case a value of "false" 1434 will override any component specific values (a value of "true" will not override the 1435 component specific values). --> 1436 <attr name="enabled" /> 1437 <attr name="exported" /> 1438 <attr name="parentActivityName" /> 1439 </declare-styleable> 1440 1441 <!-- The <code>meta-data</code> tag is used to attach additional 1442 arbitrary data to an application component. The data can later 1443 be retrieved programmatically from the 1444 {@link android.content.pm.ComponentInfo#metaData 1445 ComponentInfo.metaData} field. There is no meaning given to this 1446 data by the system. You may supply the data through either the 1447 <code>value</code> or <code>resource</code> attribute; if both 1448 are given, then <code>resource</code> will be used. 1449 1450 <p>It is highly recommended that you avoid supplying related data as 1451 multiple separate meta-data entries. Instead, if you have complex 1452 data to associate with a component, then use the <code>resource</code> 1453 attribute to assign an XML resource that the client can parse to 1454 retrieve the complete data. --> 1455 <declare-styleable name="AndroidManifestMetaData" 1456 parent="AndroidManifestApplication 1457 AndroidManifestActivity 1458 AndroidManifestReceiver 1459 AndroidManifestProvider 1460 AndroidManifestService 1461 AndroidManifestPermission 1462 AndroidManifestPermissionGroup 1463 AndroidManifestInstrumentation"> 1464 <attr name="name" /> 1465 <!-- Concrete value to assign to this piece of named meta-data. 1466 The data can later be retrieved from the meta data Bundle 1467 through {@link android.os.Bundle#getString Bundle.getString}, 1468 {@link android.os.Bundle#getInt Bundle.getInt}, 1469 {@link android.os.Bundle#getBoolean Bundle.getBoolean}, 1470 or {@link android.os.Bundle#getFloat Bundle.getFloat} depending 1471 on the type used here. --> 1472 <attr name="value" format="string|integer|color|float|boolean" /> 1473 <!-- Resource identifier to assign to this piece of named meta-data. 1474 The resource identifier can later be retrieved from the meta data 1475 Bundle through {@link android.os.Bundle#getInt Bundle.getInt}. --> 1476 <attr name="resource" format="reference" /> 1477 </declare-styleable> 1478 1479 <!-- The <code>intent-filter</code> tag is used to construct an 1480 {@link android.content.IntentFilter} object that will be used 1481 to determine which component can handle a particular 1482 {@link android.content.Intent} that has been given to the system. 1483 It can be used as a child of the 1484 {@link #AndroidManifestActivity activity}, 1485 {@link #AndroidManifestReceiver receiver} and 1486 {@link #AndroidManifestService service} 1487 tags. 1488 1489 <p> Zero or more {@link #AndroidManifestAction action}, 1490 {@link #AndroidManifestCategory category}, and/or 1491 {@link #AndroidManifestData data} tags should be 1492 included inside to describe the contents of the filter. 1493 1494 <p> The optional label and icon attributes here are used with 1495 an activity to supply an alternative description of that activity 1496 when it is being started through an Intent matching this filter. --> 1497 <declare-styleable name="AndroidManifestIntentFilter" 1498 parent="AndroidManifestActivity AndroidManifestReceiver AndroidManifestService"> 1499 <attr name="label" /> 1500 <attr name="icon" /> 1501 <attr name="logo" /> 1502 <attr name="priority" /> 1503 </declare-styleable> 1504 1505 <!-- Attributes that can be supplied in an AndroidManifest.xml 1506 <code>action</code> tag, a child of the 1507 {@link #AndroidManifestIntentFilter intent-filter} tag. 1508 See {@link android.content.IntentFilter#addAction} for 1509 more information. --> 1510 <declare-styleable name="AndroidManifestAction" parent="AndroidManifestIntentFilter"> 1511 <!-- The name of an action that is handled, using the Java-style 1512 naming convention. For example, to support 1513 {@link android.content.Intent#ACTION_VIEW Intent.ACTION_VIEW} 1514 you would put <code>android.intent.action.VIEW</code> here. 1515 Custom actions should generally use a prefix matching the 1516 package name. --> 1517 <attr name="name" /> 1518 </declare-styleable> 1519 1520 <!-- Attributes that can be supplied in an AndroidManifest.xml 1521 <code>data</code> tag, a child of the 1522 {@link #AndroidManifestIntentFilter intent-filter} tag, describing 1523 the types of data that match. This tag can be specified multiple 1524 times to supply multiple data options, as described in the 1525 {@link android.content.IntentFilter} class. Note that all such 1526 tags are adding options to the same IntentFilter so that, for example, 1527 <code><data android:scheme="myscheme" android:host="me.com" /></code> 1528 is equivalent to <code><data android:scheme="myscheme" /> 1529 <data android:host="me.com" /></code>. --> 1530 <declare-styleable name="AndroidManifestData" parent="AndroidManifestIntentFilter"> 1531 <!-- Specify a MIME type that is handled, as per 1532 {@link android.content.IntentFilter#addDataType 1533 IntentFilter.addDataType()}. 1534 <p><em>Note: MIME type matching in the Android framework is 1535 case-sensitive, unlike formal RFC MIME types. As a result, 1536 MIME types here should always use lower case letters.</em></p> --> 1537 <attr name="mimeType" format="string" /> 1538 <!-- Specify a URI scheme that is handled, as per 1539 {@link android.content.IntentFilter#addDataScheme 1540 IntentFilter.addDataScheme()}. 1541 <p><em>Note: scheme matching in the Android framework is 1542 case-sensitive, unlike the formal RFC. As a result, 1543 schemes here should always use lower case letters.</em></p> --> 1544 <attr name="scheme" format="string" /> 1545 <!-- Specify a URI authority host that is handled, as per 1546 {@link android.content.IntentFilter#addDataAuthority 1547 IntentFilter.addDataAuthority()}. 1548 <p><em>Note: host name matching in the Android framework is 1549 case-sensitive, unlike the formal RFC. As a result, 1550 host names here should always use lower case letters.</em></p> --> 1551 <attr name="host" format="string" /> 1552 <!-- Specify a URI authority port that is handled, as per 1553 {@link android.content.IntentFilter#addDataAuthority 1554 IntentFilter.addDataAuthority()}. If a host is supplied 1555 but not a port, any port is matched. --> 1556 <attr name="port" format="string" /> 1557 <!-- Specify a URI path that must exactly match, as per 1558 {@link android.content.IntentFilter#addDataPath 1559 IntentFilter.addDataAuthority()} with 1560 {@link android.os.PatternMatcher#PATTERN_LITERAL}. --> 1561 <attr name="path" /> 1562 <!-- Specify a URI path that must be a prefix to match, as per 1563 {@link android.content.IntentFilter#addDataPath 1564 IntentFilter.addDataAuthority()} with 1565 {@link android.os.PatternMatcher#PATTERN_PREFIX}. --> 1566 <attr name="pathPrefix" /> 1567 <!-- Specify a URI path that matches a simple pattern, as per 1568 {@link android.content.IntentFilter#addDataPath 1569 IntentFilter.addDataAuthority()} with 1570 {@link android.os.PatternMatcher#PATTERN_SIMPLE_GLOB}. 1571 Note that because '\' is used as an escape character when 1572 reading the string from XML (before it is parsed as a pattern), 1573 you will need to double-escape: for example a literal "*" would 1574 be written as "\\*" and a literal "\" would be written as 1575 "\\\\". This is basically the same as what you would need to 1576 write if constructing the string in Java code. --> 1577 <attr name="pathPattern" /> 1578 </declare-styleable> 1579 1580 <!-- Attributes that can be supplied in an AndroidManifest.xml 1581 <code>category</code> tag, a child of the 1582 {@link #AndroidManifestIntentFilter intent-filter} tag. 1583 See {@link android.content.IntentFilter#addCategory} for 1584 more information. --> 1585 <declare-styleable name="AndroidManifestCategory" parent="AndroidManifestIntentFilter"> 1586 <!-- The name of category that is handled, using the Java-style 1587 naming convention. For example, to support 1588 {@link android.content.Intent#CATEGORY_LAUNCHER Intent.CATEGORY_LAUNCHER} 1589 you would put <code>android.intent.category.LAUNCHER</code> here. 1590 Custom actions should generally use a prefix matching the 1591 package name. --> 1592 <attr name="name" /> 1593 </declare-styleable> 1594 1595 <!-- Attributes that can be supplied in an AndroidManifest.xml 1596 <code>instrumentation</code> tag, a child of the root 1597 {@link #AndroidManifest manifest} tag. --> 1598 <declare-styleable name="AndroidManifestInstrumentation" parent="AndroidManifest"> 1599 <!-- Required name of the class implementing the instrumentation, deriving from 1600 {@link android.app.Instrumentation}. This is a fully 1601 qualified class name (for example, com.mycompany.myapp.MyActivity); as a 1602 short-hand if the first character of the class 1603 is a period then it is appended to your package name. --> 1604 <attr name="name" /> 1605 <attr name="targetPackage" /> 1606 <attr name="label" /> 1607 <attr name="icon" /> 1608 <attr name="logo" /> 1609 <attr name="handleProfiling" /> 1610 <attr name="functionalTest" /> 1611 </declare-styleable> 1612 1613 <!-- Attributes that can be supplied in an AndroidManifest.xml 1614 <code>screen</code> tag, a child of <code>compatible-screens</code>, 1615 which is itseld a child of the root 1616 {@link #AndroidManifest manifest} tag. --> 1617 <declare-styleable name="AndroidManifestCompatibleScreensScreen" 1618 parent="AndroidManifest.AndroidManifestCompatibleScreens"> 1619 <!-- Specifies a compatible screen size, as per the device 1620 configuration screen size bins. --> 1621 <attr name="screenSize"> 1622 <!-- A small screen configuration, at least 240x320db. --> 1623 <enum name="small" value="200" /> 1624 <!-- A normal screen configuration, at least 320x480db. --> 1625 <enum name="normal" value="300" /> 1626 <!-- A large screen configuration, at least 400x530db. --> 1627 <enum name="large" value="400" /> 1628 <!-- An extra large screen configuration, at least 600x800db. --> 1629 <enum name="xlarge" value="500" /> 1630 </attr> 1631 <!-- Specifies a compatible screen density, as per the device 1632 configuration screen density bins. --> 1633 <attr name="screenDensity" format="integer"> 1634 <!-- A low density screen, approximately 120dpi. --> 1635 <enum name="ldpi" value="120" /> 1636 <!-- A medium density screen, approximately 160dpi. --> 1637 <enum name="mdpi" value="160" /> 1638 <!-- A high density screen, approximately 240dpi. --> 1639 <enum name="hdpi" value="240" /> 1640 <!-- An extra high density screen, approximately 320dpi. --> 1641 <enum name="xhdpi" value="320" /> 1642 </attr> 1643 </declare-styleable> 1644 1645 <!-- The attribute that holds a Base64-encoded public key. --> 1646 <attr name="publicKey" format="string" /> 1647 1648 <!-- Attributes relating to a package verifier. --> 1649 <declare-styleable name="AndroidManifestPackageVerifier" parent="AndroidManifest"> 1650 <!-- Specifies the Java-style package name that defines this 1651 package verifier. --> 1652 <attr name="name" /> 1653 1654 <!-- The Base64 encoded public key of the package verifier's 1655 signature. --> 1656 <attr name="publicKey" /> 1657 </declare-styleable> 1658 1659 <!-- Declaration of an {@link android.content.Intent} object in XML. May 1660 also include zero or more {@link #IntentCategory <category> and 1661 {@link #Extra <extra>} tags. --> 1662 <declare-styleable name="Intent"> 1663 <!-- The action name to assign to the Intent, as per 1664 {@link android.content.Intent#setAction Intent.setAction()}. --> 1665 <attr name="action" format="string" /> 1666 <!-- The data URI to assign to the Intent, as per 1667 {@link android.content.Intent#setData Intent.setData()}. 1668 <p><em>Note: scheme and host name matching in the Android framework is 1669 case-sensitive, unlike the formal RFC. As a result, 1670 URIs here should always be normalized to use lower case letters 1671 for these elements (as well as other proper Uri normalization).</em></p> --> 1672 <attr name="data" format="string" /> 1673 <!-- The MIME type name to assign to the Intent, as per 1674 {@link android.content.Intent#setType Intent.setType()}. 1675 <p><em>Note: MIME type matching in the Android framework is 1676 case-sensitive, unlike formal RFC MIME types. As a result, 1677 MIME types here should always use lower case letters.</em></p> --> 1678 <attr name="mimeType" /> 1679 <!-- The package part of the ComponentName to assign to the Intent, as per 1680 {@link android.content.Intent#setComponent Intent.setComponent()}. --> 1681 <attr name="targetPackage" /> 1682 <!-- The class part of the ComponentName to assign to the Intent, as per 1683 {@link android.content.Intent#setComponent Intent.setComponent()}. --> 1684 <attr name="targetClass" format="string" /> 1685 </declare-styleable> 1686 1687 <!-- A category to add to an Intent, as per 1688 {@link android.content.Intent#addCategory Intent.addCategory()}. --> 1689 <declare-styleable name="IntentCategory" parent="Intent"> 1690 <!-- Required name of the category. --> 1691 <attr name="name" /> 1692 </declare-styleable> 1693 1694 <!-- An extra data value to place into a an extra/name value pair held 1695 in a Bundle, as per {@link android.os.Bundle}. --> 1696 <declare-styleable name="Extra" parent="Intent"> 1697 <!-- Required name of the extra data. --> 1698 <attr name="name" /> 1699 <!-- Concrete value to put for this named extra data. --> 1700 <attr name="value" /> 1701 </declare-styleable> 1702</resources> 1703