Compilar itens

Os itens de compilação controlam como um aplicativo .NET para Android ou projeto de biblioteca é criado.

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

Observação

No .NET para Android, tecnicamente não há distinção entre um aplicativo e um projeto de associações, portanto, os itens de build funcionarão em ambos. Na prática, é altamente recomendável criar projetos separados de aplicativos e associações. Os itens de compilação usados principalmente em projetos de vinculação estão documentados no guia de referência Itens de projeto de vinculação do MSBuild.

ApplicationArtifact

@(ApplicationArtifact) contém os arquivos do artefato final do aplicativo produzidos pelos alvos package, signing e publish. Esse grupo de itens pode ser usado por destinos personalizados do MSBuild para descobrir saídas do APK e do Pacote de Aplicativos Android sem recalcular os nomes de arquivo finais. .NET para Android preenche esse grupo de itens com artefatos específicos do Android e outras plataformas móveis .NET podem usar o mesmo nome de item para seus artefatos de aplicativo finais.

Cada item inclui os seguintes metadados:

  • %(ApplicationId): O nome do pacote do AndroidManifest.xml mesclado final.
  • %(ApplicationTitle): o valor de android:label do manifesto final mesclado.
  • %(ApplicationName): O mesmo valor final do manifesto android:label que %(ApplicationTitle).
  • %(ApplicationDisplayVersion): o valor de android:versionName do manifesto final mesclado.
  • %(ApplicationVersion): o valor de android:versionCode do manifesto final mesclado.
  • %(PackageFormat): apk ou aab.
  • %(Signed): true quando o pacote é assinado.
  • %(PackageId): o nome do pacote do Android resolvido, também exposto como %(ApplicationId).
  • %(Abi): A ABI do Android para uma saída APK por ABI. Esses metadados são definidos apenas em APKs específicos por ABI.

O manifesto mesclado final é autoritativo para os metadados comuns do aplicativo. Seus valores têm precedência sobre propriedades do projeto, como $(ApplicationId), $(ApplicationTitle)e $(ApplicationDisplayVersion)$(ApplicationVersion). Isso também se aplica a manifestos personalizados e projetos que definem $(GenerateApplicationManifest) como false.

Os rótulos de aplicativos baseados em recursos são retornados inalterados. Por exemplo, um valor android:label de @string/app_name produz ApplicationTitle="@string/app_name" e ApplicationName="@string/app_name"; a compilação não seleciona nem determina um valor de recurso específico para a localidade.

O MSBuild também fornece metadados conhecidos para cada item. Por exemplo, %(Filename)%(Extension) é o nome do arquivo de pacote e %(FullPath) é o caminho completo do pacote.

Use o GetApplicationArtifacts destino quando outro destino precisar consultar os artefatos do aplicativo diretamente. Os targets acrescentados a $(GetApplicationArtifactsDependsOn) são executados após o .NET for Android preencher este grupo de itens, para que possam atualizar os itens existentes com metadados adicionais antes que GetApplicationArtifacts ou Publish os retornem.

Por exemplo:

<Target Name="WriteApplicationArtifacts" AfterTargets="Publish">
  <WriteLinesToFile
      File="$(PublishDir)application-artifacts.txt"
      Lines="@(ApplicationArtifact->'%(FullPath)|%(Filename)%(Extension)|%(PackageFormat)|%(Signed)|%(PackageId)|%(Abi)|%(ApplicationTitle)|%(ApplicationDisplayVersion)|%(ApplicationVersion)')"
      Overwrite="true" />
</Target>

AndroidAdditionalJavaManifest

<AndroidAdditionalJavaManifest> é usado em conjunto com a Resolução de Dependências do Java para especificar arquivos POM adicionais que serão necessários para verificar as dependências. Estes geralmente são arquivos POM pai ou importados que são referenciados pelo arquivo POM de uma biblioteca Java.

