@geastack/core 0.1.23

package/include/ble.h

@@ -0,0 +1,212 @@
+#pragma once
+
+#include <cstdint>
+
+namespace gea::framework::bluetooth {
+
+class BluetoothHidDriver {
+public:
+	virtual ~BluetoothHidDriver() = default;
+
+	virtual void preinit() = 0;
+	virtual void init(const char *deviceName, std::uint16_t appearance, const char *macAddress = nullptr) = 0;
+	virtual bool enabled() const = 0;
+	virtual void setEnabled(bool enabled) = 0;
+	virtual void startAdvertising() = 0;
+	virtual void stopAdvertising() = 0;
+	virtual bool connected() const = 0;
+	virtual bool bound() const = 0;
+	virtual std::uint8_t batteryLevel() const = 0;
+	virtual const char *mac() = 0;
+	virtual const char *deviceName() const = 0;
+	virtual void keyTap(int hidCode) = 0;
+	virtual void keyDown(int modifier, int hidCode) = 0;
+	virtual void keyUp() = 0;
+	virtual void mouseMove(int dx, int dy, int buttons, int wheel) = 0;
+	virtual void mouseClick(int button) = 0;
+	virtual void setBatteryLevel(std::uint8_t level) = 0;
+
+	// BLE-MIDI (MIDI over GATT, service 03B80E5A-EDE8-4B33-A751-6CE34EC4C700).
+	// Optional capability: drivers that do not implement it inherit these
+	// no-ops, so the HID-only targets are unaffected. midiEnable() registers
+	// the MIDI service in the GATT database (call before/independent of
+	// init(); the driver folds it into its advertising data). midiSend()
+	// transmits one already-framed BLE-MIDI packet (header + timestamp +
+	// MIDI bytes) as a notification on the MIDI I/O characteristic.
+	virtual void midiEnable() {}
+	virtual bool midiBound() const { return false; }
+	virtual void midiSend(const std::uint8_t *packet, int length)
+	{
+		(void)packet;
+		(void)length;
+	}
+
+	// BLE-MIDI central role: scan for BLE-MIDI peripherals (WIDI adapters,
+	// pedals), connect as a GATT client, and write framed packets to the
+	// peer's MIDI I/O characteristic. One role is active at a time: starting
+	// a scan stops advertising; a central link suppresses re-advertising.
+	virtual void midiStartScan() {}
+	virtual void midiStopScan() {}
+	virtual bool midiScanning() const { return false; }
+	virtual int midiScanCount() const { return 0; }
+	virtual const char *midiScanNameAt(int index)
+	{
+		(void)index;
+		return "";
+	}
+	virtual void midiConnect(int index) { (void)index; }
+	virtual void midiDisconnect() {}
+
+	// HID host role: the device acts as a BLE central hosting a remote HID
+	// peripheral (a keyboard/macro pad such as the XPPen ACK05). Scan,
+	// connect, subscribe to every input-report characteristic in the peer's
+	// HID service, and queue the raw notification payloads for the app to
+	// poll and decode. Optional capability with no-op defaults like MIDI.
+	virtual void hidHostStartScan() {}
+	virtual void hidHostStopScan() {}
+	virtual bool hidHostScanning() const { return false; }
+	virtual int hidHostScanCount() const { return 0; }
+	virtual const char *hidHostScanNameAt(int index)
+	{
+		(void)index;
+		return "";
+	}
+	virtual void hidHostConnect(int index) { (void)index; }
+	virtual void hidHostDisconnect() {}
+	virtual bool hidHostBound() const { return false; }
+	// Raw input-report queue (oldest first). reportIdAt() is the report ID
+	// the notification came from; bytes are the payload after the ID.
+	virtual int hidHostReportCount() const { return 0; }
+	virtual int hidHostReportIdAt(int index) const
+	{
+		(void)index;
+		return 0;
+	}
+	virtual int hidHostReportLenAt(int index) const
+	{
+		(void)index;
+		return 0;
+	}
+	virtual int hidHostReportByteAt(int index, int byteIndex) const
+	{
+		(void)index;
+		(void)byteIndex;
+		return 0;
+	}
+	virtual void hidHostClearReports() {}
+
+	// Connection registry across every role this device holds at once.
+	// kind: 0 = central peer connected TO us while we serve HID (a desktop
+	// using us as keyboard/mouse), 1 = central peer on our MIDI service (a
+	// DAW), 2 = HID peripheral WE host (the XPPen), 3 = BLE-MIDI peripheral
+	// WE drive (the pedal/WIDI adapter).
+	virtual int connectionCount() const { return 0; }
+	virtual int connectionKindAt(int index) const
+	{
+		(void)index;
+		return 0;
+	}
+	virtual const char *connectionNameAt(int index)
+	{
+		(void)index;
+		return "";
+	}
+
+	// Config service (custom GATT, service A1E0F000-...). A Web Bluetooth
+	// portal reads the app's config blob and writes a new one, gated by a
+	// 4-digit pairing code shown on the device. Optional capability with
+	// no-op defaults like MIDI/HID-host. configSetDocument() publishes the
+	// blob the portal reads back; configPending*() expose a committed inbound
+	// blob for the app to drain; the pairing trio drives the on-device
+	// pairing overlay.
+	virtual void configSetDocument(const std::uint8_t *bytes, int length)
+	{
+		(void)bytes;
+		(void)length;
+	}
+	virtual int configPendingLength() const { return 0; }
+	virtual int configPendingByteAt(int index) const
+	{
+		(void)index;
+		return 0;
+	}
+	virtual void configConsumePending() {}
+	virtual bool configPairing() const { return false; }
+	virtual const char *configPairCode() { return ""; }
+	virtual void configDismissPairing() {}
+
+	// Device -> portal activity push. When a control fires on the device, the
+	// app calls this with the control's index; a driver that hosts the config
+	// service sends a CTRL notification (opcode 0xA0 + index) so a subscribed
+	// portal can highlight the matching control live. No-op default.
+	virtual void configPushActivity(int index) { (void)index; }
+};
+
+class BluetoothHidDevice {
+public:
+	static void setDriver(BluetoothHidDriver *driver);
+	static BluetoothHidDriver *driver();
+
+	void preinit() const;
+	void init(const char *deviceName, std::uint16_t appearance, const char *macAddress = nullptr) const;
+	bool enabled() const;
+	void setEnabled(bool enabled) const;
+	void startAdvertising() const;
+	void stopAdvertising() const;
+	bool connected() const;
+	bool bound() const;
+	std::uint8_t batteryLevel() const;
+	const char *mac() const;
+	const char *deviceName() const;
+	void keyTap(int hidCode) const;
+	void keyDown(int modifier, int hidCode) const;
+	void keyUp() const;
+	void mouseMove(int dx, int dy, int buttons, int wheel) const;
+	void mouseClick(int button) const;
+	void setBatteryLevel(std::uint8_t level) const;
+	void midiEnable() const;
+	bool midiBound() const;
+	void midiSend(const std::uint8_t *packet, int length) const;
+	void midiStartScan() const;
+	void midiStopScan() const;
+	bool midiScanning() const;
+	int midiScanCount() const;
+	const char *midiScanNameAt(int index) const;
+	void midiConnect(int index) const;
+	void midiDisconnect() const;
+	void hidHostStartScan() const;
+	void hidHostStopScan() const;
+	bool hidHostScanning() const;
+	int hidHostScanCount() const;
+	const char *hidHostScanNameAt(int index) const;
+	void hidHostConnect(int index) const;
+	void hidHostDisconnect() const;
+	bool hidHostBound() const;
+	int hidHostReportCount() const;
+	int hidHostReportIdAt(int index) const;
+	int hidHostReportLenAt(int index) const;
+	int hidHostReportByteAt(int index, int byteIndex) const;
+	void hidHostClearReports() const;
+	int connectionCount() const;
+	int connectionKindAt(int index) const;
+	const char *connectionNameAt(int index) const;
+	void configSetDocument(const std::uint8_t *bytes, int length) const;
+	int configPendingLength() const;
+	int configPendingByteAt(int index) const;
+	void configConsumePending() const;
+	bool configPairing() const;
+	const char *configPairCode() const;
+	void configDismissPairing() const;
+	void configPushActivity(int index) const;
+};
+
+class Bluetooth {
+public:
+	BluetoothHidDevice hid() const { return BluetoothHidDevice{}; }
+};
+
+inline Bluetooth bluetooth() {
+	return Bluetooth{};
+}
+
+}  // namespace gea::framework::bluetooth

