Propriedades de construção

As propriedades do MSBuild controlam o comportamento dos alvos.

Eles são especificados no arquivo de projeto, por exemplo , MyApp.csproj, em um PropertyGroup do MSBuild.

Observação

No .NET para Android, tecnicamente não há distinção entre um aplicativo e um projeto de associações, portanto, as propriedades funcionarão em ambos. Na prática, é altamente recomendável criar projetos separados de aplicativos e associações. As propriedades usadas principalmente em projetos de vinculação estão documentadas no guia de referência Propriedades do projeto de vinculação do MSBuild.

Escopo de tempo de execução

Aplicativos Android comuns têm como destino o CoreCLR no .NET 11 e posterior. Os aplicativos Android direcionados ao .NET 10 e anteriores usam o Mono por padrão. Definir $(PublishAot) como true seleciona o runtime NativeAOT para publicações com suporte ou compilações otimizadas e tem precedência sobre $(UseMonoRuntime).

$(UseMonoRuntime)=true não é um mecanismo de escape do .NET 11. O SDK do .NET 11 o rejeita com NETSDK1242. Use as diretrizes do Mono do .NET 10 e versões anteriores somente ao direcionar um framework com suporte ao Mono.

Os aplicativos Android do .NET 11 exigem a API de nível 24 do Android ou posterior. $(SupportedOSPlatformVersion) define a implantação mínima do aplicativo e corresponde a //uses-sdk/@android:minSdkVersion no manifesto do Android. Ele não seleciona o SDK de destino ou representa a política do Google Play.

Os pacotes de runtime do CoreCLR do .NET 11 dão suporte aos seguintes identificadores de runtime (RIDs) do .NET e às correspondentes interfaces binárias de aplicativo (ABIs) do Android:

  • android-arm: armeabi-v7a
  • android-arm64: arm64-v8a
  • android-x64: x86_64

O Android NativeAOT é experimental e dá suporte aos mesmos três RIDs. Os RIDs são distintos dos nomes da ABI do Android e das arquiteturas de imagem do sistema emulador.

AdbTarget

A $(AdbTarget) propriedade especifica o dispositivo de destino Android no qual o pacote Android pode ser instalado ou removido. O valor desta propriedade é o mesmo que a opção adb Dispositivo Alvo.

AfterGenerateAndroidManifest

Os destinos do MSBuild listados nessa propriedade serão executados diretamente após o destino interno _GenerateJavaStubs, onde o arquivo AndroidManifest.xml é gerado no $(IntermediateOutputPath). Se você quiser fazer alguma modificação no arquivo gerado AndroidManifest.xml , poderá fazer isso usando este ponto de extensão.

AndroidAapt2CompileExtraArgs

Especifica as opções de linha de comando a serem passadas para o comando aapt2 compile ao processar ativos e recursos do Android.

AndroidAapt2LinkExtraArgs

Especifica as opções de linha de comando a serem passadas para o comando aapt2 link ao processar ativos e recursos do Android.

AndroidAddKeepAlives

Uma propriedade booleana que controla se o vinculador inserirá GC.KeepAlive() invocações em projetos de vinculação para evitar a coleta prematura de objetos.

O valor padrão é True para builds de configuração de release.

Para compilações sem remoção usando o mapa de tipos trimmable, as chamadas GC.KeepAlive() são inseridas somente quando $(AndroidEnableLegacyCompatibilityAssemblyFixups) é também True. Compilações reduzidas que usam o mapa de tipos trimmable não inserem essas chamadas.

AndroidAotAdditionalArguments

Uma propriedade de string que permite que projetos compatíveis com o .NET 10 e anteriores que usam o Mono passem opções adicionais separadas por vírgulas dentro do argumento --aot=... do compilador Mono AOT. A propriedade é usada somente quando a compilação do Mono AOT está habilitada.

Em geral, essa propriedade deve ser deixada em branco, mas em determinados cenários especiais ela pode fornecer flexibilidade útil.

A $(AndroidAotAdditionalArguments) propriedade é diferente da propriedade relacionada $(AndroidExtraAotOptions) ; $(AndroidAotAdditionalArguments) é incluída na opção --aot , enquanto $(AndroidExtraAotOptions) passa argumentos autônomos diretamente para o processo do compilador Mono AOT.

AndroidAotCustomProfilePath

O arquivo que aprofutil deve criar para armazenar dados do profilador AOT do Mono. O valor padrão é custom.aprof.

Esta propriedade se aplica aos destinos de criação de perfil AOT legados para projetos .NET 10 e anteriores compatíveis que usam Mono.

AndroidAotProfilerPort

A porta à qual aprofutil deve se conectar ao obter dados de profiling AOT do Mono. O valor padrão é 9999.

Esta propriedade se aplica aos destinos de criação de perfil AOT legados para projetos .NET 10 e anteriores compatíveis que usam Mono.

AndroidAotEnableLazyLoad

Habilita o carregamento lento (atrasado) de assemblies compilados por Mono AOT em vez de pré-carregá-los na inicialização.

Essa propriedade se aplica a projetos com suporte .NET 10 e anteriores que usam Mono. O valor padrão é True quando o Mono AOT está habilitado e os símbolos de depuração não estão incluídos. Ele não configura o CoreCLR ou o NativeAOT.

Introduzido no .NET 6.

AndroidApkDigestAlgorithm

Um valor de cadeia de caracteres que especifica o algoritmo de resumo a ser usado com jarsigner -digestalg.

O valor padrão é SHA-256.

AndroidApkSignerAdditionalArguments

Uma propriedade de cadeia de caracteres que permite que o desenvolvedor forneça argumentos para a apksigner ferramenta.

AndroidApkSigningAlgorithm

Valor de cadeia de caracteres que especifica o algoritmo de assinatura a ser usado com jarsigner -sigalg.

O valor padrão é SHA256withRSA.

Aplicativo Android

Um valor booleano que indica se o projeto é para um aplicativo Android (True) ou para um projeto de biblioteca Android (False ou não está presente).

Apenas um projeto com <AndroidApplication>True</AndroidApplication> pode estar presente em um pacote Android. (Infelizmente, esse requisito não é verificado, o que pode resultar em erros sutis e bizarros em relação aos recursos do Android.)

AndroidApplicationJavaClass

O nome completo da classe Java a ser usado no lugar de android.app.Application quando uma classe herda de Android.App.Application.

A $(AndroidApplicationJavaClass) propriedade geralmente é definida por outras propriedades, como a $(AndroidEnableMultiDex) propriedade MSBuild.

AndroidAvoidEmitForPerformance

Uma propriedade booleana que determina se System.Reflection.Emit é "evitada" ou não para melhorar o desempenho de inicialização. Essa propriedade é True por padrão.

O uso de System.Reflection.Emit tem um impacto perceptível no desempenho de inicialização no Android. Esse comportamento é desabilitado por padrão para os seguintes interruptores de recursos:

  • Switch.System.Reflection.ForceInterpretedInvoke: após a segunda chamada para MethodInfo.Invoke() ou ConstructorInfo.Invoke(), o código é emitido para melhorar o desempenho de chamadas repetidas.

  • Microsoft.Extensions.DependencyInjection.DisableDynamicEngine: após a segunda chamada para recuperar um serviço de um contêiner de injeção de dependência, o código é emitido para melhorar o desempenho de chamadas repetidas.

É desejável na maioria dos aplicativos Android desativar esse comportamento.

Consulte a documentação Alternativas de recursos das bibliotecas de classes base para obter detalhes sobre as alterações de recursos disponíveis.

Adicionado no .NET 8.

AndroidBinUtilsPath

Um caminho para um diretório contendo o binutils do Android, como ld, o vinculador nativo, e as, o montador nativo. Essas ferramentas estão incluídas na carga de trabalho do .NET para Android.

O valor padrão é $(MonoAndroidBinDirectory)\binutils\bin\.

AndroidBoundExceptionType

Um valor de cadeia de caracteres que especifica como as exceções devem ser propagadas quando um tipo fornecido pelo .NET para Android implementa um tipo ou interface do .NET em termos de tipos Java, por exemplo Android.Runtime.InputStreamInvoker , e System.IO.Stream, ou Android.Runtime.JavaDictionary e System.Collections.IDictionary.

  • Java: O tipo de exceção Java original é propagado no estado em que se encontra.

    Java significa que, por exemplo, InputStreamInvoker não implementa corretamente a API System.IO.Stream porque Java.IO.IOException pode ser lançada por Stream.Read() em vez de System.IO.IOException.

  • System: O tipo de exceção Java original é capturado e encapsulado em um tipo de exceção .NET apropriado.

    Systemsignifica que, por exemplo, InputStreamInvoker implementa System.IO.Streamcorretamente e Stream.Read() não lançará Java.IO.IOException instâncias. (Pode, em vez disso, lançar uma exceção System.IO.IOException contendo um valor Java.IO.IOException como Exception.InnerException).

    System é o valor padrão.

AndroidBoundInterfacesContainConstants

Uma propriedade booleana que determina se as constantes de associação em interfaces terão suporte ou se a solução alternativa de criar uma IMyInterfaceConsts classe será usada.

O valor padrão é True.

AndroidBoundInterfacesContainStaticAndDefaultInterfaceMethods