<ItemGroup>
  <AndroidAdditionalJavaManifest Include="mylib-parent.pom" JavaArtifact="com.example:mylib-parent" JavaVersion="1.0.0" />
</ItemGroup>

Os seguintes metadados do MSBuild são necessários:

  • %(JavaArtifact): O grupo e o ID do artefato da biblioteca Java correspondente ao arquivo POM especificado no formato {GroupId}:{ArtifactId}.
  • %(JavaVersion): A versão da biblioteca Java que corresponde ao arquivo POM especificado.

Consulte a documentação da Resolução de Dependências do Java para obter mais detalhes.

Essa ação de build foi introduzida no .NET 9.

AndroidAsset

Suporta Android Assets, arquivos que seriam incluídos na assets pasta em um projeto Java Android.

A partir do .NET 9, a @(AndroidAsset) ação de build também dá suporte a metadados adicionais para gerar Asset Packs. Os %(AndroidAsset.AssetPack) metadados podem ser usados para gerar automaticamente um pacote de ativos com esse nome. Esse recurso só é suportado quando o $(AndroidPackageFormat) é definido como .aab. O exemplo a seguir colocará movie2.mp4 e movie3.mp4 em pacotes de ativos separados.

<ItemGroup>
   <AndroidAsset Update="Asset/movie.mp4" />
   <AndroidAsset Update="Asset/movie2.mp4" AssetPack="assets1" />
   <AndroidAsset Update="Asset/movie3.mp4" AssetPack="assets2" />
</ItemGroup>

Esse recurso pode ser usado para incluir arquivos grandes em seu aplicativo que normalmente excederiam os limites máximos de tamanho de pacote do Google Play.

Se você tiver um grande número de ativos, pode ser mais eficiente usar o base pacote de ativos. Nesse cenário, você atualiza TODOS os ativos para estarem em um único pacote de ativos e, em seguida, usa os AssetPack="base" metadados para declarar quais ativos específicos terminam no arquivo aab base. Com isso, você pode usar curingas para mover a maioria dos recursos para o pacote de recursos.

<ItemGroup>
   <AndroidAsset Update="Assets/*" AssetPack="assets1" />
   <AndroidAsset Update="Assets/movie.mp4" AssetPack="base" />
   <AndroidAsset Update="Assets/some.png" AssetPack="base" />
</ItemGroup>

Neste exemplo, movie.mp4 e some.png terminarão no arquivo base aab, enquanto todos os outros ativos irão terminar no pacote de ativos assets1.

Os metadados adicionais só têm suporte no .NET para Android 9 e superior.

AndroidAarLibrary

A ação Compilar de AndroidAarLibrary deve ser usada para referenciar diretamente arquivos .aar. Essa ação do build será mais usada pelos componentes do Xamarin. Ou seja, incluir referências a .aar arquivos necessários para que o Google Play e outros serviços funcionem.

Os arquivos com essa ação Compilar serão tratados de maneira semelhante aos recursos incorporados encontrados nos projetos da Biblioteca. O .aar será extraído para o diretório intermediário. Em seguida, todos os ativos, recursos e .jar arquivos serão incluídos nos grupos de itens apropriados.

AndroidAotProfile

Usado para fornecer um perfil AOT Mono para AOT com perfil em projetos com suporte .NET 10 e anteriores que usam Mono.

Este item é consumido quando $(AndroidEnableProfiledAot) é true. Não é um perfil MIBC ou uma entrada PGO dinâmica.

Ele também pode ser usado no Visual Studio definindo a ação de compilação AndroidAotProfile em um arquivo que contenha um perfil AOT do Mono.

AndroidAppBundleMetaDataFile

Especifica um arquivo que será incluído como metadados no Android App Bundle. O formato do valor do sinalizador é <bundle-path>:<physical-file> onde bundle-path indica o local do arquivo dentro do diretório de metadados do App Bundle e physical-file é um arquivo existente que contém os dados brutos a serem armazenados.