package/include/bluetooth/hid_profile.h

@@ -0,0 +1,92 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+namespace gea::framework::bluetooth::hid {
+
+struct ByteView {
+  const std::uint8_t *data = nullptr;
+  std::size_t size = 0;
+};
+
+inline constexpr std::uint16_t kServiceUuid = 0x1812;
+inline constexpr std::uint16_t kBatteryServiceUuid = 0x180F;
+inline constexpr std::uint16_t kInformationUuid = 0x2A4A;
+inline constexpr std::uint16_t kReportMapUuid = 0x2A4B;
+inline constexpr std::uint16_t kControlPointUuid = 0x2A4C;
+inline constexpr std::uint16_t kProtocolModeUuid = 0x2A4E;
+inline constexpr std::uint16_t kReportUuid = 0x2A4D;
+inline constexpr std::uint16_t kReportReferenceUuid = 0x2908;
+inline constexpr std::uint16_t kBatteryLevelUuid = 0x2A19;
+
+inline constexpr std::uint16_t kDefaultAppearance = 0x03C2;  // HID Mouse (hid-clicker is a pointer)
+inline constexpr std::uint8_t kReportProtocol = 1;
+inline constexpr const char *kDefaultDeviceName = "Gea Embedded BLE";
+
+inline constexpr std::uint8_t kInformation[] = {0x0B, 0x01, 0x00, 0x15};
+inline constexpr std::uint8_t kKeyboardReportReference[] = {0x01, 0x01};
+inline constexpr std::uint8_t kMouseReportReference[] = {0x03, 0x01};
+
+inline constexpr std::uint8_t kReportMap[] = {
+    0x05, 0x01, 0x09, 0x06, 0xA1, 0x01, 0x85, 0x01,
+    0x05, 0x07, 0x19, 0xE0, 0x29, 0xE7, 0x15, 0x00,
+    0x25, 0x01, 0x75, 0x01, 0x95, 0x08, 0x81, 0x02,
+    0x95, 0x01, 0x75, 0x08, 0x81, 0x01, 0x95, 0x05,
+    0x75, 0x01, 0x05, 0x08, 0x19, 0x01, 0x29, 0x05,
+    0x91, 0x02, 0x95, 0x01, 0x75, 0x03, 0x91, 0x01,
+    0x95, 0x06, 0x75, 0x08, 0x15, 0x00, 0x25, 0x65,
+    0x05, 0x07, 0x19, 0x00, 0x29, 0x65, 0x81, 0x00,
+    0xC0,
+    0x05, 0x01, 0x09, 0x02, 0xA1, 0x01, 0x85, 0x03,
+    0x09, 0x01, 0xA1, 0x00, 0x05, 0x09, 0x19, 0x01,
+    0x29, 0x03, 0x15, 0x00, 0x25, 0x01, 0x95, 0x03,
+    0x75, 0x01, 0x81, 0x02, 0x95, 0x01, 0x75, 0x05,
+    0x81, 0x01, 0x05, 0x01, 0x09, 0x30, 0x09, 0x31,
+    0x09, 0x38, 0x15, 0x81, 0x25, 0x7F, 0x75, 0x08,
+    0x95, 0x03, 0x81, 0x06, 0xC0, 0xC0,
+};
+
+class KeyboardMouseReports {
+public:
+  ByteView keyboard() const { return {keyboard_, sizeof(keyboard_)}; }
+  ByteView mouse() const { return {mouse_, sizeof(mouse_)}; }
+
+  void clearKeyboard() { std::memset(keyboard_, 0, sizeof(keyboard_)); }
+  void clearMouse() { std::memset(mouse_, 0, sizeof(mouse_)); }
+  void clear()
+  {
+    clearKeyboard();
+    clearMouse();
+  }
+
+  void keyDown(int modifier, int hidCode)
+  {
+    keyboard_[0] = static_cast<std::uint8_t>(modifier);
+    keyboard_[2] = static_cast<std::uint8_t>(hidCode);
+  }
+
+  void keyUp() { clearKeyboard(); }
+
+  void mouseMove(int dx, int dy, int buttons, int wheel)
+  {
+    mouse_[0] = static_cast<std::uint8_t>(buttons & 0x07);
+    mouse_[1] = static_cast<std::uint8_t>(clampSignedByte(dx));
+    mouse_[2] = static_cast<std::uint8_t>(clampSignedByte(dy));
+    mouse_[3] = static_cast<std::uint8_t>(clampSignedByte(wheel));
+  }
+
+private:
+  static std::int8_t clampSignedByte(int value)
+  {
+    if (value < -127) return -127;
+    if (value > 127) return 127;
+    return static_cast<std::int8_t>(value);
+  }
+
+  std::uint8_t keyboard_[8] = {};
+  std::uint8_t mouse_[4] = {};
+};
+
+}  // namespace gea::framework::bluetooth::hid

