Notes

• PerMode suffix — Setting can vary by rendering mode (music / movie / podcast / neutral)
• PerSystem vs PerSource — Scope of the latency control setting
• Endpoint pattern: GET /systems/current/settings/audio/{featureName}
• Feature detection: Read availableFeatures array to determine device capabilities at runtime

Endpoint Examples

• GET /systems/current/settings/audio/nightModeOverlay → {"nightModeOverlay": "off"}
• GET /systems/current/settings/audio/renderingMode → {"availableRenderingModes": ["neutral","music","movie","podcast"], "renderingMode": "music"}
• GET /systems/current/settings/audio/balance → Balance settings

Audio Settings

• systems/current/settings/audio/adaptiveVolumeLevel — Adaptive volume level
• systems/current/settings/audio/balance — Left/right balance
• systems/current/settings/audio/equalizer — EQ settings
• systems/current/settings/audio/neutralModeOverride — Override neutral rendering
• systems/current/settings/audio/nightMode — Night mode (DOS 2)
• systems/current/settings/audio/nightModeOverlay — Night mode overlay (DOS 3)
• systems/current/settings/audio/preOut — Pre-out settings
• systems/current/settings/audio/renderingMode — Current rendering mode
• systems/current/settings/audio/renderingModes/ — Per-mode settings base
• systems/current/settings/audio/roomAdaptation — Room correction/adaptation
• systems/current/settings/audio/sam — SAM (Speaker Active Matching)

System Settings

• systems/current/settings/display — Display/screen settings (Twix)
• systems/current/settings/latency — System latency control
• systems/current/settings/ledMode — LED mode control
• systems/current/settings/powerManagement — Power/standby modes

Voice Assistants

• systems/current/voiceAssistants — Available assistants
• systems/current/settings/voiceAssistants/alexa — Alexa integration
• systems/current/settings/voiceAssistants/alexa/locale — Alexa language

Other Endpoints

• systems/current — System info & available features
• systems/current/bluetooth — Bluetooth settings
• systems/current/configurationBundle — Configuration bundle
• systems/current/network — Network settings
• systems/current/sourceConfiguration — Source configuration
• systems/current/sources/current/soundControl/volume — Volume control

AudioSettingsManager

PowerManager

Configuration (LED/Microphone)

TopologyManager (SDK Methods - HTTP endpoints unknown)

These are Kotlin SDK methods from decompiled source. Actual HTTP endpoints use native Qt code and are not visible.

GroupManager (SDK Methods - HTTP endpoints unknown)

These are Kotlin SDK methods. Likely map to /ipcontrol/v1/groups/ namespace but exact endpoints need testing.

SDK Module Codenames

Message Definition Files

Devialet/SourceOfAll/BaseService.proto
Devialet/SourceOfAll/Configuration.proto
Devialet/SourceOfAll/Metadata.proto
Devialet/SourceOfAll/Playback.proto
Devialet/SourceOfAll/SoundControl.proto
Devialet/SourceOfAll/Source.proto
Devialet/SourceOfAll/Topology.proto

Devialet/SettingTheSystem/AudioSettings.proto
Devialet/SettingTheSystem/BaseService.proto
Devialet/SettingTheSystem/GeneralSettings.proto
Devialet/SettingTheSystem/PowerManagementSettings.proto

Devialet/GetThePartyStarted/DeviceInfo.proto
Devialet/GetThePartyStarted/Installation/Device.proto
Devialet/GetThePartyStarted/Installation/DeviceState.proto
Devialet/GetThePartyStarted/Network.proto
Devialet/GetThePartyStarted/Setup/Api.proto
Devialet/Fresh/Device.proto
Devialet/Fresh/UpdateImage.proto

Devialet/IMASlave4U/Configuration.proto
Devialet/IMASlave4U/Playback.proto
Devialet/IMASlave4U/RoomCorrectionSetup.proto
Devialet/LiveIsLife/Iec958/Configuration.proto
Devialet/LiveIsLife/Manolo/Configuration.proto
Devialet/LiveIsLife/PacoV3/Configuration.proto
Devialet/LiveIsLife/Paula/Configuration.proto
Devialet/LiveIsLife/Twix/Configuration.proto