Uma propriedade booleana que indica se os membros padrão e estáticos nas interfaces terão suporte ou uma solução alternativa antiga de criar uma classe irmã contendo membros estáticos como abstract class MyInterface.

O valor padrão é True no .NET 6 e False para sistemas legados.

AndroidBoundInterfacesContainTypes

Uma propriedade booleana que indica se os tipos aninhados em interfaces terão suporte ou a solução alternativa de criar um tipo não aninhado como IMyInterfaceMyNestedClass.

O valor padrão é True no .NET 6 e False para sistemas legados.

AndroidBuildApplicationPackage

Um valor booliano que indica se o pacote (.apk deve ser criado e assinado). Definir esse valor como True é equivalente a usar o SignAndroidPackage Destino de compilação.

Essa propriedade é False por padrão.

AndroidBundleConfigurationFile

Especifica um nome de arquivo a ser usado como um arquivo de configuração para bundletool na porção de compilação de um Android App Bundle. Esse arquivo controla alguns aspectos de como os APKs são gerados a partir do pacote, como em quais dimensões o pacote é dividido para produzir APKs. O .NET para Android define algumas dessas configurações automaticamente, incluindo a lista de extensões de arquivo a serem deixadas descompactadas.

Essa propriedade só será relevante se $(AndroidPackageFormat) estiver definida como aab.

AndroidBundleToolExtraArgs

Especifica as opções de linha de comando a serem passadas para o comando bundletool ao criar pacotes de aplicativos.

AndroidClassParser

Uma propriedade de cadeia de caracteres que controla como .jar os arquivos são analisados. Entre os valores possíveis estão:

  • class-parse: usa class-parse.exe para analisar o código de bytes Java diretamente, sem a assistência de uma JVM.

  • jar2xml: esse valor está obsoleto e não é mais suportado.

AndroidCodegenTarget

Uma propriedade de cadeia de caracteres que controla a ABI de destino de geração de código. Entre os valores possíveis estão:

  • XamarinAndroid: esse valor está obsoleto e não tem mais suporte.

  • XAJavaInterop1: usar Java.Interop para invocações de JNI. Assemblies de vinculação usando XAJavaInterop1 somente podem ser compiladas e executadas com o Xamarin.Android 6.1 ou posterior. O Xamarin.Android 6.1 e os posteriores associam Mono.Android.dll com esse valor.

  • JavaInterop1: valor experimental, atualmente o padrão para o runtime NativeAOT.

O valor padrão é XAJavaInterop1.

AndroidCreatePackagePerAbi

Uma propriedade booleana que determina se deve ser criado um .apk por ABI do Android selecionada (como arm64-v8a), em vez de apenas um único .apk com suporte a todas as ABIs selecionadas. Os RIDs em $(RuntimeIdentifiers) selecionam essas ABIs; os APKs são produzidos para cada ABI, não para cada RID.

Consulte também o guia Como criar APKs específicos da ABI.

AndroidCreateProguardMappingFile

Uma propriedade booleana que controla se um arquivo de mapeamento do ProGuard é gerado como parte do processo de compilação.

Adicionar o seguinte ao csproj fará com que o arquivo seja gerado e usará a AndroidProguardMappingFile propriedade para controlar o local do arquivo de mapeamento final.

<AndroidCreateProguardMappingFile>True</AndroidCreateProguardMappingFile>

Ao criar arquivos .aab, o arquivo de mapeamento é incluído automaticamente em seu pacote. Não há necessidade de carregá-lo na Google Play Store manualmente. Ao usar arquivos .apk, o AndroidProguardMappingFile precisará ser carregado manualmente.

O valor padrão é True ao usar $(AndroidLinkTool)=r8.

AndroidDebugKeyAlgorithm

Especifica o algoritmo padrão a ser usado para o debug.keystore. O valor padrão é RSA.

ValidadeDaChaveDeDebugDoAndroid

Especifica a validade padrão a ser usada para o debug.keystore. O valor padrão é 10950 ou 30 * 365 ou .30 years

AndroidDebugStoreType

Especifica o formato de arquivo de armazenamento de chaves a ser usado para o debug.keystore. O padrão é pkcs12.

AndroidDeviceUserId

Permite a implantação e depuração do aplicativo em contas de convidado ou de trabalho. O valor é o uid valor que você obtém do seguinte comando adb:

adb shell pm list users

O comando acima retornará os seguintes dados:

Users:
	UserInfo{0:Owner:c13} running
	UserInfo{10:Guest:404}

O uid é o primeiro valor inteiro. Na saída acima, eles são 0 e 10.

AndroidDexTool

Uma propriedade do tipo enumeração com um valor válido de d8. Anteriormente, havia suporte para um valor de dx no Xamarin.Android.

Indica qual compilador dex do Android é usado durante o processo de build do .NET para Android. O valor padrão é d8. Veja nossa documentação sobre D8 e R8.

AndroidEnableDesugar

Uma propriedade booleana que determina se desugar está habilitada. No momento, o Android não oferece suporte a todos os recursos do Java 8, e o conjunto de ferramentas padrão implementa os novos recursos de linguagem executando transformações de bytecode, chamadas desugar, na saída do javac compilador. O valor padrão é False se usar $(AndroidDexTool)=dx e True se usar $(AndroidDexTool)=d8.

AndroidEnableFastDeployment

Uma propriedade booliana que determina se a Implantação Rápida está habilitada. A Implantação Rápida instala assemblies fora do pacote de aplicativos, o que pode reduzir os tempos de implantação e recompilação.

O valor padrão é True para builds de depuração e False para builds de versão. Definir essa propriedade é equivalente a definir o valor inverso de $(EmbedAssembliesIntoApk). Se ambas as propriedades estiverem definidas, $(EmbedAssembliesIntoApk) terá precedência.

AndroidEnableGooglePlayStoreChecks

Uma propriedade bool que permite que os desenvolvedores desativem as seguintes verificações da Google Play Store: XA1004, XA1005 e XA1006. Desativar essas verificações é útil para desenvolvedores que não estão direcionados para a Google Play Store e não desejam efetuá-las.

AndroidEnableLegacyCompatibilityAssemblyFixups

Uma propriedade booleana que controla se as compilações sem trimming modificam assemblies referenciados para dar suporte à vinculação legada e ao comportamento do designer de recursos. Essas modificações incluem a adição de métodos de interface abstratos ausentes, a atualização de referências legadas do designer de recursos e a inserção de chamadas GC.KeepAlive() em assemblies de vinculação Xamarin.Android mais antigos. As compilações reduzidas que usam o mapa de tipo trimmable não executam essas correções de compatibilidade e definir essa propriedade como True não as habilita para compilações reduzidas.

O valor padrão é False quando $(AndroidTypeMapImplementation) está trimmablee True , caso contrário.

AndroidEnableMarshalMethods

Uma propriedade booleana que determina se os métodos de marshal do LLVM estão habilitados ou não. Os métodos de marshal do LLVM são uma otimização de inicialização do aplicativo que usa pontos de entrada nativos para o registro de métodos Java native.

Essa propriedade tem como padrão False.

Essa propriedade não pode ser definida como true quando $(PublishReadyToRun) é true. Definir ambas as propriedades como true interrompe a compilação com XA1049.

Adicionado no .NET 8.

AndroidEnableMultiDex

Uma propriedade booleana que determina se o suporte a multidex será usado no .apk final.

Essa propriedade é False por padrão.

AndroidEnableProfiler

Para aplicativos Mono, esse é um sinônimo para a $(EnableDiagnostics) propriedade. Se for true, o componente de diagnóstico Mono, libmono-component-diagnostics_tracing.so, estará incluído no aplicativo.

Para aplicativos CoreCLR no .NET 11 e posteriores, essa propriedade habilita a configuração de porta de diagnóstico CoreCLR usada por ferramentas como dotnet-trace edotnet-gcdump; ela não adiciona um componente de diagnóstico Mono. O NativeAOT é um ambiente de execução separado selecionado por $(PublishAot), e esta propriedade documenta apenas o comportamento de empacotamento e configuração do Android suportado.

Essa propriedade é False por padrão.

AndroidEnableObsoleteOverrideInheritance

Uma propriedade booleana que determina se os métodos vinculados herdam automaticamente os atributos [Obsolete] dos métodos que eles substituem.

O suporte para essa propriedade foi adicionado no .NET 8.

Essa propriedade é True por padrão.

AndroidEnablePreloadAssemblies

Uma propriedade booleana que controla se todos os assemblies gerenciados agrupados no pacote de aplicativos são carregados durante a inicialização do processo ou não.

Quando definido como True, todos os assemblies agrupados dentro do pacote de aplicativos serão carregados durante a inicialização do processo, antes que qualquer código do aplicativo seja invocado.

Quando definido como False, os assemblies somente serão carregados conforme necessário. Carregar assemblies conforme necessário permite um início mais rápido dos aplicativos e também é mais consistente com a semântica do .NET para desktop. Para ver a economia de tempo, defina a Propriedade do Sistema debug.mono.log para incluir timing e procure a mensagem Finished loading assemblies: preloaded dentro de adb logcat.

Aplicativos ou bibliotecas, que usam injeção de dependência, podem exigir que essa propriedade seja True se, por sua vez, exigirem que AppDomain.CurrentDomain.GetAssemblies() retornem todos os assemblies dentro do pacote de aplicativos, mesmo que o assembly não fosse necessário de outra forma.

