package core:sys/android

Source

AAdditionalInfoEvent :: struct {
	// *
	//      * Event type, such as ASENSOR_ADDITIONAL_INFO_BEGIN, ASENSOR_ADDITIONAL_INFO_END and others.
	//      * Refer to {@link ASENSOR_TYPE_ADDITIONAL_INFO} for the expected reporting behavior.
	type:   SensorAdditionalInfo,
	serial: i32,
	using _: struct #raw_union {
		data_int32: [14]i32,
		data_float: [14]f32,
	},
}

AAsset :: struct {}

AAssetDir :: struct {}

AAssetManager :: struct {}

ABitmapResult :: enum i32 {
	SUCCESS           = 0, 
	BAD_PARAMETER     = -1, 
	JNI_EXCEPTION     = -2, 
	ALLOCATION_FAILED = -3, 
}

AChoreographer :: struct {}

AChoreographerFrameCallbackData :: struct {}

AChoreographer_frameCallback :: proc "c" (frameTimeNanos: i64, data: rawptr)

AChoreographer_frameCallback64 :: proc "c" (frameTimeNanos: i64, data: rawptr)

AChoreographer_refreshRateCallback :: proc "c" (vsyncPeriodNanos: i64, data: rawptr)

AChoreographer_vsyncCallback :: proc "c" (callbackData: ^AChoreographerFrameCallbackData, data: rawptr)

AColor_xy :: struct {
	x: f32,
	y: f32,
}

AConfiguration :: struct {}

ADataSpace :: enum i32 {
	// *
	//      * Default-assumption data space, when not explicitly specified.
	//      *
	//      * It is safest to assume the buffer is an image with sRGB primaries and
	//      * encoding ranges, but the consumer and/or the producer of the data may
	//      * simply be using defaults. No automatic gamma transform should be
	//      * expected, except for a possible display gamma transform when drawn to a
	//      * screen.
	UNKNOWN                            = 0, 
	// *
	//      * Standard aspect
	//      *
	//      * Defines the chromaticity coordinates of the source primaries in terms of
	//      * the CIE 1931 definition of x and y specified in ISO 11664-1.
	STANDARD_MASK                      = 4128768, 
	// *
	//      * Chromacity coordinates are unknown or are determined by the application.
	//      * Implementations shall use the following suggested standards:
	//      *
	//      * All YCbCr formats: BT709 if size is 720p or larger (since most video
	//      *                    content is letterboxed this corresponds to width is
	//      *                    1280 or greater, or height is 720 or greater).
	//      *                    BT601_625 if size is smaller than 720p or is JPEG.
	//      * All RGB formats:   BT709.
	//      *
	//      * For all other formats standard is undefined, and implementations should use
	//      * an appropriate standard for the data represented.
	STANDARD_UNSPECIFIED               = 0, 
	// *
	//      * Primaries:       x       y
	//      *  green           0.300   0.600
	//      *  blue            0.150   0.060
	//      *  red             0.640   0.330
	//      *  white (D65)     0.3127  0.3290
	//      *
	//      * Use the unadjusted KR = 0.2126, KB = 0.0722 luminance interpretation
	//      * for RGB conversion.
	STANDARD_BT709                     = 65536, 
	// *
	//      * Primaries:       x       y
	//      *  green           0.290   0.600
	//      *  blue            0.150   0.060
	//      *  red             0.640   0.330
	//      *  white (D65)     0.3127  0.3290
	//      *
	//      *  KR = 0.299, KB = 0.114. This adjusts the luminance interpretation
	//      *  for RGB conversion from the one purely determined by the primaries
	//      *  to minimize the color shift into RGB space that uses BT.709
	//      *  primaries.
	STANDARD_BT601_625                 = 131072, 
	// *
	//      * Primaries:       x       y
	//      *  green           0.290   0.600
	//      *  blue            0.150   0.060
	//      *  red             0.640   0.330
	//      *  white (D65)     0.3127  0.3290
	//      *
	//      * Use the unadjusted KR = 0.222, KB = 0.071 luminance interpretation
	//      * for RGB conversion.
	STANDARD_BT601_625_UNADJUSTED      = 196608, 
	// *
	//      * Primaries:       x       y
	//      *  green           0.310   0.595
	//      *  blue            0.155   0.070
	//      *  red             0.630   0.340
	//      *  white (D65)     0.3127  0.3290
	//      *
	//      *  KR = 0.299, KB = 0.114. This adjusts the luminance interpretation
	//      *  for RGB conversion from the one purely determined by the primaries
	//      *  to minimize the color shift into RGB space that uses BT.709
	//      *  primaries.
	STANDARD_BT601_525                 = 262144, 
	// *
	//      * Primaries:       x       y
	//      *  green           0.310   0.595
	//      *  blue            0.155   0.070
	//      *  red             0.630   0.340
	//      *  white (D65)     0.3127  0.3290
	//      *
	//      * Use the unadjusted KR = 0.212, KB = 0.087 luminance interpretation
	//      * for RGB conversion (as in SMPTE 240M).
	STANDARD_BT601_525_UNADJUSTED      = 327680, 
	// *
	//      * Primaries:       x       y
	//      *  green           0.170   0.797
	//      *  blue            0.131   0.046
	//      *  red             0.708   0.292
	//      *  white (D65)     0.3127  0.3290
	//      *
	//      * Use the unadjusted KR = 0.2627, KB = 0.0593 luminance interpretation
	//      * for RGB conversion.
	STANDARD_BT2020                    = 393216, 
	// *
	//      * Primaries:       x       y
	//      *  green           0.170   0.797
	//      *  blue            0.131   0.046
	//      *  red             0.708   0.292
	//      *  white (D65)     0.3127  0.3290
	//      *
	//      * Use the unadjusted KR = 0.2627, KB = 0.0593 luminance interpretation
	//      * for RGB conversion using the linear domain.
	STANDARD_BT2020_CONSTANT_LUMINANCE = 458752, 
	// *
	//      * Primaries:       x      y
	//      *  green           0.21   0.71
	//      *  blue            0.14   0.08
	//      *  red             0.67   0.33
	//      *  white (C)       0.310  0.316
	//      *
	//      * Use the unadjusted KR = 0.30, KB = 0.11 luminance interpretation
	//      * for RGB conversion.
	STANDARD_BT470M                    = 524288, 
	// *
	//      * Primaries:       x       y
	//      *  green           0.243   0.692
	//      *  blue            0.145   0.049
	//      *  red             0.681   0.319
	//      *  white (C)       0.310   0.316
	//      *
	//      * Use the unadjusted KR = 0.254, KB = 0.068 luminance interpretation
	//      * for RGB conversion.
	STANDARD_FILM                      = 589824, 
	// *
	//      * SMPTE EG 432-1 and SMPTE RP 431-2. (DCI-P3)
	//      * Primaries:       x       y
	//      *  green           0.265   0.690
	//      *  blue            0.150   0.060
	//      *  red             0.680   0.320
	//      *  white (D65)     0.3127  0.3290
	STANDARD_DCI_P3                    = 655360, 
	// *
	//      * Adobe RGB
	//      * Primaries:       x       y
	//      *  green           0.210   0.710
	//      *  blue            0.150   0.060
	//      *  red             0.640   0.330
	//      *  white (D65)     0.3127  0.3290
	STANDARD_ADOBE_RGB                 = 720896, 
	// *
	//      * Transfer aspect
	//      *
	//      * Transfer characteristics are the opto-electronic transfer characteristic
	//      * at the source as a function of linear optical intensity (luminance).
	//      *
	//      * For digital signals, E corresponds to the recorded value. Normally, the
	//      * transfer function is applied in RGB space to each of the R, G and B
	//      * components independently. This may result in color shift that can be
	//      * minized by applying the transfer function in Lab space only for the L
	//      * component. Implementation may apply the transfer function in RGB space
	//      * for all pixel formats if desired.
	TRANSFER_MASK                      = 130023424, 
	// *
	//      * Transfer characteristics are unknown or are determined by the
	//      * application.
	//      *
	//      * Implementations should use the following transfer functions:
	//      *
	//      * For YCbCr formats: use TRANSFER_SMPTE_170M
	//      * For RGB formats: use TRANSFER_SRGB
	//      *
	//      * For all other formats transfer function is undefined, and implementations
	//      * should use an appropriate standard for the data represented.
	TRANSFER_UNSPECIFIED               = 0, 
	// *
	//      * Transfer characteristic curve:
	//      *  E = L
	//      *      L - luminance of image 0 <= L <= 1 for conventional colorimetry
	//      *      E - corresponding electrical signal
	TRANSFER_LINEAR                    = 4194304, 
	// *
	//      * Transfer characteristic curve:
	//      *
	//      * E = 1.055 * L^(1/2.4) - 0.055  for 0.0031308 <= L <= 1
	//      *   = 12.92 * L                  for 0 <= L < 0.0031308
	//      *     L - luminance of image 0 <= L <= 1 for conventional colorimetry
	//      *     E - corresponding electrical signal
	TRANSFER_SRGB                      = 8388608, 
	// *
	//      * BT.601 525, BT.601 625, BT.709, BT.2020
	//      *
	//      * Transfer characteristic curve:
	//      *  E = 1.099 * L ^ 0.45 - 0.099  for 0.018 <= L <= 1
	//      *    = 4.500 * L                 for 0 <= L < 0.018
	//      *      L - luminance of image 0 <= L <= 1 for conventional colorimetry
	//      *      E - corresponding electrical signal
	TRANSFER_SMPTE_170M                = 12582912, 
	// *
	//      * Assumed display gamma 2.2.
	//      *
	//      * Transfer characteristic curve:
	//      *  E = L ^ (1/2.2)
	//      *      L - luminance of image 0 <= L <= 1 for conventional colorimetry
	//      *      E - corresponding electrical signal
	TRANSFER_GAMMA2_2                  = 16777216, 
	// *
	//      *  display gamma 2.6.
	//      *
	//      * Transfer characteristic curve:
	//      *  E = L ^ (1/2.6)
	//      *      L - luminance of image 0 <= L <= 1 for conventional colorimetry
	//      *      E - corresponding electrical signal
	TRANSFER_GAMMA2_6                  = 20971520, 
	// *
	//      *  display gamma 2.8.
	//      *
	//      * Transfer characteristic curve:
	//      *  E = L ^ (1/2.8)
	//      *      L - luminance of image 0 <= L <= 1 for conventional colorimetry
	//      *      E - corresponding electrical signal
	TRANSFER_GAMMA2_8                  = 25165824, 
	// *
	//      * SMPTE ST 2084 (Dolby Perceptual Quantizer)
	//      *
	//      * Transfer characteristic curve:
	//      *  E = ((c1 + c2 * L^n) / (1 + c3 * L^n)) ^ m
	//      *  c1 = c3 - c2 + 1 = 3424 / 4096 = 0.8359375
	//      *  c2 = 32 * 2413 / 4096 = 18.8515625
	//      *  c3 = 32 * 2392 / 4096 = 18.6875
	//      *  m = 128 * 2523 / 4096 = 78.84375
	//      *  n = 0.25 * 2610 / 4096 = 0.1593017578125
	//      *      L - luminance of image 0 <= L <= 1 for HDR colorimetry.
	//      *          L = 1 corresponds to 10000 cd/m2
	//      *      E - corresponding electrical signal
	TRANSFER_ST2084                    = 29360128, 
	// *
	//      * ARIB STD-B67 Hybrid Log Gamma
	//      *
	//      * Transfer characteristic curve:
	//      *  E = r * L^0.5                 for 0 <= L <= 1
	//      *    = a * ln(L - b) + c         for 1 < L
	//      *  a = 0.17883277
	//      *  b = 0.28466892
	//      *  c = 0.55991073
	//      *  r = 0.5
	//      *      L - luminance of image 0 <= L for HDR colorimetry. L = 1 corresponds
	//      *          to reference white level of 100 cd/m2
	//      *      E - corresponding electrical signal
	TRANSFER_HLG                       = 33554432, 
	// *
	//      * Range aspect
	//      *
	//      * Defines the range of values corresponding to the unit range of 0-1.
	//      * This is defined for YCbCr only, but can be expanded to RGB space.
	RANGE_MASK                         = 939524096, 
	// *
	//      * Range is unknown or are determined by the application.  Implementations
	//      * shall use the following suggested ranges:
	//      *
	//      * All YCbCr formats: limited range.
	//      * All RGB or RGBA formats (including RAW and Bayer): full range.
	//      * All Y formats: full range
	//      *
	//      * For all other formats range is undefined, and implementations should use
	//      * an appropriate range for the data represented.
	RANGE_UNSPECIFIED                  = 0, 
	// *
	//      * Full range uses all values for Y, Cb and Cr from
	//      * 0 to 2^b-1, where b is the bit depth of the color format.
	RANGE_FULL                         = 134217728, 
	// *
	//      * Limited range uses values 16/256*2^b to 235/256*2^b for Y, and
	//      * 1/16*2^b to 15/16*2^b for Cb, Cr, R, G and B, where b is the bit depth of
	//      * the color format.
	//      *
	//      * E.g. For 8-bit-depth formats:
	//      * Luma (Y) samples should range from 16 to 235, inclusive
	//      * Chroma (Cb, Cr) samples should range from 16 to 240, inclusive
	//      *
	//      * For 10-bit-depth formats:
	//      * Luma (Y) samples should range from 64 to 940, inclusive
	//      * Chroma (Cb, Cr) samples should range from 64 to 960, inclusive
	RANGE_LIMITED                      = 268435456, 
	// *
	//      * Extended range is used for scRGB. Intended for use with
	//      * floating point pixel formats. [0.0 - 1.0] is the standard
	//      * sRGB space. Values outside the range 0.0 - 1.0 can encode
	//      * color outside the sRGB gamut.
	//      * Used to blend / merge multiple dataspaces on a single display.
	RANGE_EXTENDED                     = 402653184, 
	// *
	//      * scRGB linear encoding:
	//      *
	//      * The red, green, and blue components are stored in extended sRGB space,
	//      * but are linear, not gamma-encoded.
	//      * The RGB primaries and the white point are the same as BT.709.
	//      *
	//      * The values are floating point.
	//      * A pixel value of 1.0, 1.0, 1.0 corresponds to sRGB white (D65) at 80 nits.
	//      * Values beyond the range [0.0 - 1.0] would correspond to other colors
	//      * spaces and/or HDR content.
	SCRGB_LINEAR                       = 406913024, // STANDARD_BT709 | TRANSFER_LINEAR | RANGE_EXTENDED
	// *
	//      * sRGB gamma encoding:
	//      *
	//      * The red, green and blue components are stored in sRGB space, and
	//      * converted to linear space when read, using the SRGB transfer function
	//      * for each of the R, G and B components. When written, the inverse
	//      * transformation is performed.
	//      *
	//      * The alpha component, if present, is always stored in linear space and
	//      * is left unmodified when read or written.
	//      *
	//      * Use full range and BT.709 standard.
	SRGB                               = 142671872, // STANDARD_BT709 | TRANSFER_SRGB | RANGE_FULL
	// *
	//      * scRGB:
	//      *
	//      * The red, green, and blue components are stored in extended sRGB space,
	//      * and gamma-encoded using the SRGB transfer function.
	//      * The RGB primaries and the white point are the same as BT.709.
	//      *
	//      * The values are floating point.
	//      * A pixel value of 1.0, 1.0, 1.0 corresponds to sRGB white (D65) at 80 nits.
	//      * Values beyond the range [0.0 - 1.0] would correspond to other colors
	//      * spaces and/or HDR content.
	SCRGB                              = 411107328, // STANDARD_BT709 | TRANSFER_SRGB | RANGE_EXTENDED
	// *
	//      * Display P3
	//      *
	//      * Use same primaries and white-point as DCI-P3
	//      * but sRGB transfer function.
	DISPLAY_P3                         = 143261696, // STANDARD_DCI_P3 | TRANSFER_SRGB | RANGE_FULL
	// *
	//      * ITU-R Recommendation 2020 (BT.2020)
	//      *
	//      * Ultra High-definition television
	//      *
	//      * Use full range, SMPTE 2084 (PQ) transfer and BT2020 standard
	BT2020_PQ                          = 163971072, // STANDARD_BT2020 | TRANSFER_ST2084 | RANGE_FULL
	// *
	//      * ITU-R Recommendation 2020 (BT.2020)
	//      *
	//      * Ultra High-definition television
	//      *
	//      * Use limited range, SMPTE 2084 (PQ) transfer and BT2020 standard
	BT2020_ITU_PQ                      = 298188800, // STANDARD_BT2020 | TRANSFER_ST2084 | RANGE_LIMITED
	// *
	//      * Adobe RGB
	//      *
	//      * Use full range, gamma 2.2 transfer and Adobe RGB primaries
	//      * Note: Application is responsible for gamma encoding the data as
	//      * a 2.2 gamma encoding is not supported in HW.
	ADOBE_RGB                          = 151715840, // STANDARD_ADOBE_RGB | TRANSFER_GAMMA2_2 | RANGE_FULL
	// *
	//      * JPEG File Interchange Format (JFIF)
	//      *
	//      * Same model as BT.601-625, but all values (Y, Cb, Cr) range from 0 to 255
	//      *
	//      * Use full range, SMPTE 170M transfer and BT.601_625 standard.
	JFIF                               = 146931712, // STANDARD_BT601_625 | TRANSFER_SMPTE_170M | RANGE_FULL
	// *
	//      * ITU-R Recommendation 601 (BT.601) - 525-line
	//      *
	//      * Standard-definition television, 525 Lines (NTSC)
	//      *
	//      * Use limited range, SMPTE 170M transfer and BT.601_525 standard.
	BT601_625                          = 281149440, // STANDARD_BT601_625 | TRANSFER_SMPTE_170M | RANGE_LIMITED
	// *
	//      * ITU-R Recommendation 709 (BT.709)
	//      *
	//      * High-definition television
	//      *
	//      * Use limited range, SMPTE 170M transfer and BT.709 standard.
	BT601_525                          = 281280512, // STANDARD_BT601_525 | TRANSFER_SMPTE_170M | RANGE_LIMITED
	// *
	//      * ITU-R Recommendation 2020 (BT.2020)
	//      *
	//      * Ultra High-definition television
	//      *
	//      * Use full range, BT.709 transfer and BT2020 standard
	BT2020                             = 147193856, // STANDARD_BT2020 | TRANSFER_SMPTE_170M | RANGE_FULL
	// *
	//      * ITU-R Recommendation 709 (BT.709)
	//      *
	//      * High-definition television
	//      *
	//      * Use limited range, BT.709 transfer and BT.709 standard.
	BT709                              = 281083904, // STANDARD_BT709 | TRANSFER_SMPTE_170M | RANGE_LIMITED
	// *
	//      * SMPTE EG 432-1 and SMPTE RP 431-2.
	//      *
	//      * Digital Cinema DCI-P3
	//      *
	//      * Use full range, gamma 2.6 transfer and D65 DCI-P3 standard
	//      * Note: Application is responsible for gamma encoding the data as
	//      * a 2.6 gamma encoding is not supported in HW.
	DCI_P3                             = 155844608, // STANDARD_DCI_P3 | TRANSFER_GAMMA2_6 | RANGE_FULL
	// *
	//      * sRGB linear encoding:
	//      *
	//      * The red, green, and blue components are stored in sRGB space, but
	//      * are linear, not gamma-encoded.
	//      * The RGB primaries and the white point are the same as BT.709.
	//      *
	//      * The values are encoded using the full range ([0,255] for 8-bit) for all
	//      * components.
	SRGB_LINEAR                        = 138477568, // STANDARD_BT709 | TRANSFER_LINEAR | RANGE_FULL
	// *
	//      * Hybrid Log Gamma encoding:
	//      *
	//      * Use full range, hybrid log gamma transfer and BT2020 standard.
	BT2020_HLG                         = 168165376, // STANDARD_BT2020 | TRANSFER_HLG | RANGE_FULL
	// *
	//      * ITU Hybrid Log Gamma encoding:
	//      *
	//      * Use limited range, hybrid log gamma transfer and BT2020 standard.
	BT2020_ITU_HLG                     = 302383104, // STANDARD_BT2020 | TRANSFER_HLG | RANGE_LIMITED
	// *
	//      * Depth:
	//      *
	//      * This value is valid with formats HAL_PIXEL_FORMAT_Y16 and HAL_PIXEL_FORMAT_BLOB.
	DEPTH                              = 4096, 
	// *
	//      * ISO 16684-1:2011(E) Dynamic Depth:
	//      *
	//      * Embedded depth metadata following the dynamic depth specification.
	DYNAMIC_DEPTH                      = 4098, 
}

