@typecad/hal 1.0.0-alpha.6 → 1.0.0-alpha.7

package/src/ble.ts

@@ -0,0 +1,209 @@
+import {
+  bleServerBegin,
+  bleAdvertiseStart,
+  bleAdvertiseStop,
+  bleAddService,
+  bleAddChar,
+  bleOnRead,
+  bleOnWrite,
+  bleOnConnect,
+  bleOnDisconnect,
+  bleNotify,
+  bleIsConnected,
+  bleClientCount,
+  bleSetName,
+  bleUntilConnected,
+  bleUntilConnectedStart,
+  bleSetTxPower,
+  bleStatus,
+} from './emit.js';
+import { callback } from './callback.js';
+
+/** Characteristic value encoding — drives both TS callback types and C++ marshalling. */
+export enum BleValueType {
+  Uint8 = 'uint8',
+  Uint16 = 'uint16',
+  Uint32 = 'uint32',
+  Int8 = 'int8',
+  Int16 = 'int16',
+  Int32 = 'int32',
+  Float32 = 'float32',
+  Utf8 = 'utf8',
+  Boolean = 'boolean',
+  Bytes = 'bytes',
+}
+
+/** GATT characteristic permission flags. Combine with `|`. */
+export enum BlePerm {
+  Read = 1,
+  Write = 2,
+  Notify = 4,
+}
+
+/** BLE peripheral status (mirrored by the runtime shim). */
+export enum BleStatus {
+  Idle = 0,
+  Initializing = 1,
+  Advertising = 2,
+  Connected = 3,
+  Error = 4,
+}
+
+export enum BleAdvertisingMode {
+  Connectable = 'connectable',
+  NonConnectable = 'non_connectable',
+}
+
+/** A well-known GATT characteristic entry in the catalog. */
+export interface GattCharacteristicDef {
+  readonly uuid: string;
+  readonly type: BleValueType;
+  readonly read?: boolean;
+  readonly write?: boolean;
+  readonly notify?: boolean;
+}
+
+/**
+ * Standard GATT services/characteristics. Autocomplete walks the hierarchy:
+ *   GATT.ENVIRONMENTAL. -> TEMPERATURE, HUMIDITY, ...
+ * Pass the .uuid, .type, and computed perms to BleServer.characteristic().
+ */
+export const GATT = {
+  DEVICE_INFO: {
+    MANUFACTURER_NAME: { uuid: '2A29', type: BleValueType.Utf8, read: true },
+    MODEL_NUMBER: { uuid: '2A24', type: BleValueType.Utf8, read: true },
+    FIRMWARE_REVISION: { uuid: '2A26', type: BleValueType.Utf8, read: true },
+  },
+  ENVIRONMENTAL: {
+    TEMPERATURE: { uuid: '2A6E', type: BleValueType.Int16, read: true, notify: true },
+    HUMIDITY: { uuid: '2A6F', type: BleValueType.Uint16, read: true, notify: true },
+    PRESSURE: { uuid: '2A6D', type: BleValueType.Uint32, read: true, notify: true },
+  },
+  BATTERY: {
+    LEVEL: { uuid: '2A19', type: BleValueType.Uint8, read: true, notify: true },
+  },
+} as const;
+
+/** The value passed to/from callbacks — narrowed per characteristic by type. */
+export type CharValue = number | string | boolean | Uint8Array;
+
+/**
+ * BLE GATT peripheral control, lowered to native ESP-IDF NimBLE
+ * (`nimble_host` / `ble_gap` / `ble_gatts`) by framework-esp32.
+ *
+ * No `include()` calls here — NimBLE headers are framework-owned and added via
+ * forcedIncludes when the program uses ble.* ops.
+ *
+ * Transpiler note: method bodies pass parameters directly into semantic calls
+ * (no local consts / module counters) so the resolver can statically track every
+ * argument. The characteristic index is carried through the chain via
+ * `this._charCount` fieldValues, mirroring how HttpRequest carries _method/_url.
+ */
+export class BleClass {
+  static readonly __instance_name = "Ble";
+
+  /** Begin building a GATT server with the given advertised device name. */
+  server(name: string): BleServer {
+    bleSetName(name);
+    return new BleServer(name, 0, 1);
+  }
+
+  /** Initialize NimBLE, register services, and start advertising. */
+  begin(): void {
+    bleServerBegin("TypeCAD");
+    bleAdvertiseStart();
+  }
+
+  advertise(): void { bleAdvertiseStart(); }
+  stopAdvertising(): void { bleAdvertiseStop(); }
+
+  /** Blocking at top level; cooperatively awaitable inside async functions. */
+  untilConnected(timeoutMs: number = 0): Promise<boolean> {
+    bleUntilConnected(timeoutMs);
+    return Promise.resolve(false);
+  }
+
+  untilConnectedStart(): void { bleUntilConnectedStart(); }
+  isConnected(): boolean { return bleIsConnected(); }
+  status(): BleStatus { return bleStatus() as BleStatus; }
+  clientCount(): number { return bleClientCount(); }
+  txPower(dbm: number): this { bleSetTxPower(dbm); return this; }
+  notify(index: number, value: number): void { bleNotify(index, value); }
+}
+
+/**
+ * Fluent GATT server builder. Returned by `Ble.server()`.
+ *
+ * Single-class fluent chain (like HttpRequest): characteristic() returns `this`,
+ * so onRead/onWrite/onSubscribe chain directly. The _charCount field tracks
+ * which characteristic slot the callbacks attach to.
+ *
+ * Field tracking (read by the transpiler resolver via ctor field assignment):
+ *   _name      — advertised device name
+ *   _charCount — current characteristic index (the last characteristic() target)
+ *   _svcCount  — current service index
+ */
+export class BleServer {
+  private _name: string;
+  private _charCount: number;
+  private _lastChar: number;
+  private _svcCount: number;
+
+  constructor(name: string, charCount: number, svcCount: number) {
+    this._name = name;
+    this._charCount = charCount;
+    this._lastChar = charCount;
+    this._svcCount = svcCount;
+  }
+
+  /** Add a characteristic by UUID, value type, and permissions.
+   *  Combine permissions with `|`: `BlePerm.Read | BlePerm.Notify`.
+   *  Returns this for chaining. */
+  characteristic(uuid: string, type: BleValueType, perms: number): this {
+    bleAddChar(this._charCount, uuid, type, perms, this._svcCount);
+    return this;
+  }
+
+  /** Begin a new service grouping. Subsequent characteristics attach to it. */
+  service(uuid: string): this {
+    bleAddService(uuid);
+    return this;
+  }
+
+  /** Register a read handler for the most recently added characteristic. */
+  onRead(handler: () => CharValue): this {
+    bleOnRead(this._lastChar, callback(handler));
+    return this;
+  }
+
+  /** Register a write handler for the most recently added characteristic. */
+  onWrite(handler: (value: number) => void): this {
+    bleOnWrite(this._lastChar, callback(handler));
+    return this;
+  }
+
+  /** Register a connect handler (called when a central connects). */
+  onConnect(handler: () => void): this {
+    bleOnConnect(callback(handler));
+    return this;
+  }
+
+  /** Register a disconnect handler (called when a central disconnects). */
+  onDisconnect(handler: () => void): this {
+    bleOnDisconnect(callback(handler));
+    return this;
+  }
+
+  /** Push a new value to subscribed clients on the most recently added characteristic. */
+  notify(value: number): void {
+    bleNotify(this._lastChar, value);
+  }
+
+  /** Initialize NimBLE, register services, and start advertising. */
+  begin(): void {
+    bleServerBegin(this._name);
+    bleAdvertiseStart();
+  }
+}
+
+export const Ble = new BleClass();

