- Sintaxe:
<permission android:description="string resource" android:icon="drawable resource" android:label="string resource" android:name="string" android:permissionGroup="string" android:protectionLevel=["normal" | "dangerous" | "signature" | ...] />
- contido em:
<manifest>
- descrição:
- Declara uma permissão de segurança usada para limitar o acesso a componentes ou recursos específicos desse ou de outros aplicativos. Para saber mais sobre como as permissões funcionam, consulte a seção Permissões, na visão geral do manifesto do app, e as Dicas de segurança.
- Atributos:
android:description
- Uma descrição da permissão legível pelo usuário que é mais longa e mais
informativa do que o rótulo. Pode ser mostrada para explicar a
permissão ao usuário, por exemplo, quando ela
é pedida por outro aplicativo.
Esse atributo é definido como uma referência a um recurso de string. Diferente do atributo
label
, ele não pode ser uma string bruta. android:icon
- Uma referência a um recurso drawable para um ícone que representa a permissão.
android:label
- Um nome legível pelo usuário para a permissão.
Como conveniência, o rótulo pode ser configurado diretamente como uma string bruta enquanto você desenvolve o aplicativo. No entanto, quando o aplicativo estiver pronto para ser publicado, defina o rótulo como uma referência a um recurso de string para que ele possa ser localizado como outras strings na interface do usuário.
android:name
- O nome a ser usado no
código para se referir à permissão, por exemplo, em um
elemento
<uses-permission>
ou nos atributospermission
dos componentes do aplicativo.Observação: o sistema não permite que vários pacotes declarem uma permissão com o mesmo nome, a menos que todos eles sejam assinados com o mesmo certificado. Se um pacote declarar uma permissão, o sistema não vai permitir que o usuário instale outros pacotes com o mesmo nome de permissão, a menos que eles sejam assinados com o mesmo certificado do primeiro.
Por esse motivo, o Google recomenda prefixar permissões com o nome do pacote do app usando a nomenclatura no estilo de domínio inverso. Esse prefixo precisa ser seguido de
.permission.
e uma descrição da capacidade que a permissão representa com letras maiúsculas em SNAKE_CASE. Por exemplo:com.example.myapp.permission.ENGAGE_HYPERSPACE
Essa recomendação evita conflitos na nomenclatura e ajuda a identificar com clareza o proprietário e a intenção de uma permissão personalizada.
android:permissionGroup
- Atribui esta permissão a um grupo. O valor desse atributo é
o nome do grupo, que precisa ser declarado com o elemento
<permission-group>
nesse aplicativo ou em outro. Se esse atributo não é definido, a permissão não pertence a um grupo. android:protectionLevel
-
Caracteriza o possível risco implícito na permissão e indica o procedimento que o sistema precisa seguir ao determinar se concede ou não a permissão a um aplicativo que a solicite.
Cada nível de proteção consiste em um tipo de permissão básico e em zero ou mais flags. Por exemplo, o nível de proteção
"dangerous"
não tem sinalizações. Por outro lado, o nível de proteção"signature|privileged"
é uma combinação do tipo de permissão básico"signature"
e a sinalização"privileged"
.A tabela abaixo mostra todos os tipos de permissão básicos. Para uma lista de sinalizações, consulte
protectionLevel
.Valor Significado "normal"
O valor padrão. Uma permissão de baixo risco que concede a apps que a pedem acesso a recursos isolados no nível do aplicativo, com risco mínimo a outros aplicativos, ao sistema ou ao usuário. O sistema concede automaticamente esse tipo de permissão a um aplicativo solicitante na instalação, sem pedir a aprovação explícita do usuário, que ainda tem a opção de revisar essas permissões antes da instalação. "dangerous"
Uma permissão de alto risco que concede ao app que a pede acesso a dados particulares do usuário ou controle sobre o dispositivo, podendo afetar negativamente o usuário. Como esse tipo de permissão apresenta possível risco, o sistema pode não a conceder automaticamente ao aplicativo que fez o pedido. Por exemplo, uma permissão perigosa solicitada por um app pode ser mostrada ao usuário e exigir a confirmação dele antes de prosseguir. Alguma outra medida também pode ser tomada para evitar que o usuário permita automaticamente o uso desses recursos. "signature"
Uma permissão concedida pelo sistema somente se o aplicativo que a solicitar estiver assinado com o mesmo certificado que o aplicativo que declarou a permissão. Se os certificados forem correspondentes, o sistema dará a permissão de forma automática, sem notificar o usuário ou pedir a aprovação explícita dele. "knownSigner"
Uma permissão concedida pelo sistema somente se o aplicativo solicitante estiver assinado com um certificado permitido. Se o certificado do solicitante estiver listado, o sistema dará a permissão de forma automática, sem notificar o usuário ou pedir a aprovação explícita dele. "signatureOrSystem"
Sinônimo antigo de
"signature|privileged"
. Descontinuado no nível 23 da API.Uma permissão que o sistema concede apenas a aplicativos que estejam em uma pasta dedicada na imagem do sistema Android ou que sejam assinados com o mesmo certificado do aplicativo que declarou a permissão. Evite usar essa opção, já que o nível de proteção de
"signature"
é suficiente para a maioria das necessidades e funciona independente de onde os aplicativos estejam instalados.A permissão
"signatureOrSystem"
é usada para algumas situações especiais em que vários fornecedores têm aplicativos integrados a uma imagem do sistema e precisam compartilhar explicitamente recursos específicos que estão sendo criados em conjunto.
- Introduzido no:
- Nível 1 da API
- confira também:
<uses-permission>
<permission-tree>
<permission-group>
<permissão>
O conteúdo e os exemplos de código nesta página estão sujeitos às licenças descritas na Licença de conteúdo. Java e OpenJDK são marcas registradas da Oracle e/ou suas afiliadas.
Última atualização 2025-07-27 UTC.
[[["Fácil de entender","easyToUnderstand","thumb-up"],["Meu problema foi resolvido","solvedMyProblem","thumb-up"],["Outro","otherUp","thumb-up"]],[["Não contém as informações de que eu preciso","missingTheInformationINeed","thumb-down"],["Muito complicado / etapas demais","tooComplicatedTooManySteps","thumb-down"],["Desatualizado","outOfDate","thumb-down"],["Problema na tradução","translationIssue","thumb-down"],["Problema com as amostras / o código","samplesCodeIssue","thumb-down"],["Outro","otherDown","thumb-down"]],["Última atualização 2025-07-27 UTC."],[],[],null,["# <permission\u003e\n\nsyntax:\n:\n\n ```xml\n \u003cpermission android:description=\"string resource\"\n android:icon=\"drawable resource\"\n android:label=\"string resource\"\n android:name=\"string\"\n android:permissionGroup=\"string\"\n android:protectionLevel=[\"normal\" | \"dangerous\" |\n \"signature\" | ...] /\u003e\n ```\n\ncontained in:\n: [\u003cmanifest\u003e](/guide/topics/manifest/manifest-element)\n\ndescription:\n: Declares a security permission used to\n limit access to specific components or features of this or other applications.\n For more information about how permissions work, see the [Permissions](/guide/topics/manifest/manifest-intro#perms) section in the app manifest overview and [Security tips](/guide/topics/security/security).\n\nattributes:\n:\n\n `android:description`\n\n : A user-readable description of the permission that is longer and more informative than the label. It might display, for example, to explain the permission to the user when the user is asked to grant the permission to another application.\u003cbr /\u003e\n\n\n This attribute is set as a reference to a string resource.\n Unlike the `label` attribute, it can't be a raw string.\n\n `android:icon`\n : A reference to a drawable resource for an icon that represents the\n permission.\n\n `android:label`\n\n : A user-readable name for the permission.\u003cbr /\u003e\n\n\n As a convenience, the label can be directly set\n as a raw string while you're developing the application. However,\n when the application is ready to publish, set it as a\n reference to a string resource, so that it can be localized like other\n strings in the user interface.\n\n `android:name`\n : The name to be used in\n code to refer to the permission, such as in a\n [\u003cuses-permission\u003e](/guide/topics/manifest/uses-permission-element) element or the\n `permission` attributes of application components.\n\n\n **Note:** The system doesn't let multiple packages declare\n a permission with the same name unless all the packages are signed with the\n same certificate. If a package declares a permission, the system doesn't permit\n the user to install other packages with the same permission name, unless\n those packages are signed with the same certificate as the first package.\n\n For this reason, Google recommends prefixing permissions with the app's package name,\n using reverse-domain-style naming.\n Follow this prefix with `.permission.` and then a description of the\n capability that the permission represents in upper SNAKE_CASE. For example:\n `com.example.myapp.permission.ENGAGE_HYPERSPACE`.\n\n Following this recommendation avoids naming collisions and helps clearly identify the owner\n and intention of a custom permission.\n\n `android:permissionGroup`\n : Assigns this permission to a group. The value of this attribute is\n the name of the group, which is declared with the\n [\u003cpermission-group\u003e](/guide/topics/manifest/permission-group-element) element in this\n or another application. If this attribute isn't set, the permission\n doesn't belong to a group.\n\n `android:protectionLevel`\n\n :\n Characterizes the potential risk implied in the permission and\n indicates the procedure for the system to follow when determining\n whether to grant the permission to an application requesting it.\n\n\n Each protection level consists of a base permission type and zero or more\n flags. For example, the `\"dangerous\"` protection level has no\n flags. In contrast, the protection level `\"signature|privileged\"`\n is a combination of the `\"signature\"` base permission type and the\n `\"privileged\"` flag.\n\n\n The following table shows all base permission types. For a list of flags, see\n [protectionLevel](/reference/android/R.attr#protectionLevel).\n\n | Value | Meaning |\n |-----------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n | `\"normal\"` | The default value. A lower-risk permission that gives requesting applications access to isolated application-level features with minimal risk to other applications, the system, or the user. The system automatically grants this type of permission to a requesting application at installation, without asking for the user's explicit approval, though the user always has the option to review these permissions before installing. |\n | `\"dangerous\"` | A higher-risk permission that gives a requesting application access to private user data or control over the device that can negatively impact the user. Because this type of permission introduces potential risk, the system might not automatically grant it to the requesting application. For example, any dangerous permissions requested by an application might be displayed to the user and require confirmation before proceeding, or some other approach might be taken to avoid the user automatically granting the use of such facilities. |\n | `\"signature\"` | A permission that the system grants only if the requesting application is signed with the same certificate as the application that declared the permission. If the certificates match, the system automatically grants the permission without notifying the user or asking for the user's explicit approval. |\n | `\"knownSigner\"` | A permission that the system grants only if the requesting application is signed with [an allowed certificate](/guide/topics/permissions/defining#grant-signature-permissions). If the requester's certificate is listed, the system automatically grants the permission without notifying the user or asking for the user's explicit approval. |\n | `\"signatureOrSystem\"` | *Old synonym for `\"signature|privileged\"`. Deprecated in API level 23.* A permission that the system grants only to applications that are in a dedicated folder on the Android system image *or* that are signed with the same certificate as the application that declared the permission. Avoid using this option, as the `\"signature\"` protection level is sufficient for most needs and works regardless of where apps are installed. The `\"signatureOrSystem\"` permission is used for certain special situations where multiple vendors have applications built into a system image and need to share specific features explicitly because they are being built together. |\n\nintroduced in:\n: API level 1\n\nsee also:\n: [\u003cuses-permission\u003e](/guide/topics/manifest/uses-permission-element)\n\n [\u003cpermission-tree\u003e](/guide/topics/manifest/permission-tree-element)\n\n [\u003cpermission-group\u003e](/guide/topics/manifest/permission-group-element)"]]