|
| 1 | +//! This module is for testing that we implemented certain build features and to at least make sure |
| 2 | +//! there is code coverage for new APIs added. |
| 3 | +//! |
| 4 | +//! TODO(Jae): 2026-04-12 |
| 5 | +//! Ideally adding functions to also validate the output APK file would be nice too. |
| 6 | + |
| 7 | +const std = @import("std"); |
| 8 | +const builtin = @import("builtin"); |
| 9 | + |
| 10 | +const android = @import("android"); |
| 11 | + |
| 12 | +pub fn build(b: *std.Build) void { |
| 13 | + const exe_name: []const u8 = "build_test"; |
| 14 | + const root_target = b.standardTargetOptions(.{}); |
| 15 | + const optimize = b.standardOptimizeOption(.{}); |
| 16 | + const android_targets = android.standardTargets(b, root_target); |
| 17 | + |
| 18 | + // NOTE(jae): 2026-04-12 |
| 19 | + // Run it *after* the "standardTargets" call |
| 20 | + testLazyImportAndResolveTargets(b, root_target); |
| 21 | + |
| 22 | + var root_target_single = [_]std.Build.ResolvedTarget{root_target}; |
| 23 | + const targets: []std.Build.ResolvedTarget = if (android_targets.len == 0) |
| 24 | + root_target_single[0..] |
| 25 | + else |
| 26 | + android_targets; |
| 27 | + |
| 28 | + const android_apk: ?*android.Apk = blk: { |
| 29 | + if (android_targets.len == 0) break :blk null; |
| 30 | + |
| 31 | + const android_sdk = android.Sdk.create(b, .{}); |
| 32 | + const apk = android_sdk.createApk(.{ |
| 33 | + .name = exe_name, |
| 34 | + .api_level = .android15, |
| 35 | + .build_tools_version = "35.0.1", |
| 36 | + .ndk_version = "29.0.13113456", |
| 37 | + }); |
| 38 | + const key_store_file = android_sdk.createKeyStore(.example); |
| 39 | + apk.setKeyStore(key_store_file); |
| 40 | + apk.setAndroidManifest(b.path("android/AndroidManifest.xml")); |
| 41 | + apk.addResourceDirectory(b.path("android/res")); |
| 42 | + |
| 43 | + testAddLibraryFile(b, apk); |
| 44 | + |
| 45 | + break :blk apk; |
| 46 | + }; |
| 47 | + |
| 48 | + for (targets) |target| { |
| 49 | + const app_module = b.createModule(.{ |
| 50 | + .target = target, |
| 51 | + .optimize = optimize, |
| 52 | + .root_source_file = b.path("src/build_test_main.zig"), |
| 53 | + }); |
| 54 | + |
| 55 | + var exe: *std.Build.Step.Compile = if (target.result.abi.isAndroid()) b.addLibrary(.{ |
| 56 | + .name = "main", |
| 57 | + .root_module = app_module, |
| 58 | + .linkage = .dynamic, |
| 59 | + }) else b.addExecutable(.{ |
| 60 | + .name = exe_name, |
| 61 | + .root_module = app_module, |
| 62 | + }); |
| 63 | + |
| 64 | + // if building as library for Android, add this target |
| 65 | + // NOTE: Android has different CPU targets so you need to build a version of your |
| 66 | + // code for x86, x86_64, arm, arm64 and more |
| 67 | + if (target.result.abi.isAndroid()) { |
| 68 | + const apk: *android.Apk = android_apk orelse @panic("Android APK should be initialized"); |
| 69 | + const android_dep = b.dependency("android", .{ |
| 70 | + .optimize = optimize, |
| 71 | + .target = target, |
| 72 | + }); |
| 73 | + exe.root_module.addImport("android", android_dep.module("android")); |
| 74 | + |
| 75 | + apk.addArtifact(exe); |
| 76 | + } else { |
| 77 | + b.installArtifact(exe); |
| 78 | + |
| 79 | + // If only 1 target, add "run" step |
| 80 | + if (targets.len == 1) { |
| 81 | + const run_step = b.step("run", "Run the application"); |
| 82 | + const run_cmd = b.addRunArtifact(exe); |
| 83 | + run_step.dependOn(&run_cmd.step); |
| 84 | + } |
| 85 | + } |
| 86 | + } |
| 87 | + if (android_apk) |apk| { |
| 88 | + testInstallAndAddRunStep(b, apk); |
| 89 | + } |
| 90 | +} |
| 91 | + |
| 92 | +/// Test calling lazyImport and then calling "resolveTargets" |
| 93 | +/// |
| 94 | +/// PR: https://github.com/silbinarywolf/zig-android-sdk/pull/83 |
| 95 | +fn testLazyImportAndResolveTargets(b: *std.Build, root_target: std.Build.ResolvedTarget) void { |
| 96 | + const all_android_targets = true; |
| 97 | + const android_targets: []std.Build.ResolvedTarget = blk: { |
| 98 | + if (all_android_targets or root_target.result.abi.isAndroid()) { |
| 99 | + if (b.lazyImport(@This(), "lazy_android")) |lazy_android| { |
| 100 | + break :blk lazy_android.resolveTargets(b, .{ |
| 101 | + .default_target = root_target, |
| 102 | + .all_targets = true, |
| 103 | + }); |
| 104 | + } |
| 105 | + } |
| 106 | + break :blk &[0]std.Build.ResolvedTarget{}; |
| 107 | + }; |
| 108 | + if (android_targets.len != 4) @panic("expected 'resolveTargets' it to return 4 Android targets"); |
| 109 | +} |
| 110 | + |
| 111 | +/// Test the addLibraryFile functionality |
| 112 | +/// |
| 113 | +/// Requested feature here: https://github.com/silbinarywolf/zig-android-sdk/issues/77 |
| 114 | +fn testAddLibraryFile(b: *std.Build, apk: *android.Apk) void { |
| 115 | + const vulkan_validation_dep = b.lazyDependency("vulkan_validation", .{}) orelse return; |
| 116 | + apk.addLibraryFile(.arm64_v8a, vulkan_validation_dep.path("arm64-v8a/libVkLayer_khronos_validation.so")); |
| 117 | + apk.addLibraryFile(.armeabi_v7a, vulkan_validation_dep.path("armeabi-v7a/libVkLayer_khronos_validation.so")); |
| 118 | + apk.addLibraryFile(.x86, vulkan_validation_dep.path("x86/libVkLayer_khronos_validation.so")); |
| 119 | + apk.addLibraryFile(.x86_64, vulkan_validation_dep.path("x86_64/libVkLayer_khronos_validation.so")); |
| 120 | +} |
| 121 | + |
| 122 | +fn testInstallAndAddRunStep(b: *std.Build, apk: *android.Apk) void { |
| 123 | + const installed_apk = apk.addInstallApk(); |
| 124 | + b.getInstallStep().dependOn(&installed_apk.step); |
| 125 | + |
| 126 | + const android_sdk = apk.sdk; |
| 127 | + const run_step = b.step("run", "Install and run the application on an Android device"); |
| 128 | + const adb_install = android_sdk.addAdbInstall(installed_apk.source); |
| 129 | + const adb_start = android_sdk.addAdbStart("com.zig.build_test/android.app.NativeActivity"); |
| 130 | + adb_start.step.dependOn(&adb_install.step); |
| 131 | + run_step.dependOn(&adb_start.step); |
| 132 | +} |
0 commit comments