Elemek összeállítása

A buildelési elemek vezérlik az Android-alkalmazásokhoz vagy -tárakhoz készült .NET-projektek felépítését.

A projektfájlban( például MyApp.csproj) vannak megadva egy MSBuild ItemGroup-on belül.

Megjegyzés:

Az Androidhoz készült .NET-ben gyakorlatilag nincs különbség az alkalmazások és a kötések között, így a buildelemek mindkét esetben működni fognak. A gyakorlatban erősen ajánlott külön alkalmazás- és kötésprojekteket létrehozni. Az elsősorban bindings projektekben használt Build elemeket az MSBuild bindings projektelemei referenciaútmutatójában dokumentáljuk.

ApplicationArtifact

@(ApplicationArtifact) A csomagolási, aláírási és közzétételi célok által létrehozott végleges alkalmazás-összetevőfájlokat tartalmazza. Ezt az elemcsoportot használhatják egyéni MSBuild-célok az APK és az Android App Bundle kimeneteinek felderítésére anélkül, hogy újraszámítanák a végső fájlneveket. .NET Android esetén ezt az elemcsoportot Android-specifikus összetevőkkel tölti fel, és más .NET mobilplatformok ugyanazt az elemnevet használhatják a végleges alkalmazásösszetevőkhöz.

Minden elem a következő metaadatokat tartalmazza:

  • %(ApplicationId): A végső egyesített AndroidManifest.xmlcsomagneve.
  • %(ApplicationTitle): A android:label végleges egyesített jegyzékből származó érték.
  • %(ApplicationName): Ugyanaz a végső manifestumérték android:label, mint a(z) %(ApplicationTitle).
  • %(ApplicationDisplayVersion): A android:versionName végleges egyesített jegyzékből származó érték.
  • %(ApplicationVersion): A android:versionCode végleges egyesített jegyzékből származó érték.
  • %(PackageFormat): apk vagy aab.
  • %(Signed): true a csomag aláírásakor.
  • %(PackageId): A meghatározott Android-csomagnév, amely %(ApplicationId) néven is elérhető.
  • %(Abi): Az Android ABI egy ABI-nkénti APK-kimenethez. Ez a metaadat csak ABI-alapú APK-khoz van beállítva.

A végleges egyesített jegyzék mérvadó a gyakori alkalmazás metaadataihoz. Az értékek elsőbbséget élveznek az olyan projekttulajdonságokkal szemben, mint a $(ApplicationId), $(ApplicationTitle), $(ApplicationDisplayVersion)és $(ApplicationVersion). Ez az egyéni manifesztumokra és azokra a projektekre is vonatkozik, amelyekben a $(GenerateApplicationManifest) beállítása false értékre történik.

Az erőforrás-alapú alkalmazáscímkék változatlanul lesznek visszaadva. Például a(z) android:label@string/app_name értéke ApplicationTitle="@string/app_name" és ApplicationName="@string/app_name" eredményez; a buildfolyamat nem választ ki, és nem old fel területi beállításhoz tartozó erőforrás-értéket.

Az MSBuild emellett jól ismert metaadatokat is biztosít az egyes elemekhez. Például a %(FullPath) a csomagfájl neve, a %(Filename)%(Extension) pedig a teljes csomagelérési út.

Akkor használja a GetApplicationArtifacts célértéket, ha egy másik célnak közvetlenül le kell kérdeznie az alkalmazásösszetevőket. A $(GetApplicationArtifactsDependsOn) elemhez hozzáfűzött célok azután futnak le, hogy a .NET for Android feltölti ezt az elemcsoportot, így a meglévő elemeket további metaadatokkal frissíthetik, mielőtt a GetApplicationArtifacts vagy a Publish visszaadná azokat.

Például:

<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> a Java-függőségfeloldással együtt használja a függőségek ellenőrzéséhez szükséges további POM-fájlok megadására. Ezek gyakran egy Java-kódtár POM-fájlja által hivatkozott szülő- vagy importált POM-fájlok.

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

