Refactor Airplay provider a bit

Author: marcelveldt

music_assistant/providers/airplay/helpers.py

@@ -4,16 +4,20 @@
 
 import os
 import platform
+import time
 from typing import TYPE_CHECKING
 
 from zeroconf import IPVersion
 
 from music_assistant.helpers.process import check_output
-from music_assistant.providers.airplay.constants import BROKEN_RAOP_MODELS
+from music_assistant.providers.airplay.constants import BROKEN_RAOP_MODELS, StreamingProtocol
 
 if TYPE_CHECKING:
     from zeroconf.asyncio import AsyncServiceInfo
 
+# NTP epoch delta: difference between Unix epoch (1970) and NTP epoch (1900)
+NTP_EPOCH_DELTA = 0x83AA7E80  # 2208988800 seconds
+
 
 def convert_airplay_volume(value: float) -> int:
     """Remap AirPlay Volume to 0..100 scale."""
@@ -25,7 +29,7 @@ def convert_airplay_volume(value: float) -> int:
     return int(portion + normal_min)
 
 
-def get_model_info(info: AsyncServiceInfo) -> tuple[str, str]:
+def get_model_info(info: AsyncServiceInfo) -> tuple[str, str]:  # noqa: PLR0911
     """Return Manufacturer and Model name from mdns info."""
     manufacturer = info.decoded_properties.get("manufacturer")
     model = info.decoded_properties.get("model")
@@ -57,13 +61,35 @@ def get_model_info(info: AsyncServiceInfo) -> tuple[str, str]:
         return ("Apple", "Apple TV 4K Gen2")
     if model == "AppleTV14,1":
         return ("Apple", "Apple TV 4K Gen3")
+    if model == "UPL-AMP":
+        return ("Ubiquiti Inc.", "UPL-AMP")
     if "AirPort" in model:
         return ("Apple", "AirPort Express")
     if "AudioAccessory" in model:
         return ("Apple", "HomePod")
     if "AppleTV" in model:
         model = "Apple TV"
         manufacturer = "Apple"
+    # Detect Mac devices (Mac mini, MacBook, iMac, etc.)
+    # Model identifiers like: Mac16,11, MacBookPro18,3, iMac21,1
+    if model.startswith(("Mac", "iMac")):
+        # Parse Mac model to friendly name
+        if model.startswith("MacBookPro"):
+            return ("Apple", f"MacBook Pro ({model})")
+        if model.startswith("MacBookAir"):
+            return ("Apple", f"MacBook Air ({model})")
+        if model.startswith("MacBook"):
+            return ("Apple", f"MacBook ({model})")
+        if model.startswith("iMac"):
+            return ("Apple", f"iMac ({model})")
+        if model.startswith("Macmini"):
+            return ("Apple", f"Mac mini ({model})")
+        if model.startswith("MacPro"):
+            return ("Apple", f"Mac Pro ({model})")
+        if model.startswith("MacStudio"):
+            return ("Apple", f"Mac Studio ({model})")
+        # Generic Mac device (e.g. Mac16,11 for Mac mini M4)
+        return ("Apple", f"Mac ({model})")
 
     return (manufacturer or "AirPlay", model)
 
@@ -89,17 +115,43 @@ def is_broken_raop_model(manufacturer: str, model: str) -> bool:
     return False
 
 
-async def get_cliraop_binary() -> str:
-    """Find the correct raop/airplay binary belonging to the platform."""
+async def get_cli_binary(protocol: StreamingProtocol) -> str:
+    """Find the correct raop/airplay binary belonging to the platform.
+
+    Args:
+        protocol: The streaming protocol (RAOP or AIRPLAY2)
+
+    Returns:
+        Path to the CLI binary
 
-    async def check_binary(cliraop_path: str) -> str | None:
+    Raises:
+        RuntimeError: If the binary cannot be found
+    """
+
+    async def check_binary(cli_path: str) -> str | None:
         try:
-            returncode, output = await check_output(
-                cliraop_path,
-                "-check",
-            )
-            if returncode == 0 and output.strip().decode() == "cliraop check":
-                return cliraop_path
+            if protocol == StreamingProtocol.RAOP:
+                args = [
+                    cli_path,
+                    "-check",
+                ]
+                passing_output = "cliraop check"
+            else:
+                config_file = os.path.join(os.path.dirname(__file__), "bin", "cliap2.conf")
+                args = [
+                    cli_path,
+                    "--testrun",
+                    "--config",
+                    config_file,
+                ]
+
+            returncode, output = await check_output(*args)
+            if (
+                protocol == StreamingProtocol.RAOP
+                and returncode == 0
+                and output.strip().decode() == passing_output
+            ) or (protocol == StreamingProtocol.AIRPLAY2 and returncode == 0):
+                return cli_path
         except OSError:
             pass
         return None
@@ -108,10 +160,125 @@ async def check_binary(cliraop_path: str) -> str | None:
     system = platform.system().lower().replace("darwin", "macos")
     architecture = platform.machine().lower()
 
+    if protocol == StreamingProtocol.RAOP:
+        package = "cliraop"
+    elif protocol == StreamingProtocol.AIRPLAY2:
+        package = "cliap2"
+    else:
+        raise RuntimeError(f"Unsupported streaming protocol requested: {protocol}")
+
     if bridge_binary := await check_binary(
-        os.path.join(base_path, f"cliraop-{system}-{architecture}")
+        os.path.join(base_path, f"{package}-{system}-{architecture}")
     ):
         return bridge_binary
 
-    msg = f"Unable to locate RAOP Play binary for {system}/{architecture}"
+    msg = (
+        f"Unable to locate {protocol.name} CLI stream binary {package} for {system}/{architecture}"
+    )
     raise RuntimeError(msg)
+
+
+def get_ntp_timestamp() -> int:
+    """
+    Get current NTP timestamp (64-bit).
+
+    Returns:
+        int: 64-bit NTP timestamp (upper 32 bits = seconds, lower 32 bits = fraction)
+    """
+    # Get current Unix timestamp with microsecond precision
+    current_time = time.time()
+
+    # Split into seconds and microseconds
+    seconds = int(current_time)
+    microseconds = int((current_time - seconds) * 1_000_000)
+
+    # Convert to NTP epoch (add offset from 1970 to 1900)
+    ntp_seconds = seconds + NTP_EPOCH_DELTA
+
+    # Convert microseconds to NTP fraction (2^32 parts per second)
+    # fraction = (microseconds * 2^32) / 1_000_000
+    ntp_fraction = int((microseconds << 32) / 1_000_000)
+
+    # Combine into 64-bit value
+    return (ntp_seconds << 32) | ntp_fraction
+
+
+def ntp_to_seconds_fraction(ntp_timestamp: int) -> tuple[int, int]:
+    """
+    Split NTP timestamp into seconds and fraction components.
+
+    Args:
+        ntp_timestamp: 64-bit NTP timestamp
+
+    Returns:
+        tuple: (seconds, fraction)
+    """
+    seconds = ntp_timestamp >> 32
+    fraction = ntp_timestamp & 0xFFFFFFFF
+    return seconds, fraction
+
+
+def ntp_to_unix_time(ntp_timestamp: int) -> float:
+    """
+    Convert NTP timestamp to Unix timestamp (float).
+
+    Args:
+        ntp_timestamp: 64-bit NTP timestamp
+
+    Returns:
+        float: Unix timestamp (seconds since 1970-01-01)
+    """
+    seconds = ntp_timestamp >> 32
+    fraction = ntp_timestamp & 0xFFFFFFFF
+
+    # Convert back to Unix epoch
+    unix_seconds = seconds - NTP_EPOCH_DELTA
+
+    # Convert fraction to microseconds
+    microseconds = (fraction * 1_000_000) >> 32
+
+    return unix_seconds + (microseconds / 1_000_000)
+
+
+def unix_time_to_ntp(unix_timestamp: float) -> int:
+    """
+    Convert Unix timestamp (float) to NTP timestamp.
+
+    Args:
+        unix_timestamp: Unix timestamp (seconds since 1970-01-01)
+
+    Returns:
+        int: 64-bit NTP timestamp
+    """
+    seconds = int(unix_timestamp)
+    microseconds = int((unix_timestamp - seconds) * 1_000_000)
+
+    # Convert to NTP epoch
+    ntp_seconds = seconds + NTP_EPOCH_DELTA
+
+    # Convert microseconds to NTP fraction
+    ntp_fraction = int((microseconds << 32) / 1_000_000)
+
+    return (ntp_seconds << 32) | ntp_fraction
+
+
+def add_seconds_to_ntp(ntp_timestamp: int, seconds: float) -> int:
+    """
+    Add seconds to an NTP timestamp.
+
+    Args:
+        ntp_timestamp: 64-bit NTP timestamp
+        seconds: Number of seconds to add (can be fractional)
+
+    Returns:
+        int: New NTP timestamp with seconds added
+    """
+    # Extract whole seconds and fraction
+    whole_seconds = int(seconds)
+    fraction = seconds - whole_seconds
+
+    # Convert to NTP format (upper 32 bits = seconds, lower 32 bits = fraction)
+    ntp_seconds = whole_seconds << 32
+    ntp_fraction = int(fraction * (1 << 32))
+
+    return ntp_timestamp + ntp_seconds + ntp_fraction