Por padrão, esse valor é False.

AndroidEnableProfiledAot

Uma propriedade booleana que determina se os perfis AOT do Mono são usados ou não durante a compilação Ahead-of-Time. Aplica-se a projetos .NET 10 e anteriores com suporte que usam Mono e não configura ReadyToRun, perfis MIBC, PGO dinâmico ou NativeAOT.

Os perfis estão listados em @(AndroidAotProfile) grupo de itens. Quando o AOT com perfil é habilitado, o perfil padrão é incluído, a menos que $(AndroidUseDefaultAotProfile) seja false. Perfis personalizados podem ser adicionados com @(AndroidAotProfile).

Quando $(RunAOTCompilation) é true e essa propriedade não está definida, ela usa como padrão true. Consequentemente, o padrão passa a ser true para as compilações de Release aplicáveis que usam Mono.

AndroidEnableRestrictToAttributes

Uma propriedade do tipo enumeração com valores válidos de obsolete e disable.

Quando definido como obsolete, os tipos e membros marcados com a anotação androidx.annotation.RestrictToJava ou em pacotes Java não exportados serão marcados com um [Obsolete] atributo na associação C#.

Esse [Obsolete] atributo tem uma mensagem descritiva explicando que o proprietário do pacote Java considera a API "interna" e adverte contra seu uso.

Esse atributo também tem um código XAOBS001 de aviso personalizado para que possa ser suprimido independentemente da API obsoleta "normal".

Quando definido como disable, a API será gerada normalmente, sem atributos adicionais. (Esse é o mesmo comportamento de antes do .NET 8.)

A adição [Obsolete] de atributos em vez de remover automaticamente a API foi feita para preservar a compatibilidade da API com os pacotes existentes. Se preferir remover membros que têm @RestrictTo anotação ou que estão em pacotes Java não exportados, você pode usar arquivos de transformação além desta propriedade para impedir que esses tipos sejam vinculados:

<remove-node path="//*[@annotated-visibility]" />

O suporte para essa propriedade foi adicionado no .NET 8.

Essa propriedade é definida como obsolete por padrão.

AndroidEnableSGenConcurrent

Uma propriedade booleana que determina se o coletor de GC simultâneo do Mono será usado ou não.

Essa propriedade é True por padrão. Aplica-se a projetos com suporte .NET 10 e anteriores que usam Mono e não configura os coletores de lixo CoreCLR ou NativeAOT.

AndroidErrorOnCustomJavaObject

Uma propriedade booleana que determina se os tipos podem implementar Android.Runtime.IJavaObjectse herdar de Java.Lang.Object ou Java.Lang.Throwable:

class BadType : IJavaObject {
    public IntPtr Handle {
        get {return IntPtr.Zero;}
    }

    public void Dispose()
    {
    }
}

Quando True, esses tipos gerarão um erro XA4212, caso contrário, um aviso XA4212 será gerado.

Essa propriedade é True por padrão.

AndroidExplicitCrunch

Não há mais suporte para essa propriedade.

AndroidExtraAotOptions

Uma propriedade de cadeia de caracteres que permite que projetos com suporte no .NET 10 e anteriores que usam Mono passem argumentos autônomos separados por ponto e vírgula diretamente ao processo do compilador AOT do Mono. A propriedade é usada somente quando a compilação do Mono AOT está habilitada.

Em geral, essa propriedade deve ser deixada em branco, mas em determinados cenários especiais ela pode fornecer flexibilidade útil.

A $(AndroidExtraAotOptions) propriedade é diferente da propriedade relacionada $(AndroidAotAdditionalArguments) ; $(AndroidExtraAotOptions) passa argumentos de processo autônomos, enquanto $(AndroidAotAdditionalArguments) está incluída na opção separada por vírgulas --aot=... .

AndroidFastDeploymentType

Essa propriedade foi removida no .NET 9 e não tem efeito.

AndroidFragmentType

Especifica o tipo padrão totalmente qualificado a ser usado para todos os elementos de layout <fragment> ao gerar o código de vínculos de layout. O valor padrão é o tipo padrão do Android Android.App.Fragment .

AndroidGenerateJniMarshalMethods

Esse recurso experimental foi removido no .NET 11. Definir a propriedade não tem efeito.

AndroidGenerateJniMarshalMethodsAdditionalArguments

Esse recurso experimental foi removido no .NET 11. Definir a propriedade não tem efeito.

AndroidGenerateLayoutBindings

Habilita a geração de código subjacente de layout se definido como true ou desabilita completamente se definido como false.

O valor padrão é false.

AndroidGenerateResourceDesigner (Gerador de Recursos do Android)

O valor padrão é true. Quando definido como false, desativa a geração de Resource.designer.cs.

AndroidHttpClientHandlerType

Observação

Essa propriedade não tem suporte no .NET 11. Remova-o do arquivo de projeto e use-o UseNativeHttpHandler em vez disso.

AndroidIgnoreAllJniPreload

Um valor booliano que, se definido como true, isenta todas as bibliotecas JNI nativas de serem pré-carregadas na inicialização do aplicativo. Por padrão, todas essas bibliotecas serão carregadas pelo runtime mais cedo durante a inicialização do aplicativo, a fim de garantir a inicialização adequada. No entanto, em alguns casos, pode não ser o comportamento desejado e essa propriedade permite desabilitá-lo efetivamente.

Algumas bibliotecas de estrutura que devem ser carregadas na inicialização do aplicativo não serão afetadas por essa propriedade.

Consulte também @(AndroidNativeLibraryNoJniPreload) para uma maneira mais precisa de isentar bibliotecas do mecanismo de pré-carregamento.

AndroidIncludeWrapSh

Um valor booleano que indica se o script wrapper do Android (wrap.sh) deve ser empacotado no APK. O valor padrão é false porque o script wrapper pode influenciar significativamente a maneira como o aplicativo é iniciado e funciona e o script deve ser incluído somente quando necessário, por exemplo, ao depurar ou alterar o comportamento de inicialização/tempo de execução do aplicativo.

O script é adicionado ao projeto usando o @(AndroidNativeLibrary) ação de compilação, porque é colocada no mesmo diretório que as bibliotecas nativas específicas da arquitetura e deve ser nomeada wrap.sh.

A maneira mais fácil de especificar o caminho para o wrap.sh script é colocá-lo em um diretório com o nome da arquitetura de destino. Essa abordagem funcionará se você tiver apenas uma wrap.sh por arquitetura:

<AndroidNativeLibrary Include="path/to/arm64-v8a/wrap.sh" />

No entanto, se o seu projeto precisar de mais de um wrap.sh por arquitetura, para finalidades diferentes, essa abordagem não funcionará. Em vez disso, nesses casos, o nome pode ser especificado usando os Link metadados do AndroidNativeLibrary:

<AndroidNativeLibrary Include="/path/to/my/arm64-wrap.sh">
  <Link>lib\arm64-v8a\wrap.sh</Link>
</AndroidNativeLibrary>

Se os metadados Link forem usados, o caminho especificado em seu valor deve ser um caminho de biblioteca nativa válido específico da arquitetura, relativo ao diretório raiz do APK. O formato do caminho é lib\ARCH\wrap.sh onde ARCH pode ser um dos seguintes:

  • arm64-v8a
  • armeabi-v7a
  • x86_64
  • x86

AndroidIncludeAssetPacksInPackage

Esta propriedade controla se um Asset Pack de compilação é incluído automaticamente no arquivo .aab final. O padrão será true.

Em certos casos, o usuário pode querer liberar uma liberação provisória. Nesses casos, o usuário não precisa atualizar o pacote de ativos. Especialmente se o conteúdo do pacote de ativos não tiver sido alterado. Essa propriedade permite que o usuário ignore os pacotes de ativos se eles não forem necessários.

Incluído no .NET 9

AndroidInstallJavaDependencies

O valor padrão é true para builds de linha de comando. Quando definido como true, permite a instalação do Java SDK ao executar o <InstallAndroidDependencies/> destino.

O suporte para essa propriedade foi adicionado no .NET 9.

AndroidInstrumentation

Uma propriedade de sequência de caracteres que especifica o nome da classe do runner de instrumentação do Android a ser usada ao iniciar o aplicativo por meio de dotnet run.

Quando essa propriedade não está definida, dotnet run determina o que será iniciado a partir do AndroidManifest.xml gerado na saída intermediária:

  • Se $(AndroidUseInstrumentation) estiver true, o primeiro elemento <instrumentation/> será usado.
  • Caso contrário, o <activity/> que pode ser iniciado tem preferência, e o primeiro elemento <instrumentation/> é usado quando o aplicativo não declara nenhuma atividade que possa ser iniciada. Isso possibilita dotnet run um aplicativo cujo único ponto de entrada é uma subclasse Android.App.Instrumentation como um host BenchmarkDotNet.

Se o aplicativo não declarar nenhum dos dois, a compilação falhará com o erro XA1043. Se $(AndroidUseInstrumentation) estiver true, mas o aplicativo não declarar <instrumentation/>, a compilação falha com XA1048.