A következő MSBuild metaadatok szükségesek:

  • %(JavaArtifact): A Java-kódtár csoport- és összetevő-azonosítója, amely megfelel az űrlapon {GroupId}:{ArtifactId}megadott POM-fájlnak.
  • %(JavaVersion): A Java-kódtárnak a megadott POM-fájlnak megfelelő verziója.

További részletekért tekintse meg a Java függőségfeloldási dokumentációját .

Ez a buildelési művelet a .NET 9-ben lett bevezetve.

AndroidAsset

Támogatja az Android-objektumokat, azokat a assets fájlokat, amelyek egy Java Android-projekt mappájába kerülnek.

A .NET 9-től kezdve a @(AndroidAsset) buildelési művelet további metaadatokat is támogat az eszközcsomagok létrehozásához. A %(AndroidAsset.AssetPack) metaadatok segítségével automatikusan létrehozhat egy ilyen nevű eszközcsomagot. Ez a funkció csak akkor támogatott, ha a $(AndroidPackageFormat) beállítás értéke .aab. Az alábbi példa az movie2.mp4 és movie3.mp4 elemeket külön eszközcsomagokba helyezi.

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

Ezzel a funkcióval nagy méretű fájlokat vehet fel az alkalmazásba, amelyek általában meghaladják a Google Play maximális csomagméretkorlátját.

Ha nagy számú eszközzel rendelkezik, hatékonyabb lehet az base eszközcsomag használata. Ebben a forgatókönyvben úgy frissíti az ÖSSZES objektumot, hogy egyetlen eszközcsomagban legyen, majd a AssetPack="base" metaadatok használatával deklarálja, hogy mely adott objektumok kerülnek az alap aab-fájlba. Ezzel helyettesítő karakterekkel helyezheti át a legtöbb objektumot az eszközcsomagba.

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

Ebben a példában movie.mp4some.png az base aab fájlba kerül, míg az összes többi eszköz az assets1 eszközcsomagba kerül.

A további metaadatok csak az Android 9-hez és újabb verziókhoz készült .NET-en támogatottak.

AndroidAarLibrary

A AndroidAarLibrary buildelési műveletet kell használni a .aar fájlok közvetlen hivatkozásához. Ezt a buildelési műveletet leggyakrabban a Xamarin-összetevők fogják használni. Nevezetesen a Google Play és más szolgáltatások működéséhez szükséges fájlokra mutató hivatkozások .aar belefoglalása.

Az ezzel a buildelési művelettel rendelkező fájlokat a kódtárprojektekben található beágyazott erőforrásokhoz hasonlóan kezeli a rendszer. A .aar ki lesz nyerve a köztes könyvtárba. Ezután minden eszköz, erőforrás és .jar fájl bekerül a megfelelő elemcsoportokba.

AndroidAotProfile

Mono AOT-profilt biztosít a profilozott AOT-hoz a Mono-t használó, támogatott .NET 10-es és korábbi projektekben.

Ez az elem felhasználásra kerül, amikor $(AndroidEnableProfiledAot) az true. Ez nem MIBC-profil vagy dinamikus PGO-bemenet.

A Visual Studióból is használható, ha egy Mono AOT-profilt tartalmazó fájl buildelési műveletét AndroidAotProfile értékre állítja.

AndroidAppBundleMetaDataFile

Megadja azt a fájlt, amely metaadatként szerepel az Android-alkalmazáscsomagban. A jelzőérték <bundle-path>:<physical-file> formátuma az, ahol bundle-path a fájl helye az App Bundle metaadatkönyvtárában található, és physical-file egy meglévő fájl, amely a tárolandó nyers adatokat tartalmazza.

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

További részletekért tekintse meg a bundletool dokumentációját.

AndroidBoundLayout

Azt jelzi, hogy az elrendezésfájl számára mögöttes kód van generálva abban az esetben, amikor a $(AndroidGenerateLayoutBindings) tulajdonság false értékre van állítva. Minden más szempontból megegyezik a AndroidResource.

