Native code

func App() ui.Node {
	count := signal.New(3)
	return ui.SafeArea(ui.Style{Padding: ui.All(20), Gap: 16},
		ui.Native("Stepper", ui.NativeProps{
			Props: map[string]any{"value": count, "max": 10},
			On: map[string]func(ui.NativeEvent){
				"changed": func(e ui.NativeEvent) { count.Set(int(e.Int("value"))) },
			},
		}),
		ui.Text(signal.Func(func() string { return fmt.Sprint("Count: ", count.Get()) })),
		ui.Button(ui.ButtonProps{Title: ui.Val("Reset"), OnPress: func() { count.Set(0) }}),
	)
}

func Call(module, method string, args []byte, done func(result []byte, err error))
func CallWait(module, method string, args []byte) ([]byte, error)

@MainActor public protocol AsukaNativeView: AnyObject {
    var view: UIView { get }
    func set(_ name: String, _ value: AsukaNativeValue)
}

ctx.emit("changed", ["value": .int(3)])

@objc(AsukaAppNatives) final class AppNatives: NSObject, AsukaNativeModule {
    @MainActor static func register() {
        AsukaRuntime.shared.registerNative("Stepper") { ctx in Stepper(ctx) }
    }
}

public typealias AsukaModuleMethod = (_ args: Data, _ reply: @escaping (Result<Data, Error>) -> Void) -> Void

interface AsukaNativeView {
    val view: View
    fun set(name: String, value: Any)
}

package dev.asuka.app

import dev.asuka.AsukaNativeModule
import dev.asuka.AsukaRuntime

object AsukaAppNatives : AsukaNativeModule {
    override fun register(runtime: AsukaRuntime) {
        runtime.registerNative("Stepper") { ctx -> Stepper(ctx) }
    }
}

typealias AsukaModuleMethod = (args: ByteArray, reply: (Result<ByteArray>) -> Unit) -> Unit

@MainActor public protocol AsukaNativeView: AnyObject {
    var view: NSView { get }
    func set(_ name: String, _ value: AsukaNativeValue)
    func sizeThatFits(_ size: CGSize) -> CGSize // default: view.fittingSize
    func destroy()                              // default: nothing
}

//go:build darwin && !ios

package main

import "github.com/egoist/asuka/native"

func init() {
	native.RegisterView("Stepper", newStepper)
	native.RegisterModule("battery", native.Module{"level": batteryLevel})
}

type View interface {
	Handle() uintptr
	Set(name string, value any)
}

type Module map[string]func(args []byte, reply func(result []byte, err error))

package main

import (
	"encoding/json"
	"fmt"

	"github.com/egoist/asuka/app"
	"github.com/egoist/asuka/signal"
	"github.com/egoist/asuka/ui"
)

// Battery is what the app's battery module reports.
type Battery struct {
	Level    float64 `json:"level"` // 0 to 1
	Charging bool    `json:"charging"`
}

// ReadBattery asks the module; done runs on the main thread.
func ReadBattery(done func(Battery, error)) {
	ui.Call("battery", "level", nil, func(b []byte, err error) {
		var v Battery
		if err == nil {
			err = json.Unmarshal(b, &v)
		}
		done(v, err)
	})
}

func App() ui.Node {
	count := signal.New(3)
	status := signal.New("")
	return ui.SafeArea(ui.Style{Padding: ui.All(20), Gap: 16},
		ui.Native("Stepper", ui.NativeProps{
			Props: map[string]any{"value": count, "max": 10},
			On: map[string]func(ui.NativeEvent){
				"changed": func(e ui.NativeEvent) { count.Set(int(e.Int("value"))) },
			},
			Style: ui.Style{AlignSelf: ui.AlignStart}, // its own size, not the column's width
		}),
		ui.Text(signal.Func(func() string { return fmt.Sprint("Count: ", count.Get()) })),
		ui.Button(ui.ButtonProps{Title: ui.Val("Battery"), OnPress: func() {
			ReadBattery(func(b Battery, err error) {
				if err != nil {
					status.Set(err.Error())
					return
				}
				status.Set(fmt.Sprintf("%.0f%%, charging: %v", b.Level*100, b.Charging))
			})
		}}),
		ui.Text(status),
	)
}

func main() { app.Run(App) }

go func() {
	b, err := ui.CallWait("battery", "level", nil)
	var v Battery
	if err == nil {
		err = json.Unmarshal(b, &v)
	}
	ui.Post(func() {
		if err != nil {
			status.Set(err.Error())
			return
		}
		status.Set(fmt.Sprintf("%.0f%%", v.Level*100))
	})
}()