Quando uma instrumentação é iniciada, dotnet run executa adb shell am instrument -w -r e sai com um código de saída diferente de zero se a instrumentação falhar ou chamar Instrumentation.Finish() com Result.Canceled. Definir $(WaitForExit) como false descarta o -w, de modo que dotnet run é retornado assim que a instrumentação é iniciada e nenhum resultado é reportado.

Quaisquer argumentos após -- são repassados à instrumentação como parâmetros extras de am instrument. Os argumentos do formulário KEY=VALUE tornam-se -e KEY VALUE, e todos os argumentos restantes são unidos em um único -e args "..." extra:

dotnet run -- --filter *MyBenchmark*

é entregue a Instrumentation.OnCreate(Bundle?) como arguments.GetString("args").

Introduzido no .NET 11.

AndroidJavadocVerbosidade

Especifica quão "detalhados" os Comentários de documentação XML C# devem ser ao importar a documentação Javadoc em projetos de ligação.

Requer o uso do @(JavaSourceJar) construir ação.

A $(AndroidJavadocVerbosity) propriedade é semelhante a enumeração, com valores possíveis de full ou intellisense:

O valor padrão é intellisense.

AndroidKeyStore

Um valor booliano que indica se as informações de assinatura personalizadas devem ser usadas. O valor padrão é False, que significa que a chave de assinatura de depuração padrão será usada para assinar pacotes.

AndroidLaunchActivity

A atividade do Android a ser iniciada.

AndroidLinkMode

Especifica qual tipo de vinculação deve ocorrer em assemblies contidos no pacote Android. Usado somente em projetos de aplicativo Android. O valor padrão é SdkOnly. Os valores válidos são:

  • None: nenhuma tentativa de vinculação ocorrerá.

  • SdkOnly: a vinculação ocorrerá apenas nas bibliotecas de classe base, não nos assemblies do usuário.

  • Completo: A vinculação será realizada em bibliotecas de classes base e assemblies de usuário.

    Observação

    o uso de um valor AndroidLinkMode definido como Full normalmente resulta em aplicativos com falha, principalmente quando a reflexão é usada. Evite isso, a menos que você realmente saiba o que está fazendo.

<AndroidLinkMode>SdkOnly</AndroidLinkMode>

AndroidLinkResources

Quando true, o sistema de compilação vinculará os tipos aninhados da classe Resource.Designer.cs Resource em todos os assemblies. O código IL que usa esses tipos será atualizado para usar os valores diretamente em vez de acessar campos.

A remoção dos tipos aninhados pode ter um pequeno impacto na redução do tamanho do APK e também pode ajudar no desempenho de inicialização. Somente as versões "Release" são vinculadas.

Experimental. Projetado apenas para funcionar com código como

var view = FindViewById(Resources.Ids.foo);

Quaisquer outros cenários (como reflexão) não serão suportados.

AndroidLinkPular

Especifica uma lista de nomes de assemblies separados por ponto e vírgula (;) sem extensões de arquivo, que não devem ser vinculados. Usado somente em projetos de aplicativo Android.

<AndroidLinkSkip>Assembly1;Assembly2</AndroidLinkSkip>

AndroidLinkTool

Uma propriedade de estilo enumeração com valores válidos de proguard ou r8. Indica qual redutor de código é usado para o código Java. O valor padrão é uma string vazia ou proguard se $(AndroidEnableProguard) for True. Veja nossa documentação sobre D8 e R8.

AndroidLintEnabled

Uma propriedade bool que permite que o desenvolvedor execute a ferramenta Android lint como parte do processo de empacotamento.

Quando $(AndroidLintEnabled)=True, as seguintes propriedades são usadas:

As seguintes ações de compilação também podem ser usadas:

Confira a Ajuda do Lint para obter mais detalhes sobre as ferramentas lint do Android.

AndroidLintEnabledIssues

Uma propriedade de string que é uma lista separada por vírgulas de problemas de lint a serem ativados.

Usado apenas quando $(AndroidLintEnabled)=True.

AndroidLintDisabledIssues

Uma propriedade de string que é uma lista separada por vírgulas de problemas de lint a serem desativados.

Usado apenas quando $(AndroidLintEnabled)=True.

AndroidLintCheckIssues

Uma propriedade de string que é uma lista separada por vírgulas de problemas de lint a serem verificados.

Usado apenas quando $(AndroidLintEnabled)=True.

Observação: somente esses problemas serão verificados.

AndroidManagedSymbols

Uma propriedade booleana que controla se os pontos de sequência são gerados para que as informações de nome de arquivo e número de linha possam ser extraídas dos rastreamentos de pilha Release.

AndroidManifest

Especifica um nome de arquivo para usar como modelo do AndroidManifest.xml do aplicativo. Durante o build, quaisquer outros valores necessários serão mesclados para produzir o AndroidManifest.xml propriamente dito. O $(AndroidManifest) deve conter o nome do pacote no atributo /manifest/@package.

AndroidManifestMerger

Especifica a implementação para mesclar arquivos AndroidManifest.xml . Essa é uma propriedade de estilo de enumeração em que legacy seleciona a implementação original do C# e manifestmerger.jar seleciona a implementação Java do Google.

O valor padrão é atualmente manifestmerger.jar. Se você quiser usar a versão antiga, adicione o seguinte ao seu csproj

<AndroidManifestMerger>legacy</AndroidManifestMerger>

A fusão do Google permite o suporte para xmlns:tools="http://schemas.android.com/tools", conforme descrito na documentação do Android.

AndroidManifestMergerExtraArgs

Uma variável de tipo string para fornecer argumentos para a ferramenta de documentação do Android.

Se você quiser um resultado detalhado da ferramenta, você pode adicionar o seguinte ao .csproj.

<AndroidManifestMergerExtraArgs>--log VERBOSE</AndroidManifestMergerExtraArgs>

AndroidManifestType

Uma propriedade de estilo enumeração com valores válidos de Xamarin ou GoogleV2. Isso controla qual repositório é usado pelo InstallAndroidDependencies target para determinar quais pacotes e versões de pacotes do Android estão disponíveis e podem ser instalados.

Xamarin é o repositório Lista Aprovada (Recomendado) no Gerenciador de SDK do Visual Studio.

GoogleV2 é o repositório Lista Completa (Não Suportada) dentro do Gerenciador de SDK do Visual Studio.

Se $(AndroidManifestType) não estiver definido, então Xamarin é usado.

AndroidManifestSource

Uma propriedade do tipo string que especifica um URI absoluto ou um caminho de arquivo local existente para o manifesto do repositório usado pelo InstallAndroidDependencies destino. Quando essa propriedade não é definida, o manifesto de repositório padrão selecionado por $(AndroidManifestType) é usado.

Por exemplo:

<AndroidManifestSource>https://example.com/AndroidManifestFeed.xml</AndroidManifestSource>

AndroidManifestPlaceholders

Uma lista separada por ponto-e-vírgula de pares de substituição de chave-valor para AndroidManifest.xml, onde cada par tem o formato key=value.

Por exemplo, um valor de propriedade assemblyName=$(AssemblyName) define um espaço reservado ${assemblyName} que pode aparecer em AndroidManifest.xml:

<application android:label="${assemblyName}"

Isso fornece uma maneira de inserir variáveis do processo de compilação no arquivo AndroidManifest.xml .

AndroidMultiDexClassListExtraArgs

Uma propriedade de string que permite que os desenvolvedores passem argumentos para o com.android.multidex.MainDexListBuilder ao gerar o multidex.keep arquivo.

Um caso específico é se você estiver recebendo o erro a seguir durante a compilação de dx.

com.android.dex.DexException: Too many classes in --main-dex-list, main dex capacity exceeded

Se você estiver recebendo esse erro, poderá adicionar o seguinte ao .csproj.

<DxExtraArguments>--force-jumbo </DxExtraArguments>
<AndroidMultiDexClassListExtraArgs>--disable-annotation-resolution-workaround</AndroidMultiDexClassListExtraArgs>

o que permitirá que a etapa dx seja concluída com sucesso.

AndroidNdkDirectory

A $(AndroidNdkDirectory) propriedade especifica um diretório de instalação personalizado do Android NDK. O caminho pode ser definido no arquivo de projeto ou na linha de comando:

dotnet build -p:AndroidNdkDirectory=/path/to/android-ndk

Se essa propriedade não estiver definida, .NET para Android localizará o NDK do ambiente de desenvolvimento do Android configurado.

AndroidPackageFormat

Uma propriedade de estilo enumeração com valores válidos de apk ou aab. Indica se você deseja empacotar o aplicativo Android como um arquivo APK ou Android App Bundle. Os Lote de Aplicativo são um novo formato para builds de Release destinados ao envio no Google Play. O valor padrão é apk.

Quando $(AndroidPackageFormat) é definido como aab, outras propriedades do MSBuild são definidas, que são necessárias para o Lote de Aplicativo do Android:

Essa propriedade será obsoleta no .net 6. Os usuários devem mudar para a versão mais recente AndroidPackageFormats.

Formatos de pacote Android

Uma propriedade delimitada por ponto-e-vírgula com valores válidos de apk e aab. Indica se você deseja empacotar o aplicativo Android como um arquivo APK ou Android App Bundle. Os Lote de Aplicativo são um novo formato para builds de Release destinados ao envio no Google Play.

Ao criar uma versão de lançamento, você pode querer gerar um aab e um apk para distribuição em várias lojas.

