commit 803aebe826635862784f99e059a16a3d6cec0def · pyrox.dev/nixpkgs

+2 -2

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

···

       1
       1
       -
       {deployAndroidPackage, lib, stdenv, package, os, autoPatchelfHook, makeWrapper, pkgs, pkgsi686Linux, postInstall, meta}:

     

       1
       1
       +
       {deployAndroidPackage, lib, stdenv, package, os, arch, autoPatchelfHook, makeWrapper, pkgs, pkgsi686Linux, postInstall, meta}:

     

       2
       2
        
       

     

       3
       3
        
       deployAndroidPackage {

     

       4
       4
       -
         inherit package;

     

       4
       4
       +
         inherit package os arch;

     

       5
       5
        
         nativeBuildInputs = [ makeWrapper ]

     

       6
       6
        
           ++ lib.optionals (os == "linux") [ autoPatchelfHook ];

     

       7
       7
        
         buildInputs = lib.optionals (os == "linux") [ pkgs.glibc pkgs.zlib pkgs.ncurses5 pkgs.libcxx ]

+2 -2

pkgs/development/mobile/androidenv/cmake.nix

···

       1
       1
       -
       {deployAndroidPackage, lib, package, os, autoPatchelfHook, pkgs, stdenv, meta}:

     

       1
       1
       +
       {deployAndroidPackage, lib, package, os, arch, autoPatchelfHook, pkgs, stdenv, meta}:

     

       2
       2
        
       

     

       3
       3
        
       deployAndroidPackage {

     

       4
       4
       -
         inherit package;

     

       4
       4
       +
         inherit package os arch;

     

       5
       5
        
         nativeBuildInputs = lib.optionals stdenv.hostPlatform.isLinux [ autoPatchelfHook ];

     

       6
       6
        
         buildInputs = lib.optionals (os == "linux") [ pkgs.stdenv.cc.libc pkgs.stdenv.cc.cc pkgs.ncurses5 ];

     

       7
       7
        
         patchInstructions = lib.optionalString (os == "linux") ''

+2 -1

pkgs/development/mobile/androidenv/cmdline-tools.nix

···

       5
       5
        
         autoPatchelfHook,

     

       6
       6
        
         makeWrapper,

     

       7
       7
        
         os,

     

       8
       8
       +
         arch,

     

       8
       9
        
         pkgs,

     

       9
       10
        
         stdenv,

     

       10
       11
        
         postInstall,

     
···

       13
       14
        
       

     

       14
       15
        
       deployAndroidPackage {

     

       15
       16
        
         name = "androidsdk";

     

       16
       16
       -
         inherit package os;

     

       17
       17
       +
         inherit package os arch;

     

       17
       18
        
         nativeBuildInputs = [

     

       18
       19
        
           makeWrapper

     

       19
       20
        
         ] ++ lib.optionals stdenv.hostPlatform.isLinux [ autoPatchelfHook ];

+64 -41

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

···

       50
       50
        
       , includeSystemImages ? false

     

       51
       51
        
       , systemImageTypes ? [ "google_apis" "google_apis_playstore" ]

     

       52
       52
        
       , abiVersions ? [ "x86" "x86_64" "armeabi-v7a" "arm64-v8a" ]

     

       53
       53
       +
         # cmake has precompiles on x86_64 and Darwin platforms. Default to true there for compatibility.

     

       54
       54
       +
       , includeCmake ? stdenv.hostPlatform.isx86_64 || stdenv.hostPlatform.isDarwin

     

       53
       55
        
       , cmakeVersions ? [ repo.latest.cmake ]

     

       54
       56
        
       , includeNDK ? false

     

       55
       57
        
       , ndkVersion ? repo.latest.ndk

     
···

       87
       89
        
                     let

     

       88
       90
        
                       isTargetOs = if builtins.hasAttr "os" archive then

     

       89
       91
        
                         archive.os == os || archive.os == "all" else true;

     

       90
       90
       -
                       isTargetArc = if builtins.hasAttr "arch" archive then

     

       92
       92
       +
                       isTargetArch = if builtins.hasAttr "arch" archive then

     

       91
       93
        
                         archive.arch == arch || archive.arch == "all" else true;

     

       92
       94
        
                     in

     

       93
       93
       -
                       isTargetOs && isTargetArc

     

       95
       95
       +
                       isTargetOs && isTargetArch

     

       94
       96
        
                   ) value;

     

       95
       97
        
                 in

     

       96
       96
       -
                 lib.warnIf (builtins.length validArchives == 0)

     

       97
       97
       -
                   "No valid archives for ${lib.concatMapStringsSep "." (x: ''"${x}"'') path} for os=${os}, arch=${arch}"

     

       98
       98
       -
                   (lib.optionals (builtins.length validArchives > 0)

     

       99
       99
       -
                     (lib.last (map (archive:

     

       100
       100
       -
                       (fetchurl { inherit (archive) url sha1; })

     

       101
       101
       -
                     ) validArchives)))

     

       98
       98
       +
                 lib.optionals (builtins.length validArchives > 0)

     

       99
       99
       +
                   (lib.last (map (archive:

     

       100
       100
       +
                     (fetchurl { inherit (archive) url sha1; })

     

       101
       101
       +
                   ) validArchives))

     

       102
       102
        
               else value

     

       103
       103
        
             )

     

       104
       104
        
             attrSet;

     
···

       139
       139
        
       in

     

       140
       140
        
       lib.recurseIntoAttrs rec {

     

       141
       141
        
         deployAndroidPackages = callPackage ./deploy-androidpackages.nix {

     

       142
       142
       -
           inherit stdenv lib mkLicenses meta;

     

       142
       142
       +
           inherit stdenv lib mkLicenses meta os arch;

     

       143
       143
        
         };

     

       144
       144
        
       

     

       145
       145
        
         deployAndroidPackage = ({package, buildInputs ? [], patchInstructions ? "", meta ? {}, ...}@args:

     

       146
       146
        
           let

     

       147
       147
       -
             extraParams = removeAttrs args [ "package" "os" "buildInputs" "patchInstructions" ];

     

       147
       147
       +
             extraParams = removeAttrs args [ "package" "os" "arch" "buildInputs" "patchInstructions" ];

     

       148
       148
        
           in

     

       149
       149
        
           deployAndroidPackages ({

     

       150
       150
        
             inherit buildInputs;

     
···

       164
       164
        
             '';

     

       165
       165
        
       

     

       166
       166
        
         platform-tools = callPackage ./platform-tools.nix {

     

       167
       167
       -
           inherit deployAndroidPackage os meta;

     

       167
       167
       +
           inherit deployAndroidPackage os arch meta;

     

       168
       168
        
           package = check-version packages "platform-tools" platformToolsVersion;

     

       169
       169
        
         };

     

       170
       170
        
       

     

       171
       171
        
         tools = callPackage ./tools.nix {

     

       172
       172
       -
           inherit deployAndroidPackage os meta;

     

       172
       172
       +
           inherit deployAndroidPackage os arch meta;

     

       173
       173
        
           package = check-version packages "tools" toolsVersion;

     

       174
       174
        
       

     

       175
       175
        
           postInstall = ''

     
···

       180
       180
        
       

     

       181
       181
        
         build-tools = map (version:

     

       182
       182
        
           callPackage ./build-tools.nix {

     

       183
       183
       -
             inherit deployAndroidPackage os meta;

     

       183
       183
       +
             inherit deployAndroidPackage os arch meta;

     

       184
       184
        
             package = check-version packages "build-tools" version;

     

       185
       185
        
       

     

       186
       186
        
             postInstall = ''

     
···

       189
       189
        
           }

     

       190
       190
        
         ) buildToolsVersions;

     

       191
       191
        
       

     

       192
       192
       -
         emulator = lib.optionals includeEmulator (callPackage ./emulator.nix {

     

       193
       193
       -
           inherit deployAndroidPackage os meta;

     

       194
       194
       -
           package = check-version packages "emulator" emulatorVersion;

     

       192
       192
       +
         emulator =

     

       193
       193
       +
           callPackage ./emulator.nix {

     

       194
       194
       +
             inherit deployAndroidPackage os arch meta;

     

       195
       195
       +
             package = check-version packages "emulator" emulatorVersion;

     

       195
       196
        
       

     

       196
       196
       -
           postInstall = ''

     

       197
       197
       -
             ${linkSystemImages { images = system-images; check = includeSystemImages; }}

     

       198
       198
       -
           '';

     

       199
       199
       -
         });

     

       197
       197
       +
             postInstall = ''

     

       198
       198
       +
               ${linkSystemImages { images = system-images; check = includeSystemImages; }}

     

       199
       199
       +
             '';

     

       200
       200
       +
           };

     

       200
       201
        
       

     

       201
       202
        
         platforms = map (version:

     

       202
       203
        
           deployAndroidPackage {

     
···

       248
       249
        
       

     

       249
       250
        
         cmake = map (version:

     

       250
       251
        
           callPackage ./cmake.nix {

     

       251
       251
       -
             inherit deployAndroidPackage os meta;

     

       252
       252
       +
             inherit deployAndroidPackage os arch meta;

     

       252
       253
        
             package = check-version packages "cmake" version;

     

       253
       254
        
           }

     

       254
       255
        
         ) cmakeVersions;

     

       255
       256
        
       

     

       257
       257
       +
         # Returns true if we should link the specified plugins.

     

       258
       258
       +
         shouldLink = check: packages:

     

       259
       259
       +
           assert builtins.isList packages;

     

       260
       260
       +
           if check == true then

     

       261
       261
       +
             true

     

       262
       262
       +
           else if check == false then

     

       263
       263
       +
             false

     

       264
       264
       +
           else if check == null || check == "if-supported" then

     

       265
       265
       +
             let

     

       266
       266
       +
               hasSrc = package: package.src != null && (builtins.isList package.src -> builtins.length package.src > 0);

     

       267
       267
       +
             in

     

       268
       268
       +
             packages != [] && lib.all hasSrc packages

     

       269
       269
       +
           else

     

       270
       270
       +
             throw "Invalid argument ${toString check}; use true, false, or null/if-supported";

     

       271
       271
       +
       

     

       256
       272
        
         # Creates a NDK bundle.

     

       257
       257
       -
         makeNdkBundle = ndkVersion:

     

       273
       273
       +
         makeNdkBundle = package:

     

       258
       274
        
           callPackage ./ndk-bundle {

     

       259
       259
       -
             inherit deployAndroidPackage os platform-tools meta;

     

       260
       260
       -
             package = packages.ndk-bundle.${ndkVersion} or packages.ndk.${ndkVersion};

     

       275
       275
       +
             inherit deployAndroidPackage os arch platform-tools meta package;

     

       261
       276
        
           };

     

       262
       277
        
       

     

       263
       278
        
         # All NDK bundles.

     

       264
       264
       -
         ndk-bundles = lib.optionals includeNDK (map makeNdkBundle ndkVersions);

     

       279
       279
       +
         ndk-bundles = lib.flatten (

     

       280
       280
       +
           map (version:

     

       281
       281
       +
             let

     

       282
       282
       +
               package = makeNdkBundle (packages.ndk-bundle.${ndkVersion} or packages.ndk.${ndkVersion});

     

       283
       283
       +
             in

     

       284
       284
       +
             lib.optional (shouldLink includeNDK [package]) package

     

       285
       285
       +
           ) ndkVersions

     

       286
       286
       +
         );

     

       265
       287
        
       

     

       266
       288
        
         # The "default" NDK bundle.

     

       267
       267
       -
         ndk-bundle = if includeNDK then lib.findFirst (x: x != null) null ndk-bundles else null;

     

       289
       289
       +
         ndk-bundle = if ndk-bundles == [] then null else lib.head ndk-bundles;

     

       268
       290
        
       

     

       291
       291
       +
         # Makes a Google API bundle.

     

       269
       292
        
         google-apis = map (version:

     

       270
       293
        
           deployAndroidPackage {

     

       271
       294
        
             package = (check-version addons "addons" version).google_apis;

     

       272
       295
        
           }

     

       273
       273
       -
         ) (builtins.filter (platformVersion: platformVersion < "26") platformVersions); # API level 26 and higher include Google APIs by default

     

       296
       296
       +
         ) (builtins.filter (platformVersion: lib.versionOlder platformVersion "26") platformVersions); # API level 26 and higher include Google APIs by default

     

       274
       297
        
       

     

       275
       298
        
         google-tv-addons = map (version:

     

       276
       299
        
           deployAndroidPackage {

     
···

       279
       302
        
         ) platformVersions;

     

       280
       303
        
       

     

       281
       304
        
         # Function that automatically links all plugins for which multiple versions can coexist

     

       282
       282
       -
         linkPlugins = {name, plugins}:

     

       283
       283
       -
           lib.optionalString (plugins != []) ''

     

       305
       305
       +
         linkPlugins = {name, plugins, check ? true}:

     

       306
       306
       +
           lib.optionalString (shouldLink check plugins) ''

     

       284
       307
        
             mkdir -p ${name}

     

       285
       308
        
             ${lib.concatMapStrings (plugin: ''

     

       286
       309
        
               ln -s ${plugin}/libexec/android-sdk/${name}/* ${name}

     
···

       288
       311
        
           '';

     

       289
       312
        
       

     

       290
       313
        
         # Function that automatically links all NDK plugins.

     

       291
       291
       -
         linkNdkPlugins = {name, plugins, rootName ? name}:

     

       292
       292
       -
           lib.optionalString (plugins != []) ''

     

       314
       314
       +
         linkNdkPlugins = {name, plugins, rootName ? name, check ? true}:

     

       315
       315
       +
           lib.optionalString (shouldLink check plugins) ''

     

       293
       316
        
             mkdir -p ${rootName}

     

       294
       317
        
             ${lib.concatMapStrings (plugin: ''

     

       295
       318
        
               ln -s ${plugin}/libexec/android-sdk/${name} ${rootName}/${plugin.version}

     
···

       298
       321
        
       

     

       299
       322
        
         # Function that automatically links the default NDK plugin.

     

       300
       323
        
         linkNdkPlugin = {name, plugin, check}:

     

       301
       301
       -
           lib.optionalString check ''

     

       324
       324
       +
           lib.optionalString (shouldLink check [plugin]) ''

     

       302
       325
        
             ln -s ${plugin}/libexec/android-sdk/${name} ${name}

     

       303
       326
        
           '';

     

       304
       327
        
       

     

       305
       328
        
         # Function that automatically links a plugin for which only one version exists

     

       306
       329
        
         linkPlugin = {name, plugin, check ? true}:

     

       307
       307
       -
           lib.optionalString check ''

     

       330
       330
       +
           lib.optionalString (shouldLink check [plugin]) ''

     

       308
       331
        
             ln -s ${plugin}/libexec/android-sdk/${name} ${name}

     

       309
       332
        
           '';

     

       310
       333
        
       

     

       311
       311
       -
         linkSystemImages = { images, check }: lib.optionalString check ''

     

       334
       334
       +
         linkSystemImages = { images, check }: lib.optionalString (shouldLink check images) ''

     

       312
       335
        
           mkdir -p system-images

     

       313
       336
        
           ${lib.concatMapStrings (system-image: ''

     

       314
       337
        
             apiVersion=$(basename $(echo ${system-image}/libexec/android-sdk/system-images/*))

     
···

       320
       343
        
       

     

       321
       344
        
         # Links all plugins related to a requested platform

     

       322
       345
        
         linkPlatformPlugins = {name, plugins, check}:

     

       323
       323
       -
           lib.optionalString check ''

     

       346
       346
       +
           lib.optionalString (shouldLink check plugins) ''

     

       324
       347
        
             mkdir -p ${name}

     

       325
       348
        
             ${lib.concatMapStrings (plugin: ''

     

       326
       349
        
               ln -s ${plugin}/libexec/android-sdk/${name}/* ${name}

     
···

       344
       367
        
             by an environment variable for a single invocation of the nix tools.

     

       345
       368
        
               $ export NIXPKGS_ACCEPT_ANDROID_SDK_LICENSE=1

     

       346
       369
        
         '' else callPackage ./cmdline-tools.nix {

     

       347
       347
       -
           inherit deployAndroidPackage os meta;

     

       370
       370
       +
           inherit deployAndroidPackage os arch meta;

     

       348
       371
        
       

     

       349
       372
        
           package = cmdline-tools-package;

     

       350
       373
        
       

     
···

       356
       379
        
             ${linkPlugin { name = "emulator"; plugin = emulator; check = includeEmulator; }}

     

       357
       380
        
             ${linkPlugins { name = "platforms"; plugins = platforms; }}

     

       358
       381
        
             ${linkPlatformPlugins { name = "sources"; plugins = sources; check = includeSources; }}

     

       359
       359
       -
             ${linkPlugins { name = "cmake"; plugins = cmake; }}

     

       360
       360
       -
             ${linkNdkPlugins { name = "ndk-bundle"; rootName = "ndk"; plugins = ndk-bundles; }}

     

       382
       382
       +
             ${linkPlugins { name = "cmake"; plugins = cmake; check = includeCmake; }}

     

       383
       383
       +
             ${linkNdkPlugins { name = "ndk-bundle"; rootName = "ndk"; plugins = ndk-bundles; check = includeNDK; }}

     

       361
       384
        
             ${linkNdkPlugin { name = "ndk-bundle"; plugin = ndk-bundle; check = includeNDK; }}

     

       362
       385
        
             ${linkSystemImages { images = system-images; check = includeSystemImages; }}

     

       363
       386
        
             ${linkPlatformPlugins { name = "add-ons"; plugins = google-apis; check = useGoogleAPIs; }}

     

       364
       364
       -
             ${linkPlatformPlugins { name = "add-ons"; plugins = google-apis; check = useGoogleTVAddOns; }}

     

       387
       387
       +
             ${linkPlatformPlugins { name = "add-ons"; plugins = google-tv-addons; check = useGoogleTVAddOns; }}

     

       365
       388
        
       

     

       366
       389
        
             # Link extras

     

       367
       390
        
             ${lib.concatMapStrings (identifier:

     
···

       369
       392
        
                 package = addons.extras.${identifier};

     

       370
       393
        
                 path = package.path;

     

       371
       394
        
                 extras = callPackage ./extras.nix {

     

       372
       372
       -
                   inherit deployAndroidPackage package os meta;

     

       395
       395
       +
                   inherit deployAndroidPackage package os arch meta;

     

       373
       396
        
                 };

     

       374
       397
        
               in

     

       375
       398
        
               ''

     
···

       385
       408
        
                 ln -s $i $out/bin

     

       386
       409
        
             done

     

       387
       410
        
       

     

       388
       388
       -
             ${lib.optionalString includeEmulator ''

     

       411
       411
       +
             ${lib.optionalString (shouldLink includeEmulator [emulator]) ''

     

       389
       412
        
               for i in ${emulator}/bin/*; do

     

       390
       413
        
                   ln -s $i $out/bin

     

       391
       414
        
               done

+3 -9

pkgs/development/mobile/androidenv/default.nix

···

       29
       29
        
             "34"

     

       30
       30
        
             "35"

     

       31
       31
        
           ];

     

       32
       32
       -
           includeEmulator =

     

       33
       33
       -
             with pkgs.stdenv.hostPlatform;

     

       34
       34
       -
             system == "x86_64-linux" || system == "x86_64-darwin" || system == "aarch64-darwin";

     

       35
       35
       -
           includeSystemImages =

     

       36
       36
       -
             with pkgs.stdenv.hostPlatform;

     

       37
       37
       -
             system == "x86_64-linux" || system == "x86_64-darwin" || system == "aarch64-darwin";

     

       38
       38
       -
           includeNDK =

     

       39
       39
       -
             with pkgs.stdenv.hostPlatform;

     

       40
       40
       -
             system == "x86_64-linux" || system == "x86_64-darwin" || system == "aarch64-darwin";

     

       32
       32
       +
           includeEmulator = "if-supported";

     

       33
       33
       +
           includeSystemImages = "if-supported";

     

       34
       34
       +
           includeNDK = "if-supported";

     

       41
       35
        
         };

     

       42
       36
        
       

     

       43
       37
        
         test-suite = pkgs.callPackage ./test-suite.nix {

+16 -4

pkgs/development/mobile/androidenv/deploy-androidpackages.nix

···

       1
       1
       -
       {stdenv, lib, unzip, mkLicenses, meta}:

     

       1
       1
       +
       {stdenv, lib, unzip, mkLicenses, os, arch, meta}:

     

       2
       2
        
       {packages, nativeBuildInputs ? [], buildInputs ? [], patchesInstructions ? {}, ...}@args:

     

       3
       3
        
       

     

       4
       4
        
       let

     
···

       62
       62
        
         inherit buildInputs;

     

       63
       63
        
         pname = "android-sdk-${lib.concatMapStringsSep "-" (package: package.name) sortedPackages}";

     

       64
       64
        
         version = lib.concatMapStringsSep "-" (package: package.revision) sortedPackages;

     

       65
       65
       -
         src = map (package: package.archives) packages;

     

       65
       65
       +
         src = lib.flatten (map (package: package.archives) packages);

     

       66
       66
       +
         inherit os arch;

     

       66
       67
        
         nativeBuildInputs = [ unzip ] ++ nativeBuildInputs;

     

       67
       68
        
         preferLocalBuild = true;

     

       68
       69
        
       

     

       69
       70
        
         unpackPhase = ''

     

       71
       71
       +
           runHook preUnpack

     

       72
       72
       +
           if [ -z "$src" ]; then

     

       73
       73
       +
             echo "$pname did not have any sources available for os=$os, arch=$arch." >&2

     

       74
       74
       +
             echo "Are packages available for this architecture?" >&2

     

       75
       75
       +
             exit 1

     

       76
       76
       +
           fi

     

       70
       77
        
           buildDir=$PWD

     

       71
       78
        
           i=0

     

       72
       79
        
           for srcArchive in $src; do

     
···

       77
       84
        
             cd "$extractedZip"

     

       78
       85
        
             unpackFile "$srcArchive"

     

       79
       86
        
           done

     

       87
       87
       +
           runHook postUnpack

     

       80
       88
        
         '';

     

       81
       89
        
       

     

       82
       82
       -
         installPhase = lib.concatStrings (lib.imap0 (i: package: ''

     

       90
       90
       +
         installPhase = ''

     

       91
       91
       +
           runHook preInstall

     

       92
       92
       +
         '' + lib.concatStrings (lib.imap0 (i: package: ''

     

       83
       93
        
           cd $buildDir/extractedzip-${toString i}

     

       84
       94
        
       

     

       85
       95
        
           # Most Android Zip packages have a root folder, but some don't. We unpack

     
···

       101
       111
        
           ${mkXmlPackage package}

     

       102
       112
        
           EOF

     

       103
       113
        
           fi

     

       104
       104
       -
         '') packages);

     

       114
       114
       +
         '') packages) + ''

     

       115
       115
       +
           runHook postInstall

     

       116
       116
       +
         '';

     

       105
       117
        
       

     

       106
       118
        
         # Some executables that have been patched with patchelf may not work any longer after they have been stripped.

     

       107
       119
        
         dontStrip = true;

+2 -2

pkgs/development/mobile/androidenv/emulator.nix

···

       1
       1
       -
       { deployAndroidPackage, lib, stdenv, package, os, autoPatchelfHook, makeWrapper, pkgs, pkgsi686Linux, postInstall, meta }:

     

       1
       1
       +
       { deployAndroidPackage, lib, stdenv, package, os, arch, autoPatchelfHook, makeWrapper, pkgs, pkgsi686Linux, postInstall, meta }:

     

       2
       2
        
       

     

       3
       3
        
       deployAndroidPackage {

     

       4
       4
       -
         inherit package;

     

       4
       4
       +
         inherit package os arch;

     

       5
       5
        
         nativeBuildInputs = [ makeWrapper ]

     

       6
       6
        
           ++ lib.optionals (os == "linux") [ autoPatchelfHook ];

     

       7
       7
        
         buildInputs = lib.optionals (os == "linux") (with pkgs; [

+9 -5

pkgs/development/mobile/androidenv/examples/shell-with-emulator.nix

···

       46
       46
        
           inherit config pkgs licenseAccepted;

     

       47
       47
        
         };

     

       48
       48
        
       

     

       49
       49
       +
         emulatorSupported = pkgs.stdenv.hostPlatform.isx86_64 || pkgs.stdenv.hostPlatform.isDarwin;

     

       50
       50
       +
       

     

       49
       51
        
         sdkArgs = {

     

       50
       52
        
           includeSystemImages = true;

     

       51
       51
       -
           includeEmulator = true;

     

       53
       53
       +
           includeEmulator = "if-supported";

     

       52
       54
        
       

     

       53
       55
        
           # Accepting more licenses declaratively:

     

       54
       56
        
           extraLicenses = [

     
···

       122
       124
        
       

     

       123
       125
        
                 packages=(

     

       124
       126
        
                   "build-tools" "cmdline-tools" \

     

       125
       125
       -
                   "emulator" "platform-tools" "platforms;android-35" \

     

       127
       127
       +
                   "platform-tools" "platforms;android-35" \

     

       126
       128
        
                   "system-images;android-35;google_apis;x86_64"

     

       127
       129
        
                 )

     

       130
       130
       +
                 ${pkgs.lib.optionalString emulatorSupported ''packages+=("emulator")''}

     

       128
       131
        
       

     

       129
       132
        
                 for package in "''${packages[@]}"; do

     

       130
       133
        
                   if [[ ! $installed_packages_section =~ "$package" ]]; then

     
···

       183
       186
        
                   jdk

     

       184
       187
        
                 ];

     

       185
       188
        
               }

     

       186
       186
       -
               ''

     

       189
       189
       +
               (pkgs.lib.optionalString emulatorSupported ''

     

       187
       190
        
                 export ANDROID_USER_HOME=$PWD/.android

     

       188
       191
        
                 mkdir -p $ANDROID_USER_HOME

     

       189
       192
        
       

     
···

       197
       200
        
                 fi

     

       198
       201
        
       

     

       199
       202
        
                 avdmanager delete avd -n testAVD || true

     

       200
       200
       -
                 touch "$out"

     

       201
       201
       -
               '';

     

       203
       203
       +
               '' + ''

     

       204
       204
       +
                 touch $out

     

       205
       205
       +
               '');

     

       202
       206
        
         };

     

       203
       207
        
       }

+7 -3

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

···

       41
       41
        
           inherit config pkgs licenseAccepted;

     

       42
       42
        
         };

     

       43
       43
        
       

     

       44
       44
       +
         # The head unit only works on these platforms

     

       45
       45
       +
         includeAuto = pkgs.stdenv.hostPlatform.isx86_64 || pkgs.stdenv.hostPlatform.isDarwin;

     

       46
       46
       +
       

     

       44
       47
        
         androidComposition = androidEnv.composeAndroidPackages {

     

       45
       48
        
           includeSources = true;

     

       46
       49
        
           includeSystemImages = true;

     

       47
       47
       -
           includeEmulator = true;

     

       48
       48
       -
           includeNDK = true;

     

       50
       50
       +
           includeEmulator = "if-supported";

     

       51
       51
       +
           includeNDK = "if-supported";

     

       49
       52
        
           useGoogleAPIs = true;

     

       50
       53
        
       

     

       51
       54
        
           platformVersions = [ "23" "24" "25" "26" "27" "28" "29" "30" "31" "32" "33" "34" "35" ];

     
···

       69
       72
        
       

     

       70
       73
        
           includeExtras = [

     

       71
       74
        
             "extras;google;gcm"

     

       75
       75
       +
           ] ++ pkgs.lib.optionals includeAuto [

     

       72
       76
        
             "extras;google;auto"

     

       73
       77
        
           ];

     

       74
       78
        
       

     
···

       159
       163
        
               "system-images;android-34;google_apis;x86_64" \

     

       160
       164
        
               "system-images;android-35;google_apis;x86_64" \

     

       161
       165
        
               "extras;google;gcm"

     

       162
       162
       -
               "extras;google;auto"

     

       163
       166
        
             )

     

       167
       167
       +
             ${pkgs.lib.optionalString includeAuto ''packages+=("extras;google;auto")''}

     

       164
       168
        
       

     

       165
       169
        
             for package in "''${packages[@]}"; do

     

       166
       170
        
               if [[ ! $installed_packages_section =~ "$package" ]]; then

+2 -1

pkgs/development/mobile/androidenv/extras.nix

···

       3
       3
        
         lib,

     

       4
       4
        
         package,

     

       5
       5
        
         os,

     

       6
       6
       +
         arch,

     

       6
       7
        
         autoPatchelfHook,

     

       7
       8
        
         makeWrapper,

     

       8
       9
        
         pkgs,

     
···

       10
       11
        
       }:

     

       11
       12
        
       

     

       12
       13
        
       deployAndroidPackage {

     

       13
       13
       -
         inherit package os;

     

       14
       14
       +
         inherit package os arch;

     

       14
       15
        
         nativeBuildInputs = [ makeWrapper ] ++ lib.optionals (os == "linux") [ autoPatchelfHook ];

     

       15
       16
        
         buildInputs = lib.optionals (os == "linux") (

     

       16
       17
        
           with pkgs;

+2 -2

pkgs/development/mobile/androidenv/ndk-bundle/default.nix

···

       1
       1
        
       { stdenv, lib, pkgs, pkgsHostHost, makeWrapper, autoPatchelfHook

     

       2
       2
       -
       , deployAndroidPackage, package, os, platform-tools, meta

     

       2
       2
       +
       , deployAndroidPackage, package, os, arch, platform-tools, meta

     

       3
       3
        
       }:

     

       4
       4
        
       

     

       5
       5
        
       let

     
···

       8
       8
        
         ]) + ":${platform-tools}/platform-tools";

     

       9
       9
        
       in

     

       10
       10
        
       deployAndroidPackage rec {

     

       11
       11
       -
         inherit package;

     

       11
       11
       +
         inherit package os arch;

     

       12
       12
        
         nativeBuildInputs = [ makeWrapper ]

     

       13
       13
        
           ++ lib.optionals stdenv.hostPlatform.isLinux [ autoPatchelfHook ];

     

       14
       14
        
         autoPatchelfIgnoreMissingDeps = [ "*" ];

+2 -1

pkgs/development/mobile/androidenv/patcher.nix

···

       3
       3
        
         lib,

     

       4
       4
        
         package,

     

       5
       5
        
         os,

     

       6
       6
       +
         arch,

     

       6
       7
        
         autoPatchelfHook,

     

       7
       8
        
         stdenv,

     

       8
       9
        
       }:

     

       9
       10
        
       

     

       10
       11
        
       deployAndroidPackage {

     

       11
       11
       -
         inherit package os;

     

       12
       12
       +
         inherit package os arch;

     

       12
       13
        
         nativeBuildInputs = lib.optionals stdenv.hostPlatform.isLinux [ autoPatchelfHook ];

     

       13
       14
        
         patchInstructions = lib.optionalString (os == "linux") ''

     

       14
       15
        
           autoPatchelf $packageBaseDir/bin

+2 -2

pkgs/development/mobile/androidenv/platform-tools.nix

···

       1
       1
       -
       {deployAndroidPackage, lib, package, os, autoPatchelfHook, pkgs, meta}:

     

       1
       1
       +
       {deployAndroidPackage, lib, package, os, arch, autoPatchelfHook, pkgs, meta}:

     

       2
       2
        
       

     

       3
       3
        
       deployAndroidPackage {

     

       4
       4
       -
         inherit package;

     

       4
       4
       +
         inherit package os arch;

     

       5
       5
        
         nativeBuildInputs = lib.optionals (os == "linux") [ autoPatchelfHook ];

     

       6
       6
        
         buildInputs = lib.optionals (os == "linux") [ pkgs.glibc (lib.getLib pkgs.stdenv.cc.cc) pkgs.zlib pkgs.ncurses5 ];

     

       7
       7

+2 -2

pkgs/development/mobile/androidenv/tools.nix

···

       1
       1
       -
       {deployAndroidPackage, lib, stdenv, package, autoPatchelfHook, makeWrapper, os, pkgs, pkgsi686Linux, postInstall, meta}:

     

       1
       1
       +
       {deployAndroidPackage, lib, stdenv, package, os, arch, autoPatchelfHook, makeWrapper, pkgs, pkgsi686Linux, postInstall, meta}:

     

       2
       2
        
       

     

       3
       3
        
       deployAndroidPackage {

     

       4
       4
        
         name = "androidsdk-tools";

     

       5
       5
       -
         inherit package;

     

       5
       5
       +
         inherit package os arch;

     

       6
       6
        
         nativeBuildInputs = [ makeWrapper ]

     

       7
       7
        
           ++ lib.optionals (os == "linux") [ autoPatchelfHook ];

     

       8
       8
        
         buildInputs = lib.optional (os == "linux") (