androidenv: support linking "latest" version of all plugins

As noted in #379534, the NDK linking broke during refactoring. Add a test
for that, and support linking the latest for all platform plugins that
take at least one version.

pkgs/development/mobile/androidenv/compose-android-packages.nix

···
 let
   # Coerces a string to an int.
   coerceInt = val: if lib.isInt val then val else lib.toIntBase10 val;
+
+  # Parses a single version, substituting "latest" with the latest version.
+  parseVersion =
+    repo: key: version:
+    if version == "latest" then repo.latest.${key} else version;
+
+  # Parses a list of versions, substituting "latest" with the latest version.
+  parseVersions =
+    repo: key: versions:
+    lib.unique (map (parseVersion repo key) versions);
 in
 {
   repoJson ? ./repo.json,
···
     else
       lib.importJSON repoJson
   ),
-  cmdLineToolsVersion ? repo.latest.cmdline-tools,
-  toolsVersion ? repo.latest.tools,
-  platformToolsVersion ? repo.latest.platform-tools,
-  buildToolsVersions ? [ repo.latest.build-tools ],
+  cmdLineToolsVersion ? "latest",
+  toolsVersion ? "latest",
+  platformToolsVersion ? "latest",
+  buildToolsVersions ? [ "latest" ],
   includeEmulator ? false,
-  emulatorVersion ? repo.latest.emulator,
+  emulatorVersion ? "latest",
   minPlatformVersion ? null,
-  maxPlatformVersion ? coerceInt repo.latest.platforms,
+  maxPlatformVersion ? "latest",
   numLatestPlatformVersions ? 1,
   platformVersions ?
     if minPlatformVersion != null && maxPlatformVersion != null then
       let
-        minPlatformVersionInt = coerceInt minPlatformVersion;
-        maxPlatformVersionInt = coerceInt maxPlatformVersion;
+        minPlatformVersionInt = coerceInt (parseVersion repo "platforms" minPlatformVersion);
+        maxPlatformVersionInt = coerceInt (parseVersion repo "platforms" maxPlatformVersion);
       in
       lib.range (lib.min minPlatformVersionInt maxPlatformVersionInt) (
         lib.max minPlatformVersionInt maxPlatformVersionInt
       )
     else
       let
-        minPlatformVersionInt = if minPlatformVersion == null then 1 else coerceInt minPlatformVersion;
+        minPlatformVersionInt =
+          if minPlatformVersion == null then
+            1
+          else
+            coerceInt (parseVersion repo "platforms" minPlatformVersion);
         latestPlatformVersionInt = lib.max minPlatformVersionInt (coerceInt repo.latest.platforms);
         firstPlatformVersionInt = lib.max minPlatformVersionInt (
           latestPlatformVersionInt - (lib.max 1 numLatestPlatformVersions) + 1
···
   ],
   # cmake has precompiles on x86_64 and Darwin platforms. Default to true there for compatibility.
   includeCmake ? stdenv.hostPlatform.isx86_64 || stdenv.hostPlatform.isDarwin,
-  cmakeVersions ? [ repo.latest.cmake ],
+  cmakeVersions ? [ "latest" ],
   includeNDK ? false,
-  ndkVersion ? repo.latest.ndk,
+  ndkVersion ? "latest",
   ndkVersions ? [ ndkVersion ],
   useGoogleAPIs ? false,
   useGoogleTVAddOns ? false,
···
 }:
 
 let
+  # Resolve all the platform versions.
+  platformVersions' = map coerceInt (parseVersions repo "platforms" platformVersions);
+
   # Determine the Android os identifier from Nix's system identifier
   os =
     {
···
       arch
       meta
       ;
-    package = checkVersion allArchives.packages "platform-tools" platformToolsVersion;
+    package = checkVersion allArchives.packages "platform-tools" (
+      parseVersion repo "platform-tools" platformToolsVersion
+    );
   };
 
   tools = callPackage ./tools.nix {
···
       arch
       meta
       ;
-    package = checkVersion allArchives.packages "tools" toolsVersion;
+    package = checkVersion allArchives.packages "tools" (parseVersion repo "tools" toolsVersion);
 
     postInstall = ''
       ${linkPlugin {
···
         }}
       '';
     }