<ItemGroup>
  <AndroidAppBundleMetaDataFile
    Include="com.android.tools.build.obfuscation/proguard.map:$(OutputPath)mapping.txt"
  />
</ItemGroup>

Consulte a documentação do bundletool para obter mais detalhes.

AndroidBoundLayout

Indica que o arquivo de layout deve ter código subjacente gerado caso a propriedade $(AndroidGenerateLayoutBindings) esteja definida como false. Em todos os outros aspectos, é idêntico a AndroidResource.

Essa ação pode ser usada apenas com arquivos de layout:

<AndroidBoundLayout Include="Resources\layout\Main.axml" />

AndroidEnvironment

Arquivos com uma ação de build AndroidEnvironment são usados para inicializar variáveis de ambiente e propriedades do sistema durante a inicialização do processo. A ação de build AndroidEnvironment pode ser aplicada a vários arquivos, e eles serão avaliados sem nenhuma ordem específica (então não especifique a mesma propriedade de sistema ou variável de ambiente em vários arquivos).

Projeto AndroidGradle

<AndroidGradleProject> pode ser usado para criar e consumir os resultados de projetos do Android Gradle criados no Android Studio ou em outro lugar.

Os Include metadados devem apontar para o nível build.gradle superior ou build.gradle.kts arquivo que será usado para construir o projeto. Isso será encontrado no diretório raiz do seu projeto Gradle, que também deve conter scripts de encapsulamento gradlew.

<ItemGroup>
  <AndroidGradleProject Include="path/to/project/build.gradle.kts" ModuleName="mylibrary" />
</ItemGroup>

Há suporte para os seguintes metadados do MSBuild:

  • %(Configuration): O nome da configuração a ser usada para compilar ou montar o projeto ou o módulo de projeto especificado. O valor padrão é Release.
  • %(ModuleName): o nome do módulo ou subprojeto que deve ser criado. O valor padrão é vazio.
  • %(OutputPath): Pode ser definido para substituir o caminho de saída de compilação do projeto Gradle. O valor padrão é $(IntermediateOutputPath)gradle/%(ModuleName)%(Configuration)-{Hash}.
  • %(CreateAndroidLibrary): Os arquivos AAR de saída serão adicionados como um AndroidLibrary ao projeto. Os metadados suportados por <AndroidLibrary> como %(Bind) ou %(Pack) serão encaminhados se definidos. O valor padrão é true.

Essa ação de build foi introduzida no .NET 9.

BibliotecaJavaParaAndroid

Arquivos com uma ação de compilação de AndroidJavaLibrary são arquivos Java (arquivos .jar) que serão incluídos no pacote Android final.

AndroidIgnoredJavaDependency

<AndroidIgnoredJavaDependency> é usado em conjunto com Resolução de Dependência de Java.

Ele é usado para especificar uma dependência Java que deve ser ignorada. Isso pode ser usado se uma dependência for atendida de uma forma que a resolução de dependência Java não possa detectar.

<!-- Include format is {GroupId}:{ArtifactId} -->
<ItemGroup>
  <AndroidIgnoredJavaDependency Include="com.google.errorprone:error_prone_annotations" Version="2.15.0" />
</ItemGroup>

Os seguintes metadados do MSBuild são necessários:

  • %(Version): A versão da biblioteca Java correspondente ao arquivo %(Include).

Consulte a documentação da Resolução de Dependências do Java para obter mais detalhes.

Essa ação de build foi introduzida no .NET 9.

AndroidJavaSource

Os arquivos com uma ação Build de AndroidJavaSource são código-fonte Java que serão incluídos no pacote final do Android.

A partir do .NET 7, todos os arquivos **\*.java dentro do diretório do projeto têm automaticamente uma ação de compilação de AndroidJavaSource, e serão vinculados antes da compilação do Assembly. Permite que o código C# use facilmente tipos e membros presentes nos **\*.java arquivos.

Defina %(AndroidJavaSource.Bind) como False para desabilitar esse comportamento.

