spotifywebapiPython 1.0.131__py3-none-any.whl → 1.0.133__py3-none-any.whl

spotifywebapipython/models/zeroconfdiscoveryresult.py

@@ -22,6 +22,8 @@ class ZeroconfDiscoveryResult:
         self._HostIpAddresses:list = []
         self._HostIpPort:int = None
         self._HostTTL:int = None
+        self._IsChromeCast:bool = False
+        self._Id:str = None
         self._Key:str = None
         self._Name:str = None
         self._OtherTTL:int = None
@@ -162,6 +164,24 @@ class ZeroconfDiscoveryResult:
             self._HostTTL = value
 
 
+    @property
+    def Id(self) -> str:
+        """ 
+        Result ID (e.g. "Bose-ST10-1" (192.168.1.81:8200)).
+
+        This is a helper property, and not part of the Zeroconf interface.
+        """
+        return self._Id
+    
+    @Id.setter
+    def Id(self, value:str):
+        """ 
+        Sets the Id property value.
+        """
+        if isinstance(value, str):
+            self._Id = value
+
+
     @property
     def IsDynamicDevice(self) -> bool:
         """
@@ -172,7 +192,23 @@ class ZeroconfDiscoveryResult:
         process, but still exist in the player device list.  These are usually Spotify Connect
         web or mobile players with temporary device id's.       
         """
-        return (self._HostIpPort == 0)
+        return (self._HostIpPort == 0) and (self._ServiceType is None)
+
+
+    @property
+    def IsChromeCast(self) -> bool:
+        """ 
+        True if the device is a Google ChromeCast device; otherwise, False.
+        """
+        return self._IsChromeCast
+    
+    @IsChromeCast.setter
+    def IsChromeCast(self, value:bool):
+        """ 
+        Sets the IsChromeCast property value.
+        """
+        if isinstance(value, bool):
+            self._IsChromeCast = value
 
 
     @property
