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