@geastack/apple 0.2.8

package/targets/macos/main/macos_sensors.cpp

@@ -0,0 +1,148 @@
+#include "imu.h"
+#include "memory.h"
+#include "power.h"
+#include "touch.h"
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOKit/ps/IOPSKeys.h>
+#include <IOKit/ps/IOPowerSources.h>
+
+#include <cstdint>
+
+// macOS doesn't have an IMU; stubs let host/imu.cpp link. Tilt is fixed at 0.
+namespace gea::platform::sensors {
+
+void Accelerometer::init() {}
+void Accelerometer::close() {}
+void Accelerometer::calibrateBias() {}
+int Accelerometer::tiltX() { return 0; }
+int Accelerometer::tiltY() { return 0; }
+double Accelerometer::accelerationX() { return 0.0; }
+double Accelerometer::accelerationY() { return 0.0; }
+double Accelerometer::accelerationZ() { return 9.80665; }  // gravity, plate flat
+double Accelerometer::gyroscopeX() { return 0.0; }
+double Accelerometer::gyroscopeY() { return 0.0; }
+double Accelerometer::gyroscopeZ() { return 0.0; }
+void Accelerometer::setWebTilt(int, int) {}
+
+}  // namespace gea::platform::sensors
+
+// Memory diagnostics — stub everything to zeros. macOS has plenty of RAM
+// and the diagnostics views just show "0" for the embedded-only metrics.
+namespace gea::platform::memory {
+
+std::uint32_t Memory::internalFree() { return 0; }
+std::uint32_t Memory::internalLargestFreeBlock() { return 0; }
+std::uint32_t Memory::internalMinimumFree() { return 0; }
+std::uint32_t Memory::psramFree() { return 0; }
+std::uint32_t Memory::currentTaskStackHighWaterMark() { return 0; }
+std::uint32_t Memory::geaMainStackBytes() { return 0; }
+std::uint32_t Memory::geaInitStackBytes() { return 0; }
+std::uint32_t Memory::appFrameStackWords() { return 0; }
+std::uint32_t Memory::appFrameStackBytes() { return 0; }
+std::uint32_t Memory::displayFlushConfiguredRows() { return 0; }
+std::uint32_t Memory::displayFlushConfiguredDepth() { return 0; }
+std::uint32_t Memory::displayFlushBufferMaxBytes() { return 0; }
+std::uint32_t Memory::displayFlushRows() { return 0; }
+std::uint32_t Memory::displayFlushDepth() { return 0; }
+std::uint32_t Memory::displayFlushBufferBytes() { return 0; }
+
+// No internal/external split here, so there is nothing to hold back for the
+// display; the caller treats nullptr as "no reserve" and carries on.
+void *Memory::reserveInternalDma(std::size_t) { return nullptr; }
+void Memory::releaseInternalDma(void *) {}
+}  // namespace gea::platform::memory
+
+// Touch is driven by AppKit mouse events (GeaCanvasView dispatches them as
+// touch events, mirroring the iOS renderer's gea_ios_touch_set_state flow).
+// The mouse handler keeps this cache current so the frame loop's Move
+// dispatch — which re-reads coordinates via consumeLatestMove — and
+// immediate-mode apps polling read()/readCached() see the real pointer.
+// Coordinates are PANEL-NATIVE, matching the hardware touch controllers
+// (TouchRuntime::transformTouchToLogical maps them back to logical space).
+namespace gea::platform::touch {
+
+namespace {
+bool g_touching = false;
+int g_touch_x = 0;
+int g_touch_y = 0;
+}  // namespace
+
+extern "C" void gea_macos_touch_set_state(int touching, int x, int y)
+{
+	g_touching = touching != 0;
+	g_touch_x = x;
+	g_touch_y = y;
+}
+
+void Touchscreen::setObserver(Observer) {}
+bool Touchscreen::init() { return true; }
+int Touchscreen::read(int *x, int *y)
+{
+	if (x) *x = g_touch_x;
+	if (y) *y = g_touch_y;
+	return g_touching ? 1 : 0;
+}
+int Touchscreen::readCached(int *x, int *y)
+{
+	if (x) *x = g_touch_x;
+	if (y) *y = g_touch_y;
+	return g_touching ? 1 : 0;
+}
+void Touchscreen::consumeLatestMove(int *x, int *y)
+{
+	if (x) *x = g_touch_x;
+	if (y) *y = g_touch_y;
+}
+
+}  // namespace gea::platform::touch
+
+// Battery. `gea::platform::power::Power` had no macOS implementation at all,
+// so `host/battery.h`'s inline `batteryPercent()` left an undefined symbol and
+// every app that shows a battery level failed to LINK (`watch`, `watch-date`:
+// "gea::platform::power::Power::batteryPercent()", referenced from ...).
+//
+// A stub returning a constant would link and lie. macOS publishes the real
+// figure through IOKit's power-sources API, and the target already links
+// -framework IOKit (targets/macos/build-macos.sh LINK_FRAMEWORKS), so the
+// honest implementation costs nothing the build was not already paying.
+// A desktop with no battery reports 100: "not running on battery" is the
+// truthful answer there, and it is what the embedded API's callers expect
+// when the device is on external power.
+namespace gea::platform::power {
+
+bool Power::init() { return true; }
+
+int Power::batteryPercent()
+{
+	CFTypeRef blob = IOPSCopyPowerSourcesInfo();
+	if (blob == nullptr) return 100;
+	CFArrayRef sources = IOPSCopyPowerSourcesList(blob);
+	if (sources == nullptr) {
+		CFRelease(blob);
+		return 100;
+	}
+	int percent = 100;
+	const CFIndex count = CFArrayGetCount(sources);
+	for (CFIndex i = 0; i < count; ++i) {
+		CFDictionaryRef description = IOPSGetPowerSourceDescription(blob, CFArrayGetValueAtIndex(sources, i));
+		if (description == nullptr) continue;
+		CFNumberRef current = static_cast<CFNumberRef>(CFDictionaryGetValue(description, CFSTR(kIOPSCurrentCapacityKey)));
+		CFNumberRef maximum = static_cast<CFNumberRef>(CFDictionaryGetValue(description, CFSTR(kIOPSMaxCapacityKey)));
+		int currentValue = 0;
+		int maximumValue = 0;
+		if (current == nullptr || maximum == nullptr) continue;
+		if (!CFNumberGetValue(current, kCFNumberIntType, &currentValue)) continue;
+		if (!CFNumberGetValue(maximum, kCFNumberIntType, &maximumValue)) continue;
+		if (maximumValue <= 0) continue;
+		percent = static_cast<int>((static_cast<double>(currentValue) / maximumValue) * 100.0 + 0.5);
+		break;
+	}
+	CFRelease(sources);
+	CFRelease(blob);
+	if (percent < 0) return 0;
+	if (percent > 100) return 100;
+	return percent;
+}
+
+}  // namespace gea::platform::power