Devialet/Blue/Configuration.proto
Devialet/CantTouchThis/Configuration.proto
Devialet/CantTouchThis/PowerManager.proto
Devialet/UnderTheBridge/Configuration.proto
Devialet/UnderTheBridge/Messages.proto
Devialet/RoonRaat/Metadata.proto
Devialet/Collector/LogFacility.proto
Devialet/TikTok/Registry.proto

Core Classes (io.dvlt.*)

PowerManager.java — Native Power Control

Shows how JNI wraps native C++ calls. All methods delegate to libmetaandroidd.so:

package io.dvlt.canttouchthis;

public class PowerManager extends NativeWrapper {
    private native void initialize();

    // Power off device - calls native Qt code
    public native Task<Void> powerOff(UUID uuid);

    // Reboot device
    public native Task<Void> reboot(UUID uuid);

    // Factory reset
    public native Task<Void> resetToFactory(UUID uuid);
}

Configuration.java — LED & Microphone Control

Observable configuration with listener pattern:

package io.dvlt.canttouchthis;

public class Configuration extends NativeWrapper {
    public interface Listener {
        void onLedModeChanged();
        void onMicrophoneStatusChanged();
    }

    // Get available LED modes for this device
    public native Set<LedMode> availableLedModes();

    // Get current LED mode
    public native LedMode ledMode();

    // Set LED mode (AUTO, ALWAYS_ON, ALWAYS_OFF)
    public native Task<Void> setLedMode(LedMode ledMode);

    // Get microphone status (ON, OFF, UNKNOWN)
    public native MicrophoneStatus microphoneStatus();

    // Get device configuration features
    public native Set<ConfigurationFeature> features();
}

EndpointResolver.java — Dynamic Endpoint Discovery

This is why HTTP endpoints aren't hardcoded - they're resolved at runtime:

package io.dvlt.whatsup;

public class EndpointResolver extends NativeWrapper {
    // Resolve service endpoints for a device by UUID
    // Returns set of endpoint URLs/paths
    public native Set<String> resolve(UUID uuid);
}

AudioSettingsManager.java — Complete Audio Control Interface

The main interface for all audio settings. 30+ methods for complete control:

public interface AudioSettingsManager {
    // State getters - all return Map<UUID, State>
    Map<UUID, NightModeState> getNightModeStates();
    Map<UUID, NightModeOverlay> getNightModeOverlayStates();
    Map<UUID, BalanceState> getBalanceStates();
    Map<UUID, EqualizerState> getEqualizerStates();
    Map<UUID, SAMState> getSamStates();
    Map<UUID, RoomAdaptationState> getRoomAdaptationStates();
    Map<UUID, Latency> getSystemLatencies();

    // Per-rendering-mode states
    Map<UUID, Map<RenderingModes.Mode, EqualizerState>> getRenderingModeEqualizerStates();
    Map<UUID, Map<RenderingModes.Mode, LoudnessState>> getRenderingModeLoudnessStates();
    Map<UUID, Map<RenderingModes.Mode, BassReducerState>> getRenderingModeBassReducerStates();

    // Setters - all return Completable (RxJava)
    Completable setNightMode(UUID uuid, boolean enabled);        // DOS 2
    Completable setNightModeOverlay(UUID uuid, boolean enabled); // DOS 3
    Completable setBalance(UUID uuid, int value);               // -100 to 100
    Completable setSystemLatency(UUID uuid, int ms);
    Completable setSAM(UUID uuid, boolean enabled, int quantity);

    // Per-mode setters
    Completable setEqualizer(UUID uuid, RenderingModes.Mode mode, Map<Band, Double> values);
    Completable setLoudness(UUID uuid, RenderingModes.Mode mode, boolean enabled);
    Completable setBassReducer(UUID uuid, RenderingModes.Mode mode, boolean enabled);

    // Calibration
    Completable calibrateADH(UUID systemId);
    Completable calibrateForRoom(UUID deviceId);
    Completable eraseCalibration(UUID deviceId);
}

Device.java — Complete Device Model

Data class with topology relationships and features:

public final class Device {
    private final UUID id;           // Unique device identifier
    private final UUID rendererId;   // Audio renderer ID
    private final UUID systemId;     // Parent system ID
    private final UUID groupId;      // Parent group ID
    private final boolean isSystemLeader;
    private final String name;       // User-defined name
    private final String modelName;  // e.g., "Phantom Ultimate 98"
    private final String serial;
    private final Role role;         // Mono, FrontLeft, FrontRight, Loop
    private final Set<Feature> availableFeatures;
    private final SetupState setupState;

    // Role: Position in stereo/surround setup
    public interface Role {
        class Mono implements Role { }     // Single speaker
        class FrontLeft implements Role { } // Stereo left
        class FrontRight implements Role { }// Stereo right
        class Loop implements Role {       // Multi-room loop
            String identifier;
        }
        class Unknown implements Role { }
    }

    // Device-level features
    public enum Feature {
        AutomaticInstallationId, BatteryPowered, Chromecast,
        ExplicitInstallationId, InputConfiguration, LatencyControlPerSource,
        Orientation, PowerManagement, PreferredInterfaceControl,
        RoomCorrection, Standby, StreamQuality
    }

    public enum SetupState { Ongoing, Finalized, Unknown }
}

System.java — System Configuration Model

A "System" is a logical grouping of devices (Solo, Duo, Surround, Multi):

public final class System {
    private final UUID id;
    private final UUID groupId;           // Parent group
    private final Map<UUID, Device> devices;
    private final Type type;              // Solo, Duo, Surround, Multi, Loop
    private final String name;
    private final Set<Feature> availableFeatures;
    private final SyncFamily syncFamily;
    private final boolean isGroupLeader;

    public enum Type { Solo, Duo, Surround, Multi, Loop }

    // System-level features (27 total)
    public enum Feature {
        AdaptiveVolumeLevelPerSource, AdaptiveVolumeLevelPerMode,
        ADHCalibration, Balance, BassReducerPerMode, BatteryPowered,
        ConfigurationBundle, Display, Equalizer, EqualizerPerMode,
        LatencyControlPerSource, LatencyControlPerSystem, LedMode,
        LoudnessPerMode, NightMode, NightModeOverlay, NightModePerSource,
        NeutralModeOverride, PerDeviceBluetoothControl, PowerManagement,
        PreferredInterfaceControl, PreOutPerSource, RenderingMode,
        RenderingModesPerSourceType, RoomAdaptation, SAM, Standby
    }
}

SourceManager.java — Complete Playback Control Interface

The central interface for all source, playback, and volume operations. This is what slPhantomRemote needs to implement full control:

public interface SourceManager {
    // === Constants ===
    static final int defaultSeekStepMs = 15000;      // 15 sec seek step
    static final int defaultSkipThresholdMs = 5000;  // 5 sec skip threshold
    static final int defaultVolumeStep = 5;          // Volume step size
    static final long volumeThrottleIntervalMs = 100; // Rate limit

    // === State Getters (all keyed by UUID) ===
    Map<UUID, SourceState> getActiveSourceByGroup();       // Active source per group
    Map<UUID, List<Source>> getSourcesByGroup();        // All sources per group
    Map<UUID, Integer> getVolumeByNode();                // Volume per node (0-100)
    Map<UUID, UUID> getPlaybackTargets();                // Playback target per source
    Map<UUID, RenderingModes> getRenderingModes();        // Audio mode per system
    Map<UUID, SourceConfiguration> getSourceConfigurations();
    Map<UUID, NightModeState> getNightModeStates();
    Map<UUID, AdaptiveVolumeLevelState> getAdaptiveVolumeLevelStates();
    Map<UUID, PreAmplificationOutputState> getPreAmplificationOutputStates();

    // === Input Configuration ===
    Map<UUID, ManoloConfiguration> getManoloConfigurations();  // Analog (RCA)
    Map<UUID, AuxConfiguration> getAuxConfigurations();       // Aux inputs
    Map<UUID, PhonoInputSettings> getPhonoInputSettings();    // Phono stage
    Map<UUID, BluetoothConfiguration> getBluetoothConfigurations();

    // === Streaming Metadata ===
    Map<UUID, ChromecastState> getChromecastStatuses();
    Map<UUID, RoonMetadata> getRoonMetadata();

    // === Events (RxJava Observable) ===
    Observable<SourceEvent> getObserve();

    // === Playback Control ===
    Completable play(UUID groupId, UUID sourceId);     // Play specific source
    Completable pause(UUID groupId);                    // Pause playback
    Completable togglePlay(UUID groupId);               // Play/pause toggle
    Completable next(UUID groupId);                     // Next track
    Completable previous(UUID groupId, int skipThresholdMs); // Previous track

    // === Seeking ===
    Completable seekTo(UUID groupId, int positionMs);   // Seek to position
    Completable seekBy(UUID groupId, int seekAmountMs, int skipThresholdMs);
    Completable seekForward(UUID groupId);              // +15 seconds
    Completable seekBackwards(UUID groupId);            // -15 seconds

    // === Volume Control ===
    Completable setVolume(UUID nodeId, int volume);     // Set volume (0-100)
    Completable increaseVolume(UUID nodeId);            // +5 volume
    Completable decreaseVolume(UUID nodeId);            // -5 volume
    Completable setMute(UUID groupId, boolean isMuted);

    // === Audio Settings Per Source ===
    Completable setRenderingMode(UUID sourceId, RenderingModes.Mode mode);
    Completable setConfiguredRenderingMode(UUID systemId, Source.Type sourceType, RenderingModes.Mode mode);
    Completable setNightMode(UUID sourceId, NightModeState state);
    Completable setAdaptiveVolumeLevel(UUID sourceId, AdaptiveVolumeLevelState state);
    Completable setLatency(UUID sourceId, int latencyMs);
    Completable setPreAmplificationOutput(UUID sourceId, PreAmplificationOutputState state);

    // === Analog Input (Manolo) ===
    Completable setActiveInput(UUID deviceId, ManoloConfiguration.InputMode mode);
    Completable setAutoSwitch(UUID sourceId, boolean enabled);
    Completable setAutoSwitch(UUID sourceId, ManoloConfiguration.InputMode mode, boolean enabled);
    Completable setInputSensitivity(UUID sourceId, ManoloConfiguration.InputMode mode, long sensitivity);

    // === Phono Stage Settings ===
    Completable setPhonoCartridgeBalance(UUID sourceId, int balance);
    Completable setPhonoLoadingCapacitance(UUID sourceId, PhonoInputSettings.LoadCapacitance capacitance);
    Completable setPhonoLoadingResistance(UUID sourceId, PhonoInputSettings.LoadResistance resistance);
    Completable setPhonoMaxOutputLevel(UUID sourceId, int maxLevel);
    Completable setPhonoStartupCurve(UUID sourceId, PhonoInputSettings.StartupCurve curve);

    // === Bluetooth ===
    Completable startBluetoothDiscoverability(UUID nodeId);

    // === Chromecast ===
    Completable acceptChromecastTermsOfService(UUID deviceId);
    Completable setChromecastDataSharingPolicy(UUID deviceId, boolean allowed);
}

Source.java — Source Model with All Types

public final class Source {
    private final UUID id;            // Source UUID
    private final UUID hostDeviceId;  // Host device UUID
    private final Type type;          // Source type enum
    private final String subType;     // Optional subtype
    private final String displayName; // User-visible name
    private final ImageResource icon;

    public enum Category { Online, Physical, Bluetooth, Unknown }

    public enum Type {
        // Online/Streaming (Category.Online)
        SpotifyConnect, Airplay, Airplay2, Chromecast, UPnP,
        RAAT, TidalConnect, Audirvana, Alexa,

        // Physical Inputs (Category.Physical)
        Optical1, Optical2, Optical, OpticalJack,
        Digital1, Digital2, Digital3, Digital4, DigitalLeft, DigitalRight,
        Line1, Line2, Line,
        Phono1, Phono2, Phono,
        UsbIn, HDMI, ArchPhysical,

        // Bluetooth (Category.Bluetooth)
        Bluetooth,

        Unknown
    }

    // Returns false for Chromecast, Airplay(1/2), Alexa, RAAT (multiroom not supported)
    public boolean getSupportsMultiroom();
}

Metadata.java — Track Information

public final class Metadata {
    private final String title;       // Track title
    private final String artist;      // Artist name
    private final String album;       // Album name
    private final MediaType mediaType;
    private final Integer duration;   // Duration in ms (nullable)
    private final ImageResource coverArt;

    public enum MediaType { Track, Podcast, Station, Live, Unknown }
}

RenderingModes.java — Audio Modes (Sound Profiles)

public final class RenderingModes {
    private final Set<Mode> availableModes;
    private final Mode activeMode;

    public enum Mode {
        Neutral,   // Flat response
        Music,     // Music optimized
        Movie,     // Movie/cinema
        Voice,     // Voice/dialog enhancement
        Podcast,   // Podcast/spoken word
        Spatial    // Spatial audio
    }
}

Quick Reference: What HTTP endpoints map to what SDK methods

Device → System → Group Relationship

┌─────────────────────────────────────────────────────────────────────────────┐
│  GROUP (Multi-room zone)                                                    │
│  └── groupId: UUID                                                          │
│  └── systemIds: Set<UUID>                                                   │
│                                                                             │
│  ┌─────────────────────────────┐    ┌─────────────────────────────┐        │
│  │ SYSTEM (Stereo pair/single)  │    │ SYSTEM                        │        │
│  │ type: Duo                   │    │ type: Solo                   │        │
│  │ isGroupLeader: true         │    │ isGroupLeader: false         │        │
│  │                             │    │                              │        │
│  │  ┌─────────┐  ┌─────────┐  │    │  ┌─────────┐                 │        │
│  │  │DEVICE   │  │DEVICE   │  │    │  │DEVICE   │                 │        │
│  │  │FrontLeft│  │FrontRigt│  │    │  │Mono     │                 │        │
│  │  │leader   │  │         │  │    │  │         │                 │        │
│  │  └─────────┘  └─────────┘  │    │  └─────────┘                 │        │
│  └─────────────────────────────┘    └─────────────────────────────┘        │
└─────────────────────────────────────────────────────────────────────────────┘

// Example: Get all devices in a group
Group group = topologyManager.getGroups().get(groupId);
for (UUID systemId : group.getSystemIds()) {
    System system = topologyManager.getSystems().get(systemId);
    for (Device device : system.getDevices().values()) {
        // Process each device
    }
}

TopologyManager.java — Group/System/Device Operations

Main interface for topology management. HTTP endpoints are resolved internally:

public interface TopologyManager {
    // Observable events (RxJava)
    Observable<TopologyEvent> getObserve();

    // Read topology state
    Map<UUID, Group> getGroups();
    Map<UUID, System> getSystems();
    Map<UUID, Device> getDevices();

    // Configured (persisted) state
    Map<UUID, Group> getConfiguredGroups();
    Map<UUID, System> getConfiguredSystems();
    Map<UUID, Device> getConfiguredDevices();

    // Create new system (Solo, Duo, Surround, Multi)
    Single<UUID> createSystem(String name, System.Type type, Map<UUID, Device.Role> devices);

    // Group operations
    Single<UUID> joinGroup(UUID systemId, UUID groupId);
    Single<UUID> ejectFromGroup(UUID systemId);

    // Device/System naming
    Completable setDeviceName(UUID deviceId, String name);
    Completable setSystemName(UUID systemId, String name);

    // Device configuration
    Completable setDeviceRoles(UUID systemId, Map<UUID, Device.Role> roles);
    Completable setDeviceSetupState(UUID deviceId, Device.SetupState state);
    Completable splitFromSystem(UUID deviceId);
}

GroupManager.java — Multi-room Group Operations

Kotlin coroutine-based interface for group management:

public interface GroupManager {
    // Check if group operations are allowed
    boolean canPerformGroupOperations(UUID groupId);

    // Get systems compatible with this group (same sync family)
    Set<UUID> getCompatibleSystems(UUID groupId);

    // Join a system to a group (suspend function - Kotlin coroutine)
    // Returns Result<UUID> - the new group ID
    Object join(UUID systemId, UUID groupId, Continuation<Result<UUID>> cont);

    // Remove system from its current group
    Object leaveGroup(UUID systemId, Continuation<Result<UUID>> cont);

    // Remove a system as group leader (makes another system leader)
    Object removeGroupLeader(UUID groupId, Continuation<Result<UUID>> cont);
}

Group.java — Group Data Model

public final class Group {
    private final UUID id;
    private final Set<UUID> systemIds;  // Systems in this group

    // Immutable operations - return new Group
    public Group plusSystem(UUID... systemIds);  // Add systems
    public Group minusSystem(UUID systemId);    // Remove system
}

How Module Codenames Map to Network Services

The song-themed codenames you see in network traffic are internal service identifiers used by Devialet's WhatsUp endpoint resolver. The resolver maps Java class namespaces to network endpoints:

Service Resolution Flow

// When you call setLedMode(), this happens internally:

// 1. Java layer (canttouchthis.Configuration)
configuration.setLedMode(LedMode.ALWAYS_ON);  // native method

// 2. JNI → Native (libmetaandroidd.so)
//    Calls into Qt/C++ code

// 3. EndpointResolver resolves service URL
Set<String> endpoints = endpointResolver.resolve(deviceUuid);
// Returns: ["http://192.168.1.x:80/ipcontrol/v1/"]

// 4. CallMeMaybe RPC serializes request as protobuf
//    or JSON depending on content-type

// 5. HTTP request sent:
PUT /ipcontrol/v1/systems/current/settings/ledMode
Content-Type: application/json
{"value": "alwaysOn"}

⚠️ Important for Third-Party Implementations: Not all Devialet app features are accessible via the HTTP IP Control API. Group management operations require the native library (libmetaandroidd.so) which uses a proprietary protocol.

Current Capability: slPhantomRemote can control playback, volume, sources, and read group status — covering ~80% of daily use cases.

Limitation: Users must use the official Devialet app (iOS/Android) to:

• Create or modify multi-room groups
• Set up stereo pairs (Left/Right assignment)
• Perform initial device setup and Wi-Fi provisioning
• Update firmware

Workaround: Once groups are configured via the Devialet app, slPhantomRemote can control them using the /groups/ namespace.

The native library uses these components for group management:

• MasterOfPuppets: Group coordination and leadership
• GetThePartyStarted: Multi-room session initiation
• CantTouchThis: Likely audio sync/timing
• WhatsUp: Service discovery and endpoint resolution

Reverse engineering would require:

1. Packet capture during group operations (Wireshark)
2. Analysis of Protocol Buffer message structures
3. Understanding the multicast coordination protocol
4. Potentially decompiling the native ARM64 library

This is a significant undertaking and may not be practical for a third-party project.

Protocol & Communication

• Transport: HTTP REST API wraps internal Protocol Buffer messages
• Content Types: application/json and application/protobuf supported
• Endpoint Resolution: WhatsUp module handles service discovery dynamically
• RPC Framework: CallMeMaybe provides request/response messaging

Native Library Details

• Main Library: libmetaandroidd.so (24.5 MB) - Devialet's proprietary code
• Qt Framework: Qt5 Core, Network, WebSockets, Bluetooth libraries
• Crypto: Custom libcrypto.dvlt.so and libssl.dvlt.so
• Build System: Built with Clang 9.0.9 from Android NDK
• Source Paths: /home/devialet/worker/blaze_android_builder_34/blazeandroid/LightMyFire/meta/

Hardware Codenames

• Manolo: Analog input (RCA/phono) - io.dvlt.liveislife.manolo
• PacoV3: HDMI input (ARC) - io.dvlt.liveislife.pacov3
• Paula: Network audio - io.dvlt.liveislife.paula
• Twix: Display/screen settings - io.dvlt.liveislife.twix
• Iec958: S/PDIF digital input - io.dvlt.liveislife.iec958