@@ -429,6 +465,7 @@ class ZeroconfDiscoveryResult:
         """
         result:dict = \
         {
+            'Id': self._Id,
             'DeviceName': self._DeviceName,
             'Domain': self._Domain,
             'HostIpAddress': self.HostIpAddress,
@@ -436,6 +473,7 @@ class ZeroconfDiscoveryResult:
             'HostIpPort': self._HostIpPort,
             'HostTTL': self._HostTTL,
             'IsDynamicDevice': self.IsDynamicDevice,
+            'IsChromeCast': self._IsChromeCast,
             'Key': self._Key,
             'Name': self._Name,
             'Priority': self._Priority,
@@ -473,12 +511,14 @@ class ZeroconfDiscoveryResult:
         zeroconfApiEndpointResetUsers:str = self.ZeroconfApiEndpointResetUsers
         
         # build result.
+        if self._Id is not None: msg = '%s\n Id="%s"' % (msg, str(self._Id))
         if self._DeviceName is not None: msg = '%s\n DeviceName="%s"' % (msg, str(self._DeviceName))
         if self._Domain is not None: msg = '%s\n Domain="%s"' % (msg, str(self._Domain))
         if self._HostIpAddresses is not None: msg = '%s\n HostIpAddresses Count=%s' % (msg, str(len(self._HostIpAddresses)))
         if self.HostIpAddress is not None: msg = '%s\n HostIpAddress="%s"' % (msg, str(self.HostIpAddress))
         if self._HostIpPort is not None: msg = '%s\n HostIpPort="%s"' % (msg, str(self._HostIpPort))
         if self._HostTTL is not None: msg = '%s\n HostTTL="%s"' % (msg, str(self._HostTTL))
+        if self._IsChromeCast is not None: msg = '%s\n IsChromeCast="%s"' % (msg, str(self._IsChromeCast))
         if self._Key is not None: msg = '%s\n Key="%s"' % (msg, str(self._Key))
         if self._Name is not None: msg = '%s\n Name="%s"' % (msg, str(self._Name))
         if self._Priority is not None: msg = '%s\n Priority="%s"' % (msg, str(self._Priority))

spotifywebapipython/spotifyclient.py

@@ -49,6 +49,11 @@ from .const import (
 CACHE_SOURCE_CACHED:str = "cached"
 CACHE_SOURCE_CURRENT:str = "current"
 
+DELAY_DISCONNECT:float = 0.350
+"""
+Time to wait after a Spotify Connect Disconnect command is issued (350ms).
+"""
+
 SPOTIFY_DJ_PLAYLIST_ID = "37i9dqzf1eykqdzj48dyyq"
 
 SPOTIFY_ONLINE_LINK_PREFIX = "https://open.spotify.com"
@@ -6944,10 +6949,41 @@ class SpotifyClient:
                         # Spotify Connect Zeroconf `resetUsers` endpoint is not implemented and will
                         # generate a 404 request response.
                         if (info.BrandDisplayName != 'librespot'):
+
                             _logsi.LogVerbose("Issuing Disconnect to Spotify Connect device '%s' for current user context '%s'" % (scDevice.Title, deviceActiveUser))
                             zcfResult = zconn.Disconnect(delay)
                             status = status + 'disconnected from user context "%s"; ' % deviceActiveUser
+
+                            # delay just a little to give the device time to process the disconnect.
+                            # some devices only support a single connection on the spotify connect 
+                            # zeroconf webserver, so we have to give it a little time to process the 
+                            # disconnect command before we try to call the Connect method.
+                            _logsi.LogVerbose(TRACE_MSG_DELAY_DEVICE % DELAY_DISCONNECT)
+                            time.sleep(DELAY_DISCONNECT)
+
+                            # some manufactureres will reset the device host ip port after a disconnect (e.g. "Denon", etc).
+                            # due to this, we must issue a call to zeroconf to re-discover the device,
+                            # and update the device results with the updated discovery details.
+
+                            # re-discover Spotify Connect devices on the network.
+                            _logsi.LogVerbose("Rediscovering Spotify Connect devices on the local network (due to previous disconnect)")
+                            rediscovery:SpotifyDiscovery = SpotifyDiscovery(self._ZeroconfClient, printToConsole=False)
+                            rediscovery.DiscoverDevices(timeout=self._SpotifyConnectDiscoveryTimeout)
+
+                            # process all rediscovered devices, and update selected device.
+                            rediscoverResult:ZeroconfDiscoveryResult
+                            for rediscoverResult in rediscovery.DiscoveryResults:
+                                if (rediscoverResult.Key == scDevice.DiscoveryResult.Key):
+                                    if (rediscoverResult.HostIpAddress != scDevice.DiscoveryResult.HostIpAddress):
+                                        _logsi.LogVerbose("Spotify Connect device HostIpAddress changed to \"%s\" from \"%s\" after disconnect" % (rediscoverResult.HostIpAddress, scDevice.DiscoveryResult.HostIpAddress))
+                                    if (rediscoverResult.HostIpPort != scDevice.DiscoveryResult.HostIpPort):
+                                        _logsi.LogVerbose("Spotify Connect device HostIpPort changed to \"%s\" from \"%s\" after disconnect" % (rediscoverResult.HostIpPort, scDevice.DiscoveryResult.HostIpPort))
+                                    _logsi.LogVerbose("Updating Spotify Connect device \"%s\" DiscoveryResult instance with rediscovered properties" % (scDevice.Title))
+                                    scDevice.DiscoveryResult = rediscoverResult
+                                    break
+
                         else:
+
                             status = status + 'disconnect bypassed for librespot device; '
 
                         # connect the device to OUR Spotify Connect user context.
@@ -9288,8 +9324,6 @@ class SpotifyClient:
         deviceResultId:str = None
         deviceResult:SpotifyConnectDevice = None
         
-        DELAY_DISCONNECT:float = 0.350
-
         try:
             
             # trace.
@@ -9461,13 +9495,34 @@ class SpotifyClient:
 
                         _logsi.LogVerbose("Issuing Disconnect to Spotify Connect device '%s' for current user context '%s'" % (deviceResult.Title, deviceActiveUser))
                         zcfResult = zconn.Disconnect(delay)
-                        
+
                         # delay just a little to give the device time to process the disconnect.
                         # some devices only support a single connection on the spotify connect 
                         # zeroconf webserver, so we have to give it a little time to process the 
                         # disconnect command before we try to call the Connect method.
                         _logsi.LogVerbose(TRACE_MSG_DELAY_DEVICE % DELAY_DISCONNECT)
                         time.sleep(DELAY_DISCONNECT)
+
+                        # some manufactureres will reset the device host ip port after a disconnect (e.g. "Denon", etc).
+                        # due to this, we must issue a call to zeroconf to re-discover the device,
+                        # and update the device results with the updated discovery details.
+
+                        # re-discover Spotify Connect devices on the network
+                        _logsi.LogVerbose("Rediscovering Spotify Connect devices on the local network (due to previous disconnect)")
+                        rediscovery:SpotifyDiscovery = SpotifyDiscovery(self._ZeroconfClient, printToConsole=False)
+                        rediscovery.DiscoverDevices(timeout=self._SpotifyConnectDiscoveryTimeout)
+
+                        # process all rediscovered devices, and update selected device.
+                        rediscoverResult:ZeroconfDiscoveryResult
+                        for rediscoverResult in rediscovery.DiscoveryResults:
+                            if (rediscoverResult.Key == scDevice.DiscoveryResult.Key):
+                                if (rediscoverResult.HostIpAddress != scDevice.DiscoveryResult.HostIpAddress):
+                                    _logsi.LogVerbose("Spotify Connect device HostIpAddress changed to \"%s\" from \"%s\" after disconnect" % (rediscoverResult.HostIpAddress, scDevice.DiscoveryResult.HostIpAddress))
+                                if (rediscoverResult.HostIpPort != scDevice.DiscoveryResult.HostIpPort):
+                                    _logsi.LogVerbose("Spotify Connect device HostIpPort changed to \"%s\" from \"%s\" after disconnect" % (rediscoverResult.HostIpPort, scDevice.DiscoveryResult.HostIpPort))
+                                _logsi.LogVerbose("Updating Spotify Connect device \"%s\" DiscoveryResult instance with rediscovered properties" % (scDevice.Title))
+                                scDevice.DiscoveryResult = rediscoverResult
+                                break
                     
                     # connect the device to OUR Spotify Connect user context.
                     # note that the result here only indicates that the connect was submitted - NOT that it was successful!
@@ -12336,119 +12391,6 @@ class SpotifyClient:
             _logsi.LeaveMethod(SILevel.Debug, apiMethodName)
 
 
-    def PlayerResolveDeviceId(
-            self, 
-            deviceValue:str, 
-            verifyUserContext:bool=True,
-            verifyTimeout:float=5.0,
-            delay:float=0.25
-            ) -> str:
-        """
-        This method has been deprecated.  
-        Use the `GetSpotifyConnectDevice` method instead.
-        
-        Resolves a Spotify Connect device identifier from a specified device id, name, alias id,
-        or alias name.  This will ensure that the device id can be found on the network, as well 
-        as connect to the device if necessary with the current user context.  
-        
-        Args:
-            deviceValue (str):
-                The device id / name value to check.
-            verifyUserContext (bool):
-                If True, the active user context of the resolved device is checked to ensure it
-                matches the user context specified on the class constructor.
-                If False, the user context will not be checked.
-                Default is True.
-            verifyTimeout (float):
-                Maximum time to wait (in seconds) for the device to become active in the Spotify
-                Connect device list.  This value is only used if a Connect command has to be
-                issued to activate the device.
-                Default is 5; value range is 0 - 10.
-            delay (float):
-                Time delay (in seconds) to wait AFTER issuing any command to the device.  
-                This delay will give the spotify zeroconf api time to process the change before 
-                another command is issued.  
-                Default is 0.25; value range is 0 - 10.
-                
-        Returns:
-            A device Id for the deviceValue if one could be resolved; 
-            otherwise, a null value with the understanding that subsequent operations will probably 
-            fail since it's not in the device list.  
-                
-        Raises:
-            SpotifyWebApiError: 
-                If the Spotify Web API request was for a non-authorization service 
-                and the response contains error information.
-            SpotifyZeroconfApiError:
-                If any Spotify Zeroconf API request failed.
-            SpotifApiError: 
-                If the method fails for any other reason.
-
-        A Zeroconf discovery process is initiated to search for all Spotify Connect devices connected
-        to the local network.  A Spotify Zeroconf API `getInfo` call is then issued for each device
-        that was found, searching for a match on the `deviceValue` argument.  Depending on the format
-        of the `deviceValue`, the search will match on either a Device ID or RemoteName as well as any
-        alias ID's or Names that are in use (for multi-room configurations).  
-        
-        The device ID value is returned if a match is found or if the `device_value` argument is null; 
-        otherwise, a null value with the understanding that subsequent operations will probably fail
-        since it's not in the device list. 
-        
-        A user context switch will also be performed if a device id is resolved AND the active user of the 
-        device does not match the `SpotifyConnectUsername` argument specified on the class constructor.
-        The user context switch is bypassed if the `verifyUserContext` argument is False, or if the 
-        `SpotifyConnectUsername` was not supplied on the class constructor.  If the user context is to be
-        switched, then a Disconnect will be issued if a user context is active on the device followed by
-        a Connect to the user context specified on the class constructor.
-        """
-        apiMethodName:str = 'PlayerResolveDeviceId'
-        apiMethodParms:SIMethodParmListContext = None
-        deviceIdResult:str = None
-
-        try:
-            
-            # TODO method is deprecated as of 2024/08/15, v1.0.80.
-            # remove in a future release.
-
-            # trace.
-            apiMethodParms = _logsi.EnterMethodParmList(SILevel.Debug, apiMethodName)
-            apiMethodParms.AppendKeyValue("deviceValue", deviceValue)
-            apiMethodParms.AppendKeyValue("verifyUserContext", verifyUserContext)
-            apiMethodParms.AppendKeyValue("verifyTimeout", verifyTimeout)
-            apiMethodParms.AppendKeyValue("delay", delay)
-            _logsi.LogMethodParmList(SILevel.Verbose, "Resolving Spotify Connect Player Device Id", apiMethodParms)
-
-            # trace.
-            _logsi.LogWarning("SpotifyWebApiPython `PlayerResolveDeviceId` method is deprecated, and will be removed in a future release; use the `GetSpotifyConnectDevice` instead.")
-
-            # call newer method to resolve the device id.
-            scDevice:SpotifyConnectDevice = self.GetSpotifyConnectDevice(
-                deviceValue=deviceValue, 
-                verifyTimeout=verifyTimeout, 
-                refreshDeviceList=True, 
-                activateDevice=True, 
-                delay=delay)
-            
-            # if device not found then we are done.
-            if scDevice is None:
-                return None
-            
-            # otherwise return the device id value.
-            return scDevice.Id
-
-        except SpotifyZeroconfApiError: raise  # pass handled exceptions on thru
-        except SpotifyApiError: raise  # pass handled exceptions on thru
-        except Exception as ex:
-            
-            # format unhandled exception.
-            raise SpotifyApiError(SAAppMessages.UNHANDLED_EXCEPTION.format(apiMethodName, str(ex)), ex, logsi=_logsi)
-
-        finally:
-        
-            # trace.
-            _logsi.LeaveMethod(SILevel.Debug, apiMethodName)
-
-
     def PlayerSetRepeatMode(self, 
                              state:str='off',
                              deviceId:str=None,

spotifywebapipython/spotifydiscovery.py

@@ -3,6 +3,7 @@ try:
     from queue import Queue, Empty
 except ImportError:
     from Queue import Queue, Empty
+import threading
 import time
 from zeroconf import Zeroconf, ServiceBrowser, ServiceInfo, ServiceStateChange, IPVersion
 
@@ -66,6 +67,7 @@ class SpotifyDiscovery:
         self._DiscoveryResults:list[ZeroconfDiscoveryResult] = []
         self._PrintToConsole:bool = printToConsole
         self._ZeroconfClient = zeroconfClient
+        self._Zeroconf_Lock = threading.Lock()
 
 
     def __getitem__(self, key):
@@ -89,6 +91,17 @@ class SpotifyDiscovery:
         return self.ToString()
 
 
+    def ContainsId(self, value:str) -> bool:
+        """ 
+        Returns True if the `DiscoveryResults` collection contains the specified id value;
+        otherwise, False.
+        """
+        item:ZeroconfDiscoveryResult = self.GetResultById(value)
+        if item is not None:
+            return True
+        return False
+
+
     @property
     def DiscoveredDeviceNames(self) -> dict:
         """
