something-x-dev 1.2.3.dev1__py3-none-any.whl

nothing_app/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "1.0.0"
+APP_ID = "com.something.x.omarchy"

nothing_app/application.py

@@ -0,0 +1,244 @@
+import os
+import shutil
+import subprocess
+import sys
+import importlib.resources
+import gi
+
+gi.require_version("Gtk", "4.0")
+gi.require_version("Adw", "1")
+gi.require_version("Gdk", "4.0")
+from gi.repository import Gtk, Adw, Gdk, Gio, GLib
+
+from .bluetooth import BluetoothManager
+from .window import SomethingXWindow
+from .splash import SplashScreen
+
+
+def _install_desktop_file():
+    dest_dir = os.path.expanduser("~/.local/share/applications")
+    dest = os.path.join(dest_dir, "com.something.x.omarchy.desktop")
+    if os.path.exists(dest):
+        return
+    try:
+        ref = importlib.resources.files("nothing_app.data").joinpath("com.something.x.omarchy.desktop")
+        os.makedirs(dest_dir, exist_ok=True)
+        with importlib.resources.as_file(ref) as src:
+            shutil.copy2(src, dest)
+        subprocess.run(["update-desktop-database", dest_dir], capture_output=True)
+        print("[app] desktop file installed to ~/.local/share/applications/")
+    except Exception as exc:
+        print(f"[app] desktop file install skipped: {exc}")
+
+
+def _css_path() -> str:
+    try:
+        ref = importlib.resources.files("nothing_app.data").joinpath("style.css")
+        return str(ref)
+    except Exception:
+        import os
+
+        return os.path.join(os.path.dirname(__file__), "data", "style.css")
+
+
+class SomethingXApplication(Adw.Application):
+    def __init__(self):
+        super().__init__(
+            application_id="com.something.x.omarchy",
+            flags=Gio.ApplicationFlags.DEFAULT_FLAGS,
+        )
+        self._bt: BluetoothManager | None = None
+        self._splash: SplashScreen | None = None
+        self._window: SomethingXWindow | None = None
+        self.connect("activate", self._on_activate)
+
+    def _on_activate(self, _app):
+        # Second launch while already running: just show the existing window
+        if self._window is not None:
+            self._window.present()
+            return
+
+        _install_desktop_file()
+        Adw.StyleManager.get_default().set_color_scheme(Adw.ColorScheme.FORCE_DARK)
+        self._load_css()
+        self._bt = BluetoothManager()
+        splash = SplashScreen(on_done=self._on_splash_done)
+        splash.set_application(self)
+        self._splash = splash
+        splash.present()
+        splash.start()
+
+    def _on_splash_done(self):
+        win = SomethingXWindow(bt_manager=self._bt, application=self)
+        win.connect("close-request", self._on_window_close)
+        self._window = win
+        win.present()
+        if self._splash:
+            self._splash.destroy()
+            self._splash = None
+
+    def _on_window_close(self, _win):
+        # Hide instead of destroy so the app keeps running in background
+        self._window.hide()
+        subprocess.Popen(
+            [
+                "notify-send",
+                "-i",
+                "audio-headphones",
+                "Something X",
+                "Running in background. Launch again to reopen.",
+            ],
+            start_new_session=True,
+        )
+        return True  # prevent default close/destroy
+
+    def _load_css(self):
+        provider = Gtk.CssProvider()
+        css = _css_path()
+        try:
+            provider.load_from_path(css)
+        except Exception as exc:
+            print(f"[app] CSS load failed ({css}): {exc}")
+
+        display = Gdk.Display.get_default()
+        if display:
+            Gtk.StyleContext.add_provider_for_display(
+                display,
+                provider,
+                Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
+            )
+
+
+# ── CLI quick-toggle mode ─────────────────────────────────────────────────────
+
+_ANC_ALIASES = {
+    "off": 0,
+    "0": 0,
+    "on": 1,
+    "anc": 1,
+    "noise": 1,
+    "transparency": 2,
+    "trans": 2,
+    "passthrough": 2,
+}
+
+_EQ_ALIASES = {
+    "balanced": "Balanced",
+    "bass": "More Bass",
+    "treble": "More Treble",
+    "voice": "Voice",
+}
+
+
+def _run_cli(argv: list[str]) -> int:
+    from . import protocol as _proto
+
+    _proto._QUIET = True
+    from .protocol import NothingDevice, ANCMode
+    from . import profiles
+
+    address = None
+    if "--device" in argv:
+        idx = argv.index("--device")
+        if idx + 1 < len(argv):
+            address = argv[idx + 1]
+
+    if address is None:
+        address = profiles.get_last_device()
+
+    if address is None:
+        print(
+            "No known device. Open the GUI and connect to a device first,\n"
+            "or pass --device AA:BB:CC:DD:EE:FF.",
+            file=sys.stderr,
+        )
+        return 1
+
+    loop = GLib.MainLoop()
+    dev = NothingDevice(address)
+    exit_code = [0]
+    _acted = [False]
+
+    def _act():
+        if _acted[0]:
+            return False
+        _acted[0] = True
+
+        if "--battery" in argv:
+            s = dev.state
+            parts = []
+            if s.left_battery >= 0:
+                parts.append(f"Left: {s.left_battery}%")
+            if s.right_battery >= 0:
+                parts.append(f"Right: {s.right_battery}%")
+            if s.case_battery >= 0:
+                parts.append(f"Case: {s.case_battery}%")
+            print("  ".join(parts) if parts else "No battery data received.")
+
+        if "--anc" in argv:
+            idx = argv.index("--anc")
+            val = argv[idx + 1] if idx + 1 < len(argv) else ""
+            mode = _ANC_ALIASES.get(val.lower())
+            if mode is None:
+                print(f"Unknown ANC value '{val}'. Use: off, on, transparency", file=sys.stderr)
+                exit_code[0] = 1
+            else:
+                dev.set_anc_mode(mode)
+                print(f"ANC → {ANCMode.LABELS.get(mode)}")
+
+        if "--eq" in argv:
+            idx = argv.index("--eq")
+            val = argv[idx + 1] if idx + 1 < len(argv) else ""
+            preset = _EQ_ALIASES.get(val.lower())
+            if preset is None:
+                print(f"Unknown EQ preset '{val}'. Use: balanced, bass, treble, voice", file=sys.stderr)
+                exit_code[0] = 1
+            else:
+                dev.set_eq_preset(preset)
+                print(f"EQ → {preset}")
+
+        GLib.timeout_add(600, loop.quit)
+        return False
+
+    def _on_state_changed(_d):
+        if dev.state.left_battery >= 0 or dev.state.right_battery >= 0:
+            _act()
+
+    def _on_timeout():
+        print("Timeout: device did not respond in time.", file=sys.stderr)
+        exit_code[0] = 1
+        loop.quit()
+        return False
+
+    dev.connect("state-changed", _on_state_changed)
+    dev.connect_rfcomm()
+    GLib.timeout_add(12000, _on_timeout)
+    loop.run()
+    dev.disconnect_rfcomm()
+    return exit_code[0]
+
+
+def _print_help():
+    print(
+        "Usage:\n"
+        "  something-x                             launch GUI\n"
+        "  something-x --battery                   print battery levels\n"
+        "  something-x --anc off|on|transparency   set ANC mode\n"
+        "  something-x --eq balanced|bass|treble|voice  set EQ preset\n"
+        "  something-x --device AA:BB:CC:DD:EE:FF  target specific device\n"
+    )
+
+
+def main():
+    argv = sys.argv[1:]
+    cli_flags = {"--battery", "--anc", "--eq"}
+
+    if "--help" in argv or "-h" in argv:
+        _print_help()
+        sys.exit(0)
+
+    if any(f in argv for f in cli_flags):
+        sys.exit(_run_cli(argv))
+
+    app = SomethingXApplication()
+    sys.exit(app.run(sys.argv))