Definir AndroidPackageFormats como aab;apk resultará na geração de ambos. Configurar AndroidPackageFormats para aab ou apk gerará apenas um arquivo.

O valor padrão é aab;apk apenas para Release compilações. Usar apk para depuração é mais rápido, mas aab também é compatível com implantação rápida, se necessário (por exemplo, ao testar pacotes de recursos).

AndroidPackageNamingPolicy

Uma propriedade do tipo enum para especificar os nomes dos pacotes Java do código-fonte Java gerado.

O único valor com suporte é LowercaseCrc64.

AndroidPrepareForBuildDependsOn

Uma propriedade delimitada por ponto-e-vírgula que pode ser usada para estender o processo de compilação do Android. Os alvos do MSBuild adicionados a essa propriedade serão executados no início do build para ambos os tipos de projeto, Aplicativo e Biblioteca. Essa propriedade está vazia por padrão.

Exemplo:

<PropertyGroup>
  <AndroidPrepareForBuildDependsOn>MyCustomTarget</AndroidPrepareForBuildDependsOn>
</PropertyGroup>

<Target Name="MyCustomTarget" >
  <Message Text="Running target: 'MyCustomTarget'" Importance="high"  />
</Target>

AndroidProguardMappingFile

Especifica a regra ProGuard -printmapping para r8. Isso significa que o mapping.txt arquivo será produzido na $(OutputPath) pasta. Esse arquivo pode ser usado ao fazer upload de pacotes para a Google Play Store.

Por padrão, esse arquivo é produzido automaticamente ao usar AndroidLinkTool=r8 e gerará o seguinte arquivo $(OutputPath)mapping.txt.

Se você não quiser gerar esse arquivo de mapeamento, poderá usar a AndroidCreateProguardMappingFile propriedade para parar de criá-lo. Adicione o seguinte em seu projeto

<AndroidCreateProguardMappingFile>False</AndroidCreateProguardMappingFile>

ou use -p:AndroidCreateProguardMappingFile=False na linha de comando.

AndroidD8IgnoreWarnings

Especifica --map-diagnostics warning info a ser passado para d8. O valor padrão é True, mas pode ser definido como False para impor um comportamento mais rigoroso. Consulte o código-fonte D8 e R8 para obter detalhes.

Adicionado no .NET 8.

AndroidR8IgnoreWarnings

Especifica a regra ProGuard -ignorewarnings para r8. Isso permite r8 continuar com a compilação dex mesmo se certos avisos forem encontrados. O valor padrão é True, mas pode ser definido como False para impor um comportamento mais rigoroso. Consulte o manual do ProGuard para obter detalhes.

A partir do .NET 8, especifica --map-diagnostics warning info. Consulte o código-fonte D8 e R8 para obter detalhes.

AndroidR8JarPath

O caminho para r8.jar para uso com o compilador e redutor dex do r8. O valor padrão é um caminho para a instalação do workload do .NET para Android. Para obter mais informações, confira nossa documentação sobre o D8 e R8.

AndroidR8ObfuscationMode

Uma propriedade do tipo enumeração que especifica a forma como r8 ofusca nomes em Java quando $(AndroidLinkTool) é r8. Os valores suportados são:

  • private-members preserva os nomes de classes e interfaces Java e os nomes de membros públicos ou protegidos. Membros privados e privados de pacote podem ser ofuscados e a otimização R8 está habilitada.
  • disableddesabilita a ofuscação, preserva todos os nomes de Java e usa os padrões não otimizadores do Android R8.

Essa propriedade não desabilita o encolhimento de código R8.

Esta propriedade foi introduzida em um release de manutenção do .NET 10. O padrão é disabled no .NET 10 e private-members no .NET 11 e posteriores.

AndroidResgenExtraArgs

Especifica as opções de linha de comando a serem passadas para o comando aapt ao processar ativos e recursos do Android.

AndroidResgenFile

Especifica o nome do arquivo de recurso a ser gerado. O modelo padrão define isso como Resource.designer.cs.

AndroidResourceDesignerClassModifier

Especifica o modificador de classe para a classe intermediária Resource que é gerada. Os valores válidos são public e internal.

Por padrão, isso será public.

Adicionado em .NET 9.

AndroidSdkBuildToolsVersion

O pacote de ferramentas de compilação do SDK do Android fornece as ferramentas aapt e zipalign , entre outras. Várias versões diferentes do pacote de ferramentas de build podem ser instaladas simultaneamente. O pacote de ferramentas de compilação escolhido para empacotamento é determinado verificando e usando a versão de ferramentas de compilação "preferencial", caso esteja presente; se a versão "preferencial" não estiver presente, então é utilizado o pacote de ferramentas de compilação com a versão mais alta entre as instaladas.

A propriedade do MSBuild $(AndroidSdkBuildToolsVersion) contém a versão preferencial das ferramentas de build. O sistema de compilação do .NET para Android fornece um valor padrão em Xamarin.Android.Common.targets, e o valor padrão pode ser substituído no arquivo do seu projeto para escolher uma versão alternativa das ferramentas de compilação, se (por exemplo) a versão mais recente do aapt estiver apresentando falhas, enquanto uma versão anterior do aapt funciona.

AndroidSigningKeyAlias

Especifica o alias da chave no armazenamento de chaves. Este é o valor de keytool-alias usado ao criar o repositório de chaves.

AndroidSigningKeyPass

Especifica a senha da chave dentro do arquivo de armazenamento de chaves. Esse é o valor digitado quando keytool solicita Insira a senha da chave para $(AndroidSigningKeyAlias).

Essa propriedade também dá suporte a prefixos env: e file: que podem ser usados para especificar uma variável de ambiente ou arquivo que contenha a senha. Essas opções fornecem uma maneira de impedir que a senha apareça nos logs de build.

Por exemplo, para usar uma variável de ambiente chamada AndroidSigningPassword:

<PropertyGroup>
  <AndroidSigningKeyPass>env:AndroidSigningPassword</AndroidSigningKeyPass>
</PropertyGroup>

Para usar um arquivo localizado em C:\Users\user1\AndroidSigningPassword.txt:

<PropertyGroup>
  <AndroidSigningKeyPass>file:C:\Users\user1\AndroidSigningPassword.txt</AndroidSigningKeyPass>
</PropertyGroup>

Observação

O env: prefixo não é suportado quando $(AndroidPackageFormat) é definido como aab.

AndroidSigningKeyStore

Especifica o nome do arquivo de armazenamento de chaves criado pelo keytool. Isso corresponde ao valor fornecido à opção keytool -keystore.

AndroidSigningStorePass

Especifica a senha para $(AndroidSigningKeyStore). Esse é o valor fornecido a keytool ao criar o arquivo de repositório de chaves e ao solicitar Insira a senha do repositório de chaves:.

Essa propriedade também dá suporte a prefixos env: e file: que podem ser usados para especificar uma variável de ambiente ou arquivo que contenha a senha. Essas opções fornecem uma maneira de impedir que a senha apareça nos logs de build.

Por exemplo, para usar uma variável de ambiente chamada AndroidSigningPassword:

<PropertyGroup>
  <AndroidSigningStorePass>env:AndroidSigningPassword</AndroidSigningStorePass>
</PropertyGroup>

Para usar um arquivo localizado em C:\Users\user1\AndroidSigningPassword.txt:

<PropertyGroup>
  <AndroidSigningStorePass>file:C:\Users\user1\AndroidSigningPassword.txt</AndroidSigningStorePass>
</PropertyGroup>

Observação

O env: prefixo não é suportado quando $(AndroidPackageFormat) é definido como aab.

AndroidSigningPlatformKey

Especifica o arquivo de chave a ser usado para assinar o apk. Isso só é usado ao criar system aplicativos.

AndroidSigningPlatformCert

Especifica o arquivo de certificado a ser usado para assinar o apk. Isso só é usado ao criar system aplicativos.

AndroidStripILAfterAOT

Uma propriedade booleana que especifica se os corpos dos métodos compilados AOT serão removidos ou não.

O valor padrão é false, e os corpos dos métodos compilados AOT não serão removidos.

Quando definido como true, $(AndroidEnableProfiledAot) é definido como false por padrão. Isso significa que, em compilações Mono Release com suporte do .NET 8 e do .NET 9 — nas quais $(RunAOTCompilation) é true por padrão —, o Mono AOT é habilitado para tudo. Isso pode resultar em tamanhos de aplicativos maiores. Esse comportamento pode ser substituído definindo $(AndroidEnableProfiledAot) explicitamente como true dentro do arquivo de projeto.

O suporte experimental para essa propriedade foi adicionado ao .NET 8, removido no .NET 10.

AndroidStripNativeLibraries

Uma propriedade booleana que instrui o processo de empacotamento a remover os símbolos de depuração das bibliotecas compartilhadas nativas (arquivos ..so )

O valor padrão é false e os símbolos de depuração, se houver, serão preservados ao empacotar.

AndroidSupportedAbis

Essa propriedade não tem mais suporte no .NET 6 e posterior. Remova-o e use $(RuntimeIdentifier) ou $(RuntimeIdentifiers) com RIDs do .NET em vez de nomes de ABI do Android.

Por exemplo, a seguinte configuração .NET 11 inclui todas as arquiteturas CoreCLR com suporte:

<PropertyGroup>
  <RuntimeIdentifiers>android-arm;android-arm64;android-x64</RuntimeIdentifiers>
</PropertyGroup>

AndroidTlsProvider

Essa propriedade está obsoleta e não deve ser usada.

AndroidTypeMapImplementation

Uma propriedade do tipo enum que seleciona a implementação de mapeamento de tipos. Os valores válidos são llvm-ir e trimmable.

O valor padrão é trimmable quando $(PublishAot) está true e llvm-ir de outra forma.

AndroidUseApkSigner

Uma propriedade bool que permite que o desenvolvedor use a apksigner ferramenta em vez de jarsigner.

AndroidUseDefaultAotProfile

Uma propriedade bool que permite ao desenvolvedor suprimir o uso do perfil AOT Mono padrão.

O perfil padrão é usado quando $(AndroidEnableProfiledAot) é true , a menos que essa propriedade seja definida como false.

Essa propriedade se aplica a projetos com suporte .NET 10 e anteriores que usam Mono. Ele não seleciona perfis MIBC ou PGO dinâmico para CoreCLR.

AndroidUseDesignerAssembly

Uma propriedade bool que controla se o sistema de compilação gerará um _Microsoft.Android.Resource.Designer.dll ao invés de um Resource.Designer.cs arquivo. Os benefícios disso são aplicativos menores e tempo de inicialização mais rápido.

O valor padrão está true no .NET 8.

Como um Autor do NuGet, é recomendável que você forneça três versões do assembly se quiser manter a compatibilidade com versões anteriores. Um para MonoAndroid, um para net6.0-android e um para net8.0-android. Você pode fazer isso usando o Xamarin.Legacy.Sdk. Isso só será necessário se o projeto de biblioteca NuGet fizer uso de AndroidResource elementos no projeto ou por meio de uma dependência.

<TargetFrameworks>monoandroid90;net6.0-android;net8.0-android</TargetFrameworks>

Como alternativa, desative essa configuração até que o Classic e o net7.0-android tenham sido descontinuados.

Os projetos do .NET 8 que optarem por desativar essa configuração não poderão consumir referências que a usam. Se você tentar usar um assembly que tenha esse recurso habilitado em um projeto que não tenha, você receberá um erro de XA1034 compilação.

Adicionado no .NET 8.

AndroidUseInstrumentation

Uma propriedade booleana que indica que o aplicativo é iniciado por meio de seu elemento <instrumentation/> em vez de um <activity/>, como um host de teste ou BenchmarkDotNet.

Quando true, dotnet run resolve $(AndroidInstrumentation) do AndroidManifest.xml gerado e o inicia com adb shell am instrument, mesmo que o aplicativo também declare uma atividade que pode ser iniciada.

O valor padrão é true quando $(EnableMSTestRunner) está truee false , caso contrário. Observe que um aplicativo sem <activity/> iniciável é iniciado por meio de seu <instrumentation/>, independentemente dessa propriedade.

Introduzido no .NET 11.

AndroidUseInterpreter

Uma propriedade booliana que faz com que uma MonoVM .apk contenha o interpretador Mono e não o JIT normal. O padrão é True para compilações de depuração que usam Mono e False caso contrário.

Essa propriedade se aplica a projetos com suporte .NET 10 e anteriores que usam Mono. Não é uma configuração CoreCLR e o Android não tem interpretador no .NET 11 e posterior.

Experimental.

AndroidUseLegacyVersionCode

Uma propriedade booliana que permite que o desenvolvedor reverta o cálculo versionCode de volta ao seu antigo comportamento anterior ao Xamarin.Android 8.2. Isso deve ser usado SOMENTE por desenvolvedores com aplicativos existentes na Google Play Store. É altamente recomendável que a nova propriedade $(AndroidVersionCodePattern) seja usada.

AndroidUseManagedDesignTimeResourceGenerator

Uma propriedade booleana que alternará as compilações em tempo de design para usar o analisador de recursos gerenciados em vez de aapt.

AndroidUseNegotiateAuthentication

Uma propriedade booleana que habilita o suporte para autenticação NTLMv2/Negotiate no AndroidMessageHandler. O valor padrão é Falso.

Funcionalidade adicionada no .NET 7.

AndroidUseSharedRuntime

Essa propriedade está obsoleta e não deve ser usada.

AndroidVersionCode

Uma propriedade do MSBuild que pode ser usada como uma alternativa a /manifest/@android:versionCode no arquivo AndroidManifest.xml. Para ativar esse recurso, você também deve ativar <GenerateApplicationManifest>true</GenerateApplicationManifest>. Esse será o padrão daqui para frente no .NET 6.

Essa propriedade é ignorada se $(AndroidCreatePackagePerAbi) e $(AndroidVersionCodePattern) forem usados.

@android:versionCode é um valor inteiro que deve ser incrementado para cada versão do Google Play. Consulte a documentação do Android para obter mais detalhes sobre os requisitos do /manifest/@android:versionCode.

PadrãoDeCódigoDeVersãoAndroid

Uma propriedade de string que permite que o desenvolvedor personalize o versionCode no manifesto. Confira Criar um código de versão para o APK para obter informações sobre como decidir um versionCode.

Alguns exemplos: se abi for armeabi e versionCode no manifesto for 123, {abi}{versionCode} produzirá um versionCode de 1123 quando $(AndroidCreatePackagePerAbi) for True; caso contrário, gerará um valor de 123. Se abi é x86_64 e versionCode no manifesto é 44. Isso produzirá 544 quando $(AndroidCreatePackagePerAbi) for True; caso contrário, gerará um valor de 44.

Se nós incluíssemos uma cadeia de caracteres de formato de preenchimento esquerdo {abi}{versionCode:0000}, isso produziria 50044 porque estamos aplicando preenchimento esquerdo ao versionCode com 0. Como alternativa, você pode usar o preenchimento decimal, como {abi}{versionCode:D4} que faz o mesmo que o exemplo anterior.

Somente os formatos de cadeias de caracteres de preenchimento '0' e 'Dx' são compatíveis, já que o valor PRECISA ser um inteiro.

Itens chave pré-definidos

  • abi – Insere o abi alvo para o aplicativo

    • 2 – armeabi-v7a
    • 3 – x86
    • 4 – arm64-v8a
    • 5 – x86_64

  • minSDK – Insere o valor mínimo do SDK com suporte do AndroidManifest.xml ou 11 se nenhum estiver definido.

  • versionCode – Usa o código da versão diretamente do Properties\AndroidManifest.xml.

Você pode definir itens personalizados usando a propriedade $(AndroidVersionCodeProperties) (definida a seguir).

Por padrão o valor será definido como {abi}{versionCode:D6}. Se um desenvolvedor quiser manter o comportamento anterior, você poderá configurar a propriedade $(AndroidUseLegacyVersionCode) como true para substituir o padrão

AndroidVersionCodeProperties

Uma propriedade de cadeia de caracteres que permite ao desenvolvedor definir itens personalizados a serem usados com o $(AndroidVersionCodePattern). Eles estão na forma de um par key=value. Todos os itens no value devem ser valores inteiros. Por exemplo: screen=23;target=$(_AndroidApiLevel). Como você pode ver, você pode fazer uso de propriedades do MSBuild existentes ou personalizadas na cadeia de caracteres.

ApplicationId

Uma propriedade do MSBuild que pode ser usada como uma alternativa a /manifest/@package no arquivo AndroidManifest.xml. Para ativar esse recurso, você também deve ativar <GenerateApplicationManifest>true</GenerateApplicationManifest>. Esse será o padrão daqui para frente no .NET 6.

Consulte a documentação do Android para obter mais detalhes sobre os requisitos do /manifest/@package.

Título da Aplicação

Uma propriedade do MSBuild que pode ser usada como uma alternativa a /manifest/application/@android:label no arquivo AndroidManifest.xml. Para ativar esse recurso, você também deve ativar <GenerateApplicationManifest>true</GenerateApplicationManifest>. Esse será o padrão daqui para frente no .NET 6.

Consulte a documentação do Android para obter mais detalhes sobre os requisitos do /manifest/application/@android:label.

Versão do Aplicativo

Uma propriedade do MSBuild que pode ser usada como uma alternativa a /manifest/@android:versionName no arquivo AndroidManifest.xml. Para ativar esse recurso, você também deve ativar <GenerateApplicationManifest>true</GenerateApplicationManifest>. Esse será o padrão daqui para frente no .NET 6.

Consulte a documentação do Android para obter mais detalhes sobre os requisitos do /manifest/@android:versionName.

AotAssemblies

Uma propriedade booliana que determina se os assemblies serão ou não compilados antecipadamente em código nativo pelo Mono e incluídos em aplicativos. Quando não especificado, seu valor efetivo segue $(RunAOTCompilation): True para compilações Debug e False para compilações Release que usam Mono em frameworks de destino com suporte do .NET 10 e anteriores.

Obsoleto no .NET 7. Para projetos com suporte do .NET 10 e versões anteriores que usam Mono, migre para a propriedade MSBuild $(RunAOTCompilation) em vez disso. Especificar $(AotAssemblies), inclusive defini-lo como false, emite o aviso XA1029. Definir isso como true para CoreCLR ou NativeAOT causa o erro XA1044, que interrompe a compilação, quando $(RunAOTCompilation) não está definido (ou é avaliado de outra forma como true), porque a lógica de valor padrão encaminha $(AotAssemblies) para $(RunAOTCompilation).