package/targets/macos/main/macos_smoke_app.cpp

@@ -0,0 +1,65 @@
+// Phase B smoke app: exercises View / Text / Button / event dispatch
+// without the JSX → C++ pipeline. Real apps generated by geatsc will
+// drop into targets/macos/generated/<app>/ and supersede this.
+
+#include "ui/document.h"
+#include "events.h"
+#include <cstdio>
+
+namespace {
+gea::embedded::ui::TextElement g_counterLabel;
+int g_counterValue = 0;
+
+void refreshCounterLabel()
+{
+	char buf[32];
+	std::snprintf(buf, sizeof(buf), "Clicked %d", g_counterValue);
+	g_counterLabel.setText(buf);
+}
+}  // namespace
+
+extern "C" {
+
+void gea_embedded_app_init(int width, int height)
+{
+	using namespace gea::embedded::ui;
+	using gea::framework::events::PointerEvent;
+
+	auto &doc = Document::instance();
+	doc.clear();
+	auto root = doc.createView();
+	root.style().backgroundColor(0x33DE);  // RGB565 ~ #3478F6
+	root.style().set(Property::FlexDirection, 0);   // column
+	root.style().set(Property::JustifyContent, 1);  // center
+	root.style().set(Property::AlignItems, 1);      // center
+	root.style().set(Property::Gap, 16);
+
+	auto title = doc.createText("Hello, native Mac!");
+	title.style().color(0xFFFF);     // white
+	title.style().set(Property::FontSize, 24);
+	root.appendChild(title);
+
+	g_counterLabel = doc.createText("Clicked 0");
+	g_counterLabel.style().color(0xFFFF);
+	g_counterLabel.style().set(Property::FontSize, 16);
+	root.appendChild(g_counterLabel);
+	g_counterValue = 0;
+
+	auto button = doc.createButton();
+	auto buttonLabel = doc.createText("Click me");
+	button.appendChild(buttonLabel);
+	button.addEventListener("click", [](PointerEvent &) {
+		g_counterValue++;
+		refreshCounterLabel();
+	});
+	root.appendChild(button);
+
+	doc.mount(root, width, height);
+}
+
+void gea_embedded_app_frame(int timestampMs)
+{
+	(void)timestampMs;
+}
+
+}  // extern "C"