package/src/emit.ts

@@ -30,6 +30,49 @@ export function gpioSetMode(pin: number | string, mode: string): void {}
 /** Write PWM duty cycle to a pin. */
 export function pwmWrite(pin: number | string, duty: number): void {}
 
+// ---------------------------------------------------------------------------
+// RMT — Remote Control Transceiver (addressable LEDs, IR, raw digital waveforms)
+// ---------------------------------------------------------------------------
+// rmtTxInit/rmtRxInit are POSITIONAL semantic primitives — the ergonomic
+// opts-object form lives in hal/rmt.ts (which destructures and forwards). The
+// resolver collapses object literals, so HALOpIR fields must be scalars; the
+// rmt.ts wrapper bridges the ergonomic API to these positional calls.
+//
+// Pin params accept Pin | number | string so callers can pass a board alias
+// like LED (a Pin object) directly; the transpiler resolves it to its number.
+import type { Pin } from './gpio.js';
+type RmtPin = Pin | number | string;
+
+/** Positional semantic primitive. Args: pin, resolutionHz, bit0Hi, bit0Lo,
+ *  bit1Hi, bit1Lo, msbFirst, queueDepth. Use rmtTxInit() from hal/rmt.ts. */
+export function rmtTxInit(
+  pin: RmtPin,
+  resolutionHz: number,
+  bit0Hi: number, bit0Lo: number, bit1Hi: number, bit1Lo: number,
+  msbFirst: boolean, queueDepth: number,
+): void {}
+/** Write bytes via the channel's bytes-encoder (timings fixed at init). */
+export function rmtTxWriteBytes(pin: RmtPin, bytes: number[] | Uint8Array): void {}
+/** Write raw RMT symbols — arbitrary [hiTicks, loTicks] pairs. */
+export function rmtTxWriteSymbols(pin: RmtPin, symbols: [number, number][]): void {}
+/** Block until the queued TX completes. */
+export function rmtTxWaitDone(pin: RmtPin, timeoutMs?: number): void {}
+/** Tear down the TX channel and release its slot. */
+export function rmtTxDeinit(pin: RmtPin): void {}
+
+/** Positional semantic primitive — use rmtRxInit() from hal/rmt.ts. */
+export function rmtRxInit(pin: RmtPin, resolutionHz: number): void {}
+/** Register a callback-by-name invoked when an RX burst completes. */
+export function rmtRxOnReceived(pin: RmtPin, handler: string): void {}
+/** Start receiving. */
+export function rmtRxStart(pin: RmtPin): void {}
+/** Stop receiving. */
+export function rmtRxStop(pin: RmtPin): void {}
+/** Blocking read — returns flattened symbols [d0,l0,d1,l1,…] in ticks. */
+export function rmtRxRead(pin: RmtPin, maxCount: number): number[] { return []; }
+/** Tear down the RX channel and release its slot. */
+export function rmtRxDeinit(pin: RmtPin): void {}
+
 // ---------------------------------------------------------------------------
 // ADC — analog-to-digital conversion
 // ---------------------------------------------------------------------------
@@ -218,6 +261,104 @@ export function powerDeepSleep(ms: number): void {}
 export function powerLightSleep(): void {}
 /** Set the CPU frequency (MHz). */
 export function powerSetCpuFrequency(mhz: number): void {}
+/** Enter deep sleep until `pin` reaches `level` (pin wakeup). Architecture-aware:
+ *  ext0 on Xtensa (RTC pins), gpio-wakeup on RISC-V. */
+export function powerDeepSleepPin(pin: number, level: number): void {}
+
+// ---------------------------------------------------------------------------
+// Preferences (NVS-backed key/value store)
+// ---------------------------------------------------------------------------
+
+export function preferencesBegin(namespace: string, readOnly: boolean): void {}
+export function preferencesEnd(): void {}
+export function preferencesClear(): void {}
+export function preferencesRemove(key: string): void {}
+export function preferencesPutInt(key: string, value: number): void {}
+export function preferencesGetInt(key: string, defaultValue: number): number { return 0; }
+export function preferencesPutUInt(key: string, value: number): void {}
+export function preferencesGetUInt(key: string, defaultValue: number): number { return 0; }
+export function preferencesPutBool(key: string, value: boolean): void {}
+export function preferencesGetBool(key: string, defaultValue: boolean): boolean { return false; }
+export function preferencesPutFloat(key: string, value: number): void {}
+export function preferencesGetFloat(key: string, defaultValue: number): number { return 0; }
+export function preferencesPutString(key: string, value: string): void {}
+export function preferencesGetString(key: string, defaultValue: string): string { return ""; }
+
+export function wifiConnect(ssid: string, password?: string, timeoutMs?: number): boolean { return false; }
+export function wifiConnectStart(ssid: string, password?: string): void {}
+export function wifiDisconnect(): void {}
+export function wifiStatus(): number { return 0; }
+export function wifiIsConnected(): boolean { return false; }
+export function wifiLocalIp(): string { return ""; }
+export function wifiRssi(): number { return 0; }
+export function wifiMac(): string { return ""; }
+export function wifiSetHostname(name: string): void {}
+export function wifiSetStaticIp(ip: string, gateway: string, subnet: string, dns?: string): void {}
+export function wifiSetAutoReconnect(enabled: boolean): void {}
+export function wifiSetPowerSave(mode: string): void {}
+export function wifiSetTxPower(dbm: number): void {}
+export function wifiOnEvent(event: string, handler: string): void {}
+export function wifiApStart(ssid: string, password?: string, channel?: number, hidden?: boolean, maxClients?: number): boolean { return false; }
+export function wifiApStop(): void {}
+export function wifiApClientCount(): number { return 0; }
+export function wifiApIp(): string { return ""; }
+export function wifiApSetChannel(channel: number): void {}
+export function wifiApSetHidden(hidden: boolean): void {}
+export function wifiApSetMaxClients(maxClients: number): void {}
+export function wifiScan(): number { return 0; }
+export function wifiScanStart(): void {}
+export function wifiScanCount(): number { return 0; }
+export function wifiScanSsid(index: number): string { return ""; }
+export function wifiScanRssi(index: number): number { return 0; }
+export function wifiScanEncryption(index: number): number { return 0; }
+export function wifiScanChannel(index: number): number { return 0; }
+export function wifiSaveCredentials(ssid: string, password: string): void {}
+export function wifiConnectSaved(timeoutMs?: number): boolean { return false; }
+export function wifiClearCredentials(): void {}
+export function wifiWaitConnected(timeoutMs?: number): boolean { return false; }
+export function wifiWaitDisconnected(): void {}
+
+// ---------------------------------------------------------------------------
+// HTTP client
+// ---------------------------------------------------------------------------
+
+export function httpBegin(method: string, url: string): void {}
+export function httpReset(): void {}
+export function httpSetHeader(name: string, value: string): void {}
+export function httpSetTimeout(ms: number): void {}
+export function httpSetMaxBody(bytes: number): void {}
+export function httpSetBody(data: string, json?: boolean): void {}
+export function httpSetInsecure(): void {}
+export function httpSetCaCert(pem: string): void {}
+export function httpSend(): boolean { return false; }
+export function httpSendStart(): void {}
+export function httpStatus(): number { return 0; }
+export function httpOk(): boolean { return false; }
+export function httpBody(): string { return ""; }
+export function httpContentLength(): number { return 0; }
+export function httpResponseHeader(name: string): string { return ""; }
+
+// ---------------------------------------------------------------------------
+// BLE (NimBLE GATT peripheral)
+// ---------------------------------------------------------------------------
+
+export function bleServerBegin(name: string): void {}
+export function bleAdvertiseStart(): void {}
+export function bleAdvertiseStop(): void {}
+export function bleAddService(uuid: string): void {}
+export function bleAddChar(index: number, uuid: string, type: string, perms: number, svcIndex: number): void {}
+export function bleOnRead(index: number, handler: string): void {}
+export function bleOnWrite(index: number, handler: string): void {}
+export function bleOnConnect(handler: string): void {}
+export function bleOnDisconnect(handler: string): void {}
+export function bleNotify(index: number, value: number | string): void {}
+export function bleIsConnected(): boolean { return false; }
+export function bleClientCount(): number { return 0; }
+export function bleSetName(name: string): void {}
+export function bleUntilConnected(timeoutMs?: number): boolean { return false; }
+export function bleUntilConnectedStart(): void {}
+export function bleSetTxPower(dbm: number): void {}
+export function bleStatus(): number { return 0; }
 
 // ---------------------------------------------------------------------------
 // Raw C++ escape hatch