import UIKit

@objc(AsukaAppNatives) final class AppNatives: NSObject, AsukaNativeModule {
    @MainActor static func register() {
        AsukaRuntime.shared.registerNative("Stepper") { ctx in Stepper(ctx) }
        AsukaRuntime.shared.registerModule("battery", [
            "level": { _, reply in
                let device = UIDevice.current
                device.isBatteryMonitoringEnabled = true
                guard device.batteryLevel >= 0 else {
                    reply(.failure(BatteryError()))
                    return
                }
                let info: [String: Any] = [
                    "level": Double(device.batteryLevel),
                    "charging": device.batteryState == .charging || device.batteryState == .full,
                ]
                reply(Result { try JSONSerialization.data(withJSONObject: info) })
            },
        ])
    }
}

struct BatteryError: LocalizedError {
    var errorDescription: String? { "no battery level (the simulator has none)" }
}

/// A UIStepper: props "value" and "max"; event "changed" with "value".
@MainActor final class Stepper: AsukaNativeView {
    let stepper = UIStepper()
    var view: UIView { stepper }
    private var wanted = 0.0

    init(_ ctx: AsukaNativeContext) {
        stepper.addAction(UIAction { [weak self] _ in
            guard let self else { return }
            wanted = stepper.value
            ctx.emit("changed", ["value": .int(Int64(stepper.value))])
        }, for: .valueChanged)
    }

    func set(_ name: String, _ value: AsukaNativeValue) {
        switch name {
        case "value": wanted = value.float
        case "max": stepper.maximumValue = value.float
        default: return
        }
        // Props come in no set order: max may follow value.
        stepper.value = wanted
    }
}

package dev.asuka.app

import android.content.Context
import android.os.BatteryManager
import android.view.View
import android.widget.NumberPicker
import dev.asuka.AsukaModuleMethod
import dev.asuka.AsukaNativeContext
import dev.asuka.AsukaNativeModule
import dev.asuka.AsukaNativeView
import dev.asuka.AsukaRuntime
import dev.asuka.registerModule
import org.json.JSONObject

object AsukaAppNatives : AsukaNativeModule {
    override fun register(runtime: AsukaRuntime) {
        runtime.registerNative("Stepper") { ctx -> Stepper(ctx) }
        val level: AsukaModuleMethod = { _, reply ->
            val bm = runtime.app.getSystemService(Context.BATTERY_SERVICE) as BatteryManager
            val info = JSONObject()
                .put("level", bm.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY) / 100.0)
                .put("charging", bm.isCharging)
            reply(Result.success(info.toString().toByteArray()))
        }
        runtime.registerModule("battery", mapOf("level" to level))
    }
}

/** A NumberPicker: props "value" and "max"; event "changed" with "value". */
class Stepper(ctx: AsukaNativeContext) : AsukaNativeView {
    private val picker = NumberPicker(ctx.context)
    override val view: View get() = picker
    private var wanted = 0

    init {
        picker.setOnValueChangedListener { _, _, v ->
            wanted = v
            ctx.emit("changed", mapOf("value" to v.toLong()))
        }
    }

    override fun set(name: String, value: Any) {
        when (name) {
            "value" -> wanted = (value as Long).toInt()
            "max" -> picker.maxValue = (value as Long).toInt()
            else -> return
        }
        // Props come in no set order: max may follow value.
        picker.value = wanted
    }
}

import AppKit
import IOKit.ps

@objc(AsukaAppNatives) final class AppNatives: NSObject, AsukaNativeModule {
    @MainActor static func register() {
        AsukaRuntime.shared.registerNative("Stepper") { ctx in Stepper(ctx) }
        AsukaRuntime.shared.registerModule("battery", [
            "level": { _, reply in
                let info = IOPSCopyPowerSourcesInfo().takeRetainedValue()
                let sources = IOPSCopyPowerSourcesList(info).takeRetainedValue() as [CFTypeRef]
                for source in sources {
                    guard let d = IOPSGetPowerSourceDescription(info, source)?.takeUnretainedValue() as? [String: Any],
                          d[kIOPSTypeKey] as? String == kIOPSInternalBatteryType,
                          let now = d[kIOPSCurrentCapacityKey] as? Int,
                          let max = d[kIOPSMaxCapacityKey] as? Int, max > 0
                    else { continue }
                    let battery: [String: Any] = [
                        "level": Double(now) / Double(max),
                        "charging": d[kIOPSIsChargingKey] as? Bool ?? false,
                    ]
                    reply(Result { try JSONSerialization.data(withJSONObject: battery) })
                    return
                }
                reply(.failure(BatteryError()))
            },
        ])
    }
}

struct BatteryError: LocalizedError {
    var errorDescription: String? { "this Mac has no battery" }
}

/// An NSStepper: props "value" and "max"; event "changed" with "value".
@MainActor final class Stepper: NSObject, AsukaNativeView {
    let stepper = NSStepper()
    var view: NSView { stepper }
    private let ctx: AsukaNativeContext
    private var wanted = 0.0

    init(_ ctx: AsukaNativeContext) {
        self.ctx = ctx
        super.init()
        stepper.target = self
        stepper.action = #selector(changed)
    }

    // The control's action: the user stepped it.
    @objc private func changed() {
        wanted = stepper.doubleValue
        ctx.emit("changed", ["value": .int(Int64(stepper.integerValue))])
    }

    func set(_ name: String, _ value: AsukaNativeValue) {
        switch name {
        case "value": wanted = value.float
        case "max": stepper.maxValue = value.float
        default: return
        }
        // Props come in no set order: max may follow value.
        stepper.doubleValue = wanted
    }
}

//go:build darwin && !ios

package main

import (
	"encoding/json"
	"errors"

	"github.com/ebitengine/purego"
	"github.com/ebitengine/purego/objc"
	"github.com/egoist/asuka/native"
)

func init() {
	native.RegisterView("Stepper", newStepper)
	native.RegisterModule("battery", native.Module{"level": batteryLevel})
}

var sel = objc.RegisterName

// stepper is an NSStepper: props "value" and "max"; event "changed" with
// "value".
type stepper struct {
	ctx    native.Context
	view   objc.ID
	wanted int64
}

// steppers are the steppers shown, by their NSStepper: the action's
// sender.
var steppers = map[objc.ID]*stepper{}

// target is the steppers' target: an object of a class of the app's,
// whose changed: is their action.
var target objc.ID

func newStepper(ctx native.Context) native.View {
	if target == 0 {
		cls, err := objc.RegisterClass("AppStepperTarget", objc.GetClass("NSObject"), nil, nil, []objc.MethodDef{{
			Cmd: sel("changed:"),
			Fn: func(self objc.ID, cmd objc.SEL, sender objc.ID) {
				if s := steppers[sender]; s != nil {
					s.wanted = objc.Send[int64](sender, sel("integerValue"))
					s.ctx.Emit("changed", map[string]any{"value": s.wanted})
				}
			},
		}})
		if err != nil {
			panic(err)
		}
		target = objc.ID(cls).Send(sel("new"))
	}
	v := objc.ID(objc.GetClass("NSStepper")).Send(sel("new"))
	v.Send(sel("setTarget:"), target)
	v.Send(sel("setAction:"), sel("changed:"))
	s := &stepper{ctx: ctx, view: v}
	steppers[v] = s
	return s
}

func (s *stepper) Handle() uintptr { return uintptr(s.view) }

func (s *stepper) Set(name string, value any) {
	n, _ := value.(int64)
	switch name {
	case "value":
		s.wanted = n
	case "max":
		s.view.Send(sel("setMaxValue:"), float64(n))
	default:
		return
	}
	// Props come in no set order: max may follow value.
	s.view.Send(sel("setIntegerValue:"), s.wanted)
}

// Destroy lets the NSStepper go: new made it, its superview holds it
// until the host removes it.
func (s *stepper) Destroy() {
	delete(steppers, s.view)
	s.view.Send(sel("release"))
}

// IOKit's power sources, and CoreFoundation's CFRelease.
var (
	copyPowerSourcesInfo func() uintptr
	copyPowerSourcesList func(blob uintptr) uintptr
	powerSourceInfo      func(blob, source uintptr) uintptr
	cfRelease            func(uintptr)
)