Ez a művelet csak elrendezésfájlok esetén használható:

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

AndroidEnvironment

A buildelési művelettel AndroidEnvironment rendelkező fájlok a környezeti változók és a rendszertulajdonságok inicializálására szolgálnak a folyamat indításakor. A AndroidEnvironment Build műveletet több fájlra is alkalmazhatja, és a rendszer nem meghatározott sorrendben értékeli ki őket (ezért ne adja meg ugyanazt a környezeti változót vagy rendszertulajdonságot több fájlban).

AndroidGradleProject

<AndroidGradleProject> Az Android Studióban vagy más módon létrehozott Android Gradle-projektek kimenetének összeállítására és felhasználására használható.

A Include metaadatoknak a projekt létrehozásához használt legfelső szintre build.gradle vagy build.gradle.kts fájlra kell mutatniuk. Ez a Gradle-projekt gyökérkönyvtárában található, és a projektnek gradlew burkolószkripteket is tartalmaznia kell.

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

A következő MSBuild metaadatok támogatottak:

  • %(Configuration): A megadott projekt vagy projektmodul összeállításához vagy összeállításához használandó konfiguráció neve. Az alapértelmezett érték a Release.
  • %(ModuleName): A létrehozandó modul vagy alprojekt neve. Az alapértelmezett érték üres.
  • %(OutputPath): Beállítható úgy, hogy felülbírálja a Gradle-projekt buildkimeneti útvonalát. Az alapértelmezett érték a $(IntermediateOutputPath)gradle/%(ModuleName)%(Configuration)-{Hash}.
  • %(CreateAndroidLibrary): A kimeneti AAR-fájlok hozzá lesznek adva AndroidLibrary a projekthez. A <AndroidLibrary> által, mint a %(Bind) vagy a %(Pack) által támogatott metaadatok továbbítva lesznek, ha be vannak állítva. Az alapértelmezett érték a true.

Ez a buildelési művelet a .NET 9-ben lett bevezetve.

Android Java Könyvtár

A buildelési művelettel AndroidJavaLibrary rendelkező fájlok java archívumok ( .jar fájlok), amelyeket a végső Android-csomag tartalmaz.

AndroidFigyelmenKívüliJavaFüggőség

<AndroidIgnoredJavaDependency> java-függőségfeloldással együtt használható.

Java-függőség megadására szolgál, amelyet figyelmen kívül kell hagyni. Ez akkor használható, ha egy függőség olyan módon lesz teljesítve, amelyet a Java-függőség feloldási folyamata nem képes észlelni.

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

A következő MSBuild metaadatok szükségesek:

  • %(Version): A Java-kódtár a megadottnak %(Include)megfelelő verziója.

További részletekért tekintse meg a Java függőségfeloldási dokumentációját .

Ez a buildelési művelet a .NET 9-ben lett bevezetve.

AndroidJavaSource

A buildelési művelettel AndroidJavaSource rendelkező fájlok Java-forráskódok, amelyek szerepelni fognak a végső Android-csomagban.

A .NET 7-től kezdve a projektkönyvtárban lévő összes **\*.java fájl automatikusan rendelkezik a buildelési művelettel AndroidJavaSource, és a szerelvény buildje előtt lesz kötve. Lehetővé teszi a C#-kód számára a fájlokban **\*.java található típusok és tagok egyszerű használatát.

Állítsa false %(AndroidJavaSource.Bind) (Hamis) értékre a viselkedés letiltásához.

Android Könyvtár

Az AndroidLibrary egy új build művelet, amely leegyszerűsíti a .jar és .aar fájlok projektekbe való beillesztését.

Bármely projekt megadhatja a következőket:

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

A fenti kódrészlet eredménye eltérő hatással van az androidos .NET-projekttípusokra:

Ez az egyszerűsítés azt jelenti, hogy mindenhol használhatja az AndroidLibraryt .

AndroidLintConfig

