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