@@ -225,3 +366,20 @@ export function powerSetCpuFrequency(mhz: number): void {}
 
 /** Emit raw C++ code (escape hatch for unsupported operations). */
 export function rawCpp(code: string): void {}
+
+/**
+ * Emit raw C++ in expression context. Use when an IDF macro or constructor
+ * must produce a value (e.g. `WIFI_INIT_CONFIG_DEFAULT()` expands to a struct
+ * initializer; there's no TS-side way to construct it). The type parameter
+ * is purely a TS hint — the transpiler doesn't check it; it just emits the
+ * raw text in expression position.
+ *
+ *   const cfg = rawCpp<wifi_init_config_t>('WIFI_INIT_CONFIG_DEFAULT()');
+ *
+ * lowers to:
+ *
+ *   wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+ */
+export function rawCppExpr<T>(code: string): T {
+  return undefined as unknown as T;
+}

package/src/http.ts

@@ -0,0 +1,144 @@
+import {
+  httpBegin,
+  httpReset,
+  httpSetHeader,
+  httpSetTimeout,
+  httpSetMaxBody,
+  httpSetBody,
+  httpSetInsecure,
+  httpSetCaCert,
+  httpSend,
+  httpStatus,
+  httpOk,
+  httpBody,
+  httpContentLength,
+  httpResponseHeader,
+} from './emit.js';
+
+export enum HttpMethod {
+  GET = 0,
+  POST = 1,
+  PUT = 2,
+  DELETE = 3,
+  HEAD = 4,
+  PATCH = 5,
+}
+
+/**
+ * Fluent HTTP/S request builder, lowered to native ESP-IDF
+ * `esp_http_client` by framework-esp32 (TLS via esp-tls / mbedTLS bundle).
+ * Response fields are read from this object after send() — mirrors
+ * `await WiFi.connect(); WiFi.localIP()`.
+ *
+ * No `include()` calls here — ESP-IDF headers are framework-owned and added
+ * via forcedIncludes when the program uses http.* ops.
+ */
+export class HttpRequest {
+  private _method: string;
+  private _url: string;
+
+  constructor(method: string, url: string) {
+    this._method = method;
+    this._url = url;
+  }
+
+  header(name: string, value: string): this {
+    httpSetHeader(name, value);
+    return this;
+  }
+
+  timeout(ms: number): this {
+    httpSetTimeout(ms);
+    return this;
+  }
+
+  maxBody(bytes: number): this {
+    httpSetMaxBody(bytes);
+    return this;
+  }
+
+  body(data: string): this {
+    httpSetBody(data, false);
+    return this;
+  }
+
+  jsonBody(json: string): this {
+    httpSetBody(json, true);
+    return this;
+  }
+
+  /** Skip TLS certificate verification (development only). */
+  insecure(): this {
+    httpSetInsecure();
+    return this;
+  }
+
+  caCert(pem: string): this {
+    httpSetCaCert(pem);
+    return this;
+  }
+
+  /** Blocking at top level; cooperatively awaitable inside async functions. */
+  send(): Promise<boolean> {
+    httpBegin(this._method, this._url);
+    httpSend();
+    return Promise.resolve(false);
+  }
+
+  status(): number {
+    return httpStatus();
+  }
+
+  ok(): boolean {
+    return httpOk();
+  }
+
+  /** Response body as a C string (valid until the next request). */
+  text(): string {
+    return httpBody();
+  }
+
+  contentLength(): number {
+    return httpContentLength();
+  }
+
+  responseHeader(name: string): string {
+    return httpResponseHeader(name);
+  }
+}
+
+export class HttpClass {
+  static readonly __instance_name = "Http";
+
+  get(url: string): HttpRequest {
+    httpReset();
+    return new HttpRequest("GET", url);
+  }
+
+  post(url: string): HttpRequest {
+    httpReset();
+    return new HttpRequest("POST", url);
+  }
+
+  put(url: string): HttpRequest {
+    httpReset();
+    return new HttpRequest("PUT", url);
+  }
+
+  del(url: string): HttpRequest {
+    httpReset();
+    return new HttpRequest("DELETE", url);
+  }
+
+  head(url: string): HttpRequest {
+    httpReset();
+    return new HttpRequest("HEAD", url);
+  }
+
+  patch(url: string): HttpRequest {
+    httpReset();
+    return new HttpRequest("PATCH", url);
+  }
+}
+
+export const Http = new HttpClass();