Az "AndroidLintConfig" buildelési műveletet a következővel együtt kell használni: $(AndroidLintEnabled) számú tulajdonság. Ehhez a build művelethez tartozó fájlok egyesülnek, és átkerülnek az androidos lint eszközrendszerhez. Xml-fájloknak kell lenniük, amelyek információkat tartalmaznak az engedélyezendő és letiltandó tesztekről.

További részletekért tekintse meg a lint dokumentációját .

AndroidManifestOverlay

A buildművelet segítségével a AndroidManifestOverlay fájlokat lehet biztosítani a AndroidManifest.xml eszköznek. Az ezzel a létrehozási művelettel rendelkező fájlokat a fő AndroidManifest.xml fájl és a hivatkozásokból származó jegyzékfájlokkal együtt a jegyzékösszevonó programnak továbbítja a rendszer. Ezek ezután egyesülnek a végleges jegyzékben.

Ezzel a buildelési műveletsel módosításokat és beállításokat adhat meg az alkalmazásnak a buildkonfigurációtól függően. Ha például csak a hibakeresés során van szüksége egy adott engedélyre, az átfedés használatával beszúrhatja ezt az engedélyt a hibakeresés során. Például a következő fedőfájl tartalmát figyelembe véve:

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

A hibakeresési buildekhez az alábbiakat használhatja jegyzékfedés hozzáadásához:

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

AndroidInstallModules

Az alkalmazáscsomagok telepítésekor a bundletool parancs által telepített modulokat adja meg.

AndroidMavenLibrary

<AndroidMavenLibrary> Lehetővé teszi egy Maven-összetevő megadását, amely automatikusan letöltődik és hozzáadódik egy .NET for Android-kötési projekthez. Ez hasznos lehet a Mavenben tárolt artifaktumokhoz tartozó .NET-kötések karbantartásának egyszerűsítésére.

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

A következő MSBuild metaadatok támogatottak:

  • %(Version): A %(Include) által hivatkozott Java-könyvtár szükséges verziója.
  • %(Repository): Nem kötelező a Maven-adattár használata. A támogatott értékek: Central (alapértelmezett), Google, vagy egy https Maven-adattár URL-címe.
  • %(AllowInsecureHttp): Opcionális logikai érték. Ha %(Repository) URL-címről http:// van szó, ezt úgy kell beállítani, hogy true engedélyezze a nem biztonságos kapcsolatot. Alapértelmezett érték: false. A HTTPS használata erősen ajánlott az ellátási lánc biztonsága érdekében.

Az <AndroidMavenLibrary> elem lefordítva van AndroidLibrary-re, így minden <AndroidLibrary> által támogatott metaadat, mint például %(Bind) vagy %(Pack), szintén támogatott.

További részletekért tekintse meg az AndroidMavenLibrary dokumentációját .

Ez a buildelési művelet a .NET 9-ben lett bevezetve.

AndroidNativeLibrary

Natív kódtárakat a Build beállítás beállításával adunk hozzá a buildhez AndroidNativeLibrary.

Vegye figyelembe, hogy mivel az Android több alkalmazás bináris adaptert (ABI-t) támogat, a buildelési rendszernek ismernie kell azt az ABI-t, amelyhez a natív kódtár készült. Az ABI kétféleképpen adható meg:

  1. Path "szimatolás".
  2. Az elem metaadatainak %(Abi) használata.

Az elérési út sniffing használatával a natív könyvtár szülőkönyvtárának neve adja meg a tár által célként megadott ABI-t. Így, ha hozzáadja lib/armeabi-v7a/libfoo.so a buildhez, akkor az ABI érzékelve lesz armeabi-v7a.

Elem attribútum neve

Abi – A natív kódtár ABI-ját adja meg.

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

AndroidNativeLibraryNoJniPreload

Az elemcsoportban szereplő natív kódtárak kivételt képeznek a JNI-kódtár előbetöltési mechanizmusa alól. Alapértelmezés szerint az alkalmazás indításakor a futtatókörnyezet minden ilyen kódtárat betölt, hogy biztosítsa a megfelelő inicializálást. Bizonyos esetekben azonban előfordulhat, hogy nem ez a kívánt viselkedés, és ez az elemcsoport lehetővé teszi a kódtárak egyéni kizárását ebből a folyamatból.

Az alkalmazás indításakor betöltendő keretrendszerkódtárak némelyike nem lesz hatással, ha ebbe az elemcsoportba tartozik.

Lásd még: $(AndroidIgnoreAllJniPreload)

AndroidCsomagolásiOpciókKizárása (AndroidPackagingOptionsExclude)

Fájlglob kompatibilis elemek készlete, amelyek lehetővé teszik az elemek kizárását a végső csomagból. Az alapértelmezett értékek a következők:

<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>

Az elemek fájlblob karaktereket használhatnak helyettesítő karakterekhez, például * és ?. Azonban ezeknek az elemeknek URL-kódolt formában kell lenniük, vagy $([MSBuild]::Escape(''))-et kell használniuk. Így az MSBuild nem próbálja őket ténylegesen fájl mintázatként értelmezni.

Például

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

MEGJEGYZÉS: A *, ? és . a BuildApk feladatban a megfelelő fájlmintákra lesznek cserélve.

Ha az alapértelmezett fájl glob túl korlátozó, eltávolíthatja az alábbiak hozzáadásával a csproj fájlhoz.

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

A .NET 7-ben hozzáadva.

Az Android csomagolási lehetőségek közé tartozik

Fájlglob kompatibilis elemek készlete, amelyek lehetővé teszik, hogy az elemek bekerüljenek a végső csomagba. Az alapértelmezett értékek a következők:

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

Az elemek fájlblob karaktereket használhatnak helyettesítő karakterekhez, például * és ?. Ezeknek az elemeknek azonban URL-kódolást vagy "$([MSBuild]::Escape(''))"-t kell használniuk. Így az MSBuild nem próbálja őket ténylegesen fájl mintázatként értelmezni. Például

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

MEGJEGYZÉS: A *, ? és . a BuildApk feladatban a megfelelő fájlmintákra lesznek cserélve.

A .NET 9-ben hozzáadva.

AndroidResource

Az összes fájl, amely AndroidResource build művelettel rendelkezik, a buildfolyamat során androidos erőforrásokká fordul, és $(AndroidResgenFile) által elérhetővé válik.

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

A fejlettebb felhasználók esetleg eltérő erőforrásokat szeretnének használni különböző konfigurációkban, de ugyanolyan hatékony elérési úton. Ez úgy érhető el, hogy több erőforráskönyvtárral rendelkezik, és ugyanazon relatív elérési úttal rendelkező fájlokat tartalmaz a különböző könyvtárakban, és az MSBuild feltételek használatával feltételesen különböző fájlokat tartalmaz a különböző konfigurációkban. Például:

<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 – Explicit módon adja meg az erőforrás elérési útját. Engedélyezi a fájlok "aliasolását", hogy több különböző erőforrásnévként is elérhetők legyenek.

<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>

Content

A normál Content buildelési művelet nem támogatott (mivel még nem tudtuk, hogyan támogatható egy esetlegesen költséges első futtatási lépés nélkül).

A Build művelet használatának @(Content) megkísérlése XA0101 figyelmeztetést eredményez.

EmbeddedJar

Az Androidhoz készült .NET kötési projektben az EmbeddedJar buildelési művelet köti a Java-/Kotlin-kódtárat, és beágyazza a fájlt a .jar tárba. Amikor egy Android-alapú .NET-alkalmazásprojekt felhasználja a kódtárat, hozzáférése lesz a Java/Kotlin API-khoz a C#-ból, valamint a Java/Kotlin kódot is belefoglalja a végleges Android-alkalmazásba.

Ehelyett használja az AndroidLibrary buildelési műveletet alternatívaként, például:

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

BeágyazottNatívKönyvtár