package/include/camera.h

@@ -0,0 +1,107 @@
+#pragma once
+
+#include "pixel.h"
+
+#include <cstdint>
+#include <string>
+
+namespace gea::platform::camera {
+
+enum class Facing {
+	Back = 0,
+	Front = 1,
+	External = 2,
+};
+
+struct DeviceInfo {
+	std::string id;
+	Facing facing = Facing::Back;
+	int sensorWidth = 0;
+	int sensorHeight = 0;
+};
+
+// Static facade — one active camera at a time on the device. The platform
+// layer maintains the live preview buffer and exposes a small surface that
+// the host bridge forwards into.
+class Camera {
+public:
+	static bool isAvailable();
+	static bool hasPermission();
+	static bool requestPermission();
+
+	// facingHint: "front"|"back"|"external"|<device id>
+	// preferredWidth/Height: 0 = platform default. The platform may pick the
+	// closest supported size; query width()/height() after open() to read back.
+	static bool open(const std::string &facingHint, int preferredWidth, int preferredHeight);
+	static void close();
+	static bool isOpen();
+
+	static int width();
+	static int height();
+	static int orientation();
+	static Facing currentFacing();
+	static std::string currentFacingString();
+
+	static int deviceCount();
+	static DeviceInfo deviceAt(int index);
+
+	// Render the latest preview frame into the framebuffer at (x, y). When
+	// destW/destH are >0 the frame is scaled; otherwise it's drawn at its
+	// native capture size.
+	static void drawPreview(int x, int y, int destW, int destH);
+
+	// How the platform composites the live preview for a <camera> leaf node:
+	//   0 = Framebuffer  — the runtime owns an RGB565 buffer the backend fills
+	//                      (fillPreview) and blits through the normal display
+	//                      list, so the preview obeys CSS clip / z-order.
+	//   1 = NativeOverlay — the backend owns a native preview surface (e.g. an
+	//                      iOS AVCaptureVideoPreviewLayer) which the runtime
+	//                      positions over the node's computed rect.
+	static int previewMode();
+
+	// Framebuffer mode: scale + convert the latest frame into the caller's
+	// native-pixel buffer of size dstWidth x dstHeight (pixel::native_t is RGB565
+	// on 16-bit targets, RGBA8888 on full-colour targets like iOS). `fit` is
+	// 0=cover, 1=contain, 2=fill; `mirror` flips horizontally. Returns true if a
+	// frame was written.
+	static bool fillPreview(gea::framework::graphics::pixel::native_t *dst, int dstWidth, int dstHeight, int fit, bool mirror);
+
+	// NativeOverlay mode: position / hide the native preview surface. The rect
+	// is in framebuffer pixels (the <camera> node's computed layout box).
+	static void positionPreviewLayer(int x, int y, int width, int height);
+	static void hidePreviewLayer();
+
+	// NativeOverlay mode: present one fresh frame into the positioned rect (called
+	// once per frame by the render tick). On the ESP32-P4 this PPA-scales the
+	// frame straight into the display framebuffer and flushes just that rect.
+	static void presentNativeOverlay();
+
+	// Captures a still and registers it with the embedded ImageStore so it
+	// can be drawn via image.draw(id, ...). Returns -1 on failure.
+	static int capture(bool mirror);
+
+	// Video recording. startRecording opens a sink at `path` (platform decides
+	// the container/codec — MJPEG on esp32-p4). stopRecording finalizes and
+	// returns the duration in milliseconds, or -1 on failure.
+	static bool startRecording(const std::string &path, double fps);
+	static double stopRecording();
+	static bool isRecording();
+
+	static void setFlash(const std::string &mode);
+	static void setZoom(double factor);
+	static void setMirror(bool mirror);
+
+	// Capture controls. `mode` is a lowercase keyword the backend maps to its
+	// native control set:
+	//   exposure:      "auto" | "continuous" | "locked" | "manual"
+	//   whiteBalance:  "auto" | "continuous" | "locked"
+	//   focus:         "auto" | "continuous" | "locked"
+	//   torch:         "off"  | "on"        | "auto"
+	// Unused numeric args are 0 (meaning "platform default / leave as is").
+	static void setExposure(const std::string &mode, double bias, double iso, double durationMs);
+	static void setWhiteBalance(const std::string &mode, double temperatureK, double tint);
+	static void setFocus(const std::string &mode, double pointX, double pointY);
+	static void setTorch(const std::string &mode, double level);
+};
+
+}  // namespace gea::platform::camera