Biblioteca Android

AndroidLibrary é uma nova ação de compilação para simplificar como .jar e .aar os arquivos são incluídos nos projetos.

Qualquer projeto pode especificar:

<ItemGroup>
  <AndroidLibrary Include="foo.jar" />
  <AndroidLibrary Include="bar.aar" />
</ItemGroup>

O resultado do snippet de código acima tem um efeito diferente para cada tipo de projeto do .NET para Android:

Essa simplificação significa que você pode usar AndroidLibrary em qualquer lugar.

AndroidLintConfig

A ação Build 'AndroidLintConfig' deve ser usada em conjunto com oPropriedade $(AndroidLintEnabled). Os arquivos com essa ação de build serão mesclados e passados para as ferramentas lint do Android. Eles devem ser arquivos XML contendo informações sobre testes a serem habilitados e desabilitados.

Confira a documentação do lint para obter mais detalhes.

AndroidManifestOverlay

A AndroidManifestOverlay ação de compilação pode ser usada para fornecer AndroidManifest.xml arquivos para a ferramenta Manifest Merger. Os arquivos com esta ação de construção serão passados para o Manifest Merger junto com o arquivo AndroidManifest.xml principal e os arquivos de manifesto das referências. Eles serão então mesclados no manifesto final.

Você pode usar essa ação de compilação para fornecer alterações e configurações ao seu aplicativo, dependendo da configuração de compilação. Por exemplo, se você precisar ter uma permissão específica somente durante a depuração, poderá usar a sobreposição para injetar essa permissão durante a depuração. Por exemplo, considerando o seguinte conteúdo de arquivo de sobreposição:

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
  <uses-permission android:name="android.permission.CAMERA" />
</manifest>

Você pode usar o seguinte para adicionar uma sobreposição de manifesto para uma compilação de depuração:

<ItemGroup>
  <AndroidManifestOverlay Include="DebugPermissions.xml" Condition=" '$(Configuration)' == 'Debug' " />
</ItemGroup>

AndroidInstallModules

Especifica os módulos que são instalados pelo comando bundletool ao instalar pacotes de aplicativos.

AndroidMavenBiblioteca

<AndroidMavenLibrary> permite a especificação de um artefato Maven que será automaticamente baixado e incorporado a um projeto de vinculação do .NET para Android. Isso pode ser útil para simplificar a manutenção de associações do .NET para Android para artefatos hospedados no Maven.

<!-- Include format is {GroupId}:{ArtifactId} -->
<ItemGroup>
  <AndroidMavenLibrary Include="com.squareup.okhttp3:okhttp" Version="4.9.3" />
</ItemGroup>

Há suporte para os seguintes metadados do MSBuild:

  • %(Version): Versão necessária da biblioteca Java referenciada por %(Include).
  • %(Repository): Repositório Maven opcional a ser usado. Os valores suportados são Central (padrão), Google, ou uma https URL para um repositório Maven.
  • %(AllowInsecureHttp): booliano opcional. Quando %(Repository) é um URL http://, deve ser definido como true para permitir a conexão insegura. Usa false como padrão. O uso de HTTPS é altamente recomendável para a segurança da cadeia de suprimentos.

O <AndroidMavenLibrary> item é traduzido para AndroidLibrary, portanto, todos os metadados suportados por <AndroidLibrary> like %(Bind) ou %(Pack) também são suportados.

Consulte a documentação do AndroidMavenLibrary para obter mais detalhes.

Essa ação de build foi introduzida no .NET 9.

AndroidNativeLibrary

Bibliotecas nativas são adicionadas ao build definindo-se as ações de build delas para AndroidNativeLibrary.

Observe que, como o Android é compatível com várias interfaces binárias de aplicativos (ABIs), o sistema de compilação deve conhecer a ABI para a qual a biblioteca nativa foi criada. Há duas maneiras de especificar a ABI:

  1. "Detecção" de caminho.
  2. Usando os metadados do %(Abi) item.

