<provider android:authorities="list" android:enabled=["true" | "false"] android:exported=["true" | "false"] android:grantUriPermissions=["true" | "false"] android:icon="drawable resource" android:initOrder="integer" android:label="string resource" android:multiprocess=["true" | "false"] android:name="string" android:permission="string" android:process="string" android:readPermission="string" android:syncable=["true" | "false"] android:writePermission="string" > . . . </provider>
<application><meta-data>
<grant-uri-permission>ContentProvider — that supplies structured
access to data managed by the application. All content providers that
are part of the application must be represented by <provider>
elements in the manifest file. The system cannot see, and therefore will
not run, any that are not declared. (You need to declare only
those content providers that you develop as part of your application,
not those developed by others that your application uses.)
The Android system identifies content providers by the authority part
of a content: URI. For example, suppose that the following URI
is passed to :
ContentResolver.query()
content://com.example.project.healthcareprovider/nurses/rn
The content: scheme identifies the data as belonging to a content
provider and the authority (com.example.project.healthcareprovider)
identifies the particular provider. The authority therefore must be unique.
Typically, as in this example, it's the fully qualified name of a
ContentProvider subclass. The path part of a URI may be used by a content
provider to identify particular data subsets, but those paths are not
declared in the manifest.
For information on using and developing content providers, see a separate document, Content Providers.
android:authoritiescom.example.provider.cartoonprovider). Typically, it's the name
of the ContentProvider subclass.
There is no default. At least one authority must be specified.
android:enabledtrue" if it can be, and "false" if not. The default value
is "true".
The <application> element has its own
enabled attribute that applies to all
application components, including content providers. The
<application> and <provider>
attributes must both be "true" (as they both
are by default) for the content provider to be enabled. If either is
"false", the provider is disabled; it cannot be instantiated.
android:exportedtrue" if it can be, and "false" if not.
If "false", the provider is available only to components of the
same application or applications with the same user ID. The default value
is "true".
You can export a content provider but still limit access to it with the
permission attribute.
android:grantUriPermissionsreadPermission,
writePermission, and
permission attributes
—
"true" if permission can be granted, and "false" if not.
If "true", permission can be granted to any of the content
provider's data. If "false", permission can be granted only
to the data subsets listed in
<grant-uri-permission> subelements,
if any. The default value is "false".
Granting permission is a way of giving an application component one-time access to data protected by a permission. For example, when an e-mail message contains an attachment, the mail application may call upon the appropriate viewer to open it, even though the viewer doesn't have general permission to look at all the content provider's data.
In such cases, permission is granted by
and FLAG_GRANT_READ_URI_PERMISSION
flags in the Intent object that activates the component. For example, the
mail application might put FLAG_GRANT_WRITE_URI_PERMISSIONFLAG_GRANT_READ_URI_PERMISSION in the
Intent passed to Context.startActivity(). The permission is specific
to the URI in the Intent.
If you enable this feature, either by setting this attribute to "true"
or by defining <grant-uri-permission>
subelements, you must call
when a covered URI is deleted from
the provider.
Context.revokeUriPermission()
See also the <grant-uri-permission>
element.
android:icon<application>
element's icon attribute).android:initOrderandroid:label<application> element's
label attribute).
The label should be set as a reference to a string resource, so that it can be localized like other strings in the user interface. However, as a convenience while you're developing the application, it can also be set as a raw string.
android:multiprocesstrue" if instances can run in multiple
processes, and "false" if not. The default value is "false".
Normally, a content provider is instantiated in the process of the
application that defined it. However, if this flag is set to "true",
the system can create an instance in every process where there's a client
that wants to interact with it, thus avoiding the overhead of interprocess
communication.
android:nameContentProvider. This should be a fully qualified
class name (such as, "com.example.project.TransportationProvider").
However, as a shorthand, if the first character of the name is a period,
it is appended to the package name specified in the
<manifest> element.
There is no default. The name must be specified.
android:permissionreadPermission and
writePermission attributes take precedence
over this one. If the readPermission
attribute is also set, it controls access for querying the content provider.
And if the writePermission attribute is set,
it controls access for modifying the provider's data.
For more information on permissions, see the Permissions section in the introduction and a separate document, Security and Permissions.
android:process<application> element's
process
attribute can set a different
default for all components. But each component can override the default
with its own process attribute, allowing you to spread your
application across multiple processes.
If the name assigned to this attribute begins with a colon (':'), a new process, private to the application, is created when it's needed and the activity runs in that process. If the process name begins with a lowercase character, the activity will run in a global process of that name, provided that it has permission to do so. This allows components in different applications to share a process, reducing resource usage.
android:readPermissionpermission and
writePermission attributes.android:syncabletrue"
if it is to be synchronized, and "{@ code false}" if not.android:writePermissionpermission and
readPermission attributes.