ADynamicSensorEvent :: struct {
	connected: i32,
	handle:    i32,
}

AFont :: struct {}

AFontMatcher :: struct {}

AHardwareBuffer :: struct {}

AHardwareBuffer_Desc :: struct {
	width:  u32,
	// /< Width in pixels.
	height: u32,
	// *
	//      * Number of images in an image array. AHardwareBuffers with one
	//      * layer correspond to regular 2D textures. AHardwareBuffers with
	//      * more than layer correspond to texture arrays. If the layer count
	//      * is a multiple of 6 and the usage flag
	//      * AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP is present, the buffer is
	//      * a cube map or a cube map array.
	layers: u32,
	format: AHardwareBuffer_Format,
	// /< One of AHardwareBuffer_Format.
	usage:  AHardwareBuffer_UsageFlags,
	// /< Combination of AHardwareBuffer_UsageFlags.
	stride: u32,
	// /< Row stride in pixels, ignored for AHardwareBuffer_allocate()
	rfu0:   u32,
	// /< Initialize to zero, reserved for future use.
	rfu1:   u64,
}

AHardwareBuffer_Format :: enum u32 {
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_R8G8B8A8_UNORM
	//      *   OpenGL ES: GL_RGBA8
	R8G8B8A8_UNORM     = 1, 
	// *
	//      * 32 bits per pixel, 8 bits per channel format where alpha values are
	//      * ignored (always opaque).
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_R8G8B8A8_UNORM
	//      *   OpenGL ES: GL_RGB8
	R8G8B8X8_UNORM     = 2, 
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_R8G8B8_UNORM
	//      *   OpenGL ES: GL_RGB8
	R8G8B8_UNORM       = 3, 
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_R5G6B5_UNORM_PACK16
	//      *   OpenGL ES: GL_RGB565
	R5G6B5_UNORM       = 4, 
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_R16G16B16A16_SFLOAT
	//      *   OpenGL ES: GL_RGBA16F
	R16G16B16A16_FLOAT = 22, 
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_A2B10G10R10_UNORM_PACK32
	//      *   OpenGL ES: GL_RGB10_A2
	R10G10B10A2_UNORM  = 43, 
	// *
	//      * Opaque binary blob format.
	//      * Must have height 1 and one layer, with width equal to the buffer
	//      * size in bytes. Corresponds to Vulkan buffers and OpenGL buffer
	//      * objects. Can be bound to the latter using GL_EXT_external_buffer.
	BLOB               = 33, 
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_D16_UNORM
	//      *   OpenGL ES: GL_DEPTH_COMPONENT16
	D16_UNORM          = 48, 
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_X8_D24_UNORM_PACK32
	//      *   OpenGL ES: GL_DEPTH_COMPONENT24
	D24_UNORM          = 49, 
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_D24_UNORM_S8_UINT
	//      *   OpenGL ES: GL_DEPTH24_STENCIL8
	D24_UNORM_S8_UINT  = 50, 
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_D32_SFLOAT
	//      *   OpenGL ES: GL_DEPTH_COMPONENT32F
	D32_FLOAT          = 51, 
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_D32_SFLOAT_S8_UINT
	//      *   OpenGL ES: GL_DEPTH32F_STENCIL8
	D32_FLOAT_S8_UINT  = 52, 
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_S8_UINT
	//      *   OpenGL ES: GL_STENCIL_INDEX8
	S8_UINT            = 53, 
	// *
	//      * YUV 420 888 format.
	//      * Must have an even width and height. Can be accessed in OpenGL
	//      * shaders through an external sampler. Does not support mip-maps
	//      * cube-maps or multi-layered textures.
	Y8Cb8Cr8_420       = 35, 
	// *
	//      * YUV P010 format.
	//      * Must have an even width and height. Can be accessed in OpenGL
	//      * shaders through an external sampler. Does not support mip-maps
	//      * cube-maps or multi-layered textures.
	YCbCr_P010         = 54, 
	// *
	//      * YUV P210 format.
	//      * Must have an even width and height. Can be accessed in OpenGL
	//      * shaders through an external sampler. Does not support mip-maps
	//      * cube-maps or multi-layered textures.
	YCbCr_P210         = 60, 
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_R8_UNORM
	//      *   OpenGL ES: GR_GL_R8
	R8_UNORM           = 56, 
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_R16_UINT
	//      *   OpenGL ES: GL_R16UI
	R16_UINT           = 57, 
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_R16G16_UINT
	//      *   OpenGL ES: GL_RG16UI
	R16G16_UINT        = 58, 
	// *
	//      * Corresponding formats:
	//      *   Vulkan: VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16
	//      *   OpenGL ES: N/A
	R10G10B10A10_UNORM = 59, 
}

AHardwareBuffer_Plane :: struct {
	data:        rawptr,
	// /< Points to first byte in plane
	pixelStride: u32,
	// /< Distance in bytes from the color channel of one pixel to the next
	rowStride:   u32,
}

AHardwareBuffer_Planes :: struct {
	planeCount: u32,
	// /< Number of distinct planes
	planes:     [4]AHardwareBuffer_Plane,
}

AHardwareBuffer_UsageFlags :: enum u64 {
	// *
	//      * The buffer will never be locked for direct CPU reads using the
	//      * AHardwareBuffer_lock() function. Note that reading the buffer
	//      * using OpenGL or Vulkan functions or memory mappings is still
	//      * allowed.
	CPU_READ_NEVER      = 0, 
	// *
	//      * The buffer will sometimes be locked for direct CPU reads using
	//      * the AHardwareBuffer_lock() function. Note that reading the
	//      * buffer using OpenGL or Vulkan functions or memory mappings
	//      * does not require the presence of this flag.
	CPU_READ_RARELY     = 2, 
	// *
	//      * The buffer will often be locked for direct CPU reads using
	//      * the AHardwareBuffer_lock() function. Note that reading the
	//      * buffer using OpenGL or Vulkan functions or memory mappings
	//      * does not require the presence of this flag.
	CPU_READ_OFTEN      = 3, 
	// CPU read value mask. 
	CPU_READ_MASK       = 15, 
	// *
	//      * The buffer will never be locked for direct CPU writes using the
	//      * AHardwareBuffer_lock() function. Note that writing the buffer
	//      * using OpenGL or Vulkan functions or memory mappings is still
	//      * allowed.
	CPU_WRITE_NEVER     = 0, 
	// *
	//      * The buffer will sometimes be locked for direct CPU writes using
	//      * the AHardwareBuffer_lock() function. Note that writing the
	//      * buffer using OpenGL or Vulkan functions or memory mappings
	//      * does not require the presence of this flag.
	CPU_WRITE_RARELY    = 32, 
	// *
	//      * The buffer will often be locked for direct CPU writes using
	//      * the AHardwareBuffer_lock() function. Note that writing the
	//      * buffer using OpenGL or Vulkan functions or memory mappings
	//      * does not require the presence of this flag.
	CPU_WRITE_OFTEN     = 48, 
	// CPU write value mask. 
	CPU_WRITE_MASK      = 240, 
	// The buffer will be read from by the GPU as a texture. 
	GPU_SAMPLED_IMAGE   = 256, 
	// The buffer will be written to by the GPU as a framebuffer attachment.
	GPU_FRAMEBUFFER     = 512, 
	// *
	//      * The buffer will be written to by the GPU as a framebuffer
	//      * attachment.
	//      *
	//      * Note that the name of this flag is somewhat misleading: it does
	//      * not imply that the buffer contains a color format. A buffer with
	//      * depth or stencil format that will be used as a framebuffer
	//      * attachment should also have this flag. Use the equivalent flag
	//      * AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER to avoid this confusion.
	GPU_COLOR_OUTPUT    = 512, 
	// *
	//      * The buffer will be used as a composer HAL overlay layer.
	//      *
	//      * This flag is currently only needed when using ASurfaceTransaction_setBuffer
	//      * to set a buffer. In all other cases, the framework adds this flag
	//      * internally to buffers that could be presented in a composer overlay.
	//      * ASurfaceTransaction_setBuffer is special because it uses buffers allocated
	//      * directly through AHardwareBuffer_allocate instead of buffers allocated
	//      * by the framework.
	COMPOSER_OVERLAY    = 2048, 
	// *
	//      * The buffer is protected from direct CPU access or being read by
	//      * non-secure hardware, such as video encoders.
	//      *
	//      * This flag is incompatible with CPU read and write flags. It is
	//      * mainly used when handling DRM video. Refer to the EGL extension
	//      * EGL_EXT_protected_content and GL extension
	//      * GL_EXT_protected_textures for more information on how these
	//      * buffers are expected to behave.
	PROTECTED_CONTENT   = 16384, 
	// The buffer will be read by a hardware video encoder. 
	VIDEO_ENCODE        = 65536, 
	// *
	//      * The buffer will be used for direct writes from sensors.
	//      * When this flag is present, the format must be AHARDWAREBUFFER_FORMAT_BLOB.
	SENSOR_DIRECT_DATA  = 8388608, 
	// *
	//      * The buffer will be used as a shader storage or uniform buffer object.
	//      * When this flag is present, the format must be AHARDWAREBUFFER_FORMAT_BLOB.
	GPU_DATA_BUFFER     = 16777216, 
	// *
	//      * The buffer will be used as a cube map texture.
	//      * When this flag is present, the buffer must have a layer count
	//      * that is a multiple of 6. Note that buffers with this flag must be
	//      * bound to OpenGL textures using the extension
	//      * GL_EXT_EGL_image_storage instead of GL_KHR_EGL_image.
	GPU_CUBE_MAP        = 33554432, 
	// *
	//      * The buffer contains a complete mipmap hierarchy.
	//      * Note that buffers with this flag must be bound to OpenGL textures using
	//      * the extension GL_EXT_EGL_image_storage instead of GL_KHR_EGL_image.
	GPU_MIPMAP_COMPLETE = 67108864, 
	// *
	//      * Usage: The buffer is used for front-buffer rendering. When
	//      * front-buffering rendering is specified, different usages may adjust their
	//      * behavior as a result. For example, when used as GPU_COLOR_OUTPUT the buffer
	//      * will behave similar to a single-buffered window. When used with
	//      * COMPOSER_OVERLAY, the system will try to prioritize the buffer receiving
	//      * an overlay plane & avoid caching it in intermediate composition buffers.
	FRONT_BUFFER        = 4294967296, 
	VENDOR_0            = 268435456, 
	VENDOR_1            = 536870912, 
	VENDOR_2            = 1073741824, 
	VENDOR_3            = 2147483648, 
	VENDOR_4            = 281474976710656, 
	VENDOR_5            = 562949953421312, 
	VENDOR_6            = 1125899906842624, 
	VENDOR_7            = 2251799813685248, 
	VENDOR_8            = 4503599627370496, 
	VENDOR_9            = 9007199254740992, 
	VENDOR_10           = 18014398509481984, 
	VENDOR_11           = 36028797018963968, 
	VENDOR_12           = 72057594037927936, 
	VENDOR_13           = 144115188075855872, 
	VENDOR_14           = 288230376151711744, 
	VENDOR_15           = 576460752303423488, 
	VENDOR_16           = 1152921504606846976, 
	VENDOR_17           = 2305843009213693952, 
	VENDOR_18           = 4611686018427387904, 
	VENDOR_19           = 9223372036854775808, 
}

AHdrMetadataType :: enum u32 {
	HDR10_SMPTE2086 = 1, 
	HDR10_CTA861_3  = 2, 
	HDR10PLUS_SEI   = 3, 
}

AHdrMetadata_cta861_3 :: struct {
	maxContentLightLevel:      f32,
	maxFrameAverageLightLevel: f32,
}

AHdrMetadata_smpte2086 :: struct {
	displayPrimaryRed:   AColor_xy,
	displayPrimaryGreen: AColor_xy,
	displayPrimaryBlue:  AColor_xy,
	whitePoint:          AColor_xy,
	maxLuminance:        f32,
	minLuminance:        f32,
}

AHeadTrackerEvent :: struct {
	// *
	//      * The fields rx, ry, rz are an Euler vector (rotation vector, i.e. a vector
	//      * whose direction indicates the axis of rotation and magnitude indicates
	//      * the angle to rotate around that axis) representing the transform from
	//      * the (arbitrary, possibly slowly drifting) reference frame to the
	//      * head frame. Expressed in radians. Magnitude of the vector must be
	//      * in the range [0, pi], while the value of individual axes are
	//      * in the range [-pi, pi].
	rx:                  f32,
	ry:                  f32,
	rz:                  f32,
	// *
	//      * The fields vx, vy, vz are an Euler vector (rotation vector) representing
	//      * the angular velocity of the head (relative to itself), in radians per
	//      * second. The direction of this vector indicates the axis of rotation, and
	//      * the magnitude indicates the rate of rotation.
	vx:                  f32,
	vy:                  f32,
	vz:                  f32,
	// *
	//      * This value changes each time the reference frame is suddenly and
	//      * significantly changed, for example if an orientation filter algorithm
	//      * used for determining the orientation has had its state reset.
	discontinuity_count: i32,
}

AHeadingEvent :: struct {
	// *
	//      * The direction in which the device is pointing relative to true north in
	//      * degrees. The value must be between 0.0 (inclusive) and 360.0 (exclusive),
	//      * with 0 indicating north, 90 east, 180 south, and 270 west.
	heading:  f32,
	// *
	//      * Accuracy is defined at 68% confidence. In the case where the underlying
	//      * distribution is assumed Gaussian normal, this would be considered one
	//      * standard deviation. For example, if the heading returns 60 degrees, and
	//      * accuracy returns 10 degrees, then there is a 68 percent probability of
	//      * the true heading being between 50 degrees and 70 degrees.
	accuracy: f32,
}

AHeartRateEvent :: struct {
	bpm:    f32,
	status: SensorStatus,
}

AImageDecoder :: struct {}

AImageDecoderBlendOp :: enum i32 {
	// / This frame replaces existing content. This corresponds
	// / to webp’s “do not blend”.
	SRC      = 1, 
	// / This frame blends with the previous frame.
	SRC_OVER = 2, 
}

AImageDecoderFrameDisposalOp :: enum i32 {
	// / No disposal. The following frame will be drawn directly
	// / on top of this one.
	NONE       = 1, 
	// / The frame’s rectangle is cleared to transparent (by AImageDecoder)
	// / before decoding the next frame.
	BACKGROUND = 2, 
	// / The frame’s rectangle is reverted to the prior frame before decoding
	// / the next frame. This is handled by AImageDecoder, unless
	// / {@link AImageDecoder_setInternallyHandleDisposePrevious} is set to false.
	PREVIOUS   = 3, 
}

AImageDecoderFrameInfo :: struct {}

AImageDecoderHeaderInfo :: struct {}

AImageDecoderRepeatCount :: enum i32 {
	// *
	// 	* Reported by {@link AImageDecoder_getRepeatCount} if the
	// 	* animation should repeat forever.
	// 	*
	// 	* Introduced in API 31
	INFINITE = 2147483647, 
}