Android-osztálytárakhoz vagy Java-kötési projektekhez készült .NET-ben az EmbeddedNativeLibrary buildelési művelet egy natív kódtárat köt össze, például lib/armeabi-v7a/libfoo.so a tárba. Amikor egy Android-alapú .NET-alkalmazás használja a kódtárat, a libfoo.so fájl bekerül a végleges Android-alkalmazásba.

Alternatív megoldásként használhatja az AndroidNativeLibrary buildelési műveletet.

EmbeddedReferenceJar

Az Androidhoz készült .NET kötési projektben az EmbeddedReferenceJar buildelési művelet beágyazza a .jar fájlt a tárba, de nem hoz létre C#-kötést, ahogy az EmbeddedJar teszi. Amikor egy Android-alapú .NET-alkalmazásprojekt használja a kódtárat, az a Java/Kotlin kódot fogja tartalmazni a végleges Android-alkalmazásba.

Alternatívaként használhatja az AndroidLibrary buildelési műveletet, például <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

Az Androidhoz készült .NET kötési projektekben a JavaSourceJar buildelési művelet java .jar tartalmazó fájlokon használatos, amelyek javadoc dokumentációs megjegyzéseket tartalmaznak.

A Javadoc ehelyett C# XML-dokumentációs megjegyzésekké lesz konvertálva a létrehozott kötési forráskódon belül.

$(AndroidJavadocVerbosity) az importált Javadoc "részletes" vagy "teljes" működését szabályozza.

A következő MSBuild metaadatok támogatottak:

  • %(CopyrightFile): A Javadoc-tartalom szerzői jogi adatait tartalmazó fájl elérési útja, amely hozzá lesz fűzve az összes importált dokumentációhoz.

  • %(UrlPrefix): Egy URL-előtag, amely támogatja az online dokumentációhoz való csatolást az importált dokumentációban.

  • %(UrlStyle): Az online dokumentációhoz való csatoláskor létrehozandó URL-címek "stílusa". Jelenleg csak egy stílus támogatott: developer.android.com/reference@2020-Nov.

  • %(DocRootUrl): Az importált dokumentáció összes {@docroot} példánya helyett használható URL-előtag.

LibraryProjectZip

A LibraryProjectZip buildelési művelet összekapcsolja a Java/Kotlin könyvtárat, és beágyazza a .zip vagy .aar fájlt a könyvtárba. Amikor egy Android-alapú .NET-alkalmazásprojekt felhasználja a kódtárat, hozzáférése lesz a Java/Kotlin API-khoz a C#-ból, valamint a Java/Kotlin kódot is belefoglalja a végleges Android-alkalmazásba.

LinkLeírás

A LinkDescription buildelési művelettel rendelkező fájlok a linker viselkedésének szabályozására szolgálnak.

Proguard-konfiguráció

A ProguardConfiguration buildelési művelettel rendelkező fájlok olyan beállításokat tartalmaznak, amelyek a viselkedés szabályozására proguard szolgálnak. A buildelési műveletről további információt a ProGuardban talál.

Ezeket a fájlokat a rendszer figyelmen kívül hagyja, kivéve, ha a $(EnableProguard)Az MSBuild tulajdonsága True.

RuntimeEnvironmentVariable

@(RuntimeEnvironmentVariable)Az elemek lehetővé teszik, hogy a környezeti változókat futásidőben a dotnet run -e segítségével adják át az Android-alkalmazásnak. Például:

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

Ezeket az elemeket a .NET SDK automatikusan kitölti a használat dotnet run -e NAME=VALUE során, és a build során bekerülnek a létrehozott környezeti fájlba. Minden elem %(Identity) a változó neve, és %(Value) a változó értéke.

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

Ez a funkció csak Android-alkalmazásprojektekhez érhető el, és a projektképességet támogató RuntimeEnvironmentVariableSupport .NET SDK-t igényel.

Ez a buildelem a .NET 10.0.300 SDK-ban és .NET 11-ben lett bevezetve.

  • Utolsó frissítés időpontja: