msg = f"Unknown provider domain: {provider_domain}"
raise KeyError(msg)
config_entries = await self.get_provider_config_entries(provider_domain)
- instance_id = f"{manifest.domain}--{shortuuid.random(8)}"
+ if manifest.multi_instance:
+ instance_id = f"{manifest.domain}--{shortuuid.random(8)}"
+ else:
+ instance_id = manifest.domain
default_config: ProviderConfig = ProviderConfig.parse(
config_entries,
{
if existing and not manifest.multi_instance:
msg = f"Provider {manifest.name} does not support multiple instances"
raise ValueError(msg)
- instance_id = f"{manifest.domain}--{shortuuid.random(8)}"
+ if manifest.multi_instance:
+ instance_id = f"{manifest.domain}--{shortuuid.random(8)}"
+ else:
+ instance_id = manifest.domain
# all checks passed, create config object
config_entries = await self.get_provider_config_entries(
provider_domain=provider_domain, instance_id=instance_id, values=values
msg = f"Player {player_id} is already registered"
raise AlreadyRegisteredError(msg)
- # make sure that the player's provider is set to the lookup key (=instance id)
+ # make sure that the player's provider is set to the instance_id
prov = self.mass.get_provider(player.provider)
- if not prov or prov.lookup_key != player.provider:
+ if not prov or prov.instance_id != player.provider:
raise RuntimeError(f"Invalid provider ID given: {player.provider}")
# make sure a default config exists
volume = FALLBACK_VOLUME
mass_player = Player(
player_id=player_id,
- provider=self.lookup_key,
+ provider=self.instance_id,
type=PlayerType.PLAYER,
name=display_name,
available=True,
PlayerFeature.VOLUME_SET,
},
volume_level=volume,
- can_group_with={self.lookup_key},
+ can_group_with={self.instance_id},
enabled_by_default=not is_broken_raop_model(manufacturer, model),
)
await self.mass.players.register_or_update(mass_player)
bluos_player.mass_player = mass_player = Player(
player_id=self.player_id,
- provider=self.lookup_key,
+ provider=self.instance_id,
type=PlayerType.PLAYER,
name=name,
available=True,
},
needs_poll=True,
poll_interval=30,
- can_group_with={self.lookup_key},
+ can_group_with={self.instance_id},
)
await self.mass.players.register(mass_player)
),
player=Player(
player_id=player_id,
- provider=self.lookup_key,
+ provider=self.instance_id,
type=player_type,
name=cast_info.friendly_name,
available=False,
udn=udn,
player=Player(
player_id=udn,
- provider=self.lookup_key,
+ provider=self.instance_id,
type=PlayerType.PLAYER,
name=udn,
available=False,
player = Player(
player_id=state["entity_id"],
- provider=self.lookup_key,
+ provider=self.instance_id,
type=PlayerType.PLAYER,
name=state["attributes"]["friendly_name"],
available=state["state"] not in UNAVAILABLE_STATES,
return base_entries # guard
if TYPE_CHECKING:
player_provider = cast(PlayerProvider, player_provider)
- assert player_provider.lookup_key != self.lookup_key
+ assert player_provider.instance_id != self.instance_id
if not (child_player := next((x for x in player_provider.players), None)):
return base_entries # guard
if ProviderFeature.SYNC_PLAYERS not in player_prov.supported_features:
msg = f"Provider {player_prov.name} does not support creating groups"
raise UnsupportedFeaturedException(msg)
- group_type = player_prov.lookup_key # just in case only domain was sent
+ group_type = player_prov.instance_id # just in case only domain was sent
new_group_id = f"{prefix}{shortuuid.random(8).lower()}"
# cleanup list, just in case the frontend sends some garbage
async def _register_all_players(self) -> None:
"""Register all (virtual/fake) group players in the Player controller."""
player_configs = await self.mass.config.get_player_configs(
- self.lookup_key, include_values=True
+ self.instance_id, include_values=True
)
for player_config in player_configs:
if self.mass.players.get(player_config.player_id):
)
can_group_with = {
# allow grouping with all providers, except the playergroup provider itself
- x.lookup_key
+ x.instance_id
for x in self.mass.players.providers
- if x.lookup_key != self.lookup_key
+ if x.instance_id != self.instance_id
}
player_features.add(PlayerFeature.MULTI_DEVICE_DSP)
elif player_provider := self.mass.get_provider(group_type):
player_provider = cast(PlayerProvider, player_provider)
model_name = "Sync Group"
manufacturer = self.mass.get_provider(group_type).name
- can_group_with = {player_provider.lookup_key}
+ can_group_with = {player_provider.instance_id}
for feature in (PlayerFeature.PAUSE, PlayerFeature.VOLUME_MUTE, PlayerFeature.ENQUEUE):
if all(feature in x.supported_features for x in player_provider.players):
player_features.add(feature)
player = Player(
player_id=group_player_id,
- provider=self.lookup_key,
+ provider=self.instance_id,
type=PlayerType.GROUP,
name=name,
available=True,
if group_type == GROUP_TYPE_UNIVERSAL:
can_group_with = {
# allow grouping with all providers, except the playergroup provider itself
- x.lookup_key
+ x.instance_id
for x in self.mass.players.providers
- if x.lookup_key != self.lookup_key
+ if x.instance_id != self.instance_id
}
elif sync_player_provider := self.mass.get_provider(group_type):
- can_group_with = {sync_player_provider.lookup_key}
+ can_group_with = {sync_player_provider.instance_id}
else:
can_group_with = {}
player.can_group_with = can_group_with
x
for x in members
if (player := self.mass.players.get(x))
- and player.provider == player_provider.lookup_key
+ and player.provider == player_provider.instance_id
]
# cleanup members - filter out impossible choices
syncgroup_childs: list[str] = []
# player does not yet exist, create it
player = Player(
player_id=player_id,
- provider=self.lookup_key,
+ provider=self.instance_id,
type=PlayerType.PLAYER,
name=slimplayer.name,
available=True,
PlayerFeature.VOLUME_MUTE,
PlayerFeature.ENQUEUE,
},
- can_group_with={self.lookup_key},
+ can_group_with={self.instance_id},
)
await self.mass.players.register_or_update(player)
)
player = Player(
player_id=player_id,
- provider=self.lookup_key,
+ provider=self.instance_id,
type=PlayerType.PLAYER,
name=snap_client.friendly_name,
available=snap_client.connected,
PlayerFeature.VOLUME_MUTE,
},
synced_to=self._synced_to(player_id),
- can_group_with={self.lookup_key},
+ can_group_with={self.instance_id},
)
asyncio.run_coroutine_threadsafe(
self.mass.players.register_or_update(player), loop=self.mass.loop
# instantiate the MA player
self.mass_player = mass_player = Player(
player_id=self.player_id,
- provider=self.prov.lookup_key,
+ provider=self.prov.instance_id,
type=PlayerType.PLAYER,
name=self.discovery_info["device"]["name"]
or self.discovery_info["device"]["modelDisplayName"],
supported_features=supported_features,
# NOTE: strictly taken we can have multiple sonos households
# but for now we assume we only have one
- can_group_with={self.prov.lookup_key},
+ can_group_with={self.prov.instance_id},
)
if SonosCapability.LINE_IN in self.discovery_info["device"]["capabilities"]:
mass_player.source_list.append(PLAYER_SOURCE_MAP[SOURCE_LINE_IN])
if x.player_id != airplay_player.player_id
)
else:
- self.mass_player.can_group_with = {self.prov.lookup_key}
+ self.mass_player.can_group_with = {self.prov.instance_id}
self.mass_player.synced_to = None
else:
# player is group child (synced to another player)
if not (mass_player := self.mass.players.get(soco.uid)):
mass_player = Player(
player_id=soco.uid,
- provider=self.lookup_key,
+ provider=self.instance_id,
type=PlayerType.PLAYER,
name=soco.player_name,
available=True,
),
needs_poll=True,
poll_interval=30,
- can_group_with={self.lookup_key},
+ can_group_with={self.instance_id},
)
self.sonosplayers[player_id] = sonos_player = SonosPlayer(
self,
self._librespot_started = asyncio.Event()
self.named_pipe = f"/tmp/{self.instance_id}" # noqa: S108
self._source_details = PluginSource(
- id=self.lookup_key,
+ id=self.instance_id,
name=self.manifest.name,
# we set passive to true because we
# dont allow this source to be selected directly
# initiate playback by selecting this source on the default player
self.logger.error("Initiating playback on %s", self.mass_player_id)
self.mass.create_task(
- self.mass.players.select_source(self.mass_player_id, self.lookup_key)
+ self.mass.players.select_source(self.mass_player_id, self.instance_id)
)
self._source_details.in_use_by = self.mass_player_id
projects / music-assistant-server.git / commitdiff