-  ) buildToolsVersions;
+  ) (parseVersions repo "build-tools" buildToolsVersions);
 
   emulator = callPackage ./emulator.nix {
     inherit
···
       arch
       meta
       ;
-    package = checkVersion allArchives.packages "emulator" emulatorVersion;
+    package = checkVersion allArchives.packages "emulator" (
+      parseVersion repo "emulator" emulatorVersion
+    );
 
     postInstall = ''
       ${linkSystemImages {
···
     '';
   };
 
-  inherit platformVersions;
+  platformVersions = platformVersions';
 
   platforms = map (
     version:
     deployAndroidPackage {
       package = checkVersion allArchives.packages "platforms" version;
     }
-  ) platformVersions;
+  ) platformVersions';
 
   sources = map (
     version:
     deployAndroidPackage {
       package = checkVersion allArchives.packages "sources" version;
     }
-  ) platformVersions;
+  ) platformVersions';
 
   system-images = lib.flatten (
     map (
···
           patchesInstructions = instructions;
         })
       ) systemImageTypes
-    ) platformVersions
+    ) platformVersions'
   );
 
   cmake = map (
···
         ;
       package = checkVersion allArchives.packages "cmake" version;
     }
-  ) cmakeVersions;
+  ) (parseVersions repo "cmake" cmakeVersions);
 
   # All NDK bundles.
   ndk-bundles =
···
         version:
         let
           package = makeNdkBundle (
-            allArchives.packages.ndk-bundle.${ndkVersion} or allArchives.packages.ndk.${ndkVersion}
+            allArchives.packages.ndk-bundle.${version} or allArchives.packages.ndk.${version}
           );
         in
         lib.optional (shouldLink includeNDK [ package ]) package
-      ) ndkVersions
+      ) (parseVersions repo "ndk" ndkVersions)
     );
 
   # The "default" NDK bundle.
···
     deployAndroidPackage {
       package = (checkVersion allArchives "addons" version).google_apis;
     }
-  ) (lib.filter (hasVersion allArchives "addons") platformVersions);
+  ) (lib.filter (hasVersion allArchives "addons") platformVersions');
 
   # Makes a Google TV addons bundle from supported versions.
   google-tv-addons = map (
···
     deployAndroidPackage {
       package = (checkVersion allArchives "addons" version).google_tv_addon;
     }
-  ) (lib.filter (hasVersion allArchives "addons") platformVersions);
+  ) (lib.filter (hasVersion allArchives "addons") platformVersions');
 
-  cmdline-tools-package = checkVersion allArchives.packages "cmdline-tools" cmdLineToolsVersion;
+  cmdline-tools-package = checkVersion allArchives.packages "cmdline-tools" (
+    parseVersion repo "cmdline-tools" cmdLineToolsVersion
+  );
 
   # This derivation deploys the tools package and symlinks all the desired
   # plugins that we want to use. If the license isn't accepted, prints all the licenses

pkgs/development/mobile/androidenv/examples/shell.nix

···
   # The head unit only works on these platforms
   includeAuto = pkgs.stdenv.hostPlatform.isx86_64 || pkgs.stdenv.hostPlatform.isDarwin;
 
+  ndkVersions = [
+    "23.1.7779620"
+    "25.1.8937393"
+    "26.1.10909125"
+    "latest"
+  ];
+
   androidComposition = androidEnv.composeAndroidPackages {
     includeSources = true;
     includeSystemImages = false;
     includeEmulator = "if-supported";
     includeNDK = "if-supported";
+    inherit ndkVersions;
     useGoogleAPIs = true;
     useGoogleTVAddOns = true;
 
···
               exit 1
             fi
           done
+
+          num_ndk_packages="$(echo "$installed_packages_section" | grep '^ndk;' | wc -l)"
+          if [ $num_ndk_packages -ne ${toString (pkgs.lib.length ndkVersions)} ]; then
+            echo "Invalid NDK package count: $num_ndk_packages"
+            exit 1
+          fi
 
           touch "$out"
         '';