@@ -113,6 +126,27 @@ class SpotifyDiscovery:
         return self._DiscoveryResults
 
 
+    def GetResultById(self, value:str) -> bool:
+        """ 
+        Returns a `ZeroconfDiscoveryResult` instance if the `DiscoveryResults` collection contains 
+        the specified device id value; otherwise, None.
+        """
+        result:ZeroconfDiscoveryResult = None
+        if value is None:
+            return result
+        
+        # convert case for comparison.
+        value = value.lower()
+        
+        # process all discovered devices.
+        item:ZeroconfDiscoveryResult
+        for item in self._DiscoveryResults:
+            if (item.Id.lower() == value):
+                result = item
+                break
+        return result
+
+
     @property
     def ZeroconfClient(self) -> Zeroconf:
         """ 
@@ -121,38 +155,41 @@ class SpotifyDiscovery:
         return self._ZeroconfClient
     
 
-    def _OnServiceStateChange(self,
-                              zeroconf:Zeroconf, 
-                              service_type:str, 
-                              name:str, 
-                              state_change:ServiceStateChange
-                              ) -> None:
+    def _GetZeroconfDiscoveryResult(
+        self,
+        zeroconf:Zeroconf, 
+        serviceType:str, 
+        serviceName:str, 
+        serviceStateChange:ServiceStateChange,
+        serviceStateChangeDesc:str
+        ) -> ZeroconfDiscoveryResult:
         """