Para projetos CoreCLR do .NET 11, remova $(AotAssemblies) sem adicionar $(RunAOTCompilation). O CoreCLR não usa o pipeline AOT do Mono.

AProfUtilExtraOptions

Opções extras a serem passadas para aprofutil ao usar os alvos legados de criação de perfil do Mono AOT em projetos compatíveis com o .NET 10 e versões anteriores.

Antes do Build Android Asset Packs

Os destinos do MSBuild listados nesta propriedade serão executados imediatamente antes da compilação dos itens AssetPack.

Incluído no .NET 9

BeforeGenerateAndroidManifest

Os destinos do MSBuild listados nesta propriedade serão executados diretamente antes de _GenerateJavaStubs.

Configuração

Especifica a configuração de build a ser usada, como "Debug" ou "Release". A propriedade Configuration é usada para determinar os valores padrão de outras propriedades que determinam o comportamento de destino. Configurações adicionais podem ser criadas dentro de seu IDE.

Por padrão, a Debug configuração resultará no Install e SignAndroidPackage visa criar um pacote Android menor que requer a presença de outros arquivos e pacotes para operar.

A configuração padrão Release resultará no Install e SignAndroidPackage visa criar um pacote Android que seja autônomo e possa ser usado sem instalar outros pacotes ou arquivos.

DebugSymbols

Um valor booleano que determina se o pacote Android é depurável, em combinação com a propriedade $(DebugType). Um pacote depurável contém símbolos de depuração, define o atributo //application/@android:debuggable como true, e adiciona automaticamente a INTERNET permissão para que um depurador possa se conectar ao processo. Um aplicativo é depurável se DebugSymbols for TrueeDebugType for uma string vazia ou Full.

DebugType

Especifica o tipo de símbolos de depuração a serem gerados como parte da compilação, o que também afeta se o aplicativo é depurável. Entre os valores possíveis estão:

  • Full: os símbolos completos são gerados. Se o Se a propriedade DebugSymbols do MSBuild também for True, o pacote Application é depurável.

  • PdbOnly: os símbolos "PDB" são gerados. O pacote Application não é depurável.

Se DebugType não está definida ou é uma cadeia de caracteres vazia, a propriedade DebugSymbols controla se o Aplicativo é depurável.

Dispositivo

Especifica qual dispositivo ou emulador Android deve ser direcionado ao utilizar dotnet run --device <Device> ou alvos do MSBuild que interagem com dispositivos (como Run, Install, ou Uninstall).

O valor deve ser o número de série completo do dispositivo ou o identificador conforme retornado por adb devices. Por exemplo, se a série do dispositivo for emulator-5554, você deverá usar -p:Device=emulator-5554.

Quando definida, essa propriedade é usada para inicializar a AdbTarget propriedade com o valor -s "<Device>".

Para obter mais informações sobre a seleção do dispositivo, consulte a especificação de seleção de dispositivo do SDK do .NET.

DiagnosticAddress

Um valor fornecido por dotnet-dsrouter, tal como 127.0.0.1, o componente de endereço IP de $(DiagnosticConfiguration) ou DOTNET_DiagnosticPorts.

Quando esta propriedade não está vazia e $(AndroidEnableProfiler) não está explicitamente definido como false, ela habilita implicitamente os diagnósticos do Android. Para o CoreCLR, o endpoint TCP resultante normalmente é mantido na interface de loopback e é usado por dotnet-dsrouter. Para um emulador Android, use 10.0.2.2 para acessar a máquina de desenvolvimento; para um dispositivo físico, use 127.0.0.1 com o redirecionamento de portas do Android ativado com dotnet-dsrouter server-server --tcp-server 127.0.0.1:9000 --forward-port Android.

Usa 127.0.0.1 como padrão.

Configuração de diagnóstico

Um valor fornecido por dotnet-dsrouter, para DOTNET_DiagnosticPorts, tais como:

  • 127.0.0.1:9000,connect,suspend
  • 127.0.0.1:9000,connect,nosuspend

Quando o diagnóstico é habilitado sem uma configuração explícita, os padrões derivados são endereço127.0.0.1, porta DiagnosticSuspend=false9000e DiagnosticListenMode=connect.

Observe que o caractere , precisará ser escapado com %2c se passado na linha de comando para dotnet build:

dotnet build -c Release -p:DiagnosticConfiguration=127.0.0.1:9000%2cconnect%2csuspend

Isso define automaticamente a variável de DOTNET_DiagnosticPorts ambiente empacotada dentro do aplicativo. No modo connect, o runtime do Android se conecta ao endpoint TCP configurado e dotnet-dsrouter encaminha essa conexão para a ferramenta de diagnóstico local. O endpoint não requer autenticação e é sem criptografia, portanto mantenha-o em uma interface de desenvolvimento local.

Definir essa propriedade ou qualquer uma das propriedades de componente abaixo habilita implicitamente o diagnóstico do Android quando $(AndroidEnableProfiler) não está explicitamente definido como false.

DiagnosticListenMode

Um valor fornecido por dotnet-dsrouter, comoconnect, o componente de modo de escuta de $(DiagnosticConfiguration) ou DOTNET_DiagnosticPorts.

Quando esta propriedade não está vazia e $(AndroidEnableProfiler) não está explicitamente definido como false, ela habilita implicitamente os diagnósticos do Android.

Usa connect como padrão.

DiagnosticPort

Um valor fornecido por dotnet-dsrouter como 9000, o componente de porta de $(DiagnosticConfiguration) ou DOTNET_DiagnosticPorts.

Quando esta propriedade não está vazia e $(AndroidEnableProfiler) não está explicitamente definido como false, ela habilita implicitamente os diagnósticos do Android.

Usa 9000 como padrão.

DiagnosticSuspend

Um valor booliano fornecido por dotnet-dsrouter , como true/suspend ou false/nosuspend, um componente de $(DiagnosticConfiguration) ou DOTNET_DiagnosticPorts.

Quando esta propriedade não está vazia e $(AndroidEnableProfiler) não está explicitamente definido como false, ela habilita implicitamente os diagnósticos do Android.

Usa false como padrão.

EmbedAssembliesIntoApk

Uma propriedade booleana que determina se os assemblies do aplicativo devem ou não ser incorporados ao pacote do aplicativo.

Essa propriedade é o inverso de $(AndroidEnableFastDeployment). Novos projetos devem usar $(AndroidEnableFastDeployment) para controlar a Implantação Rápida. Se ambas as propriedades estiverem definidas, $(EmbedAssembliesIntoApk) terá precedência.

Essa propriedade deve ser True para builds de Release e False para builds de Debug. Ele pode precisar estar True em builds de depuração se o Fast Deployment não for compatível com o dispositivo de destino.

EnableCrashReport

Uma propriedade booliana que define a DOTNET_EnableCrashReport variável de ambiente para 1 ao usar o runtime CoreCLR ou NativeAOT. Isso permite a geração de relatórios de falha na inicialização do aplicativo.

Essa propriedade é False por padrão e é ignorada quando $(UseMonoRuntime) é True.

AtivarDiagnóstico

Uma propriedade do Android SDK/MSBuild que habilita diagnósticos para o tempo de execução selecionado. É um sinônimo de $(AndroidEnableProfiler) para aplicativos Mono. Para o CoreCLR, ele habilita a configuração de porta de diagnóstico usada por dotnet-trace e dotnet-gcdump.

$(EnableDiagnostics) não é o mesmo que a variável DOTNET_EnableDiagnosticsde ambiente de runtime CoreCLR. O primeiro é avaliado pelos alvos do SDK do Android/MSBuild; o segundo é lido pelo tempo de execução quando fornecido na forma de variável de ambiente.

Essa propriedade é False por padrão.

HabilitarLLVM

Uma propriedade booleana que determina se o LLVM será ou não usado pelo compilador Mono AOT durante a compilação Ahead-of-Time de assemblies para código nativo.

O Android NDK deve ser instalado para criar um projeto que tenha essa propriedade ativada.

Essa propriedade é False por padrão.

Essa propriedade se aplica a projetos com suporte .NET 10 e anteriores que usam Mono e afeta a compilação somente quando $(RunAOTCompilation) é True.

Definir essa propriedade como true no CoreCLR ou no NativeAOT a redefine como false e interrompe a compilação com XA1044.

EnableMSTestRunner

Uma propriedade booliana que habilita o executor MSTest para projetos de teste do Android. Quando definido como true, dotnet run iniciará o aplicativo por meio de am instrument, em vez de am start, permitindo que os resultados do teste sejam relatados por meio do protocolo de instrumentação do Android.

Essa propriedade é False por padrão.

Introduzido no .NET 11.

Habilite Proguard

Uma propriedade booleana que determina se proguard é executado ou não como parte do processo de empacotamento para vincular o código Java.

Essa propriedade é False por padrão.

Quando True, os arquivos @(ProguardConfiguration) serão usados para controlar a execução de proguard.

EventSourceSupport

Quando definido como false, desativa o suporte a EventSource do .NET em aplicativos Android otimizados. Desabilitar esse recurso impediria que ferramentas de diagnóstico do .NET, como dotnet-counters, funcionassem, mas proporcionaria a vantagem de reduzir o tamanho do aplicativo.

