commit 310cc429402200d0f240f3f7c262f17c88f19d41 · pyrox.dev/nixpkgs

-1

nixos/modules/module-list.nix

···

       1750
       1750
        
         ./tasks/trackpoint.nix

     

       1751
       1751
        
         ./testing/service-runner.nix

     

       1752
       1752
        
         ./virtualisation/amazon-options.nix

     

       1753
       1753
       -
         ./virtualisation/anbox.nix

     

       1754
       1753
        
         ./virtualisation/appvm.nix

     

       1755
       1754
        
         ./virtualisation/build-vm.nix

     

       1756
       1755
        
         ./virtualisation/container-config.nix

nixos/modules/rename.nix

···

       80
       80
        
           )

     

       81
       81
        
           (mkRemovedOptionModule [

     

       82
       82
        
             "services"

     

       83
       83
       +
             "anbox"

     

       84
       84
       +
           ] "The corresponding package was removed from nixpkgs as it is not maintained upstream anymore.")

     

       85
       85
       +
           (mkRemovedOptionModule [

     

       86
       86
       +
             "services"

     

       83
       87
        
             "ankisyncd"

     

       84
       88
        
           ] "`services.ankisyncd` has been replaced by `services.anki-sync-server`.")

     

       85
       89
        
           (mkRemovedOptionModule [

-194

nixos/modules/virtualisation/anbox.nix

···

       1
       1
       -
       {

     

       2
       2
       -
         config,

     

       3
       3
       -
         lib,

     

       4
       4
       -
         pkgs,

     

       5
       5
       -
         ...

     

       6
       6
       -
       }:

     

       7
       7
       -
       

     

       8
       8
       -
       with lib;

     

       9
       9
       -
       

     

       10
       10
       -
       let

     

       11
       11
       -
       

     

       12
       12
       -
         cfg = config.virtualisation.anbox;

     

       13
       13
       -
       

     

       14
       14
       -
         addrOpts = v: addr: pref: name: {

     

       15
       15
       -
           address = mkOption {

     

       16
       16
       -
             default = addr;

     

       17
       17
       -
             type = types.str;

     

       18
       18
       -
             description = ''

     

       19
       19
       -
               IPv${toString v} ${name} address.

     

       20
       20
       -
             '';

     

       21
       21
       -
           };

     

       22
       22
       -
       

     

       23
       23
       -
           prefixLength = mkOption {

     

       24
       24
       -
             default = pref;

     

       25
       25
       -
             type = types.addCheck types.int (n: n >= 0 && n <= (if v == 4 then 32 else 128));

     

       26
       26
       -
             description = ''

     

       27
       27
       -
               Subnet mask of the ${name} address, specified as the number of

     

       28
       28
       -
               bits in the prefix (`${if v == 4 then "24" else "64"}`).

     

       29
       29
       -
             '';

     

       30
       30
       -
           };

     

       31
       31
       -
         };

     

       32
       32
       -
       

     

       33
       33
       -
         finalImage =

     

       34
       34
       -
           if cfg.imageModifications == "" then

     

       35
       35
       -
             cfg.image

     

       36
       36
       -
           else

     

       37
       37
       -
             (pkgs.callPackage (

     

       38
       38
       -
               { runCommandNoCC, squashfsTools }:

     

       39
       39
       -
       

     

       40
       40
       -
               runCommandNoCC "${cfg.image.name}-modified.img"

     

       41
       41
       -
                 {

     

       42
       42
       -
                   nativeBuildInputs = [

     

       43
       43
       -
                     squashfsTools

     

       44
       44
       -
                   ];

     

       45
       45
       -
                 }

     

       46
       46
       -
                 ''

     

       47
       47
       -
                   echo "-> Extracting Anbox root image..."

     

       48
       48
       -
                   unsquashfs -dest rootfs ${cfg.image}

     

       49
       49
       -
       

     

       50
       50
       -
                   echo "-> Modifying Anbox root image..."

     

       51
       51
       -
                   (

     

       52
       52
       -
                   cd rootfs

     

       53
       53
       -
                   ${cfg.imageModifications}

     

       54
       54
       -
                   )

     

       55
       55
       -
       

     

       56
       56
       -
                   echo "-> Packing modified Anbox root image..."

     

       57
       57
       -
                   mksquashfs rootfs $out -comp xz -no-xattrs -all-root

     

       58
       58
       -
                 ''

     

       59
       59
       -
             ) { });

     

       60
       60
       -
       

     

       61
       61
       -
       in

     

       62
       62
       -
       

     

       63
       63
       -
       {

     

       64
       64
       -
       

     

       65
       65
       -
         options.virtualisation.anbox = {

     

       66
       66
       -
       

     

       67
       67
       -
           enable = mkEnableOption "Anbox";

     

       68
       68
       -
       

     

       69
       69
       -
           image = mkOption {

     

       70
       70
       -
             default = pkgs.anbox.image;

     

       71
       71
       -
             defaultText = literalExpression "pkgs.anbox.image";

     

       72
       72
       -
             type = types.package;

     

       73
       73
       -
             description = ''

     

       74
       74
       -
               Base android image for Anbox.

     

       75
       75
       -
             '';

     

       76
       76
       -
           };

     

       77
       77
       -
       

     

       78
       78
       -
           imageModifications = mkOption {

     

       79
       79
       -
             default = "";

     

       80
       80
       -
             type = types.lines;

     

       81
       81
       -
             description = ''

     

       82
       82
       -
               Commands to edit the image filesystem.

     

       83
       83
       -
       

     

       84
       84
       -
               This can be used to e.g. bundle a privileged F-Droid.

     

       85
       85
       -
       

     

       86
       86
       -
               Commands are ran with PWD being at the root of the filesystem.

     

       87
       87
       -
             '';

     

       88
       88
       -
           };

     

       89
       89
       -
       

     

       90
       90
       -
           extraInit = mkOption {

     

       91
       91
       -
             type = types.lines;

     

       92
       92
       -
             default = "";

     

       93
       93
       -
             description = ''

     

       94
       94
       -
               Extra shell commands to be run inside the container image during init.

     

       95
       95
       -
             '';

     

       96
       96
       -
           };

     

       97
       97
       -
       

     

       98
       98
       -
           ipv4 = {

     

       99
       99
       -
             container = addrOpts 4 "192.168.250.2" 24 "Container";

     

       100
       100
       -
             gateway = addrOpts 4 "192.168.250.1" 24 "Host";

     

       101
       101
       -
       

     

       102
       102
       -
             dns = mkOption {

     

       103
       103
       -
               default = "1.1.1.1";

     

       104
       104
       -
               type = types.str;

     

       105
       105
       -
               description = ''

     

       106
       106
       -
                 Container DNS server.

     

       107
       107
       -
               '';

     

       108
       108
       -
             };

     

       109
       109
       -
           };

     

       110
       110
       -
         };

     

       111
       111
       -
       

     

       112
       112
       -
         config = mkIf cfg.enable {

     

       113
       113
       -
       

     

       114
       114
       -
           assertions = singleton {

     

       115
       115
       -
             assertion = with config.boot.kernelPackages; kernelAtLeast "5.5" && kernelOlder "5.18";

     

       116
       116
       -
             message = "Anbox needs a kernel with binder and ashmem support";

     

       117
       117
       -
           };

     

       118
       118
       -
       

     

       119
       119
       -
           environment.systemPackages = with pkgs; [ anbox ];

     

       120
       120
       -
       

     

       121
       121
       -
           systemd.mounts = singleton {

     

       122
       122
       -
             requiredBy = [ "anbox-container-manager.service" ];

     

       123
       123
       -
             description = "Anbox Binder File System";

     

       124
       124
       -
             what = "binder";

     

       125
       125
       -
             where = "/dev/binderfs";

     

       126
       126
       -
             type = "binder";

     

       127
       127
       -
           };

     

       128
       128
       -
       

     

       129
       129
       -
           virtualisation.lxc.enable = true;

     

       130
       130
       -
           networking.bridges.anbox0.interfaces = [ ];

     

       131
       131
       -
           networking.interfaces.anbox0.ipv4.addresses = [ cfg.ipv4.gateway ];

     

       132
       132
       -
       

     

       133
       133
       -
           networking.nat = {

     

       134
       134
       -
             enable = true;

     

       135
       135
       -
             internalInterfaces = [ "anbox0" ];

     

       136
       136
       -
           };

     

       137
       137
       -
       

     

       138
       138
       -
           # Ensures NetworkManager doesn't touch anbox0

     

       139
       139
       -
           networking.networkmanager.unmanaged = [ "anbox0" ];

     

       140
       140
       -
       

     

       141
       141
       -
           systemd.services.anbox-container-manager =

     

       142
       142
       -
             let

     

       143
       143
       -
               anboxloc = "/var/lib/anbox";

     

       144
       144
       -
             in

     

       145
       145
       -
             {

     

       146
       146
       -
               description = "Anbox Container Management Daemon";

     

       147
       147
       -
       

     

       148
       148
       -
               environment.XDG_RUNTIME_DIR = "${anboxloc}";

     

       149
       149
       -
       

     

       150
       150
       -
               wantedBy = [ "multi-user.target" ];

     

       151
       151
       -
               preStart =

     

       152
       152
       -
                 let

     

       153
       153
       -
                   initsh = pkgs.writeText "nixos-init" (

     

       154
       154
       -
                     ''

     

       155
       155
       -
                       #!/system/bin/sh

     

       156
       156
       -
                       setprop nixos.version ${config.system.nixos.version}

     

       157
       157
       -
       

     

       158
       158
       -
                       # we don't have radio

     

       159
       159
       -
                       setprop ro.radio.noril yes

     

       160
       160
       -
                       stop ril-daemon

     

       161
       161
       -
       

     

       162
       162
       -
                       # speed up boot

     

       163
       163
       -
                       setprop debug.sf.nobootanimation 1

     

       164
       164
       -
                     ''

     

       165
       165
       -
                     + cfg.extraInit

     

       166
       166
       -
                   );

     

       167
       167
       -
                   initshloc = "${anboxloc}/rootfs-overlay/system/etc/init.goldfish.sh";

     

       168
       168
       -
                 in

     

       169
       169
       -
                 ''

     

       170
       170
       -
                   mkdir -p ${anboxloc}

     

       171
       171
       -
                   mkdir -p $(dirname ${initshloc})

     

       172
       172
       -
                   [ -f ${initshloc} ] && rm ${initshloc}

     

       173
       173
       -
                   cp ${initsh} ${initshloc}

     

       174
       174
       -
                   chown 100000:100000 ${initshloc}

     

       175
       175
       -
                   chmod +x ${initshloc}

     

       176
       176
       -
                 '';

     

       177
       177
       -
       

     

       178
       178
       -
               serviceConfig = {

     

       179
       179
       -
                 ExecStart = ''

     

       180
       180
       -
                   ${pkgs.anbox}/bin/anbox container-manager \

     

       181
       181
       -
                     --data-path=${anboxloc} \

     

       182
       182
       -
                     --android-image=${finalImage} \

     

       183
       183
       -
                     --container-network-address=${cfg.ipv4.container.address} \

     

       184
       184
       -
                     --container-network-gateway=${cfg.ipv4.gateway.address} \

     

       185
       185
       -
                     --container-network-dns-servers=${cfg.ipv4.dns} \

     

       186
       186
       -
                     --use-rootfs-overlay \

     

       187
       187
       -
                     --privileged \

     

       188
       188
       -
                     --daemon

     

       189
       189
       -
                 '';

     

       190
       190
       -
               };

     

       191
       191
       -
             };

     

       192
       192
       -
         };

     

       193
       193
       -
       

     

       194
       194
       -
       }

-1

nixos/tests/all-tests.nix

···

       124
       124
        
         amazon-init-shell = handleTest ./amazon-init-shell.nix {};

     

       125
       125
        
         amazon-ssm-agent = handleTest ./amazon-ssm-agent.nix {};

     

       126
       126
        
         amd-sev = runTest ./amd-sev.nix;

     

       127
       127
       -
         anbox = runTest ./anbox.nix;

     

       128
       127
        
         angie-api = handleTest ./angie-api.nix {};

     

       129
       128
        
         anki-sync-server = handleTest ./anki-sync-server.nix {};

     

       130
       129
        
         anuko-time-tracker = handleTest ./anuko-time-tracker.nix {};

-41

nixos/tests/anbox.nix

···

       1
       1
       -
       { lib, pkgs, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       {

     

       4
       4
       -
         name = "anbox";

     

       5
       5
       -
         meta.maintainers = with lib.maintainers; [ mvnetbiz ];

     

       6
       6
       -
       

     

       7
       7
       -
         nodes.machine =

     

       8
       8
       -
           { pkgs, config, ... }:

     

       9
       9
       -
           {

     

       10
       10
       -
             imports = [

     

       11
       11
       -
               ./common/user-account.nix

     

       12
       12
       -
               ./common/x11.nix

     

       13
       13
       -
             ];

     

       14
       14
       -
       

     

       15
       15
       -
             environment.systemPackages = with pkgs; [ android-tools ];

     

       16
       16
       -
       

     

       17
       17
       -
             test-support.displayManager.auto.user = "alice";

     

       18
       18
       -
       

     

       19
       19
       -
             virtualisation.anbox.enable = true;

     

       20
       20
       -
             boot.kernelPackages = pkgs.linuxKernel.packages.linux_5_15;

     

       21
       21
       -
             virtualisation.memorySize = 2500;

     

       22
       22
       -
           };

     

       23
       23
       -
       

     

       24
       24
       -
         testScript =

     

       25
       25
       -
           { nodes, ... }:

     

       26
       26
       -
           let

     

       27
       27
       -
             user = nodes.machine.users.users.alice;

     

       28
       28
       -
             bus = "DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/${toString user.uid}/bus";

     

       29
       29
       -
           in

     

       30
       30
       -
           ''

     

       31
       31
       -
             machine.wait_for_x()

     

       32
       32
       -
       

     

       33
       33
       -
             machine.wait_until_succeeds(

     

       34
       34
       -
                 "sudo -iu alice ${bus} anbox wait-ready"

     

       35
       35
       -
             )

     

       36
       36
       -
       

     

       37
       37
       -
             machine.wait_until_succeeds("adb shell true")

     

       38
       38
       -
       

     

       39
       39
       -
             print(machine.succeed("adb devices"))

     

       40
       40
       -
           '';

     

       41
       41
       -
       }

-34

pkgs/os-specific/linux/anbox/0001-NixOS-Use-anbox-from-PATH-in-desktop-files.patch

···

       1
       1
       -
       From cb61e856c4357d9787f7a2313bacb1c3b2133d36 Mon Sep 17 00:00:00 2001

     

       2
       2
       -
       From: Samuel Dionne-Riel <samuel@dionne-riel.com>

     

       3
       3
       -
       Date: Fri, 4 Jun 2021 19:05:53 -0400

     

       4
       4
       -
       Subject: [PATCH] [NixOS] Use `anbox` from PATH in desktop files

     

       5
       5
       -
       

     

       6
       6
       -
       ---

     

       7
       7
       -
        src/anbox/application/launcher_storage.cpp | 6 ++----

     

       8
       8
       -
        1 file changed, 2 insertions(+), 4 deletions(-)

     

       9
       9
       -
       

     

       10
       10
       -
       diff --git a/src/anbox/application/launcher_storage.cpp b/src/anbox/application/launcher_storage.cpp

     

       11
       11
       -
       index d5053cf..a4be719 100644

     

       12
       12
       -
       --- a/src/anbox/application/launcher_storage.cpp

     

       13
       13
       -
       +++ b/src/anbox/application/launcher_storage.cpp

     

       14
       14
       -
       @@ -69,9 +69,7 @@ void LauncherStorage::add_or_update(const Database::Item &item) {

     

       15
       15
       -
          auto package_name = item.package;

     

       16
       16
       -
          std::replace(package_name.begin(), package_name.end(), '.', '-');

     

       17
       17
       -
        

     

       18
       18
       -
       -  auto exe_path = utils::process_get_exe_path(getpid());

     

       19
       19
       -
       -  if (utils::get_env_value("SNAP").length() > 0)

     

       20
       20
       -
       -    exe_path = snap_exe_path;

     

       21
       21
       -
       +  auto exe_path = "anbox";

     

       22
       22
       -
        

     

       23
       23
       -
          std::string exec = utils::string_format("%s launch ", exe_path);

     

       24
       24
       -
        

     

       25
       25
       -
       @@ -121,4 +119,4 @@ void LauncherStorage::remove(const Database::Item &item) {

     

       26
       26
       -
            fs::remove(item_icon_path);

     

       27
       27
       -
        }

     

       28
       28
       -
        

     

       29
       29
       -
       -}

     

       30
       30
       -
       \ No newline at end of file

     

       31
       31
       -
       +}

     

       32
       32
       -
       -- 

     

       33
       33
       -
       2.29.2

     

       34
       34
       -

-11

pkgs/os-specific/linux/anbox/0002-NixOS-Build-android-emugl-with-cpp-14.patch

···

       1
       1
       -
       --- a/external/android-emugl/CMakeLists.txt

     

       2
       2
       -
       +++ b/external/android-emugl/CMakeLists.txt

     

       3
       3
       -
       @@ -1,7 +1,7 @@

     

       4
       4
       -
        # Don't treat any warnings as error as we take the source directly from

     

       5
       5
       -
        # upstream and just compile it.

     

       6
       6
       -
        set(CMAKE_C_FLAGS "-Wall")

     

       7
       7
       -
       -set(CMAKE_CXX_FLAGS "-std=c++11 -Wall")

     

       8
       8
       -
       +set(CMAKE_CXX_FLAGS "-std=c++14 -Wall")

     

       9
       9
       -
        

     

       10
       10
       -
        # Ensure -fPIC

     

       11
       11
       -
        set(CMAKE_POSITION_INDEPENDENT_CODE ON)

-189

pkgs/os-specific/linux/anbox/default.nix

···

       1
       1
       -
       {

     

       2
       2
       -
         lib,

     

       3
       3
       -
         stdenv,

     

       4
       4
       -
         fetchFromGitHub,

     

       5
       5
       -
         callPackage,

     

       6
       6
       -
         fetchpatch,

     

       7
       7
       -
         cmake,

     

       8
       8
       -
         pkg-config,

     

       9
       9
       -
         dbus,

     

       10
       10
       -
         makeWrapper,

     

       11
       11
       -
         boost,

     

       12
       12
       -
         elfutils, # for libdw

     

       13
       13
       -
         git,

     

       14
       14
       -
         glib,

     

       15
       15
       -
         glm,

     

       16
       16
       -
         gtest,

     

       17
       17
       -
         libbfd,

     

       18
       18
       -
         libcap,

     

       19
       19
       -
         libdwarf,

     

       20
       20
       -
         libGL,

     

       21
       21
       -
         libglvnd,

     

       22
       22
       -
         lxc,

     

       23
       23
       -
         libgbm,

     

       24
       24
       -
         properties-cpp,

     

       25
       25
       -
         protobuf,

     

       26
       26
       -
         protobufc,

     

       27
       27
       -
         python3,

     

       28
       28
       -
         runtimeShell,

     

       29
       29
       -
         SDL2,

     

       30
       30
       -
         SDL2_image,

     

       31
       31
       -
         systemd,

     

       32
       32
       -
         writeText,

     

       33
       33
       -
         writeShellScript,

     

       34
       34
       -
         nixosTests,

     

       35
       35
       -
       }:

     

       36
       36
       -
       

     

       37
       37
       -
       let

     

       38
       38
       -
       

     

       39
       39
       -
         dbus-service = writeText "org.anbox.service" ''

     

       40
       40
       -
           [D-BUS Service]

     

       41
       41
       -
           Name=org.anbox

     

       42
       42
       -
           Exec=@out@/libexec/anbox-session-manager

     

       43
       43
       -
         '';

     

       44
       44
       -
       

     

       45
       45
       -
         anbox-application-manager = writeShellScript "anbox-application-manager" ''

     

       46
       46
       -
           exec @out@/bin/anbox launch --package=org.anbox.appmgr --component=org.anbox.appmgr.AppViewActivity

     

       47
       47
       -
         '';

     

       48
       48
       -
       

     

       49
       49
       -
       in

     

       50
       50
       -
       

     

       51
       51
       -
       stdenv.mkDerivation rec {

     

       52
       52
       -
         pname = "anbox";

     

       53
       53
       -
         version = "unstable-2023-02-03";

     

       54
       54
       -
       

     

       55
       55
       -
         src = fetchFromGitHub {

     

       56
       56
       -
           owner = pname;

     

       57
       57
       -
           repo = pname;

     

       58
       58
       -
           rev = "ddf4c57ebbe3a2e46099087570898ab5c1e1f279";

     

       59
       59
       -
           hash = "sha256-QXWhatewiUDQ93cH1UZsYgbjUxpgB1ajtGFYZnKmabc=";

     

       60
       60
       -
           fetchSubmodules = true;

     

       61
       61
       -
         };

     

       62
       62
       -
       

     

       63
       63
       -
         nativeBuildInputs = [

     

       64
       64
       -
           cmake

     

       65
       65
       -
           pkg-config

     

       66
       66
       -
           makeWrapper

     

       67
       67
       -
           protobufc

     

       68
       68
       -
         ];

     

       69
       69
       -
       

     

       70
       70
       -
         buildInputs = [

     

       71
       71
       -
           boost

     

       72
       72
       -
           dbus

     

       73
       73
       -
           elfutils # libdw

     

       74
       74
       -
           glib

     

       75
       75
       -
           glm

     

       76
       76
       -
           gtest

     

       77
       77
       -
           libbfd

     

       78
       78
       -
           libcap

     

       79
       79
       -
           libdwarf

     

       80
       80
       -
           libGL

     

       81
       81
       -
           lxc

     

       82
       82
       -
           libgbm

     

       83
       83
       -
           properties-cpp

     

       84
       84
       -
           protobuf

     

       85
       85
       -
           python3

     

       86
       86
       -
           SDL2

     

       87
       87
       -
           SDL2_image

     

       88
       88
       -
           systemd

     

       89
       89
       -
         ];

     

       90
       90
       -
       

     

       91
       91
       -
         env.CXXFLAGS = toString [ "-include cstdint" ];

     

       92
       92
       -
       

     

       93
       93
       -
         env.NIX_CFLAGS_COMPILE = lib.optionalString stdenv.cc.isGNU (toString [

     

       94
       94
       -
           "-Wno-error=redundant-move"

     

       95
       95
       -
           # Flag needed by GCC 12 but unrecognized by GCC 9 (aarch64-linux default now)

     

       96
       96
       -
           (lib.optionalString (lib.versionAtLeast stdenv.cc.version "12") "-Wno-error=mismatched-new-delete")

     

       97
       97
       -
         ]);

     

       98
       98
       -
       

     

       99
       99
       -
         prePatch = ''

     

       100
       100
       -
           patchShebangs scripts

     

       101
       101
       -
       

     

       102
       102
       -
           cat >cmake/FindGMock.cmake <<'EOF'

     

       103
       103
       -
             add_library(gtest INTERFACE)

     

       104
       104
       -
             target_include_directories(gtest INTERFACE ${gtest.dev}/include)

     

       105
       105
       -
             target_link_libraries(gtest INTERFACE ${gtest}/lib/libgtest.so ''${CMAKE_THREAD_LIBS_INIT})

     

       106
       106
       -
             add_dependencies(gtest GMock)

     

       107
       107
       -
       

     

       108
       108
       -
             add_library(gtest_main INTERFACE)

     

       109
       109
       -
             target_include_directories(gtest_main INTERFACE ${gtest.dev}/include)

     

       110
       110
       -
             target_link_libraries(gtest_main INTERFACE ${gtest}/lib/libgtest_main.so gtest)

     

       111
       111
       -
       

     

       112
       112
       -
             add_library(gmock INTERFACE)

     

       113
       113
       -
             target_include_directories(gmock INTERFACE ${gtest.dev}/include)

     

       114
       114
       -
             target_link_libraries(gmock INTERFACE ${gtest}/lib/libgmock.so gtest)

     

       115
       115
       -
       

     

       116
       116
       -
             add_library(gmock_main INTERFACE)

     

       117
       117
       -
             target_include_directories(gmock_main INTERFACE ${gtest.dev}/include)

     

       118
       118
       -
             target_link_libraries(gmock_main INTERFACE ${gtest}/lib/libgmock_main.so gmock gtest_main)

     

       119
       119
       -
       

     

       120
       120
       -
             set(GTEST_LIBRARIES gtest)

     

       121
       121
       -
             set(GTEST_MAIN_LIBRARIES gtest_main)

     

       122
       122
       -
             set(GMOCK_LIBRARIES gmock gmock_main)

     

       123
       123
       -
             set(GTEST_BOTH_LIBRARIES ''${GTEST_LIBRARIES} ''${GTEST_MAIN_LIBRARIES})

     

       124
       124
       -
           EOF

     

       125
       125
       -
         '';

     

       126
       126
       -
       

     

       127
       127
       -
         patches = [

     

       128
       128
       -
           # Fixes compatibility with lxc 4

     

       129
       129
       -
           (fetchpatch {

     

       130
       130
       -
             url = "https://git.alpinelinux.org/aports/plain/community/anbox/lxc4.patch?id=64243590a16aee8d4e72061886fc1b15256492c3";

     

       131
       131
       -
             sha256 = "1da5xyzyjza1g2q9nbxb4p3njj2sf3q71vkpvmmdphia5qnb0gk5";

     

       132
       132
       -
           })

     

       133
       133
       -
           # Wait 10× more time when starting

     

       134
       134
       -
           # Not *strictly* needed, but helps a lot on slower hardware

     

       135
       135
       -
           (fetchpatch {

     

       136
       136
       -
             url = "https://git.alpinelinux.org/aports/plain/community/anbox/give-more-time-to-start.patch?id=058b56d4b332ef3379551b343bf31e0f2004321a";

     

       137
       137
       -
             sha256 = "0iiz3c7fgfgl0dvx8sf5hv7a961xqnihwpz6j8r0ib9v8piwxh9a";

     

       138
       138
       -
           })

     

       139
       139
       -
           # Ensures generated desktop files work on store path change

     

       140
       140
       -
           ./0001-NixOS-Use-anbox-from-PATH-in-desktop-files.patch

     

       141
       141
       -
           # Allows android-emugl to build with gtest 1.13+

     

       142
       142
       -
           ./0002-NixOS-Build-android-emugl-with-cpp-14.patch

     

       143
       143
       -
           # Provide window icons

     

       144
       144
       -
           (fetchpatch {

     

       145
       145
       -
             url = "https://github.com/samueldr/anbox/commit/2387f4fcffc0e19e52e58fb6f8264fbe87aafe4d.patch";

     

       146
       146
       -
             sha256 = "12lmr0kxw1n68g3abh1ak5awmpczfh75c26f53jc8qpvdvv1ywha";

     

       147
       147
       -
           })

     

       148
       148
       -
         ];

     

       149
       149
       -
       

     

       150
       150
       -
         postInstall = ''

     

       151
       151
       -
           wrapProgram $out/bin/anbox \

     

       152
       152
       -
             --set SDL_VIDEO_X11_WMCLASS "anbox" \

     

       153
       153
       -
             --prefix LD_LIBRARY_PATH : ${

     

       154
       154
       -
               lib.makeLibraryPath [

     

       155
       155
       -
                 libGL

     

       156
       156
       -
                 libglvnd

     

       157
       157
       -
               ]

     

       158
       158
       -
             } \

     

       159
       159
       -
             --prefix PATH : ${git}/bin

     

       160
       160
       -
       

     

       161
       161
       -
           mkdir -p $out/share/dbus-1/services

     

       162
       162
       -
           substitute ${dbus-service} $out/share/dbus-1/services/org.anbox.service \

     

       163
       163
       -
             --subst-var out

     

       164
       164
       -
       

     

       165
       165
       -
           mkdir $out/libexec

     

       166
       166
       -
           makeWrapper $out/bin/anbox $out/libexec/anbox-session-manager \

     

       167
       167
       -
             --add-flags session-manager

     

       168
       168
       -
       

     

       169
       169
       -
           substitute ${anbox-application-manager} $out/bin/anbox-application-manager \

     

       170
       170
       -
             --subst-var out

     

       171
       171
       -
           chmod +x $out/bin/anbox-application-manager

     

       172
       172
       -
         '';

     

       173
       173
       -
       

     

       174
       174
       -
         passthru.tests = { inherit (nixosTests) anbox; };

     

       175
       175
       -
         passthru.image = callPackage ./postmarketos-image.nix { };

     

       176
       176
       -
       

     

       177
       177
       -
         meta = with lib; {

     

       178
       178
       -
           homepage = "https://anbox.io";

     

       179
       179
       -
           description = "Android in a box";

     

       180
       180
       -
           license = licenses.gpl2Only;

     

       181
       181
       -
           maintainers = with maintainers; [ edwtjo ];

     

       182
       182
       -
           platforms = [

     

       183
       183
       -
             "armv7l-linux"

     

       184
       184
       -
             "aarch64-linux"

     

       185
       185
       -
             "x86_64-linux"

     

       186
       186
       -
           ];

     

       187
       187
       -
         };

     

       188
       188
       -
       

     

       189
       189
       -
       }

-20

pkgs/os-specific/linux/anbox/postmarketos-image.nix

···

       1
       1
       -
       { stdenv, fetchurl }:

     

       2
       2
       -
       

     

       3
       3
       -
       let

     

       4
       4
       -
         imgroot = "https://web.archive.org/web/20211027150924/https://anbox.postmarketos.org";

     

       5
       5
       -
       in

     

       6
       6
       -
       {

     

       7
       7
       -
         armv7l-linux = fetchurl {

     

       8
       8
       -
           url = imgroot + "/android-7.1.2_r39.1-anbox_armv7a_neon-userdebug.img";

     

       9
       9
       -
           sha256 = "1bgzqw4yp52a2q40dr1jlay1nh73jl5mx6wqsxvpb09xghxsng0a";

     

       10
       10
       -
         };

     

       11
       11
       -
         aarch64-linux = fetchurl {

     

       12
       12
       -
           url = imgroot + "/android-7.1.2_r39-anbox_arm64-userdebug.img";

     

       13
       13
       -
           sha256 = "0dx8mhfcjbkak982zfh65bvy35slz5jk31yl4ara50ryrxsp32nx";

     

       14
       14
       -
         };

     

       15
       15
       -
         x86_64-linux = fetchurl {

     

       16
       16
       -
           url = imgroot + "/android-7.1.2_r39-anbox_x86_64-userdebug.img";

     

       17
       17
       -
           sha256 = "16vmiz5al2r19wjpd44nagvz7d901ljxdms8gjp2w4xz1d91vzpm";

     

       18
       18
       -
         };

     

       19
       19
       -
       }

     

       20
       20
       -
       .${stdenv.system} or (throw "Unsupported platform ${stdenv.system}")

pkgs/top-level/aliases.nix

···

       110
       110
        
         ankisyncd = throw "ankisyncd is dead, use anki-sync-server instead"; # Added 2024-08-10

     

       111
       111
        
         ao = libfive; # Added 2024-10-11

     

       112
       112
        
         apacheKafka_3_5 = throw "apacheKafka_2_8 through _3_5 have been removed from nixpkgs as outdated"; # Added 2024-06-13

     

       113
       113
       +
         anbox = throw "'anbox' has been removed as the upstream project is unmaintained, see https://github.com/anbox/.github/blob/main/profile/README.md"; # Added 2025-01-04

     

       113
       114
        
         antimicroX = throw "'antimicroX' has been renamed to/replaced by 'antimicrox'"; # Converted to throw 2024-10-17

     

       114
       115
        
         apacheAnt = ant; # Added 2024-11-28

     

       115
       116
        
         apple-sdk_10_12 = throw "apple-sdk_10_12 was removed as Nixpkgs no longer supports macOS 10.12; see the 25.05 release notes"; # Added 2024-10-27

-4

pkgs/top-level/all-packages.nix

···

       1906
       1906
        
           inherit (androidenv.androidPkgs) platform-tools;

     

       1907
       1907
        
         };

     

       1908
       1908
        
       

     

       1909
       1909
       -
         anbox = callPackage ../os-specific/linux/anbox {

     

       1910
       1910
       -
           protobuf = protobuf_21;

     

       1911
       1911
       -
         };

     

       1912
       1912
       -
       

     

       1913
       1909
        
         androidenv = callPackage ../development/mobile/androidenv { };

     

       1914
       1910
        
       

     

       1915
       1911
        
         androidndkPkgs = androidndkPkgs_26;