nothing_app/bluetooth.py

@@ -0,0 +1,212 @@
+import dbus
+import dbus.mainloop.glib
+from gi.repository import GLib, GObject
+
+BLUEZ_SERVICE = "org.bluez"
+ADAPTER_IFACE = "org.bluez.Adapter1"
+DEVICE_IFACE = "org.bluez.Device1"
+BATTERY_IFACE = "org.bluez.Battery1"
+OBJ_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
+PROPERTIES_IFACE = "org.freedesktop.DBus.Properties"
+
+NOTHING_PATTERNS = (
+    "nothing ear",
+    "ear (1)",
+    "ear (2)",
+    "ear (a)",
+    "ear (stick)",
+    "cmf buds",
+    "cmf earphone",
+    "nothing phone",
+)
+
+
+class BluetoothDevice:
+    def __init__(self, path: str, props: dict):
+        self.path = path
+        self.address: str = str(props.get("Address", ""))
+        self.name: str = str(props.get("Name", props.get("Alias", "Unknown Device")))
+        self.connected: bool = bool(props.get("Connected", False))
+        self.paired: bool = bool(props.get("Paired", False))
+        self.battery: int | None = None
+        self.icon: str = str(props.get("Icon", "audio-headphones"))
+        self.is_nothing: bool = any(p in self.name.lower() for p in NOTHING_PATTERNS)
+
+    def update(self, changed: dict):
+        if "Connected" in changed:
+            self.connected = bool(changed["Connected"])
+        if "Name" in changed:
+            self.name = str(changed["Name"])
+        if "Alias" in changed and not self.name:
+            self.name = str(changed["Alias"])
+
+    def __repr__(self):
+        return f"<BTDevice {self.name!r} {'●' if self.connected else '○'}>"
+
+
+class BluetoothManager(GObject.Object):
+    __gsignals__ = {
+        "devices-changed": (GObject.SignalFlags.RUN_FIRST, None, ()),
+        "device-connected": (GObject.SignalFlags.RUN_FIRST, None, (str,)),
+        "device-disconnected": (GObject.SignalFlags.RUN_FIRST, None, (str,)),
+    }
+
+    def __init__(self):
+        super().__init__()
+        self.devices: dict[str, BluetoothDevice] = {}
+        self._bus: dbus.SystemBus | None = None
+        self._available = False
+        self._init_dbus()
+
+    def _init_dbus(self):
+        try:
+            dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+            self._bus = dbus.SystemBus()
+            self._refresh()
+            self._subscribe()
+            self._available = True
+        except Exception as exc:
+            print(f"[bluetooth] D-Bus init failed: {exc}")
+
+    def _refresh(self):
+        if not self._bus:
+            return
+        try:
+            mgr = dbus.Interface(
+                self._bus.get_object(BLUEZ_SERVICE, "/"),
+                OBJ_MANAGER_IFACE,
+            )
+            objects = mgr.GetManagedObjects()
+            self.devices = {}
+            for path, ifaces in objects.items():
+                if DEVICE_IFACE not in ifaces:
+                    continue
+                props = {str(k): v for k, v in ifaces[DEVICE_IFACE].items()}
+                dev = BluetoothDevice(str(path), props)
+                if BATTERY_IFACE in ifaces:
+                    dev.battery = int(ifaces[BATTERY_IFACE].get("Percentage", 0))
+                self.devices[str(path)] = dev
+        except Exception as exc:
+            print(f"[bluetooth] Refresh failed: {exc}")
+
+    def _subscribe(self):
+        if not self._bus:
+            return
+        try:
+            self._bus.add_signal_receiver(
+                self._on_props_changed,
+                signal_name="PropertiesChanged",
+                dbus_interface=PROPERTIES_IFACE,
+                path_keyword="path",
+            )
+            self._bus.add_signal_receiver(
+                self._on_ifaces_added,
+                signal_name="InterfacesAdded",
+                dbus_interface=OBJ_MANAGER_IFACE,
+                bus_name=BLUEZ_SERVICE,
+            )
+            self._bus.add_signal_receiver(
+                self._on_ifaces_removed,
+                signal_name="InterfacesRemoved",
+                dbus_interface=OBJ_MANAGER_IFACE,
+                bus_name=BLUEZ_SERVICE,
+            )
+        except Exception as exc:
+            print(f"[bluetooth] Signal subscribe failed: {exc}")
+
+    def _on_props_changed(self, interface, changed, _invalidated=None, path=None):
+        if interface != DEVICE_IFACE:
+            return
+        if not path:
+            return
+        path = str(path)
+        if path not in self.devices:
+            return
+        dev = self.devices[path]
+        old_connected = dev.connected
+        dev.update({str(k): v for k, v in changed.items()})
+        if dev.connected != old_connected:
+            sig = "device-connected" if dev.connected else "device-disconnected"
+            GLib.idle_add(self.emit, sig, path)
+        GLib.idle_add(self.emit, "devices-changed")
+
+    def _on_ifaces_added(self, path, ifaces):
+        if DEVICE_IFACE not in ifaces:
+            return
+        props = {str(k): v for k, v in ifaces[DEVICE_IFACE].items()}
+        dev = BluetoothDevice(str(path), props)
+        if BATTERY_IFACE in ifaces:
+            dev.battery = int(ifaces[BATTERY_IFACE].get("Percentage", 0))
+        self.devices[str(path)] = dev
+        GLib.idle_add(self.emit, "devices-changed")
+
+    def _on_ifaces_removed(self, path, ifaces):
+        path = str(path)
+        if DEVICE_IFACE in ifaces and path in self.devices:
+            del self.devices[path]
+            GLib.idle_add(self.emit, "devices-changed")
+
+    @property
+    def available(self) -> bool:
+        return self._available
+
+    def get_all(self) -> list[BluetoothDevice]:
+        return sorted(self.devices.values(), key=lambda d: (not d.connected, d.name))
+
+    def get_nothing_devices(self) -> list[BluetoothDevice]:
+        return [d for d in self.get_all() if d.is_nothing]
+
+    def refresh(self):
+        self._refresh()
+        self.emit("devices-changed")
+
+    def connect_device(self, path: str, on_error=None):
+        if not self._bus:
+            return
+
+        def _err(e):
+            print(f"[BT] connect error: {e}")
+            if on_error:
+                GLib.idle_add(on_error)
+
+        try:
+            iface = dbus.Interface(self._bus.get_object(BLUEZ_SERVICE, path), DEVICE_IFACE)
+            iface.Connect(reply_handler=lambda: None, error_handler=_err)
+        except Exception as exc:
+            print(f"[bluetooth] connect {path}: {exc}")
+            if on_error:
+                GLib.idle_add(on_error)
+
+    def disconnect_device(self, path: str):
+        if not self._bus:
+            return
+        try:
+            iface = dbus.Interface(self._bus.get_object(BLUEZ_SERVICE, path), DEVICE_IFACE)
+            iface.Disconnect(
+                reply_handler=lambda: None,
+                error_handler=lambda e: print(f"[BT] disconnect error: {e}"),
+            )
+        except Exception as exc:
+            print(f"[bluetooth] disconnect {path}: {exc}")
+
+    def start_discovery(self):
+        if not self._bus:
+            return
+        try:
+            mgr = dbus.Interface(self._bus.get_object(BLUEZ_SERVICE, "/"), OBJ_MANAGER_IFACE)
+            for path, ifaces in mgr.GetManagedObjects().items():
+                if ADAPTER_IFACE in ifaces:
+                    adapter = dbus.Interface(self._bus.get_object(BLUEZ_SERVICE, path), ADAPTER_IFACE)
+                    adapter.StartDiscovery()
+                    GLib.timeout_add_seconds(30, self._stop_discovery_on_path, str(path))
+                    break
+        except Exception as exc:
+            print(f"[bluetooth] discovery start: {exc}")
+
+    def _stop_discovery_on_path(self, path: str):
+        try:
+            adapter = dbus.Interface(self._bus.get_object(BLUEZ_SERVICE, path), ADAPTER_IFACE)
+            adapter.StopDiscovery()
+        except Exception:
+            pass
+        return False

nothing_app/data/com.something.x.omarchy.desktop

@@ -0,0 +1,13 @@
+[Desktop Entry]
+Version=1.0
+Type=Application
+Name=Something X
+GenericName=Bluetooth Device Manager
+Comment=Manage Nothing and CMF Bluetooth devices
+Exec=something-x
+Icon=audio-headphones
+Categories=Utility;GTK;HardwareSettings;
+Keywords=bluetooth;nothing;ear;cmf;audio;headphones;earbuds;
+Terminal=false
+StartupNotify=true
+StartupWMClass=com.something.x.omarchy