Merge pull request #66747 from erikarvstedt/androidenv-fixes

Androidenv fixes

doc/languages-frameworks/android.section.md

···
 
 androidenv.emulateApp {
   name = "emulate-MyAndroidApp";
-  platformVersion = "24";
-  abiVersion = "armeabi-v7a"; # mips, x86 or x86_64
-  systemImageType = "default";
-  useGoogleAPIs = false;
+  platformVersion = "28";
+  abiVersion = "x86_64"; # armeabi-v7a, mips, x86
+  systemImageType = "google_apis_playstore";
 }
 ```
 
···
 androidenv.emulateApp {
   name = "emulate-MyAndroidApp";
   platformVersion = "24";
-  abiVersion = "armeabi-v7a"; # mips, x86 or x86_64
+  abiVersion = "armeabi-v7a"; # mips, x86, x86_64
   systemImageType = "default";
   useGoogleAPIs = false;
   app = ./MyApp.apk;

pkgs/development/mobile/androidenv/build-app.nix

···
-{ composeAndroidPackages, stdenv, ant, jdk, gnumake, gawk }:
+{ composeAndroidPackages, stdenv, lib, ant, jdk, gnumake, gawk }:
 
 { name
 , release ? false, keyStore ? null, keyAlias ? null, keyStorePassword ? null, keyAliasPassword ? null
···
   extraArgs = removeAttrs args ([ "name" ] ++ builtins.attrNames androidSdkFormalArgs);
 in
 stdenv.mkDerivation ({
-  name = stdenv.lib.replaceChars [" "] [""] name; # Android APKs may contain white spaces in their names, but Nix store paths cannot
+  name = lib.replaceChars [" "] [""] name; # Android APKs may contain white spaces in their names, but Nix store paths cannot
   ANDROID_HOME = "${androidsdk}/libexec/android-sdk";
   buildInputs = [ jdk ant ];
   buildPhase = ''
-    ${stdenv.lib.optionalString release ''
+    ${lib.optionalString release ''
       # Provide key singing attributes
       ( echo "key.store=${keyStore}"
         echo "key.alias=${keyAlias}"
···
 
     export ANDROID_SDK_HOME=`pwd` # Key files cannot be stored in the user's home directory. This overrides it.
 
-    ${stdenv.lib.optionalString (args ? includeNDK && args.includeNDK) ''
+    ${lib.optionalString (args ? includeNDK && args.includeNDK) ''
       export GNUMAKE=${gnumake}/bin/make
       export NDK_HOST_AWK=${gawk}/bin/gawk
       ${androidsdk}/libexec/android-sdk/ndk-bundle/ndk-build

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

···
 }:
 
 let
-  inherit (pkgs) stdenv fetchurl makeWrapper unzip;
+  inherit (pkgs) stdenv lib fetchurl makeWrapper unzip;
 
   # Determine the Android os identifier from Nix's system identifier
   os = if stdenv.system == "x86_64-linux" then "linux"
···
   };
 
   system-images-packages =
-    stdenv.lib.recursiveUpdate
+    lib.recursiveUpdate
       system-images-packages-android
-      (stdenv.lib.recursiveUpdate system-images-packages-android-tv
-        (stdenv.lib.recursiveUpdate system-images-packages-android-wear
-          (stdenv.lib.recursiveUpdate system-images-packages-android-wear-cn
-            (stdenv.lib.recursiveUpdate system-images-packages-google_apis system-images-packages-google_apis_playstore))));
+      (lib.recursiveUpdate system-images-packages-android-tv
+        (lib.recursiveUpdate system-images-packages-android-wear
+          (lib.recursiveUpdate system-images-packages-android-wear-cn
+            (lib.recursiveUpdate system-images-packages-google_apis system-images-packages-google_apis_playstore))));
 
   # Generated addons
   addons = import ./generated/addons.nix {
···
   };
 
   platform-tools = import ./platform-tools.nix {
-    inherit deployAndroidPackage os autoPatchelfHook pkgs;
-    inherit (stdenv) lib;
+    inherit deployAndroidPackage os autoPatchelfHook pkgs lib;
     package = packages.platform-tools."${platformToolsVersion}";
   };
 
   build-tools = map (version:
     import ./build-tools.nix {
-      inherit deployAndroidPackage os autoPatchelfHook makeWrapper pkgs pkgs_i686;
-      inherit (stdenv) lib;
+      inherit deployAndroidPackage os autoPatchelfHook makeWrapper pkgs pkgs_i686 lib;
       package = packages.build-tools."${version}";
     }
   ) buildToolsVersions;
···
   };
 
   emulator = import ./emulator.nix {
-    inherit deployAndroidPackage os autoPatchelfHook makeWrapper pkgs pkgs_i686;
-    inherit (stdenv) lib;
+    inherit deployAndroidPackage os autoPatchelfHook makeWrapper pkgs pkgs_i686 lib;
     package = packages.emulator."${emulatorVersion}"."${os}";
   };
 
···
     }
   ) platformVersions;
 
-  system-images = stdenv.lib.flatten (map (apiVersion:
+  system-images = lib.flatten (map (apiVersion:
     map (type:
       map (abiVersion:
         deployAndroidPackage {
           inherit os;
           package = system-images-packages.${apiVersion}.${type}.${abiVersion};
+          # Patch 'google_apis' system images so they're recognized by the sdk.
+          # Without this, `android list targets` shows 'Tag/ABIs : no ABIs' instead
+          # of 'Tag/ABIs : google_apis*/*' and the emulator fails with an ABI-related error.
+          patchInstructions = lib.optionalString (lib.hasPrefix "google_apis" type) ''
+            sed -i '/^Addon.Vendor/d' source.properties
+          '';
         }
       ) abiVersions
     ) systemImageTypes
···
 
   lldb = map (version:
     import ./lldb.nix {
-      inherit deployAndroidPackage os autoPatchelfHook pkgs;
-      inherit (stdenv) lib;
+      inherit deployAndroidPackage os autoPatchelfHook pkgs lib;
       package = packages.lldb."${version}";
     }
   ) lldbVersions;
 
   cmake = map (version:
     import ./cmake.nix {
-      inherit deployAndroidPackage os autoPatchelfHook pkgs;
-      inherit (stdenv) lib;
+      inherit deployAndroidPackage os autoPatchelfHook pkgs lib;
       package = packages.cmake."${version}";
     }
   ) cmakeVersions;
 
   ndk-bundle = import ./ndk-bundle {
-    inherit deployAndroidPackage os autoPatchelfHook makeWrapper pkgs platform-tools;
-    inherit (stdenv) lib;
+    inherit deployAndroidPackage os autoPatchelfHook makeWrapper pkgs lib platform-tools;
     package = packages.ndk-bundle."${ndkVersion}";
   };
 
···
 
   # Function that automatically links all plugins for which multiple versions can coexist
   linkPlugins = {name, plugins}:
-    stdenv.lib.optionalString (plugins != []) ''
+    lib.optionalString (plugins != []) ''
       mkdir -p ${name}
-      ${stdenv.lib.concatMapStrings (plugin: ''
+      ${lib.concatMapStrings (plugin: ''
         ln -s ${plugin}/libexec/android-sdk/${name}/* ${name}
       '') plugins}
     '';
 
   # Function that automatically links a plugin for which only one version exists
   linkPlugin = {name, plugin, check ? true}:
-    stdenv.lib.optionalString check ''
+    lib.optionalString check ''
       ln -s ${plugin}/libexec/android-sdk/* ${name}
     '';
 
   # Links all plugins related to a requested platform
   linkPlatformPlugins = {name, plugins, check}:
-    stdenv.lib.optionalString check ''
+    lib.optionalString check ''
       mkdir -p ${name}
-      ${stdenv.lib.concatMapStrings (plugin: ''
+      ${lib.concatMapStrings (plugin: ''
         ln -s ${plugin}/libexec/android-sdk/${name}/* ${name}
       '') plugins}
     ''; # */
···
     https://developer.android.com/studio/terms
     by setting nixpkgs config option 'android_sdk.accept_license = true;'
   '' else import ./tools.nix {
-    inherit deployAndroidPackage requireFile packages toolsVersion autoPatchelfHook makeWrapper os pkgs pkgs_i686;
-    inherit (stdenv) lib;
+    inherit deployAndroidPackage requireFile packages toolsVersion autoPatchelfHook makeWrapper os pkgs pkgs_i686 lib;
 
     postInstall = ''
       # Symlink all requested plugins
···
       ${linkPlugins { name = "cmake"; plugins = cmake; }}
       ${linkPlugin { name = "ndk-bundle"; plugin = ndk-bundle; check = includeNDK; }}
 
-      ${stdenv.lib.optionalString includeSystemImages ''
+      ${lib.optionalString includeSystemImages ''
         mkdir -p system-images
-        ${stdenv.lib.concatMapStrings (system-image: ''
+        ${lib.concatMapStrings (system-image: ''
           apiVersion=$(basename $(echo ${system-image}/libexec/android-sdk/system-images/*))
           type=$(basename $(echo ${system-image}/libexec/android-sdk/system-images/*/*))
           mkdir -p system-images/$apiVersion/$type
···
       ${linkPlatformPlugins { name = "add-ons"; plugins = google-apis; check = useGoogleTVAddOns; }}
 
       # Link extras
-      ${stdenv.lib.concatMapStrings (identifier:
+      ${lib.concatMapStrings (identifier:
         let
           path = addons.extras."${identifier}".path;
           addon = deployAndroidPackage {

pkgs/development/mobile/androidenv/default.nix

···
   };
 
   buildApp = import ./build-app.nix {
-    inherit (pkgs) stdenv jdk ant gnumake gawk;
+    inherit (pkgs) stdenv lib jdk ant gnumake gawk;
     inherit composeAndroidPackages;
   };
 
   emulateApp = import ./emulate-app.nix {
-    inherit (pkgs) stdenv;
+    inherit (pkgs) stdenv lib;
     inherit composeAndroidPackages;
   };
 

pkgs/development/mobile/androidenv/emulate-app.nix

···
-{ composeAndroidPackages, stdenv }:
+{ composeAndroidPackages, stdenv, lib }:
 { name, app ? null
-, platformVersion ? "16", abiVersion ? "armeabi-v7a", systemImageType ? "default", useGoogleAPIs ? false
+, platformVersion ? "16", abiVersion ? "armeabi-v7a", systemImageType ? "default"
 , enableGPU ? false, extraAVDFiles ? []
 , package ? null, activity ? null
-, avdHomeDir ? null
-}@args:
+, avdHomeDir ? null, sdkExtraArgs ? {}
+}:
 
 let
-  androidSdkArgNames = builtins.attrNames (builtins.functionArgs composeAndroidPackages);
-
-  # Extract the parameters meant for the Android SDK
-  androidParams = {
+  sdkArgs = {
     platformVersions = [ platformVersion ];
     includeEmulator = true;
     includeSystemImages = true;
     systemImageTypes = [ systemImageType ];
     abiVersions = [ abiVersion ];
-  };
+  } // sdkExtraArgs;
 
-  androidsdkComposition = (composeAndroidPackages androidParams).androidsdk;
+  sdk = (composeAndroidPackages sdkArgs).androidsdk;
 in
 stdenv.mkDerivation {
   inherit name;
···
     ''}
 
     # We need to specify the location of the Android SDK root folder
-    export ANDROID_SDK_ROOT=${androidsdkComposition}/libexec/android-sdk
+    export ANDROID_SDK_ROOT=${sdk}/libexec/android-sdk
 
     # We have to look for a free TCP port
 
···
 
     for i in $(seq 5554 2 5584)
     do
-        if [ -z "$(${androidsdkComposition}/libexec/android-sdk/platform-tools/adb devices | grep emulator-$i)" ]
+        if [ -z "$(${sdk}/libexec/android-sdk/platform-tools/adb devices | grep emulator-$i)" ]
         then
             port=$i
             break
···
     export ANDROID_SERIAL="emulator-$port"
 
     # Create a virtual android device for testing if it does not exists
-    ${androidsdkComposition}/libexec/android-sdk/tools/android list targets
+    ${sdk}/libexec/android-sdk/tools/android list targets
 
-    if [ "$(${androidsdkComposition}/libexec/android-sdk/tools/android list avd | grep 'Name: device')" = "" ]
+    if [ "$(${sdk}/libexec/android-sdk/tools/android list avd | grep 'Name: device')" = "" ]
     then
         # Create a virtual android device
-        yes "" | ${androidsdkComposition}/libexec/android-sdk/tools/android create avd -n device -t 1 --abi ${systemImageType}/${abiVersion} $NIX_ANDROID_AVD_FLAGS
+        yes "" | ${sdk}/libexec/android-sdk/tools/android create avd -n device -t 1 --abi ${systemImageType}/${abiVersion} $NIX_ANDROID_AVD_FLAGS
 
-        ${stdenv.lib.optionalString enableGPU ''
+        ${lib.optionalString enableGPU ''
           # Enable GPU acceleration
           echo "hw.gpu.enabled=yes" >> $ANDROID_SDK_HOME/.android/avd/device.avd/config.ini
         ''}
 
-        ${stdenv.lib.concatMapStrings (extraAVDFile: ''
+        ${lib.concatMapStrings (extraAVDFile: ''
           ln -sf ${extraAVDFile} $ANDROID_SDK_HOME/.android/avd/device.avd
         '') extraAVDFiles}
     fi
 
     # Launch the emulator
-    ${androidsdkComposition}/libexec/android-sdk/emulator/emulator -avd device -no-boot-anim -port $port $NIX_ANDROID_EMULATOR_FLAGS &
+    ${sdk}/libexec/android-sdk/emulator/emulator -avd device -no-boot-anim -port $port $NIX_ANDROID_EMULATOR_FLAGS &
 
     # Wait until the device has completely booted
     echo "Waiting until the emulator has booted the device and the package manager is ready..." >&2
 
-    ${androidsdkComposition}/libexec/android-sdk/platform-tools/adb -s emulator-$port wait-for-device
+    ${sdk}/libexec/android-sdk/platform-tools/adb -s emulator-$port wait-for-device
 
     echo "Device state has been reached" >&2
 
-    while [ -z "$(${androidsdkComposition}/libexec/android-sdk/platform-tools/adb -s emulator-$port shell getprop dev.bootcomplete | grep 1)" ]
+    while [ -z "$(${sdk}/libexec/android-sdk/platform-tools/adb -s emulator-$port shell getprop dev.bootcomplete | grep 1)" ]
     do
         sleep 5
     done
 
     echo "dev.bootcomplete property is 1" >&2
 
-    #while [ -z "$(${androidsdkComposition}/libexec/android-sdk/platform-tools/adb -s emulator-$port shell getprop sys.boot_completed | grep 1)" ]
+    #while [ -z "$(${sdk}/libexec/android-sdk/platform-tools/adb -s emulator-$port shell getprop sys.boot_completed | grep 1)" ]
     #do
         #sleep 5
     #done
···
 
     echo "ready" >&2
 
-    ${stdenv.lib.optionalString (app != null) ''
+    ${lib.optionalString (app != null) ''
       # Install the App through the debugger, if it has not been installed yet
 
-      if [ -z "${package}" ] || [ "$(${androidsdkComposition}/libexec/android-sdk/platform-tools/adb -s emulator-$port shell pm list packages | grep package:${package})" = "" ]
+      if [ -z "${package}" ] || [ "$(${sdk}/libexec/android-sdk/platform-tools/adb -s emulator-$port shell pm list packages | grep package:${package})" = "" ]
       then
           if [ -d "${app}" ]
           then
···
               appPath="${app}"
           fi
 
-          ${androidsdkComposition}/libexec/android-sdk/platform-tools/adb -s emulator-$port install "$appPath"
+          ${sdk}/libexec/android-sdk/platform-tools/adb -s emulator-$port install "$appPath"
       fi
 
       # Start the application
-      ${stdenv.lib.optionalString (package != null && activity != null) ''
-          ${androidsdkComposition}/libexec/android-sdk/platform-tools/adb -s emulator-$port shell am start -a android.intent.action.MAIN -n ${package}/${activity}
+      ${lib.optionalString (package != null && activity != null) ''
+          ${sdk}/libexec/android-sdk/platform-tools/adb -s emulator-$port shell am start -a android.intent.action.MAIN -n ${package}/${activity}
       ''}
     ''}
     EOF