func batteryLevel(_ []byte, reply func([]byte, error)) {
	if copyPowerSourcesInfo == nil {
		iokit, err := purego.Dlopen("/System/Library/Frameworks/IOKit.framework/IOKit", purego.RTLD_NOW|purego.RTLD_GLOBAL)
		if err != nil {
			reply(nil, err)
			return
		}
		cf, err := purego.Dlopen("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation", purego.RTLD_NOW|purego.RTLD_GLOBAL)
		if err != nil {
			reply(nil, err)
			return
		}
		purego.RegisterLibFunc(&copyPowerSourcesInfo, iokit, "IOPSCopyPowerSourcesInfo")
		purego.RegisterLibFunc(&copyPowerSourcesList, iokit, "IOPSCopyPowerSourcesList")
		purego.RegisterLibFunc(&powerSourceInfo, iokit, "IOPSGetPowerSourceDescription")
		purego.RegisterLibFunc(&cfRelease, cf, "CFRelease")
	}
	blob := copyPowerSourcesInfo()
	defer cfRelease(blob)
	list := objc.ID(copyPowerSourcesList(blob)) // a CFArray: an NSArray
	defer cfRelease(uintptr(list))
	for i := range objc.Send[int](list, sel("count")) {
		info := objc.ID(powerSourceInfo(blob, uintptr(list.Send(sel("objectAtIndex:"), i)))) // an NSDictionary
		get := func(key string) objc.ID {
			k := objc.ID(objc.GetClass("NSString")).Send(sel("alloc")).Send(sel("initWithUTF8String:"), key)
			defer k.Send(sel("release"))
			return info.Send(sel("objectForKey:"), k)
		}
		cur, max := get("Current Capacity"), get("Max Capacity")
		if cur == 0 || max == 0 {
			continue
		}
		level := objc.Send[float64](cur, sel("doubleValue")) / objc.Send[float64](max, sel("doubleValue"))
		charging := objc.Send[bool](get("Is Charging"), sel("boolValue"))
		reply(json.Marshal(map[string]any{"level": level, "charging": charging}))
		return
	}
	reply(nil, errors.New("this Mac has no battery"))
}

//go:build windows

package main

import (
	"encoding/json"
	"errors"
	"syscall"
	"unsafe"

	"github.com/egoist/asuka/native"
)

func init() {
	native.RegisterView("Stepper", newStepper)
	native.RegisterModule("battery", native.Module{"level": batteryLevel})
}

var (
	user32               = syscall.NewLazyDLL("user32.dll")
	kernel32             = syscall.NewLazyDLL("kernel32.dll")
	createWindowEx       = user32.NewProc("CreateWindowExW")
	sendMessage          = user32.NewProc("SendMessageW")
	getSystemPowerStatus = kernel32.NewProc("GetSystemPowerStatus")
)

const (
	wsChild       = 0x40000000
	wsVisible     = 0x10000000
	wmVScroll     = 0x0115
	sbThumbPos    = 4
	udmSetRange32 = 0x0400 + 111
	udmSetPos32   = 0x0400 + 113
	udmGetPos32   = 0x0400 + 114
)

// stepper is an up-down control: props "value" and "max"; event
// "changed" with "value".
type stepper struct {
	ctx    native.Context
	hwnd   uintptr
	wanted int64
	max    int64
}

func newStepper(ctx native.Context) native.View {
	class, _ := syscall.UTF16PtrFromString("msctls_updown32")
	// A child window is made in its parent: the context's.
	hwnd, _, _ := createWindowEx.Call(0, uintptr(unsafe.Pointer(class)), 0,
		wsChild|wsVisible, 0, 0, 0, 0, ctx.Parent(), 0, 0, 0)
	return &stepper{ctx: ctx, hwnd: hwnd, max: 100}
}

func (s *stepper) Handle() uintptr { return s.hwnd }

func (s *stepper) Set(name string, value any) {
	n, _ := value.(int64)
	switch name {
	case "value":
		s.wanted = n
	case "max":
		s.max = n
	default:
		return
	}
	// Props come in no set order: max may follow value.
	sendMessage.Call(s.hwnd, udmSetRange32, 0, uintptr(s.max))
	sendMessage.Call(s.hwnd, udmSetPos32, 0, uintptr(s.wanted))
}

// Measure is the stepper's size, in points: a child window has none the
// host can ask for.
func (s *stepper) Measure(w, h float32) (float32, float32) { return 20, 32 }

// ParentMessage hears what the up-down tells its parent: WM_VSCROLL, as
// its value changes.
func (s *stepper) ParentMessage(msg uint32, wparam, lparam uintptr) (uintptr, bool) {
	if msg != wmVScroll || lparam != s.hwnd || wparam&0xffff != sbThumbPos {
		return 0, false
	}
	pos, _, _ := sendMessage.Call(s.hwnd, udmGetPos32, 0, 0)
	s.ctx.Emit("changed", map[string]any{"value": int64(int32(pos))})
	return 0, true
}