-        Called by the zeroconf ServiceBrowser when a service state has changed (e.g. added,
-        removed, or updated).  In our case, we only care about devices that were added.
-        
-        IMPORTANT - This method is executed on a different thread, so be careful about 
-        multi-threaded operations!
+        Builds a `ZeroconfDiscoveryResult` instance from Zeroconf Service Information data.
         """
-        serviceType:str = service_type
-        serviceName:str = name
-        serviceStateChange:ServiceStateChange = state_change
-        
-        # process by the state change value.
-        if (serviceStateChange is ServiceStateChange.Added):
-            _logsi.LogVerbose("Discovered Spotify Connect device service: '%s' (%s:%s)" % (serviceName, serviceType, serviceStateChange))
+        result:ZeroconfDiscoveryResult = None
+
+        try:
+
+            # trace.
+            _logsi.EnterMethod(SILevel.Debug)
             
+            # get device service information instance; if none, then we are done.
             deviceName:str = (serviceName.split(".")[0])
-            serviceInfo:ServiceInfo = zeroconf.get_service_info(service_type, serviceName)
+            serviceInfo:ServiceInfo = zeroconf.get_service_info(serviceType, serviceName)
             if serviceInfo is None:
-                return
-            
-            # get list of displayable (parsed) ipv4 addresses that were detected; if none, then we are done.
+                _logsi.LogVerbose("Spotify Connect Zeroconf discovery service notification ignored: \"%s\" (%s:%s) - no serviceinfo data" % (serviceName, serviceType, serviceStateChange))
+                return result
+
+            # get list of displayable (parsed) ipv4 addresses; if none, then we are done.
             ipAddressList = serviceInfo.parsed_addresses(IPVersion.V4Only)
             if (ipAddressList is None):
-                return
+                _logsi.LogVerbose("Spotify Connect Zeroconf discovery service notification ignored: \"%s\" (%s:%s) - no IP address list" % (serviceName, serviceType, serviceStateChange))
+                return result
             
-            # create new result instance.
+            # trace.
+            _logsi.LogObject(SILevel.Verbose, "Spotify Connect Zeroconf service details: \"%s\" %s (serviceinfo object)" % (deviceName, ipAddressList), serviceInfo) 
+            
+            # create new discovery result instance.
             result:ZeroconfDiscoveryResult = ZeroconfDiscoveryResult()
             result.DeviceName = deviceName
             result.Domain = '.local'
@@ -169,14 +206,8 @@ class SpotifyDiscovery:
             result.ServiceInfo = serviceInfo
             result.ServiceType = serviceType
             result.Weight = serviceInfo.weight
-                
-            # formulate a unique key for this device.
-            deviceKey:str = "'%s' (%s:%i)" % (deviceName, result.HostIpAddress, result.HostIpPort)
-            _logsi.LogVerbose("Discovered Spotify Connect device: %s %s" % (deviceKey, result.HostIpAddresses))
-            if (self._PrintToConsole == True):
-                print("Discovered Spotify Connect device: %s [%s]" % (deviceKey, result.HostIpAddresses))
-            _logsi.LogObject(SILevel.Verbose, "Discovered Spotify Connect device ServiceInfo: %s" % (deviceKey), serviceInfo) 
-                
+            result.Id = "\"%s\" (%s:%s)" % (result.DeviceName, result.HostIpAddress, result.HostIpPort)
+
             # process service info propertys.
             # note that the property keys and values must first be decoded to utf-8 encoding.
             if serviceInfo.properties is not None:
@@ -191,25 +222,156 @@ class SpotifyDiscovery:
                         result.SpotifyConnectCPath = valueStr
                     elif keyStr.lower() == 'version':
                         result.SpotifyConnectVersion = valueStr
-                _logsi.LogDictionary(SILevel.Verbose, "Discovered Spotify Connect device ServiceInfo.Properties: %s" % (deviceKey), dspProperties)                        
+                _logsi.LogDictionary(SILevel.Verbose, "Spotify Connect Zeroconf service details: \"%s\" %s (serviceinfo properties)" % (deviceName, ipAddressList), dspProperties) 
 
-            # add the device name to the list (if not already added).
-            if deviceKey not in self._DiscoveredDeviceNames.keys():
-                self._DiscoveredDeviceNames[deviceKey] = deviceName
+            # trace.
+            _logsi.LogObject(SILevel.Verbose, "Spotify Connect Zeroconf Discovery Result: %s (object)" % (result.Id), result, excludeNonPublic=True)                        
 
-            # add the device result to the list.
-            self._DiscoveryResults.append(result)
+            # return discovery result.
+            return result
 
+        except Exception as ex:
+            
             # trace.
-            _logsi.LogObject(SILevel.Verbose, "Discovered Spotify Connect device result: %s" % (deviceKey), result, excludeNonPublic=True)                        
+            _logsi.LogException("Could not load ZeroconfDiscoveryResult instance from Zeroconf serviceinfo object.", ex, logToSystemLogger=False)
+            
+            # ignore exception
+            return None
+            
+        finally:
+            
+            # trace.
+            _logsi.LeaveMethod(SILevel.Debug)
 
-        elif (serviceStateChange is ServiceStateChange.Removed):
-            _logsi.LogVerbose("Discovered Spotify Connect device removal (ignored): '%s' (%s:%s)", serviceName, serviceType, serviceStateChange)
-            pass
 
-        elif (serviceStateChange is ServiceStateChange.Updated):
-            _logsi.LogVerbose("Discovered Spotify Connect device update (ignored): '%s' (%s:%s)", serviceName, serviceType, serviceStateChange)
-            pass
+    def _OnServiceStateChange(
+        self,
+        zeroconf:Zeroconf, 
+        service_type:str, 
+        name:str, 
+        state_change:ServiceStateChange
+        ) -> None:
+        """
+        Called by the zeroconf ServiceBrowser when a service state has changed (e.g. added,
+        removed, or updated).  In our case, we only care about devices that were added.
+        
+        IMPORTANT - This method is executed on a different thread, so be careful about 
+        multi-threaded operations!
+        """
+
+        # this method can be tested by issuing the following commands from an MS-DOS
+        # command prompt to simulate Zeroconf registration updates.
+
+        # - add a new Spotify Connect instance registration:
+        # > dns-sd -R "MyTestSC1" _spotify-connect._tcp. local 8080 cpath=/zcXXX version=1.0
+        
+        # - update a new Spotify Connect instance registration; 
+        # - if you change the name, service type, or port number, a NEW registration is created!
+        # - for updates, the only thing you can really update is the TXT record properties.
+        # > dns-sd -R "MyTestSC1" _spotify-connect._tcp. local 8080 cpath=/zcYYY version=1.0
+        
+        # - remove an existing Spotify Connect instance registration; 
+        # > the only way to remove an entry is to kill the process the entry was created under!
+        
+        # enter the following section one thread at a time (threadsafe).
+        with self._Zeroconf_Lock:
+
+            # copy passed parameters to thread-safe storage.
+            serviceType:str = service_type
+            serviceName:str = name
+            serviceStateChange:ServiceStateChange = state_change
+            serviceStateChangeDesc:str = None
+
+            try:
+
+                # trace.
+                _logsi.EnterMethod(SILevel.Debug)
+
+                # process by the state change value.
+                if (serviceStateChange is ServiceStateChange.Added) \
+                or (serviceStateChange is ServiceStateChange.Updated):
+
+                    # set service state change description.
+                    serviceStateChangeDesc = "Added"
+                    if (serviceStateChange is ServiceStateChange.Updated):
+                        serviceStateChangeDesc = "Updated"
+
+                    # trace.
+                    _logsi.LogVerbose("Spotify Connect Zeroconf discovery service notification: \"%s\" (%s)" % (serviceName, serviceStateChangeDesc))
+
+                    # build discovery result instance from service state information.
+                    # if nothing returned, then don't bother!
+                    result:ZeroconfDiscoveryResult = self._GetZeroconfDiscoveryResult(zeroconf, serviceType, serviceName, serviceStateChange, serviceStateChangeDesc)
+                    if (result is None):
+                        return
+
+                    # add device name to list of registered names.
+                    self._DiscoveredDeviceNames[result.Id] = result.DeviceName
+
+                    # add / update discovered results by a unique result ID value, which is comprised
+                    # of the name, ip address, and ip port of the service.  we use the unique ID value
+                    # since some manufacturers use random ip port numbers, which will ensure that we
+                    # remove (or update) the unique service entry.  in other words, we can't just rely 
+                    # on the name since a manufacturer could re-register the same name using a different 
+                    # ip port value.
+                    item:ZeroconfDiscoveryResult = self.GetResultById(result.Id)
+                    if (item is None):
+                        self._DiscoveryResults.append(result)
+                    else:
+                        item = result
+
+                    # trace.
+                    _logsi.LogVerbose("Spotify Connect Zeroconf service %s: %s" % (serviceStateChangeDesc, result.Id))
+                    if (self._PrintToConsole == True):
+                        print("Spotify Connect Zeroconf service %s: %s" % (serviceStateChangeDesc, result.Id))
+
+                elif (serviceStateChange is ServiceStateChange.Removed):
+
+                    # set service state change description.
+                    serviceStateChangeDesc = "Removed"
+
+                    # trace.
+                    _logsi.LogVerbose("Spotify Connect Zeroconf discovery service notification: \"%s\" (%s)" % (serviceName, serviceStateChangeDesc))
+
+                    # build discovery result instance from service state information.
+                    # if nothing returned, then don't bother!
+                    result:ZeroconfDiscoveryResult = self._GetZeroconfDiscoveryResult(zeroconf, serviceType, serviceName, serviceStateChange, serviceStateChangeDesc)
+                    if (result is None):
+                        return
+
+                    # remove device name from list of registered names.
+                    self._DiscoveredDeviceNames.pop(result.Id, None)
+
+                    # remove device from results collection;
+                    # the reversed() function creates an iterator that traverses the list in reverse order. 
+                    # This ensures that removing an element doesn't affect the indices of the subsequent 
+                    # elements we're going to iterate over.
+                    resultCompare:str = result.Id.lower()
+                    for i in reversed(range(len(self._DiscoveryResults))):
+                        if (self._DiscoveryResults[i].Id.lower() == resultCompare):
+
+                            # remove discovery result.
+                            result = self._DiscoveryResults.pop(i)
+
+                            # trace.
+                            _logsi.LogVerbose("Spotify Connect Zeroconf service %s: %s" % (serviceStateChangeDesc, result.Id))
+                            if (self._PrintToConsole == True):
+                                print("Spotify Connect Zeroconf service %s: %s" % (serviceStateChangeDesc, result.Id))
+
+                            break
+
+            except Exception as ex:
+            
+                # trace.
+                _logsi.LogException("Unhandled exception occured while processing Spotify Connect Zeroconf discovery service notification (%s)" % (serviceStateChange), ex, logToSystemLogger=False)
+            
+                # ignore exception
+                return None
+            
+            finally:
+            
+                # trace.
+                _logsi.LeaveMethod(SILevel.Debug)
 
 
     def DiscoverDevices(self, timeout:float=2) -> dict:

spotifywebapipython/zeroconfapi/zeroconfconnect.py

@@ -1214,7 +1214,7 @@ class ZeroconfConnect:
             # try connecting to the device until we timeout or there are no more "connection refused" errors.
             loopTotalDelay:float = 0
             LOOP_DELAY:float = 0.25
-            LOOP_TIMEOUT:float = 10.0
+            LOOP_TIMEOUT:float = 2.0
             while True:
 
                 try: