mockdevice-testing

por facebook

MockDeviceKit para pruebas sin hardware físico de gafas

npx skills add https://github.com/facebook/meta-wearables-dat-ios --skill mockdevice-testing

Descargar ZIP GitHub

552

MockDevice Testing (iOS)

Use MockDeviceKit to test DAT SDK integrations without physical Meta glasses.

MockDeviceKit simulates Meta glasses behavior for development and testing. It provides:

MockDeviceKit.shared — Entry point (MockDeviceKitInterface) for creating simulated devices
MockGlasses — Simulated glasses, created with pairGlasses(model:)
MockGlassesServices — Per-device services: camera, captouch, display
MockCameraKit — Simulated camera with configurable video feed and photo capture
MockCaptouchKit — Simulated touchpad (tap(), tapAndHold())
MockDisplayKit — Simulated Display surface for MWDATDisplay content
MockPermissions — Control DAT permission results without the Meta AI app

GlassesModel cases: .rayBanMeta, .oakleyMetaHSTN, .oakleyMetaVanguard, .rayBanMetaOptics, .metaGlasses, .metaRayBanDisplay. Use .metaRayBanDisplay when you need a display-capable simulated device.

Setup

Add MWDATMockDevice to your target via Swift Package Manager (it's included in the meta-wearables-dat-ios package).

import MWDATMockDevice

To test a Display experience, also add MWDATDisplay to the target. After enabling MockDeviceKit, use the normal DeviceSession.addDisplay() API.

Creating a mock device

import MWDATMockDevice

let mockDeviceKit = MockDeviceKit.shared
mockDeviceKit.enable()

let mockDevice = try mockDeviceKit.pairGlasses(model: .rayBanMeta)

enable() starts from a registered, permissions-granted state. Pass a MockDeviceKitConfig when you want to exercise the registration or permission flow instead:

mockDeviceKit.enable(
    config: MockDeviceKitConfig(initiallyRegistered: false, initialPermissionsGranted: false)
)

Use mockDeviceKit.pairedDevices, mockDeviceKit.unpairDevice(_:), and mockDeviceKit.disable() to tear devices down.

Simulating device states

// Simulate glasses lifecycle
mockDevice.powerOn()
mockDevice.unfold()
mockDevice.don()    // Simulate wearing the glasses

// Later...
mockDevice.doff()   // Simulate removing
mockDevice.fold()
mockDevice.powerOff()

// Battery, charging, and thermal state
mockDevice.setBatteryLevel(35)
mockDevice.setChargingState(.charging)
mockDevice.setThermalLevel(.severe)

Simulating touchpad input

A single tap pauses an active camera stream, and a second tap resumes it — the CameraAccess tests use this to cover the StreamState.paused path.

mockDevice.services.captouch.tap()
mockDevice.services.captouch.tapAndHold()

Configuring permissions

MockDeviceKit provides permissions to control permission behavior without the Meta AI app.

By default, requestPermission() returns .granted. Use set(_:_:) to control checkPermissionStatus() and setRequestResult(_:result:) to control requestPermission() outcomes.

let mockDeviceKit = MockDeviceKit.shared

// Simulate denied camera permission status
mockDeviceKit.permissions.set(.camera, .denied)

// Simulate denied request result (user tapping "deny")
mockDeviceKit.permissions.setRequestResult(.camera, result: .denied)

Setting up mock camera feeds

Video streaming

let camera = mockDevice.services.camera
camera.setCameraFeed(fileURL: videoURL)

// Or stream live from the phone's own camera
camera.setCameraFeed(cameraFacing: .back)  // CameraFacing is .front or .back

Photo capture

let camera = mockDevice.services.camera
camera.setCapturedImage(fileURL: imageURL)

Writing tests with MockDeviceKit

Create a reusable test base class:

import MWDATCore
import MWDATMockDevice
import XCTest

@MainActor
class MockDeviceKitTestCase: XCTestCase {
    private var mockDevice: MockGlasses?
    private var cameraKit: MockCameraKit?

    override func setUp() async throws {
        try await super.setUp()
        try? Wearables.configure()
        MockDeviceKit.shared.enable()
        let device = try MockDeviceKit.shared.pairGlasses(model: .rayBanMeta)
        mockDevice = device
        cameraKit = device.services.camera

        // Make the device available to Wearables before creating a session
        device.powerOn()
        device.unfold()
    }

    override func tearDown() async throws {
        MockDeviceKit.shared.disable()
        mockDevice = nil
        cameraKit = nil
        try await super.tearDown()
    }
}

The device only shows up in Wearables.shared.devicesStream() after it is powered on and unfolded, so wait for your view model's "device available" state before calling createSession(deviceSelector:).