Com a detecção de caminho, o nome do diretório pai da biblioteca nativa é usado para especificar a ABI usada como destino pela biblioteca. Portanto, se você adicionar lib/armeabi-v7a/libfoo.so ao build, em a ABI será "detectada" como armeabi-v7a.

Nome do atributo do item

Abi – Especifica a ABI da biblioteca nativa.

<ItemGroup>
  <AndroidNativeLibrary Include="path/to/libfoo.so">
    <Abi>armeabi-v7a</Abi>
  </AndroidNativeLibrary>
</ItemGroup>

AndroidNativeLibraryNoJniPreload

Todas as bibliotecas nativas incluídas neste grupo de itens serão isentas do mecanismo de pré-carregamento da biblioteca JNI. 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 esse grupo de itens permite a exclusão de bibliotecas desse processo individualmente.

Algumas bibliotecas de estrutura que devem ser carregadas na inicialização do aplicativo não serão afetadas se incluídas neste grupo de itens.

Consulte também $(AndroidIgnoreAllJniPreload)

AndroidPackagingOptionsExclude

Um conjunto de itens compatíveis com arquivo glob que permitirá que itens sejam excluídos do pacote final. Os valores padrão são os seguintes

<ItemGroup>
	<AndroidPackagingOptionsExclude Include="DebugProbesKt.bin" />
	<AndroidPackagingOptionsExclude Include="$([MSBuild]::Escape('*.kotlin*'))" />
	<AndroidPackagingOptionsExclude Include="$([MSBuild]::Escape('*.jar$'))" />
	<AndroidPackagingOptionsExclude Include="$([MSBuild]::Escape('*.knm$'))" />
	<AndroidPackagingOptionsExclude Include="$([MSBuild]::Escape('^(|root/)[^/]+Main/default/(manifest|linkdata/*)$'))" />
	<AndroidPackagingOptionsExclude Include="$([MSBuild]::Escape('^(|root/)R.txt$'))" />
	<AndroidPackagingOptionsExclude Include="$([MSBuild]::Escape('^(|root/)proguard.txt$'))" />
	<AndroidPackagingOptionsExclude Include="$([MSBuild]::Escape('^(|root/)META-INF/kotlin-project-structure-metadata.json$'))" />
	<AndroidPackagingOptionsExclude Include="$([MSBuild]::Escape('^(|root/)META-INF/proguard/*$'))" />
	<AndroidPackagingOptionsExclude Include="$([MSBuild]::Escape('^(|root/)META-INF/com.android.tools/proguard/*$'))" />
	<AndroidPackagingOptionsExclude Include="$([MSBuild]::Escape('^(|root/)META-INF/com.android.tools/r8*/*$'))" />
	<AndroidPackagingOptionsExclude Include="$([MSBuild]::Escape('^(|root/)META-INF/com/android/build/gradle/aar-metadata.properties$'))" />
</ItemGroup>

Os itens podem usar caracteres de blob de arquivo como curingas, como * e ?. No entanto, esses itens DEVEM ser codificados por URL ou usar $([MSBuild]::Escape('')). Isso é para que o MSBuild não tente interpretá-los como se fossem curingas de arquivos reais.

Por exemplo

<ItemGroup>
	<AndroidPackagingOptionsExclude Include="%2A.foo_%2A" />
  <AndroidPackagingOptionsExclude Include="$([MSBuild]::Escape('*.foo')" />
</ItemGroup>

NOTA: *, ? e . serão substituídos na tarefa BuildApk pelos globs de arquivo apropriados.

Se o glob de arquivo padrão for muito restritivo, você pode removê-lo adicionando o seguinte ao seu csproj

<ItemGroup>
	<AndroidPackagingOptionsExclude Remove="$([MSBuild]::Escape('*.kotlin_*')" />
</ItemGroup>

Funcionalidade adicionada no .NET 7.

AndroidPackagingOptionsInclude

Um conjunto de itens compatíveis com file glob que permitirá que os itens sejam incluídos no pacote final. Os valores padrão são os seguintes

<ItemGroup>
	<AndroidPackagingOptionsInclude Include="$([MSBuild]::Escape('*.kotlin_builtins')" />
</ItemGroup>

Os itens podem usar caracteres de blob de arquivo como curingas, como * e ?. No entanto, esses itens DEVEM usar codificação URL ou '$([MSBuild]::Escape(''))'. Isso é para que o MSBuild não tente interpretá-los como se fossem curingas de arquivos reais. Por exemplo

<ItemGroup>
	<AndroidPackagingOptionsInclude Include="%2A.foo_%2A" />
  <AndroidPackagingOptionsInclude Include="$([MSBuild]::Escape('*.foo')" />
</ItemGroup>

NOTA: *, ? e . serão substituídos na tarefa BuildApk pelos globs de arquivo apropriados.

Adicionado em .NET 9.

AndroidResource

Todos os arquivos com uma ação de build AndroidResource são compilados em recursos do Android durante o processo de build e tornados acessíveis por meio de $(AndroidResgenFile).

<ItemGroup>
  <AndroidResource Include="Resources\values\strings.xml" />
</ItemGroup>

Usuários mais avançados talvez queiram usar diferentes recursos em configurações diferentes, mas com o mesmo caminho efetivo. Isso pode ser alcançado tendo vários diretórios do recurso e tendo arquivos com os mesmos caminhos relativos dentro desses diferentes diretórios, além de usar condições do MSBuild para incluir condicionalmente arquivos diferentes em configurações diferentes. Por exemplo:

<ItemGroup Condition=" '$(Configuration)' != 'Debug' ">
  <AndroidResource Include="Resources\values\strings.xml" />
</ItemGroup>
<ItemGroup  Condition=" '$(Configuration)' == 'Debug' ">
  <AndroidResource Include="Resources-Debug\values\strings.xml"/>
</ItemGroup>
<PropertyGroup>
  <MonoAndroidResourcePrefix>Resources;Resources-Debug</MonoAndroidResourcePrefix>
</PropertyGroup>

LogicalName – Especifica o caminho do recurso explicitamente. Permite a criação de "alias" para arquivos, de forma que eles fiquem disponíveis com vários nomes de recursos distintos.

<ItemGroup Condition="'$(Configuration)'!='Debug'">
  <AndroidResource Include="Resources/values/strings.xml"/>
</ItemGroup>
<ItemGroup Condition="'$(Configuration)'=='Debug'">
  <AndroidResource Include="Resources-Debug/values/strings.xml">
    <LogicalName>values/strings.xml</LogicalName>
  </AndroidResource>
</ItemGroup>

Sumário

A ação de build Content normal não é compatível (pois ainda não descobrimos como dar suporte a ela sem uma etapa de primeira execução de custo possivelmente alto).

A tentativa de usar a @(Content) ação de build lançará um aviso XA0101.

EmbeddedJar

Em um projeto de vinculação do .NET para Android, a ação de build EmbeddedJar associa a biblioteca Java/Kotlin e incorpora o arquivo .jar na biblioteca. Quando um projeto de aplicativo .NET para Android consome a biblioteca, ele tem acesso às APIs Java/Kotlin do C#, além de incluir o código Java/Kotlin no aplicativo Android final.

Em vez disso, você deve usar a ação de compilação AndroidLibrary como uma alternativa, como:

<Project>
  <ItemGroup>
    <AndroidLibrary Include="Library.jar" />
  </ItemGroup>
</Project>

Biblioteca Nativa Incorporada

Em uma biblioteca de classes do .NET para Android ou em um projeto de associação Java, a ação de build EmbeddedNativeLibrary agrupa uma biblioteca nativa, como lib/armeabi-v7a/libfoo.so na biblioteca. Quando um aplicativo .NET para Android consome a biblioteca, o libfoo.so arquivo será incluído no aplicativo Android final.