package/src/index.ts

@@ -19,7 +19,7 @@ export type { SPIBitOrder, SPIMode, SPISettings } from './types.js';
 export { include } from './include.js';
 export { board } from './board.js';
 export { callback } from './callback.js';
-export { rawCpp, boardResolve } from './emit.js';
+export { rawCpp, rawCppExpr, boardResolve } from './emit.js';
 export { HIGH, LOW, OUTPUT, INPUT, INPUT_PULLUP, INPUT_PULLDOWN, OUTPUT_OPEN_DRAIN, ANALOG, LED_BUILTIN, LSBFIRST, MSBFIRST, WDTO_15MS, WDTO_30MS, WDTO_60MS, WDTO_120MS, WDTO_250MS, WDTO_500MS, WDTO_1S, WDTO_2S, WDTO_4S, WDTO_8S } from './constants.js';
 export { delay, millis, micros, delayMicroseconds, map, constrain, TimingClass, Timing } from './timing.js';
 export { freeHeap, setInterval, setTimeout, clearInterval, clearTimeout } from './timing.js';
@@ -46,3 +46,11 @@ export { HardwareTimer, Timer0, Timer1, Timer2 } from './timer.js';
 export { FSClass, FS } from './fs.js';
 export { PowerClass, Power } from './power.js';
 export { AsyncClass, Async } from './async.js';