Definido como false por padrão no modo Release, a menos que $(EnableDiagnostics) ou $(AndroidEnableProfiler) estejam habilitados.

GenerateApplicationManifest

Habilita ou desabilita as seguintes propriedades do MSBuild que emitem valores no arquivo final AndroidManifest.xml :

O valor $(GenerateApplicationManifest) padrão é true.

JavaMaximumHeapSize

Especifica o valor do valor do parâmetro java-Xmx a ser usado ao construir o .dex arquivo como parte do processo de empacotamento. Se não for especificado, a opção -Xmx fornecerá java com um valor de 1G. Foi verificado que isso normalmente é necessário no Windows em comparação com outras plataformas.

Especificar esta propriedade é necessário se o destino _CompileDex lançar uma exceção java.lang.OutOfMemoryError.

Personalize o valor alterando:

<JavaMaximumHeapSize>1G</JavaMaximumHeapSize>

Opções Java

Especifica as opções de linha de comando a serem passadas para java ao criar o .dex arquivo.

JarsignerTimestampAuthorityCertificateAlias

Esta propriedade permite especificar um alias no keystore para uma autoridade de carimbo de data/hora. Consulte a documentação do Java Signature Timestamp Support para obter mais detalhes.

<PropertyGroup>
    <JarsignerTimestampAuthorityCertificateAlias>Alias</JarsignerTimestampAuthorityCertificateAlias>
</PropertyGroup>

JarsignerTimestampAuthorityUrl

Esta propriedade permite especificar uma URL para um serviço de autoridade de carimbo de data/hora. Isso pode ser usado para garantir que sua .apk assinatura inclua um carimbo de data/hora. Consulte a documentação do Java Signature Timestamp Support para obter mais detalhes.

<PropertyGroup>
    <JarsignerTimestampAuthorityUrl>http://example.tsa.url</JarsignerTimestampAuthorityUrl>
</PropertyGroup>

LinkerDumpDependencies

Uma propriedade bool que permite a geração de um arquivo de dependências do linker. Esse arquivo pode ser usado como entrada para a ferramenta illinkanalyzer.

O arquivo de dependências nomeado linker-dependencies.xml.gz é gravado no diretório do projeto. No .NET 5/6, ela é gravada ao lado dos assemblies vinculados no diretório obj/<Configuration>/android<ABI>/linked.

O valor padrão é Falso.

MandroidI18n

Essa propriedade do MSBuild está obsoleta e não tem mais suporte.

MauiEnableFullReadyToRun

Uma propriedade booleana para aplicativos Android do .NET MAUI que usam CoreCLR e são compilados na configuração Release com ReadyToRun habilitado. Quando essa propriedade não estiver definida ou false, o MAUI utiliza o ReadyToRun parcial com os perfis MIBC padrão. Defina essa propriedade como true para habilitar o ReadyToRun completo. Essa propriedade não tem efeito quando $(PublishReadyToRun) é false.

Full ReadyToRun aumenta o tamanho do aplicativo e do download, mas pode potencialmente melhorar o desempenho do runtime porque mais métodos são pré-compilados.

Para obter mais informações sobre CoreCLR e ReadyToRun no .NET MAUI, consulte Runtimes e compilação no .NET MAUI.

MetricsSupport

Quando definido como false, desabilita o suporte de Métricas do .NET em aplicativos Android reduzidos. Desabilitar esse recurso impediria que APIs, como, por System.Diagnostics.Metrics exemplo, funcionassem, mas em benefício da redução do tamanho do aplicativo.

Definido como false por padrão no modo Release, a menos que $(EnableDiagnostics) ou $(AndroidEnableProfiler) estejam habilitados.

MonoAndroidAssetPrefix

Especifica um prefixo de caminho que é removido do início dos nomes de arquivo com uma ação de compilação AndroidAsset. Isso é para permitir a alteração do local em que os recursos estão localizados.

O valor padrão é Assets. Altere isso para assets para a estrutura do projeto Java.

MonoAndroidResourcePrefix

Especifica um prefixo de caminho que é removido do início dos nomes de arquivo com uma ação de compilação AndroidResource. Isso é para permitir a alteração do local em que os recursos estão localizados.

O valor padrão é Resources. Altere isso para res para a estrutura do projeto Java.

Arquivo MonoSymbol

Observação

Esta era uma propriedade legada do MSBuild do Xamarin.Android. Não disponível no .NET 6+.

Uma propriedade booleana que controla se os artefatos .mSYM são criados para uso posterior com mono-symbolicate, para extrair informações "reais" de nome de arquivo e número de linha dos rastreamentos de pilha de Release.

Por padrão, é True para aplicativos "Release" que têm símbolos de depuração ativados: $(EmbedAssembliesIntoApk) é Verdadeiro, $(DebugSymbols) é Verdadeiro, e $(Optimize) é Verdadeiro.

PublishReadyToRun

Uma propriedade booliana que controla se os assemblies são compilados para o formato ReadyToRun ao usar o CoreCLR. Os assemblies ReadyToRun contêm msil e código nativo. Isso pode melhorar o tempo de inicialização do aplicativo, mantendo a compatibilidade JIT, mas aumenta o tamanho do aplicativo e do download.

Para aplicativos para Android que usam o CoreCLR, essa propriedade assume o valor padrão true na configuração Release e não é habilitada por padrão na configuração Debug. ReadyToRun não se aplica ao usar Mono ou NativeAOT.

ReadyToRun requer ajustes. Se $(PublishTrimmed) não for true, o .NET para Android desabilita PublishReadyToRun e $(PublishReadyToRunComposite) e emite o aviso XA0119.

A compilação ReadyToRun é composta por padrão. Consulte $(PublishReadyToRunComposite). .NET MAUI também usa ReadyToRun parcial com perfis MIBC padrão. Consulte $(MauiEnableFullReadyToRun) para aderir ao ReadyToRun completo.

Para obter mais informações, consulte Runtimes e compilação no .NET MAUI.

PublishReadyToRunComposite

Uma propriedade booliana que controla se a compilação ReadyToRun combina assemblies de aplicativo em uma imagem composta. O ReadyToRun composto permite otimizações entre assemblies, mas pode aumentar o tempo de compilação.

Para aplicativos Android que usam o CoreCLR, essa propriedade usa como padrão true quando $(PublishReadyToRun) é true. ReadyToRun, incluindo o ReadyToRun composto, exige que $(PublishTrimmed) seja true.

RunAOTCompilation (Executar Compilação AOT)

Uma propriedade booliana que determina se os assemblies serão compilados com antecedência com o compilador AOT Mono e incluídos em aplicativos que usam o runtime Mono. Essa propriedade é False por padrão para compilações Debug e True por padrão para compilações Release que usam Mono em frameworks de destino do .NET 10 e anteriores com suporte.

Esta propriedade do MSBuild substitui a propriedade $(AotAssemblies) do MSBuild do Xamarin.Android. Essa é a mesma propriedade usada para WASM do Blazor.

Essa propriedade não habilita ReadyToRun ou NativeAOT. Defini-lo como true para CoreCLR ou NativeAOT o redefine para false e interrompe a compilação com XA1044.

UseMonoRuntime

Uma propriedade booleana que controla se os aplicativos Android usam o runtime Mono em vez do CoreCLR para destinos com suporte do .NET 10 e anteriores. Defina essa propriedade para true usar Mono ou false usar CoreCLR nesses destinos. $(PublishAot) tem precedência e seleciona NativeAOT para builds de publicação ou otimizados com suporte quando definido como true.

Essa propriedade tem true como padrão no .NET 10 e em versões anteriores, por isso os aplicativos Android usam Mono. No .NET 11 e posterior, ele usa o padrão false, portanto, aplicativos Android usam CoreCLR e um valor explícito true é rejeitado com NETSDK1242.

Para obter mais informações, consulte Runtimes e compilação no .NET MAUI.

WaitForExit

Uma propriedade booliana que controla o comportamento de dotnet run ao iniciar aplicativos Android.

Quando $(WaitForExit) não false (o padrão), dotnet run irá:

  • Iniciar o aplicativo Android
  • Transmitir a saída logcat filtrada para o processo do aplicativo
  • Aguarde a saída do aplicativo ou para que o usuário pressione Ctrl+C
  • Forçar a parada do aplicativo quando Ctrl+C for pressionado

Quando $(WaitForExit) estiver false, dotnet run simplesmente iniciará o aplicativo e retornará imediatamente, sem esperar que o aplicativo seja encerrado nem transmitir nenhuma saída.

Esta propriedade também controla se adb shell am instrument é passado para -w quando o aplicativo é iniciado por meio de seu $(AndroidInstrumentation):

$(WaitForExit) Iniciando um <activity/> Iniciando um <instrumentation/>
true (predefinição) adb shell am start -S -W adb shell am instrument -w -r
false adb shell am start -S adb shell am instrument -r

Como adb shell am instrument apenas relata os resultados quando a instrumentação é concluída, $(WaitForExit) não deve ser false se você precisar da saída da instrumentação ou de um código de saída útil. Isso é importante para cenários como a execução de testes ou um host BenchmarkDotNet , e é por isso dotnet test que sempre usa o padrão.

Introduzido no .NET 11.

  • Last updated on