package/targets/macos/main/macos_timers.mm

@@ -0,0 +1,52 @@
+#import <Foundation/Foundation.h>
+#include "services/frame_scheduler.h"
+
+#include <mach/mach_time.h>
+
+namespace {
+
+int monotonicMillis()
+{
+	static mach_timebase_info_data_t tb = {0, 0};
+	if (tb.denom == 0) mach_timebase_info(&tb);
+	static const uint64_t start = mach_absolute_time();
+	uint64_t ns = (mach_absolute_time() - start) * tb.numer / tb.denom;
+	return static_cast<int>(ns / 1000000ULL);
+}
+
+int g_frame_interval_ms = gea::framework::services::FrameScheduler::kDefaultFrameIntervalMs;
+
+}  // namespace
+
+extern "C" int gea_embedded_now_ms(void)
+{
+	return monotonicMillis();
+}
+
+namespace gea::framework::services {
+
+EventQueue FrameScheduler::createEventQueue() { return EventQueue{}; }
+EventQueue FrameScheduler::eventQueue() { return EventQueue{}; }
+bool FrameScheduler::sendEvent(const gea::framework::events::Event &, int) { return true; }
+bool FrameScheduler::receiveEvent(gea::framework::events::Event *) { return false; }
+void FrameScheduler::start(EventQueue) {}
+void FrameScheduler::runFrame(const FrameCallbacks &callbacks)
+{
+	if (callbacks.frame) callbacks.frame(monotonicMillis(), callbacks.context);
+}
+void FrameScheduler::setFrameIntervalMs(int intervalMs)
+{
+	if (intervalMs < kMinFrameIntervalMs) intervalMs = kMinFrameIntervalMs;
+	if (intervalMs > kMaxFrameIntervalMs) intervalMs = kMaxFrameIntervalMs;
+	g_frame_interval_ms = intervalMs;
+}
+int FrameScheduler::frameIntervalMs() { return g_frame_interval_ms; }
+void FrameScheduler::setFrameRate(double fps)
+{
+	if (fps <= 0.0) return;
+	setFrameIntervalMs(static_cast<int>(1000.0 / fps + 0.5));
+}
+double FrameScheduler::frameRate() { return 1000.0 / static_cast<double>(g_frame_interval_ms); }
+int FrameScheduler::nowMs() { return monotonicMillis(); }
+
+}  // namespace gea::framework::services

package/targets/macos/main/press_bridge.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#ifdef __OBJC__
+#import <Foundation/Foundation.h>
+
+@interface PressBridge : NSObject
+@property(nonatomic, assign) int nodeId;
+- (void)fire:(id)sender;
+@end
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Dispatches a Click + Press event to the given node id via Tree::dispatchEvent.
+void gea_macos_fire_press_for_node(int nodeId);
+
+#ifdef __cplusplus
+}
+#endif

package/targets/macos/main/press_bridge.mm

@@ -0,0 +1,72 @@
+#import "press_bridge.h"
+
+#include "ui/tree_internal.h"
+#include "events.h"
+
+#include <cstring>
+
+extern "C" void gea_macos_fire_press_for_node(int nodeId)
+{
+	using gea::framework::events::PointerEvent;
+	using gea::framework::events::PointerEventType;
+	if (nodeId < 0) return;
+	auto &tree = gea::embedded::ui::Tree::instance();
+	if (nodeId >= tree.nodeCount()) return;
+
+	// A native click on macOS corresponds to a full press-and-release cycle.
+	// Apps may listen for any of these — the browser equivalent fires the
+	// whole sequence too — so dispatch them in browser order:
+	//   touchstart → touchend → click
+	// This way apps written for the ESP32 touchscreen (which only sees
+	// touchstart/touchend) still respond to mouse clicks, and JSX onClick
+	// handlers fire consistently with the web target.
+	auto fire = [&](PointerEventType type) {
+		PointerEvent ev;
+		ev.type = type;
+		ev.targetId = nodeId;
+		tree.dispatchEvent(ev);
+	};
+	fire(PointerEventType::TouchStart);
+	fire(PointerEventType::TouchEnd);
+	fire(PointerEventType::Click);
+}
+
+// Headless equivalent of a keystroke into the first `<input>` / `<textarea>`:
+// write the text into the node's `value` attribute and dispatch
+// `PointerEventType::Input`, which is exactly what `GeaTextAreaView
+// textDidChange:` / `GeaTextFieldView controlTextDidChange:` do for a real key
+// event (macos_renderer.mm). Driven by GEA_MACOS_SYNTH_INPUT so the text-input
+// path can be exercised in a shell with no Accessibility permission — posting
+// synthetic key events through CGEvent needs one, so without this there is no
+// way to regression-test "typing does not crash" from a script.
+// Returns the node it targeted, or -1 when the tree has no text input.
+extern "C" int gea_macos_fire_input_for_node(int nodeId, const char *text)
+{
+	using gea::framework::events::PointerEvent;
+	using gea::framework::events::PointerEventType;
+	auto &tree = gea::embedded::ui::Tree::instance();
+	int target = nodeId;
+	if (target < 0) {
+		for (int i = 0; i < tree.nodeCount(); i++) {
+			const char *tag = tree.tagName(i);
+			if (!tag) continue;
+			if (std::strcmp(tag, "input") == 0 || std::strcmp(tag, "textarea") == 0) { target = i; break; }
+		}
+	}
+	if (target < 0 || target >= tree.nodeCount()) return -1;
+	tree.setAttribute(target, "value", text ? text : "");
+	PointerEvent ev;
+	ev.type = PointerEventType::Input;
+	ev.targetId = target;
+	ev.keyCode = 0;
+	tree.dispatchEvent(ev);
+	return target;
+}
+
+@implementation PressBridge
+- (void)fire:(id)sender
+{
+	(void)sender;
+	gea_macos_fire_press_for_node(self.nodeId);
+}
+@end

package/targets/macos/main/thermalright_hid_display.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <cstdint>
+
+namespace gea::macos::thermalright {
+
+bool enabled();
+int width();
+int height();
+int fps();
+bool submitRgb565(const std::uint16_t *pixels, int width, int height);
+void shutdown();
+
+} // namespace gea::macos::thermalright