+export { WiFiClass, WiFi, WiFiStatus, WiFiEncryption } from './wifi.js';
+export { HttpClass, Http, HttpRequest, HttpMethod } from './http.js';
+export {
+  BleClass, Ble, BleServer,
+  BleValueType, BlePerm, BleStatus, BleAdvertisingMode, GATT,
+} from './ble.js';
+export type { GattCharacteristicDef, CharValue } from './ble.js';
+export { RmtChannel } from './rmt.js';

package/src/power.ts

@@ -1,4 +1,4 @@
-import { powerDeepSleep, powerLightSleep, powerSetCpuFrequency } from './emit.js';
+import { powerDeepSleep, powerLightSleep, powerSetCpuFrequency, powerDeepSleepPin } from './emit.js';
 
 /**
  * PowerClass provides control over MCU power states and clock frequencies.
@@ -14,6 +14,16 @@ export class PowerClass {
     powerDeepSleep(ms);
   }
 
+  /** Enter deep sleep until `pin` reaches `level` (0 = low, 1 = high).
+   *
+   *  Lowers to ext0 wakeup (Xtensa ESP32/S3, RTC pins only) or the gpio-wakeup
+   *  variant (RISC-V C3/C6) depending on the target. `pin` must be RTC-capable;
+   *  the framework flags non-RTC pins at compile time. Wakeup resets the chip,
+   *  so this call never returns. */
+  deepSleepPin(pin: number, level: 0 | 1): void {
+    powerDeepSleepPin(pin, level);
+  }
+
   lightSleep(): void {
     powerLightSleep();
   }

package/src/preferences.ts

@@ -1,57 +1,86 @@
-import { rawCpp } from './emit.js';
+import {
+  preferencesBegin,
+  preferencesEnd,
+  preferencesClear,
+  preferencesRemove,
+  preferencesPutInt,
+  preferencesGetInt,
+  preferencesPutUInt,
+  preferencesGetUInt,
+  preferencesPutBool,
+  preferencesGetBool,
+  preferencesPutFloat,
+  preferencesGetFloat,
+  preferencesPutString,
+  preferencesGetString,
+} from './emit.js';
 
+/**
+ * Preferences — a persistent key/value store, lowered to native NVS
+ * (nvs_flash / nvs_open / nvs_set_* / nvs_get_*) by framework-esp32.
+ *
+ * No include() calls here — NVS headers are framework-owned and added via
+ * forcedIncludes when the program uses preferences.* ops. Method bodies pass
+ * parameters directly into semantic calls so the resolver can statically track
+ * every argument (matching the WiFi/HTTP HAL pattern).
+ */
 export class PreferencesClass {
   static readonly __instance_name = "Preferences";
-  // NOTE: no __includes here. The transpiler emits singleton __includes on
-  // every architecture with no filtering, and <Preferences.h> is ESP32-only —
-  // adding it would break AVR builds. The class is ESP32-only by convention.
 
   begin(name: string, readOnly: boolean = false): void {
-    rawCpp(`Preferences.begin(${name}.c_str(), ${readOnly});`);
+    preferencesBegin(name, readOnly);
   }
+
   end(): void {
-    rawCpp(`Preferences.end();`);
+    preferencesEnd();
   }
+
   clear(): void {
-    rawCpp(`Preferences.clear();`);
+    preferencesClear();
   }
+
   remove(key: string): void {
-    rawCpp(`Preferences.remove(${key}.c_str());`);
+    preferencesRemove(key);
   }
+
   putInt(key: string, value: number): void {
-    rawCpp(`Preferences.putInt(${key}.c_str(), ${value});`);
+    preferencesPutInt(key, value);
   }
+
   getInt(key: string, defaultValue: number = 0): number {
-    rawCpp(`return Preferences.getInt(${key}.c_str(), ${defaultValue});`);
-    return 0;
+    return preferencesGetInt(key, defaultValue);
   }
+
   putUInt(key: string, value: number): void {
-    rawCpp(`Preferences.putUInt(${key}.c_str(), ${value});`);
+    preferencesPutUInt(key, value);
   }
+
   getUInt(key: string, defaultValue: number = 0): number {
-    rawCpp(`return Preferences.getUInt(${key}.c_str(), ${defaultValue});`);
-    return 0;
-  }
-  putFloat(key: string, value: number): void {
-    rawCpp(`Preferences.putFloat(${key}.c_str(), ${value});`);
-  }
-  getFloat(key: string, defaultValue: number = 0): number {
-    rawCpp(`return Preferences.getFloat(${key}.c_str(), ${defaultValue});`);
-    return 0;
+    return preferencesGetUInt(key, defaultValue);
   }
+
   putBool(key: string, value: boolean): void {
-    rawCpp(`Preferences.putBool(${key}.c_str(), ${value});`);
+    preferencesPutBool(key, value);
   }
+
   getBool(key: string, defaultValue: boolean = false): boolean {
-    rawCpp(`return Preferences.getBool(${key}.c_str(), ${defaultValue});`);
-    return false;
+    return preferencesGetBool(key, defaultValue);
+  }
+
+  putFloat(key: string, value: number): void {
+    preferencesPutFloat(key, value);
   }
+
+  getFloat(key: string, defaultValue: number = 0): number {
+    return preferencesGetFloat(key, defaultValue);
+  }
+
   putString(key: string, value: string): void {
-    rawCpp(`Preferences.putString(${key}.c_str(), ${value}.c_str());`);
+    preferencesPutString(key, value);
   }
+
   getString(key: string, defaultValue: string = ""): string {
-    rawCpp(`return Preferences.getString(${key}.c_str(), ${defaultValue}.c_str());`);
-    return "";
+    return preferencesGetString(key, defaultValue);
   }
 }