Você pode usar a ação de build AndroidNativeLibrary como alternativa.

EmbeddedReferenceJar

Em um projeto de binding do .NET para Android, a ação de build EmbeddedReferenceJar incorpora o arquivo .jar na biblioteca, mas não cria uma associação C# como EmbeddedJar faz. Quando um projeto de aplicativo .NET para Android consome a biblioteca, ele inclui o código Java/Kotlin no aplicativo Android final.

Você pode usar a ação de compilação AndroidLibrary como uma alternativa, como:<AndroidLibrary Include="..." Bind="false" />

<Project>
  <ItemGroup>
    <!-- A .jar file to bind & embed -->
    <AndroidLibrary Include="Library.jar" />
    <!-- A .jar file to only embed -->
    <AndroidLibrary Include="Dependency.jar" Bind="false" />
  </ItemGroup>
</Project>

JavaSourceJar

Em um projeto de vinculação .NET para Android, a ação de compilação JavaSourceJar e .jar arquivos que contêm código-fonte Java, que contêm comentários de documentação Javadoc.

O Javadoc será convertido em Comentários de Documentação XML C# dentro do código-fonte de vinculação gerado.

$(AndroidJavadocVerbosity) controla o quão "detalhado" ou "completo" é o Javadoc importado.

Há suporte para os seguintes metadados do MSBuild:

  • %(CopyrightFile): Um caminho para um arquivo que contém informações de direitos autorais para o conteúdo do Javadoc, que será anexado a toda a documentação importada.

  • %(UrlPrefix): Um prefixo de URL para dar suporte à vinculação à documentação online na documentação importada.

  • %(UrlStyle): O "estilo" dos URLs a serem gerados ao vincular à documentação online. Atualmente, apenas um estilo é suportado: developer.android.com/reference@2020-Nov.

  • %(DocRootUrl): Um prefixo de URL a ser usado no lugar de todas as {@docroot} instâncias na documentação importada.

BibliotecaProjetoZip

A ação de compilação LibraryProjectZip vincula a biblioteca Java/Kotlin e incorpora o arquivo .zip ou .aar à biblioteca. Quando um projeto de aplicativo .NET para Android consome a biblioteca, ele tem acesso às APIs Java/Kotlin do C#, além de incluir o código Java/Kotlin no aplicativo Android final.

Descrição do Link

Arquivos com uma ação de build LinkDescription são usados para controlar o comportamento do vinculador.

ProguardConfiguration

Arquivos com uma ação de build ProguardConfiguration contêm opções que são usadas para controlar o comportamento de proguard. Para obter mais informações sobre essa ação de build, consulte ProGuard.

Esses arquivos são ignorados, a menos que $(EnableProguard) A propriedade do MSBuild é True.

RuntimeEnvironmentVariable

@(RuntimeEnvironmentVariable) Itens permitem que variáveis de ambiente sejam passadas para o aplicativo Android em tempo de execução por meio de dotnet run -e. Por exemplo:

dotnet run -e DOTNET_RUN_FOO=TestValue123 -e DOTNET_RUN_BAR=AnotherValue456

Esses itens são preenchidos automaticamente pelo SDK do .NET ao usar dotnet run -e NAME=VALUE e são incluídos no arquivo de ambiente gerado durante o build. O %(Identity) de cada item é o nome da variável, e %(Value) é o valor da variável.

<ItemGroup>
  <RuntimeEnvironmentVariable Include="DOTNET_RUN_FOO" Value="TestValue123" />
</ItemGroup>

Esse recurso só está disponível para projetos de aplicativos Android e requer um SDK .NET que dê suporte à funcionalidade do RuntimeEnvironmentVariableSupport projeto.

Esse item de build foi introduzido no SDK 10.0.300 do .NET e no .NET 11.

  • Last updated on