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