func batteryLevel(_ []byte, reply func([]byte, error)) {
	var st struct {
		ACLineStatus, BatteryFlag, BatteryLifePercent, SystemStatusFlag byte
		BatteryLifeTime, BatteryFullLifeTime                            uint32
	}
	if r, _, err := getSystemPowerStatus.Call(uintptr(unsafe.Pointer(&st))); r == 0 {
		reply(nil, err)
		return
	}
	if st.BatteryFlag&128 != 0 || st.BatteryLifePercent > 100 { // no battery, or unknown
		reply(nil, errors.New("this PC has no battery"))
		return
	}
	reply(json.Marshal(map[string]any{
		"level":    float64(st.BatteryLifePercent) / 100,
		"charging": st.BatteryFlag&8 != 0,
	}))
}

//go:build linux && !android

package main

import (
	"encoding/json"
	"errors"
	"os"
	"path/filepath"
	"strconv"
	"strings"

	"github.com/ebitengine/purego"
	"github.com/egoist/asuka/native"
)

func init() {
	native.RegisterView("Stepper", newStepper)
	native.RegisterModule("battery", native.Module{"level": batteryLevel})
}

// GTK 4 and GObject, which the host has loaded.
var (
	spinButtonNew   func(min, max, step float64) uintptr
	spinButtonSet   func(spin uintptr, value float64)
	spinButtonGet   func(spin uintptr) int32
	spinButtonRange func(spin uintptr, min, max float64)
	signalConnect   func(instance uintptr, signal string, handler, data, destroy uintptr, flags uint32) uint64
	onValueChanged  uintptr // the callback every stepper's value-changed calls
	steppers        = map[uintptr]*stepper{}
)

func loadGTK() {
	gtk, err := purego.Dlopen("libgtk-4.so.1", purego.RTLD_NOW|purego.RTLD_GLOBAL)
	if err != nil {
		panic(err)
	}
	gobject, err := purego.Dlopen("libgobject-2.0.so.0", purego.RTLD_NOW|purego.RTLD_GLOBAL)
	if err != nil {
		panic(err)
	}
	purego.RegisterLibFunc(&spinButtonNew, gtk, "gtk_spin_button_new_with_range")
	purego.RegisterLibFunc(&spinButtonSet, gtk, "gtk_spin_button_set_value")
	purego.RegisterLibFunc(&spinButtonGet, gtk, "gtk_spin_button_get_value_as_int")
	purego.RegisterLibFunc(&spinButtonRange, gtk, "gtk_spin_button_set_range")
	purego.RegisterLibFunc(&signalConnect, gobject, "g_signal_connect_data")
	// One callback for all: purego's callbacks are never freed.
	onValueChanged = purego.NewCallback(func(spin, data uintptr) uintptr {
		if s := steppers[spin]; s != nil && !s.setting {
			s.ctx.Emit("changed", map[string]any{"value": int64(spinButtonGet(spin))})
		}
		return 0
	})
}

// stepper is a GtkSpinButton: props "value" and "max"; event "changed"
// with "value".
type stepper struct {
	ctx     native.Context
	spin    uintptr
	wanted  int64
	max     int64
	setting bool // GTK emits value-changed for a value set in code too
}

func newStepper(ctx native.Context) native.View {
	if spinButtonNew == nil {
		loadGTK()
	}
	s := &stepper{ctx: ctx, spin: spinButtonNew(0, 100, 1), max: 100}
	signalConnect(s.spin, "value-changed", onValueChanged, 0, 0, 0)
	steppers[s.spin] = s
	return s
}

func (s *stepper) Handle() uintptr { return s.spin }

func (s *stepper) Set(name string, value any) {
	n, _ := value.(int64)
	switch name {
	case "value":
		s.wanted = n
	case "max":
		s.max = n
	default:
		return
	}
	// Props come in no set order: max may follow value.
	s.setting = true
	spinButtonRange(s.spin, 0, float64(s.max))
	spinButtonSet(s.spin, float64(s.wanted))
	s.setting = false
}

// Destroy forgets the stepper; the host destroys the widget.
func (s *stepper) Destroy() { delete(steppers, s.spin) }

func batteryLevel(_ []byte, reply func([]byte, error)) {
	dirs, _ := filepath.Glob("/sys/class/power_supply/BAT*")
	for _, d := range dirs {
		capacity, err := os.ReadFile(filepath.Join(d, "capacity"))
		if err != nil {
			continue
		}
		percent, err := strconv.Atoi(strings.TrimSpace(string(capacity)))
		if err != nil {
			continue
		}
		status, _ := os.ReadFile(filepath.Join(d, "status"))
		charging := strings.TrimSpace(string(status)) == "Charging"
		reply(json.Marshal(map[string]any{"level": float64(percent) / 100, "charging": charging}))
		return
	}
	reply(nil, errors.New("this computer has no battery"))
}