AImageDecoderResult :: enum i32 {
	// *
	//      * Decoding was successful and complete.
	SUCCESS            = 0, 
	// *
	//      * The input is incomplete.
	INCOMPLETE         = -1, 
	// *
	//      * The input contained an error after decoding some lines.
	ERROR              = -2, 
	// *
	//      * Could not convert. For example, attempting to decode an image with
	//      * alpha to an opaque format.
	INVALID_CONVERSION = -3, 
	// *
	//      * The scale is invalid. It may have overflowed, or it may be incompatible
	//      * with the current alpha setting.
	INVALID_SCALE      = -4, 
	// *
	//      * Some other parameter is invalid.
	BAD_PARAMETER      = -5, 
	// *
	//      * Input was invalid before decoding any pixels.
	INVALID_INPUT      = -6, 
	// *
	//      * A seek was required and it failed.
	SEEK_ERROR         = -7, 
	// *
	//      * Some other error. For example, an internal allocation failed.
	INTERNAL_ERROR     = -8, 
	// *
	//      * AImageDecoder did not recognize the format.
	UNSUPPORTED_FORMAT = -9, 
	// *
	//      * The animation has reached the end.
	FINISHED           = -01, 
	// *
	//      * This method cannot be called while the AImageDecoder is in its current
	//      * state. For example, various setters (like {@link AImageDecoder_setTargetSize})
	//      * can only be called while the AImageDecoder is set to decode the first
	//      * frame of an animation. This ensures that any blending and/or restoring
	//      * prior frames works correctly.
	INVALID_STATE      = -11, 
}

AInputEvent :: struct {}

AInputQueue :: struct {}

ALimitedAxesImuEvent :: struct {
	using _: struct #raw_union {
		calib: [3]f32,
		using _: struct {
			x: f32,
			y: f32,
			z: f32,
		},
	},
	using _: struct #raw_union {
		supported: [3]f32,
		using _:   struct {
			x_supported: f32,
			y_supported: f32,
			z_supported: f32,
		},
	},
}

ALimitedAxesImuUncalibratedEvent :: struct {
	using _: struct #raw_union {
		uncalib: [3]f32,
		using _: struct {
			x_uncalib: f32,
			y_uncalib: f32,
			z_uncalib: f32,
		},
	},
	using _: struct #raw_union {
		bias: [3]f32,
		using _: struct {
			x_bias: f32,
			y_bias: f32,
			z_bias: f32,
		},
	},
	using _: struct #raw_union {
		supported: [3]f32,
		using _:   struct {
			x_supported: f32,
			y_supported: f32,
			z_supported: f32,
		},
	},
}

ALooper :: struct {}

ALooperFdFlags :: bit_set[ALooperFdFlagsBits; i32]

ALooperFdFlagsBits :: enum i32 {
	// *
	//      * The file descriptor is available for read operations.
	INPUT   = 0, 
	// *
	//      * The file descriptor is available for write operations.
	OUTPUT  = 1, 
	// *
	//      * The file descriptor has encountered an error condition.
	//      *
	//      * The looper always sends notifications about errors; it is not necessary
	//      * to specify this event flag in the requested event set.
	ERROR   = 2, 
	// *
	//      * The file descriptor was hung up.
	//      * For example, indicates that the remote end of a pipe or socket was closed.
	//      *
	//      * The looper always sends notifications about hangups; it is not necessary
	//      * to specify this event flag in the requested event set.
	HANGUP  = 3, 
	// *
	//      * The file descriptor is invalid.
	//      * For example, the file descriptor was closed prematurely.
	//      *
	//      * The looper always sends notifications about invalid file descriptors; it is not necessary
	//      * to specify this event flag in the requested event set.
	INVALID = 4, 
}

ALooperPollResult :: enum i32 {
	// *
	//      * The poll was awoken using wake() before the timeout expired
	//      * and no callbacks were executed and no other file descriptors were ready.
	WAKE     = -1, 
	// *
	//      * Result from ALooper_pollOnce() and ALooper_pollAll():
	//      * One or more callbacks were executed.
	CALLBACK = -2, 
	// *
	//      * Result from ALooper_pollOnce() and ALooper_pollAll():
	//      * The timeout expired.
	TIMEOUT  = -3, 
	// *
	//      * Result from ALooper_pollOnce() and ALooper_pollAll():
	//      * An error occurred.
	ERROR    = -4, 
}

ALooper_callbackFunc :: proc "c" (fd: i32, events: bit_set[ALooperFdFlagsBits; i32], data: rawptr) -> i32

AMetaDataEvent :: struct {
	what:   i32,
	sensor: i32,
}

AMotionClassification :: enum i32 {
	// *
	//      * Classification constant: None.
	//      *
	//      * No additional information is available about the current motion event stream.
	NONE              = 0, 
	// *
	//      * Classification constant: Ambiguous gesture.
	//      *
	//      * The user's intent with respect to the current event stream is not yet determined. Events
	//      * starting in #AMOTION_EVENT_CLASSIFICATION_AMBIGUOUS_GESTURE will eventually resolve into
	//      * either #AMOTION_EVENT_CLASSIFICATION_DEEP_PRESS or #AMOTION_EVENT_CLASSIFICATION_NONE.
	//      * Gestural actions, such as scrolling, should be inhibited until the classification resolves
	//      * to another value or the event stream ends.
	AMBIGUOUS_GESTURE = 1, 
	// *
	//      * Classification constant: Deep press.
	//      *
	//      * The current event stream represents the user intentionally pressing harder on the screen.
	//      * This classification type should be used to accelerate the long press behaviour.
	DEEP_PRESS        = 2, 
}

ANativeActivity :: struct {
	// *
	//      * Pointer to the callback function table of the native application.
	//      * You can set the functions here to your own callbacks.  The callbacks
	//      * pointer itself here should not be changed, it is allocated and managed
	//      * for you by the framework.
	callbacks:        ^ANativeActivityCallbacks,
	// *
	//      * The global handle on the process's Java VM.
	vm:               ^^JNIInvokeInterface,
	// *
	//      * JNI context for the main thread of the app.  Note that this field
	//      * can ONLY be used from the main thread of the process, that is, the
	//      * thread that calls into the ANativeActivityCallbacks.
	env:              ^^JNINativeInterface,
	// *
	//      * The NativeActivity object handle.
	//      *
	//      * IMPORTANT NOTE: This member is mis-named. It should really be named
	//      * 'activity' instead of 'clazz', since it's a reference to the
	//      * NativeActivity instance created by the system for you.
	//      *
	//      * We unfortunately cannot change this without breaking NDK
	//      * source-compatibility.
	clazz:            jobject,
	// *
	//      * Path to this application's internal data directory.
	internalDataPath: cstring,
	// *
	//      * Path to this application's external (removable/mountable) data directory.
	externalDataPath: cstring,
	// *
	//      * The platform's SDK version code.
	sdkVersion:       i32,
	// *
	//      * This is the native instance of the application.  It is not used by
	//      * the framework, but can be set by the application to its own instance
	//      * state.
	instance:         rawptr,
	// *
	//      * Pointer to the Asset Manager instance for the application.  The application
	//      * uses this to access binary assets bundled inside its own .apk file.
	assetManager:     ^AAssetManager,
	// *
	//      * Available starting with Honeycomb: path to the directory containing
	//      * the application's OBB files (if any).  If the app doesn't have any
	//      * OBB files, this directory may not exist.
	obbPath:          cstring,
}

ANativeActivityCallbacks :: struct {
	// *
	//      * NativeActivity has started.  See Java documentation for Activity.onStart()
	//      * for more information.
	onStart:                    proc "c" (activity: ^ANativeActivity),
	// *
	//      * NativeActivity has resumed.  See Java documentation for Activity.onResume()
	//      * for more information.
	onResume:                   proc "c" (activity: ^ANativeActivity),
	// *
	//      * Framework is asking NativeActivity to save its current instance state.
	//      * See Java documentation for Activity.onSaveInstanceState() for more
	//      * information.  The returned pointer needs to be created with malloc(),
	//      * the framework will call free() on it for you.  You also must fill in
	//      * outSize with the number of bytes in the allocation.  Note that the
	//      * saved state will be persisted, so it can not contain any active
	//      * entities (pointers to memory, file descriptors, etc).
	onSaveInstanceState:        proc "c" (activity: ^ANativeActivity, outSize: ^uint) -> rawptr,
	// *
	//      * NativeActivity has paused.  See Java documentation for Activity.onPause()
	//      * for more information.
	onPause:                    proc "c" (activity: ^ANativeActivity),
	// *
	//      * NativeActivity has stopped.  See Java documentation for Activity.onStop()
	//      * for more information.
	onStop:                     proc "c" (activity: ^ANativeActivity),
	// *
	//      * NativeActivity is being destroyed.  See Java documentation for Activity.onDestroy()
	//      * for more information.
	onDestroy:                  proc "c" (activity: ^ANativeActivity),
	// *
	//      * Focus has changed in this NativeActivity's window.  This is often used,
	//      * for example, to pause a game when it loses input focus.
	onWindowFocusChanged:       proc "c" (activity: ^ANativeActivity, hasFocus: i32),
	// *
	//      * The drawing window for this native activity has been created.  You
	//      * can use the given native window object to start drawing.
	onNativeWindowCreated:      proc "c" (activity: ^ANativeActivity, window: ^ANativeWindow),
	// *
	//      * The drawing window for this native activity has been resized.  You should
	//      * retrieve the new size from the window and ensure that your rendering in
	//      * it now matches.
	onNativeWindowResized:      proc "c" (activity: ^ANativeActivity, window: ^ANativeWindow),
	// *
	//      * The drawing window for this native activity needs to be redrawn.  To avoid
	//      * transient artifacts during screen changes (such resizing after rotation),
	//      * applications should not return from this function until they have finished
	//      * drawing their window in its current state.
	onNativeWindowRedrawNeeded: proc "c" (activity: ^ANativeActivity, window: ^ANativeWindow),
	// *
	//      * The drawing window for this native activity is going to be destroyed.
	//      * You MUST ensure that you do not touch the window object after returning
	//      * from this function: in the common case of drawing to the window from
	//      * another thread, that means the implementation of this callback must
	//      * properly synchronize with the other thread to stop its drawing before
	//      * returning from here.
	onNativeWindowDestroyed:    proc "c" (activity: ^ANativeActivity, window: ^ANativeWindow),
	// *
	//      * The input queue for this native activity's window has been created.
	//      * You can use the given input queue to start retrieving input events.
	onInputQueueCreated:        proc "c" (activity: ^ANativeActivity, queue: ^AInputQueue),
	// *
	//      * The input queue for this native activity's window is being destroyed.
	//      * You should no longer try to reference this object upon returning from this
	//      * function.
	onInputQueueDestroyed:      proc "c" (activity: ^ANativeActivity, queue: ^AInputQueue),
	// *
	//      * The rectangle in the window in which content should be placed has changed.
	onContentRectChanged:       proc "c" (activity: ^ANativeActivity, #by_ptr rect: ARect),
	// *
	//      * The current device AConfiguration has changed.  The new configuration can
	//      * be retrieved from assetManager.
	onConfigurationChanged:     proc "c" (activity: ^ANativeActivity),
	// *
	//      * The system is running low on memory.  Use this callback to release
	//      * resources you do not need, to help the system avoid killing more
	//      * important processes.
	onLowMemory:                proc "c" (activity: ^ANativeActivity),
}

ANativeActivity_createFunc :: proc "c" (activity: ^ANativeActivity, savedState: rawptr, savedStateSize: uint)

ANativeWindow :: struct {}

ANativeWindowTransform :: enum i32 {
	IDENTITY          = 0, 
	MIRROR_HORIZONTAL = 1, 
	MIRROR_VERTICAL   = 2, 
	ROTATE_90         = 4, 
	ROTATE_180        = 3, 
	ROTATE_270        = 7, 
}

ANativeWindow_Buffer :: struct {
	// / The number of pixels that are shown horizontally.
	width:    i32,
	// / The number of pixels that are shown vertically.
	height:   i32,
	// / The number of *pixels* that a line in the buffer takes in
	// / memory. This may be >= width.
	stride:   i32,
	// / The format of the buffer. One of AHardwareBuffer_Format.
	format:   AHardwareBuffer_Format,
	// / The actual bits.
	bits:     rawptr,
	// / Do not touch.
	reserved: [6]u32,
}

ANativeWindow_ChangeFrameRateStrategy :: enum i8 {
	// *
	// 	* Change the frame rate only if the transition is going to be seamless.
	ONLY_IF_SEAMLESS = 0, 
	// *
	// 	* Change the frame rate even if the transition is going to be non-seamless,
	// 	* i.e. with visual interruptions for the user.
	ALWAYS           = 1, 
}

ANativeWindow_FrameRateCompatibility :: enum i8 {
	// *
	// 	* There are no inherent restrictions on the frame rate of this window. When
	// 	* the system selects a frame rate other than what the app requested, the
	// 	* app will be able to run at the system frame rate without requiring pull
	// 	* down. This value should be used when displaying game content, UIs, and
	// 	* anything that isn't video.
	DEFAULT      = 0, 
	// *
	// 	* This window is being used to display content with an inherently fixed
	// 	* frame rate, e.g.\ a video that has a specific frame rate. When the system
	// 	* selects a frame rate other than what the app requested, the app will need
	// 	* to do pull down or use some other technique to adapt to the system's
	// 	* frame rate. The user experience is likely to be worse (e.g. more frame
	// 	* stuttering) than it would be if the system had chosen the app's requested
	// 	* frame rate. This value should be used for video content.
	FIXED_SOURCE = 1, 
}

ANativeWindow_LegacyFormat :: enum u32 {
	// Red: 8 bits, Green: 8 bits, Blue: 8 bits, Alpha: 8 bits. *
	RGBA_8888 = 1, 
	// Red: 8 bits, Green: 8 bits, Blue: 8 bits, Unused: 8 bits. *
	RGBX_8888 = 2, 
	// Red: 5 bits, Green: 6 bits, Blue: 5 bits. *
	RGB_565   = 4, 
}

ANeuralNetworksBurst :: struct {}

ANeuralNetworksCompilation :: struct {}

ANeuralNetworksDevice :: struct {}

ANeuralNetworksEvent :: struct {}

ANeuralNetworksExecution :: struct {}

ANeuralNetworksMemory :: struct {}

ANeuralNetworksMemoryDesc :: struct {}

ANeuralNetworksModel :: struct {}

ANeuralNetworksOperandType :: struct {
	// *
	//      * The data type, e.g ANEURALNETWORKS_FLOAT32.
	type:           OperandCode,
	// *
	//      * The number of dimensions (rank).
	//      *
	//      * Must be 0 for scalars.
	dimensionCount: u32,
	// *
	//      * The dimensions of the tensor.
	//      *
	//      * Must be nullptr for scalars.
	dimensions:     [^]u32,
	// *
	//      * The quantization scale.
	//      *
	//      * Must be 0 when not applicable to an operand type.
	//      *
	//      * See {@link OperandCode}.
	scale:          f32,
	// *
	//      * The quantization zero point.
	//      *
	//      * Must be 0 when not applicable to an operand type.
	//      *
	//      * See {@link OperandCode}.
	zeroPoint:      i32,
}

ANeuralNetworksOperationType :: OperationCode

ANeuralNetworksSymmPerChannelQuantParams :: struct {
	// The index of the channel dimension. 
	channelDim: u32,
	// The size of the scale array. Should be equal to dimension[channelDim] of the Operand. 
	scaleCount: u32,
	// The array of scaling values for each channel. Each value must be greater than zero. 
	scales:     [^]f32,
}

AObbInfo :: struct {}

APerformanceHintManager :: struct {}

APerformanceHintSession :: struct {}

ARect :: struct {
	// / Minimum X coordinate of the rectangle.
	left:   i32,
	// / Minimum Y coordinate of the rectangle.
	top:    i32,
	// / Maximum X coordinate of the rectangle.
	right:  i32,
	// / Maximum Y coordinate of the rectangle.
	bottom: i32,
}

ASensor :: struct {}

ASensorEvent :: struct {
	version:   i32,
	// sizeof(struct ASensorEvent) 
	sensor:    i32,
	// The sensor that generates this event 
	type:      SensorType,
	// Sensor type for the event, such as {@link ASENSOR_TYPE_ACCELEROMETER} 
	reserved0: i32,
	// *
	//      * The time in nanoseconds at which the event happened, and its behavior
	//      * is identical to <a href="/reference/android/hardware/SensorEvent#timestamp">
	//      * SensorEvent::timestamp</a> in Java API.
	timestamp: i64,
	using _:   struct #raw_union {
		using _: struct #raw_union {
			data:                          [16]f32,
			vector:                        ASensorVector,
			acceleration:                  ASensorVector,
			gyro:                          ASensorVector,
			magnetic:                      ASensorVector,
			temperature:                   f32,
			distance:                      f32,
			light:                         f32,
			pressure:                      f32,
			relative_humidity:             f32,
			uncalibrated_acceleration:     AUncalibratedEvent,
			uncalibrated_gyro:             AUncalibratedEvent,
			uncalibrated_magnetic:         AUncalibratedEvent,
			meta_data:                     AMetaDataEvent,
			heart_rate:                    AHeartRateEvent,
			dynamic_sensor_meta:           ADynamicSensorEvent,
			additional_info:               AAdditionalInfoEvent,
			head_tracker:                  AHeadTrackerEvent,
			limited_axes_imu:              ALimitedAxesImuEvent,
			limited_axes_imu_uncalibrated: ALimitedAxesImuUncalibratedEvent,
			heading:                       AHeadingEvent,
		},
		u64: struct #raw_union {
			data:         [8]u64,
			step_counter: u64,
		},
	},
	flags:     u32,
	reserved1: [3]i32,
}

ASensorEventQueue :: struct {}

ASensorList :: [^]^ASensor

ASensorManager :: struct {}

ASensorRef :: ^ASensor

ASensorVector :: struct {
	using _:  struct #raw_union {
		v: [3]f32,
		using _: struct {
			x: f32,
			y: f32,
			z: f32,
		},
		using _: struct {
			azimuth: f32,
			pitch:   f32,
			roll:    f32,
		},
	},
	status:   SensorStatus,
	reserved: [3]u8,
}

AStorageManager :: struct {}

AStorageManager_obbCallbackFunc :: proc "c" (filename: cstring, state: OBBState, data: rawptr)

ASurfaceControl :: struct {}

ASurfaceTexture :: struct {}

ASurfaceTransaction :: struct {}

ASurfaceTransactionStats :: struct {}

ASurfaceTransaction_OnBufferRelease :: proc "c" (_context: rawptr, release_fence_fd: i32)

ASurfaceTransaction_OnCommit :: proc "c" (_context: rawptr, stats: ^ASurfaceTransactionStats)

ASurfaceTransaction_OnComplete :: proc "c" (_context: rawptr, stats: ^ASurfaceTransactionStats)

ASystemFontIterator :: struct {}

AThermalHeadroomThreshold :: struct {
	headroom:      f32,
	thermalStatus: AThermalStatus,
}

AThermalManager :: struct {}

AThermalStatus :: enum int {
	// Error in thermal status. 
	ERROR     = -1, 
	// Not under throttling. 
	NONE      = 0, 
	// Light throttling where UX is not impacted. 
	LIGHT     = 1, 
	// Moderate throttling where UX is not largely impacted. 
	MODERATE  = 2, 
	// Severe throttling where UX is largely impacted. 
	SEVERE    = 3, 
	// Platform has done everything to reduce power. 
	CRITICAL  = 4, 
	// *
	//      * Key components in platform are shutting down due to thermal condition.
	//      * Device functionalities will be limited.
	EMERGENCY = 5, 
	// Need shutdown immediately. 
	SHUTDOWN  = 6, 
}

AThermal_StatusCallback :: proc "c" (data: rawptr, status: AThermalStatus)

AUncalibratedEvent :: struct {
	using _: struct #raw_union {
		uncalib: [3]f32,
		using _: struct {
			x_uncalib: f32,
			y_uncalib: f32,
			z_uncalib: f32,
		},
	},
	using _: struct #raw_union {
		bias: [3]f32,
		using _: struct {
			x_bias: f32,
			y_bias: f32,
			z_bias: f32,
		},
	},
}

AVsyncId :: i64

AWorkDuration :: struct {}

AndroidBitmapCompressFormat :: enum i32 {
	// *
	//      * Compress to the JPEG format. quality of 0 means
	//      * compress for the smallest size. 100 means compress for max
	//      * visual quality.
	JPEG          = 0, 
	// *
	//      * Compress to the PNG format. PNG is lossless, so quality is
	//      * ignored.
	PNG           = 1, 
	// *
	//      * Compress to the WEBP lossy format. quality of 0 means
	//      * compress for the smallest size. 100 means compress for max
	//      * visual quality.
	WEBP_LOSSY    = 3, 
	// *
	//      * Compress to the WEBP lossless format. quality refers to how
	//      * much effort to put into compression. A value of 0 means to
	//      * compress quickly, resulting in a relatively large file size.
	//      * 100 means to spend more time compressing, resulting in a
	//      * smaller file.
	WEBP_LOSSLESS = 4, 
}

AndroidBitmapFlags :: enum u32 {
	// If this bit is set in BitmapInfo.flags, the Bitmap uses the
	//       * HARDWARE Config, and its {@link AHardwareBuffer} can be retrieved via
	//       * {@link AndroidBitmap_getHardwareBuffer}.
	IS_HARDWARE = 2147483648, 
}

AndroidBitmapFlagsAlpha :: enum int {
	// Pixel components are premultiplied by alpha. 
	PREMUL   = 0, 
	// Pixels are opaque. 
	OPAQUE   = 1, 
	// Pixel components are independent of alpha. 
	UNPREMUL = 2, 
	// Bit mask for BitmapInfo.flags to isolate the alpha. 
	MASK     = 3, 
	// Shift for BitmapInfo.flags to isolate the alpha. 
	SHIFT    = 0, 
}

AndroidBitmapFormat :: enum i32 {
	// No format. 
	NONE         = 0, 
	// Red: 8 bits, Green: 8 bits, Blue: 8 bits, Alpha: 8 bits. *
	RGBA_8888    = 1, 
	// Red: 5 bits, Green: 6 bits, Blue: 5 bits. *
	RGB_565      = 4, 
	// Deprecated in API level 13. Because of the poor quality of this configuration, it is advised to use ARGB_8888 instead. *
	RGBA_4444    = 7, 
	// Alpha: 8 bits. 
	A_8          = 8, 
	// Each component is stored as a half float. *
	RGBA_F16     = 9, 
	// Red: 10 bits, Green: 10 bits, Blue: 10 bits, Alpha: 2 bits. *
	RGBA_1010102 = 10, 
}

AndroidBitmap_CompressWriteFunc :: proc "c" (userContext: rawptr, data: rawptr, size: uint) -> bool

AppCmd :: enum i32 {
	// *
	//      * Command from main thread: the AInputQueue has changed.  Upon processing
	//      * this command, android_app->inputQueue will be updated to the new queue
	//      * (or NULL).
	INPUT_CHANGED, 
	// *
	//      * Command from main thread: a new ANativeWindow is ready for use.  Upon
	//      * receiving this command, android_app->window will contain the new window
	//      * surface.
	INIT_WINDOW, 
	// *
	//      * Command from main thread: the existing ANativeWindow needs to be
	//      * terminated.  Upon receiving this command, android_app->window still
	//      * contains the existing window; after calling android_app_exec_cmd
	//      * it will be set to NULL.
	TERM_WINDOW, 
	// *
	//      * Command from main thread: the current ANativeWindow has been resized.
	//      * Please redraw with its new size.
	WINDOW_RESIZED, 
	// *
	//      * Command from main thread: the system needs that the current ANativeWindow
	//      * be redrawn.  You should redraw the window before handing this to
	//      * android_app_exec_cmd() in order to avoid transient drawing glitches.
	WINDOW_REDRAW_NEEDED, 
	// *
	//      * Command from main thread: the content area of the window has changed,
	//      * such as from the soft input window being shown or hidden.  You can
	//      * find the new content rect in android_app::contentRect.
	CONTENT_RECT_CHANGED, 
	// *
	//      * Command from main thread: the app's activity window has gained
	//      * input focus.
	GAINED_FOCUS, 
	// *
	//      * Command from main thread: the app's activity window has lost
	//      * input focus.
	LOST_FOCUS, 
	// *
	//      * Command from main thread: the current device configuration has changed.
	CONFIG_CHANGED, 
	// *
	//      * Command from main thread: the system is running low on memory.
	//      * Try to reduce your memory use.
	LOW_MEMORY, 
	// *
	//      * Command from main thread: the app's activity has been started.
	START, 
	// *
	//      * Command from main thread: the app's activity has been resumed.
	RESUME, 
	// *
	//      * Command from main thread: the app should generate a new saved state
	//      * for itself, to restore from later if needed.  If you have saved state,
	//      * allocate it with malloc and place it in android_app.savedState with
	//      * the size in android_app.savedStateSize.  The will be freed for you
	//      * later.
	SAVE_STATE, 
	// *
	//      * Command from main thread: the app's activity has been paused.
	PAUSE, 
	// *
	//      * Command from main thread: the app's activity has been stopped.
	STOP, 
	// *
	//      * Command from main thread: the app's activity is being destroyed,
	//      * and waiting for the app thread to clean up and exit before proceeding.
	DESTROY, 
}

AssetFileError :: enum int {
	None, 
	Err, 
}

AssetOpenMode :: enum i32 {
	// No specific information about how data will be accessed. *
	UNKNOWN   = 0, 
	// Read chunks, and seek forward and backward. 
	RANDOM    = 1, 
	// Read sequentially, with an occasional forward seek. 
	STREAMING = 2, 
	// Caller plans to ask for a read-only buffer with all data. 
	BUFFER    = 3, 
}

BitmapInfo :: struct {
	// The bitmap width in pixels. 
	width:  u32,
	// The bitmap height in pixels. 
	height: u32,
	// The number of byte per row. 
	stride: u32,
	// The bitmap pixel format. See {@link AndroidBitmapFormat} 
	format: AndroidBitmapFormat,
	// Bitfield containing information about the bitmap.
	//      *
	//      * <p>Two bits are used to encode alpha. Use {@link AndroidBitmapFlagsAlpha.MASK}
	//      * and {@link AndroidBitmapFlagsAlpha.SHIFT} to retrieve them.</p>
	//      *
	//      * <p>One bit is used to encode whether the Bitmap uses the HARDWARE Config. Use
	//      * {@link AndroidBitmapFlags.IS_HARDWARE} to know.</p>
	//      *
	//      * <p>These flags were introduced in API level 30.</p>
	flags:  u32,
}

DLextFlags :: bit_set[DLextFlagsBits; u64]

DLextFlagsBits :: enum u64 {
	// *
	//    * When set, the `reserved_addr` and `reserved_size` fields must point to an
	//    * already-reserved region of address space which will be used to load the
	//    * library if it fits.
	//    *
	//    * If the reserved region is not large enough, loading will fail.
	RESERVED_ADDRESS           = 0, 
	// *
	//    * Like `ANDROID_DLEXT_RESERVED_ADDRESS`, but if the reserved region is not large enough,
	//    * the linker will choose an available address instead.
	RESERVED_ADDRESS_HINT      = 1, 
	// *
	//    * When set, write the GNU RELRO section of the mapped library to `relro_fd`
	//    * after relocation has been performed, to allow it to be reused by another
	//    * process loading the same library at the same address. This implies
	//    * `ANDROID_DLEXT_USE_RELRO`.
	//    *
	//    * This is mainly useful for the system WebView implementation.
	WRITE_RELRO                = 2, 
	// *
	//    * When set, compare the GNU RELRO section of the mapped library to `relro_fd`
	//    * after relocation has been performed, and replace any relocated pages that
	//    * are identical with a version mapped from the file.
	//    *
	//    * This is mainly useful for the system WebView implementation.
	USE_RELRO                  = 3, 
	// *
	//    * Use `library_fd` instead of opening the file by name.
	//    * The filename parameter is still used to identify the library.
	USE_LIBRARY_FD             = 4, 
	// *
	//    * If opening a library using `library_fd` read it starting at `library_fd_offset`.
	//    * This is mainly useful for loading a library stored within another file (such as uncompressed
	//    * inside a ZIP archive).
	//    * This flag is only valid when `ANDROID_DLEXT_USE_LIBRARY_FD` is set.
	USE_LIBRARY_FD_OFFSET      = 5, 
	// *
	//    * When set, do not use `stat(2)` to check if the library has already been loaded.
	//    *
	//    * This flag allows forced loading of the library in the case when for some
	//    * reason multiple ELF files share the same filename (because the already-loaded
	//    * library has been removed and overwritten, for example).
	//    *
	//    * Note that if the library has the same `DT_SONAME` as an old one and some other
	//    * library has the soname in its `DT_NEEDED` list, the first one will be used to resolve any
	//    * dependencies.
	FORCE_LOAD                 = 6, 
	// *
	//    * This flag used to load library in a different namespace. The namespace is
	//    * specified in `library_namespace`.
	//    *
	//    * This flag is for internal use only (since there is no NDK API for namespaces).
	USE_NAMESPACE              = 9, 
	// *
	//    * Instructs dlopen to apply `ANDROID_DLEXT_RESERVED_ADDRESS`,
	//    * `ANDROID_DLEXT_RESERVED_ADDRESS_HINT`, `ANDROID_DLEXT_WRITE_RELRO` and
	//    * `ANDROID_DLEXT_USE_RELRO` to any libraries loaded as dependencies of the
	//    * main library as well.
	//    *
	//    * This means that if the main library depends on one or more not-already-loaded libraries, they
	//    * will be loaded consecutively into the region starting at `reserved_addr`, and `reserved_size`
	//    * must be large enough to contain all of the libraries. The libraries will be loaded in the
	//    * deterministic order constructed from the DT_NEEDED entries, rather than the more secure random
	//    * order used by default.
	//    *
	//    * Each library's GNU RELRO sections will be written out to `relro_fd` in the same order they were
	//    * loaded. This will mean that the resulting file is dependent on which of the libraries were
	//    * already loaded, as only the newly loaded libraries will be included, not any already-loaded
	//    * dependencies. The caller should ensure that the set of libraries newly loaded is consistent
	//    * for this to be effective.
	//    *
	//    * This is mainly useful for the system WebView implementation.
	RESERVED_ADDRESS_RECURSIVE = 10, 
}

DeviceTypeCode :: enum i32 {
	// The device type cannot be provided. 
	UNKNOWN     = 0, 
	// The device does not fall into any category below. 
	OTHER       = 1, 
	// The device runs NNAPI models on single or multi-core CPU. 
	CPU         = 2, 
	// The device can run NNAPI models and also accelerate graphics APIs such
	//      * as OpenGL ES and Vulkan. 
	GPU         = 3, 
	// Dedicated accelerator for Machine Learning workloads. 
	ACCELERATOR = 4, 
}

DurationCode :: enum i32 {
	// Execution time on hardware (not driver, which runs on host processor).
	DURATION_ON_HARDWARE        = 0, 
	// Execution time in driver (including time on hardware).  Excludes overhead
	// such as that of the runtime itself and the IPC needed for the runtime to
	// communicate with the driver.
	DURATION_IN_DRIVER          = 1, 
	// Execution time on hardware, after all dependencies have been signaled.
	// If no dependencies specified (for example, if the execution was scheduled other
	// than with {@link ANeuralNetworksExecution_startComputeWithDependencies}), the
	// reported time will be the same as ANEURALNETWORKS_DURATION_ON_HARDWARE.
	// Available since NNAPI feature level 4.
	FENCED_DURATION_ON_HARDWARE = 2, 
	// Execution time in driver, after all dependencies have been signaled. Excludes
	// overhead such as that of the runtime itself and the IPC needed for the runtime
	// to communicate with the driver.
	// If no dependencies specified (for example, if the execution was scheduled other
	// than with {@link ANeuralNetworksExecution_startComputeWithDependencies}), the
	// reported time will be the same as ANEURALNETWORKS_DURATION_IN_DRIVER.
	// Available since NNAPI feature level 4.
	FENCED_DURATION_IN_DRIVER   = 3, 
}

FamilyVariant :: enum u32 {
	// A family variant value for the system default variant. 
	DEFAULT = 0, 
	// *
	//      * A family variant value for the compact font family variant.
	//      *
	//      * The compact font family has Latin-based vertical metrics.
	COMPACT = 1, 
	// *
	//      * A family variant value for the elegant font family variant.
	//      *
	//      * The elegant font family may have larger vertical metrics than Latin font.
	ELEGANT = 2, 
}

FeatureLevelCode :: enum i64 {
	// NNAPI specification available in Android O-MR1, Android NNAPI feature level 1 
	LEVEL_1 = 27, 
	// NNAPI specification available in Android P, Android NNAPI feature level 2 
	LEVEL_2 = 28, 
	// NNAPI specification available in Android Q, Android NNAPI feature level 3 
	LEVEL_3 = 29, 
	// NNAPI specification available in Android R, Android NNAPI feature level 4 
	LEVEL_4 = 30, 
	// *
	//      * NNAPI specification available in Android S, Android NNAPI feature level 5.
	//      * After Android S, the NNAPI specification can be updated between Android
	//      * API releases.
	LEVEL_5 = 31, 
	// Android NNAPI feature level 6 
	LEVEL_6 = 1000006, 
	// Android NNAPI feature level 7 
	LEVEL_7 = 1000007, 
	// Android NNAPI feature level 8 
	LEVEL_8 = 1000008, 
}

FontWeight :: enum u16 {
	// The minimum value fot the font weight value. 
	MIN         = 0, 
	// A font weight value for the thin weight. 
	THIN        = 100, 
	// A font weight value for the extra-light weight. 
	EXTRA_LIGHT = 200, 
	// A font weight value for the light weight. 
	LIGHT       = 300, 
	// A font weight value for the normal weight. 
	NORMAL      = 400, 
	// A font weight value for the medium weight. 
	MEDIUM      = 500, 
	// A font weight value for the semi-bold weight. 
	SEMI_BOLD   = 600, 
	// A font weight value for the bold weight. 
	BOLD        = 700, 
	// A font weight value for the extra-bold weight. 
	EXTRA_BOLD  = 800, 
	// A font weight value for the black weight. 
	BLACK       = 900, 
	// The maximum value for the font weight value. 
	MAX         = 1000, 
}

FuseCode :: enum int {
	// NO fused activation function. 
	NONE  = 0, 
	// Fused ReLU activation function. 
	RELU  = 1, 
	// Fused ReLU1 activation function. 
	RELU1 = 2, 
	// Fused ReLU6 activation function. 
	RELU6 = 3, 
}

HideSoftInputFlags :: enum int {
	// *
	// 	* The soft input window should only be hidden if it was not
	// 	* explicitly shown by the user.
	IMPLICIT_ONLY = 1, 
	// *
	// 	* The soft input window should normally be hidden, unless it was
	// 	* originally shown with {@link ANATIVEACTIVITY_SHOW_SOFT_INPUT_FORCED}.
	NOT_ALWAYS    = 2, 
}

InputEventType :: enum i32 {
	// Indicates that the input event is a key event. 
	KEY        = 1, 
	// Indicates that the input event is a motion event. 
	MOTION     = 2, 
	// Focus event 
	FOCUS      = 3, 
	// Capture event 
	CAPTURE    = 4, 
	// Drag event 
	DRAG       = 5, 
	// TouchMode event 
	TOUCH_MODE = 6, 
}

InputSource :: distinct bit_field i32 {
	class:  i32 | 8,
	device: i32 | 24,
}

InputSourceClass :: bit_set[InputSourceClassBits; i32]

InputSourceClassBits :: enum i32 {
	BUTTON     = 0, 
	POINTER    = 1, 
	NAVIGATION = 2, 
	POSITION   = 3, 
	JOYSTICK   = 4, 
}

InputSourceDevice :: bit_set[InputSourceDeviceBits; i32]

InputSourceDeviceBits :: enum i32 {
	KEYBOARD         = 0,  // BUTTON
	DPAD             = 1,  // BUTTON
	GAMEPAD          = 2,  // BUTTON
	TOUCHSCREEN      = 4,  // POINTER
	MOUSE            = 5,  // POINTER
	STYLUS           = 6,  // POINTER
	// This activates both bit 6 and 7 but doing 7 only is fine too.
	BLUETOOTH_STYLUS = 7,  // POINTER
	TRACKBALL        = 8,  // NAVIGATION
	MOUSE_RELATIVE   = 9,  // NAVIGATION
	TOUCHPAD         = 12, // POSITION
	TOUCH_NAVIGATION = 13, // NONE
	ROTARY_ENCODER   = 14, // NONE
	JOYSTICK         = 16, // JOYSTICK
	HDMI             = 17, // BUTTON
	SENSOR           = 18, // NONE
}

JNIEnv :: ^JNINativeInterface

JNIInvokeInterface :: struct {
	reserved0:                   rawptr,
	reserved1:                   rawptr,
	reserved2:                   rawptr,
	// NOTE: same here with JNIEnv. The two occurances of ^^^JNINativeInterface are originally ^^JNIEnv but
	// that seems to trigger some sort of race bug in the compiler where it thinks ^^JNIEnv is an invalid type
	// and throws a 'Invalid type usage "^^JNIEnv"'
	DestroyJavaVM:               proc "c" (vm: ^^JNIInvokeInterface) -> i32,
	AttachCurrentThread:         proc "c" (vm: ^^JNIInvokeInterface, p_env: ^^^JNINativeInterface, thr_args: rawptr) -> i32,
	DetachCurrentThread:         proc "c" (vm: ^^JNIInvokeInterface) -> i32,
	GetEnv:                      proc "c" (vm: ^^JNIInvokeInterface, env: ^rawptr, version: i32) -> i32,
	AttachCurrentThreadAsDaemon: proc "c" (vm: ^^JNIInvokeInterface, p_env: ^^^JNINativeInterface, thr_args: ^rawptr) -> i32,
}

JNINativeInterface :: struct {
	reserved0:                     rawptr,
	reserved1:                     rawptr,
	reserved2:                     rawptr,
	reserved3:                     rawptr,
	GetVersion:                    proc "c" (jni: ^^JNINativeInterface) -> i32,
	DefineClass:                   proc "c" (jni: ^^JNINativeInterface, name: cstring, loader: jobject, #by_ptr buf: i8, bufLen: i32) -> jclass,
	FindClass:                     proc "c" (jni: ^^JNINativeInterface, name: cstring) -> jclass,
	FromReflectedMethod:           proc "c" (jni: ^^JNINativeInterface, method: jobject) -> rawptr,
	FromReflectedField:            proc "c" (jni: ^^JNINativeInterface, field: jobject) -> rawptr,
	// spec doesn't show jboolean parameter 
	ToReflectedMethod:             proc "c" (jni: ^^JNINativeInterface, cls: jclass, methodID: rawptr, isStatic: u8) -> jobject,
	GetSuperclass:                 proc "c" (jni: ^^JNINativeInterface, clazz: jclass) -> jclass,
	IsAssignableFrom:              proc "c" (jni: ^^JNINativeInterface, clazz1: jclass, clazz2: jclass) -> u8,
	// spec doesn't show jboolean parameter 
	ToReflectedField:              proc "c" (jni: ^^JNINativeInterface, cls: jclass, fieldID: rawptr, isStatic: u8) -> jobject,
	Throw:                         proc "c" (jni: ^^JNINativeInterface, obj: jthrowable) -> i32,
	ThrowNew:                      proc "c" (jni: ^^JNINativeInterface, clazz: jclass, message: cstring) -> i32,
	ExceptionOccurred:             proc "c" (jni: ^^JNINativeInterface),
	ExceptionDescribe:             proc "c" (jni: ^^JNINativeInterface),
	ExceptionClear:                proc "c" (jni: ^^JNINativeInterface),
	FatalError:                    proc "c" (jni: ^^JNINativeInterface, msg: cstring),
	PushLocalFrame:                proc "c" (jni: ^^JNINativeInterface, capacity: i32) -> i32,
	PopLocalFrame:                 proc "c" (jni: ^^JNINativeInterface, result: jobject) -> jobject,
	NewGlobalRef:                  proc "c" (jni: ^^JNINativeInterface, obj: jobject) -> jobject,
	DeleteGlobalRef:               proc "c" (jni: ^^JNINativeInterface, globalRef: jobject),
	DeleteLocalRef:                proc "c" (jni: ^^JNINativeInterface, localRef: jobject),
	IsSameObject:                  proc "c" (jni: ^^JNINativeInterface, ref1: jobject, ref2: jobject) -> u8,
	NewLocalRef:                   proc "c" (jni: ^^JNINativeInterface, ref: jobject) -> jobject,
	EnsureLocalCapacity:           proc "c" (jni: ^^JNINativeInterface, capacity: i32) -> i32,
	AllocObject:                   proc "c" (jni: ^^JNINativeInterface, clazz: jclass) -> jobject,
	NewObject:                     proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, .. args: ..any) -> jobject,
	NewObjectV:                    proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> jobject,
	NewObjectA:                    proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> jobject,
	GetObjectClass:                proc "c" (jni: ^^JNINativeInterface, obj: jobject) -> jclass,
	IsInstanceOf:                  proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass) -> u8,
	GetMethodID:                   proc "c" (jni: ^^JNINativeInterface, clazz: jclass, name: cstring, sig: cstring) -> rawptr,
	// TODO: should va_list args be pointers?
	CallObjectMethod:              proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, .. args: ..any) -> jobject,
	CallObjectMethodV:             proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, args: ^c.va_list) -> jobject,
	CallObjectMethodA:             proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, #by_ptr args: jvalue) -> jobject,
	CallBooleanMethod:             proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, .. args: ..any) -> u8,
	CallBooleanMethodV:            proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, args: ^c.va_list) -> u8,
	CallBooleanMethodA:            proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, #by_ptr args: jvalue) -> u8,
	CallByteMethod:                proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, .. args: ..any) -> i8,
	CallByteMethodV:               proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, args: ^c.va_list) -> i8,
	CallByteMethodA:               proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, #by_ptr args: jvalue) -> i8,
	CallCharMethod:                proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, .. args: ..any) -> u16,
	CallCharMethodV:               proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, args: ^c.va_list) -> u16,
	CallCharMethodA:               proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, #by_ptr args: jvalue) -> u16,
	CallShortMethod:               proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, .. args: ..any) -> i16,
	CallShortMethodV:              proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, args: ^c.va_list) -> i16,
	CallShortMethodA:              proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, #by_ptr args: jvalue) -> i16,
	CallIntMethod:                 proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, .. args: ..any) -> i32,
	CallIntMethodV:                proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, args: ^c.va_list) -> i32,
	CallIntMethodA:                proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, #by_ptr args: jvalue) -> i32,
	CallLongMethod:                proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, .. args: ..any) -> i64,
	CallLongMethodV:               proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, args: ^c.va_list) -> i64,
	CallLongMethodA:               proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, #by_ptr args: jvalue) -> i64,
	CallFloatMethod:               proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, .. args: ..any) -> f32,
	CallFloatMethodV:              proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, args: ^c.va_list) -> f32,
	CallFloatMethodA:              proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, #by_ptr args: jvalue) -> f32,
	CallDoubleMethod:              proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, .. args: ..any) -> f64,
	CallDoubleMethodV:             proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, args: ^c.va_list) -> f64,
	CallDoubleMethodA:             proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, #by_ptr args: jvalue) -> f64,
	CallVoidMethod:                proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, .. args: ..any),
	CallVoidMethodV:               proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, args: ^c.va_list),
	CallVoidMethodA:               proc "c" (jni: ^^JNINativeInterface, obj: jobject, methodID: rawptr, #by_ptr args: jvalue),
	CallNonvirtualObjectMethod:    proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, .. args: ..any) -> jobject,
	CallNonvirtualObjectMethodV:   proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> jobject,
	CallNonvirtualObjectMethodA:   proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> jobject,
	CallNonvirtualBooleanMethod:   proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, .. args: ..any) -> u8,
	CallNonvirtualBooleanMethodV:  proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> u8,
	CallNonvirtualBooleanMethodA:  proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> u8,
	CallNonvirtualByteMethod:      proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, .. args: ..any) -> i8,
	CallNonvirtualByteMethodV:     proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> i8,
	CallNonvirtualByteMethodA:     proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> i8,
	CallNonvirtualCharMethod:      proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, .. args: ..any) -> u16,
	CallNonvirtualCharMethodV:     proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> u16,
	CallNonvirtualCharMethodA:     proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> u16,
	CallNonvirtualShortMethod:     proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, .. args: ..any) -> i16,
	CallNonvirtualShortMethodV:    proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> i16,
	CallNonvirtualShortMethodA:    proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> i16,
	CallNonvirtualIntMethod:       proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, .. args: ..any) -> i32,
	CallNonvirtualIntMethodV:      proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> i32,
	CallNonvirtualIntMethodA:      proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> i32,
	CallNonvirtualLongMethod:      proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, .. args: ..any) -> i64,
	CallNonvirtualLongMethodV:     proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> i64,
	CallNonvirtualLongMethodA:     proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> i64,
	CallNonvirtualFloatMethod:     proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, .. args: ..any) -> f32,
	CallNonvirtualFloatMethodV:    proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> f32,
	CallNonvirtualFloatMethodA:    proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> f32,
	CallNonvirtualDoubleMethod:    proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, .. args: ..any) -> f64,
	CallNonvirtualDoubleMethodV:   proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> f64,
	CallNonvirtualDoubleMethodA:   proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> f64,
	CallNonvirtualVoidMethod:      proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, .. args: ..any),
	CallNonvirtualVoidMethodV:     proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, args: ^c.va_list),
	CallNonvirtualVoidMethodA:     proc "c" (jni: ^^JNINativeInterface, obj: jobject, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue),
	GetFieldID:                    proc "c" (jni: ^^JNINativeInterface, clazz: jclass, name: cstring, sig: cstring) -> rawptr,
	GetObjectField:                proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr) -> jobject,
	GetBooleanField:               proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr) -> u8,
	GetByteField:                  proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr) -> i8,
	GetCharField:                  proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr) -> u16,
	GetShortField:                 proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr) -> i16,
	GetIntField:                   proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr) -> i32,
	GetLongField:                  proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr) -> i64,
	GetFloatField:                 proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr) -> f32,
	GetDoubleField:                proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr) -> f64,
	SetObjectField:                proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr, value: jobject),
	SetBooleanField:               proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr, value: u8),
	SetByteField:                  proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr, value: i8),
	SetCharField:                  proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr, value: u16),
	SetShortField:                 proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr, value: i16),
	SetIntField:                   proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr, value: i32),
	SetLongField:                  proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr, value: i64),
	SetFloatField:                 proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr, value: f32),
	SetDoubleField:                proc "c" (jni: ^^JNINativeInterface, obj: jobject, fieldID: rawptr, value: f64),
	GetStaticMethodID:             proc "c" (jni: ^^JNINativeInterface, clazz: jclass, name: cstring, sig: cstring) -> rawptr,
	CallStaticObjectMethod:        proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, .. args: ..any) -> jobject,
	CallStaticObjectMethodV:       proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> jobject,
	CallStaticObjectMethodA:       proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> jobject,
	CallStaticBooleanMethod:       proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, .. args: ..any) -> u8,
	CallStaticBooleanMethodV:      proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> u8,
	CallStaticBooleanMethodA:      proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> u8,
	CallStaticByteMethod:          proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, .. args: ..any) -> i8,
	CallStaticByteMethodV:         proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> i8,
	CallStaticByteMethodA:         proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> i8,
	CallStaticCharMethod:          proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, .. args: ..any) -> u16,
	CallStaticCharMethodV:         proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> u16,
	CallStaticCharMethodA:         proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> u16,
	CallStaticShortMethod:         proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, .. args: ..any) -> i16,
	CallStaticShortMethodV:        proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> i16,
	CallStaticShortMethodA:        proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> i16,
	CallStaticIntMethod:           proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, .. args: ..any) -> i32,
	CallStaticIntMethodV:          proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> i32,
	CallStaticIntMethodA:          proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> i32,
	CallStaticLongMethod:          proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, .. args: ..any) -> i64,
	CallStaticLongMethodV:         proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> i64,
	CallStaticLongMethodA:         proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> i64,
	CallStaticFloatMethod:         proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, .. args: ..any) -> f32,
	CallStaticFloatMethodV:        proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> f32,
	CallStaticFloatMethodA:        proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> f32,
	CallStaticDoubleMethod:        proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, .. args: ..any) -> f64,
	CallStaticDoubleMethodV:       proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, args: ^c.va_list) -> f64,
	CallStaticDoubleMethodA:       proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue) -> f64,
	CallStaticVoidMethod:          proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, .. args: ..any),
	CallStaticVoidMethodV:         proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, args: ^c.va_list),
	CallStaticVoidMethodA:         proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methodID: rawptr, #by_ptr args: jvalue),
	GetStaticFieldID:              proc "c" (jni: ^^JNINativeInterface, clazz: jclass, name: cstring, sig: cstring) -> rawptr,
	GetStaticObjectField:          proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr) -> jobject,
	GetStaticBooleanField:         proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr) -> u8,
	GetStaticByteField:            proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr) -> i8,
	GetStaticCharField:            proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr) -> u16,
	GetStaticShortField:           proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr) -> i16,
	GetStaticIntField:             proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr) -> i32,
	GetStaticLongField:            proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr) -> i64,
	GetStaticFloatField:           proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr) -> f32,
	GetStaticDoubleField:          proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr) -> f64,
	SetStaticObjectField:          proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr, value: jobject),
	SetStaticBooleanField:         proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr, value: u8),
	SetStaticByteField:            proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr, value: i8),
	SetStaticCharField:            proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr, value: u16),
	SetStaticShortField:           proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr, value: i16),
	SetStaticIntField:             proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr, value: i32),
	SetStaticLongField:            proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr, value: i64),
	SetStaticFloatField:           proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr, value: f32),
	SetStaticDoubleField:          proc "c" (jni: ^^JNINativeInterface, clazz: jclass, fieldID: rawptr, value: f64),
	NewString:                     proc "c" (jni: ^^JNINativeInterface, unicodeChars: [^]u16, len: i32) -> jstring,
	GetStringLength:               proc "c" (jni: ^^JNINativeInterface, str: jstring) -> i32,
	GetStringChars:                proc "c" (jni: ^^JNINativeInterface, str: jstring, isCopy: ^u8) -> [^]u16,
	ReleaseStringChars:            proc "c" (jni: ^^JNINativeInterface, str: jstring, chars: [^]u16),
	NewStringUTF:                  proc "c" (jni: ^^JNINativeInterface, bytes: cstring) -> jstring,
	GetStringUTFLength:            proc "c" (jni: ^^JNINativeInterface, str: jstring) -> i32,
	// JNI spec says this returns const jbyte*, but that's inconsistent 
	GetStringUTFChars:             proc "c" (jni: ^^JNINativeInterface, str: jstring, isCopy: ^u8) -> cstring,
	ReleaseStringUTFChars:         proc "c" (jni: ^^JNINativeInterface, str: jstring, utf: cstring),
	GetArrayLength:                proc "c" (jni: ^^JNINativeInterface, array: jarray) -> i32,
	NewObjectArray:                proc "c" (jni: ^^JNINativeInterface, length: i32, elementClass: jclass, initialElement: jobject) -> jobjectArray,
	GetObjectArrayElement:         proc "c" (jni: ^^JNINativeInterface, array: jobjectArray, index: i32) -> jobject,
	SetObjectArrayElement:         proc "c" (jni: ^^JNINativeInterface, array: jobjectArray, index: i32, value: jobject),
	NewBooleanArray:               proc "c" (jni: ^^JNINativeInterface, length: i32) -> jbooleanArray,
	NewByteArray:                  proc "c" (jni: ^^JNINativeInterface, length: i32) -> jbyteArray,
	NewCharArray:                  proc "c" (jni: ^^JNINativeInterface, length: i32) -> jcharArray,
	NewShortArray:                 proc "c" (jni: ^^JNINativeInterface, length: i32) -> jshortArray,
	NewIntArray:                   proc "c" (jni: ^^JNINativeInterface, length: i32) -> jintArray,
	NewLongArray:                  proc "c" (jni: ^^JNINativeInterface, length: i32) -> jlongArray,
	NewFloatArray:                 proc "c" (jni: ^^JNINativeInterface, length: i32) -> jfloatArray,
	NewDoubleArray:                proc "c" (jni: ^^JNINativeInterface, length: i32) -> jdoubleArray,
	GetBooleanArrayElements:       proc "c" (jni: ^^JNINativeInterface, array: jbooleanArray, isCopy: ^u8) -> [^]u8,
	GetByteArrayElements:          proc "c" (jni: ^^JNINativeInterface, array: jbyteArray, isCopy: ^u8) -> [^]i8,
	GetCharArrayElements:          proc "c" (jni: ^^JNINativeInterface, array: jcharArray, isCopy: ^u8) -> [^]u16,
	GetShortArrayElements:         proc "c" (jni: ^^JNINativeInterface, array: jshortArray, isCopy: ^u8) -> [^]i16,
	GetIntArrayElements:           proc "c" (jni: ^^JNINativeInterface, array: jintArray, isCopy: ^u8) -> [^]i32,
	GetLongArrayElements:          proc "c" (jni: ^^JNINativeInterface, array: jlongArray, isCopy: ^u8) -> [^]i64,
	GetFloatArrayElements:         proc "c" (jni: ^^JNINativeInterface, array: jfloatArray, isCopy: ^u8) -> [^]f32,
	GetDoubleArrayElements:        proc "c" (jni: ^^JNINativeInterface, array: jdoubleArray, isCopy: ^u8) -> [^]f64,
	ReleaseBooleanArrayElements:   proc "c" (jni: ^^JNINativeInterface, array: jbooleanArray, elems: [^]u8, mode: i32),
	ReleaseByteArrayElements:      proc "c" (jni: ^^JNINativeInterface, array: jbyteArray, elems: [^]i8, mode: i32),
	ReleaseCharArrayElements:      proc "c" (jni: ^^JNINativeInterface, array: jcharArray, elems: [^]u16, mode: i32),
	ReleaseShortArrayElements:     proc "c" (jni: ^^JNINativeInterface, array: jshortArray, elems: [^]i16, mode: i32),
	ReleaseIntArrayElements:       proc "c" (jni: ^^JNINativeInterface, array: jintArray, elems: [^]i32, mode: i32),
	ReleaseLongArrayElements:      proc "c" (jni: ^^JNINativeInterface, array: jlongArray, elems: [^]i64, mode: i32),
	ReleaseFloatArrayElements:     proc "c" (jni: ^^JNINativeInterface, array: jfloatArray, elems: [^]f32, mode: i32),
	ReleaseDoubleArrayElements:    proc "c" (jni: ^^JNINativeInterface, array: jdoubleArray, elems: [^]f64, mode: i32),
	GetBooleanArrayRegion:         proc "c" (jni: ^^JNINativeInterface, array: jbooleanArray, start: i32, len: i32, buf: [^]u8),
	GetByteArrayRegion:            proc "c" (jni: ^^JNINativeInterface, array: jbyteArray, start: i32, len: i32, buf: [^]i8),
	GetCharArrayRegion:            proc "c" (jni: ^^JNINativeInterface, array: jcharArray, start: i32, len: i32, buf: [^]u16),
	GetShortArrayRegion:           proc "c" (jni: ^^JNINativeInterface, array: jshortArray, start: i32, len: i32, buf: [^]i16),
	GetIntArrayRegion:             proc "c" (jni: ^^JNINativeInterface, array: jintArray, start: i32, len: i32, buf: [^]i32),
	GetLongArrayRegion:            proc "c" (jni: ^^JNINativeInterface, array: jlongArray, start: i32, len: i32, buf: [^]i64),
	GetFloatArrayRegion:           proc "c" (jni: ^^JNINativeInterface, array: jfloatArray, start: i32, len: i32, buf: [^]f32),
	GetDoubleArrayRegion:          proc "c" (jni: ^^JNINativeInterface, array: jdoubleArray, start: i32, len: i32, buf: [^]f64),
	// spec shows these without const, some jni.h do, some don't 
	SetBooleanArrayRegion:         proc "c" (jni: ^^JNINativeInterface, array: jbooleanArray, start: i32, len: i32, buf: [^]u8),
	SetByteArrayRegion:            proc "c" (jni: ^^JNINativeInterface, array: jbyteArray, start: i32, len: i32, buf: [^]i8),
	SetCharArrayRegion:            proc "c" (jni: ^^JNINativeInterface, array: jcharArray, start: i32, len: i32, buf: [^]u16),
	SetShortArrayRegion:           proc "c" (jni: ^^JNINativeInterface, array: jshortArray, start: i32, len: i32, buf: [^]i16),
	SetIntArrayRegion:             proc "c" (jni: ^^JNINativeInterface, array: jintArray, start: i32, len: i32, buf: [^]i32),
	SetLongArrayRegion:            proc "c" (jni: ^^JNINativeInterface, array: jlongArray, start: i32, len: i32, buf: [^]i64),
	SetFloatArrayRegion:           proc "c" (jni: ^^JNINativeInterface, array: jfloatArray, start: i32, len: i32, buf: [^]f32),
	SetDoubleArrayRegion:          proc "c" (jni: ^^JNINativeInterface, array: jdoubleArray, start: i32, len: i32, buf: [^]f64),
	RegisterNatives:               proc "c" (jni: ^^JNINativeInterface, clazz: jclass, methods: [^]JNINativeMethod, nMethods: i32) -> i32,
	UnregisterNatives:             proc "c" (jni: ^^JNINativeInterface, clazz: jclass) -> i32,
	MonitorEnter:                  proc "c" (jni: ^^JNINativeInterface, obj: jobject) -> i32,
	MonitorExit:                   proc "c" (jni: ^^JNINativeInterface, obj: jobject) -> i32,
	GetJavaVM:                     proc "c" (jni: ^^JNINativeInterface, vm: ^^^JNIInvokeInterface) -> i32,
	GetStringRegion:               proc "c" (jni: ^^JNINativeInterface, str: jstring, start: i32, len: i32, buf: [^]u16),
	GetStringUTFRegion:            proc "c" (jni: ^^JNINativeInterface, str: jstring, start: i32, len: i32, buf: [^]u8),
	GetPrimitiveArrayCritical:     proc "c" (jni: ^^JNINativeInterface, array: jarray, isCopy: ^u8) -> rawptr,
	ReleasePrimitiveArrayCritical: proc "c" (jni: ^^JNINativeInterface, array: jarray, carray: rawptr, mode: i32),
	GetStringCritical:             proc "c" (jni: ^^JNINativeInterface, str: jstring, isCopy: ^u8) -> [^]u16,
	ReleaseStringCritical:         proc "c" (jni: ^^JNINativeInterface, str: jstring, carray: [^]u16),
	NewWeakGlobalRef:              proc "c" (jni: ^^JNINativeInterface, obj: jobject) -> jweak,
	DeleteWeakGlobalRef:           proc "c" (jni: ^^JNINativeInterface, obj: jweak),
	ExceptionCheck:                proc "c" (jni: ^^JNINativeInterface),
	NewDirectByteBuffer:           proc "c" (jni: ^^JNINativeInterface, address: rawptr, capacity: i64) -> jobject,
	GetDirectBufferAddress:        proc "c" (jni: ^^JNINativeInterface, buf: jobject) -> rawptr,
	GetDirectBufferCapacity:       proc "c" (jni: ^^JNINativeInterface, buf: jobject) -> i64,
	// added in JNI 1.6 
	GetObjectRefType:              proc "c" (jni: ^^JNINativeInterface, obj: jobject) -> jobjectRefType,
}