Do not block startup while scanning the computer for all listening network interfaces. Speeds up startup time on some windows computers with lots of spurious network interfaces.

src/calibre/devices/smart_device_app/driver.py

@@ -54,6 +54,8 @@ def synchronous(tlockname):
 
 class ConnectionListener (Thread):
 
+    all_ip_addresses = dict()
+
     NOT_SERVICED_COUNT = 6
 
     def __init__(self, driver):
@@ -61,6 +63,7 @@ class ConnectionListener (Thread):
         self.daemon = True
         self.driver = driver
         self.keep_running = True
+        all_ip_addresses = dict()
 
     def stop(self):
         self.keep_running = False
@@ -68,6 +71,8 @@ class ConnectionListener (Thread):
     def run(self):
         queue_not_serviced_count = 0
         device_socket = None
+        get_all_ips(reinitialize=True)
+
         while self.keep_running:
             try:
                 time.sleep(1)
@@ -78,6 +83,11 @@ class ConnectionListener (Thread):
             if not self.keep_running:
                 break
 
+            if not self.all_ip_addresses:
+                self.all_ip_addresses = get_all_ips()
+                if self.all_ip_addresses:
+                    self.driver._debug("All IP addresses", self.all_ip_addresses)
+
             if not self.driver.connection_queue.empty():
                 queue_not_serviced_count += 1
                 if queue_not_serviced_count >= self.NOT_SERVICED_COUNT:
@@ -1287,8 +1297,6 @@ class SMART_DEVICE_APP(DeviceConfig, DevicePlugin):
         self.client_can_stream_metadata = False
         self.client_wants_uuid_file_names = False
 
-        self._debug("All IP addresses", get_all_ips())
-
         message = None
         try:
             self.listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

src/calibre/gui2/actions/device.py

@@ -182,6 +182,7 @@ class ConnectShareAction(InterfaceAction):
 
     def genesis(self):
         self.share_conn_menu = ShareConnMenu(self.gui)
+        self.share_conn_menu.aboutToShow.connect(self.set_smartdevice_action_state)
         self.share_conn_menu.toggle_server.connect(self.toggle_content_server)
         self.share_conn_menu.control_smartdevice.connect(self.control_smartdevice)
         self.share_conn_menu.config_email.connect(partial(
@@ -258,7 +259,10 @@ class ConnectShareAction(InterfaceAction):
             show_port = True
         else:
             all_ips = get_all_ip_addresses()
-            if len(all_ips) > 3:
+            if len(all_ips) == 0:
+                formatted_addresses = _('Still looking for IP addresses')
+                show_port = False
+            elif len(all_ips) > 3:
                 formatted_addresses = _('Many IP addresses. See Start/Stop dialog.')
                 show_port = False
             else:

src/calibre/utils/mdns.py

@@ -5,29 +5,53 @@ __docformat__ = 'restructuredtext en'
 
 import socket, time, atexit
 from collections import defaultdict
+from threading import Thread
 
 from calibre.utils.filenames import ascii_text
 from calibre import force_unicode
 
 _server = None
 
-def get_all_ips():
+_all_ip_addresses = dict()
-    ''' Return a mapping of interface names to the configuration of the
+
-    interface, which includes the ip address, netmask and broadcast addresses
+class AllIpAddressesGetter(Thread):
-    '''
+
-    import netifaces
+    def get_all_ips(self):
-    all_ips = defaultdict(list)
+        ''' Return a mapping of interface names to the configuration of the
-    if hasattr(netifaces, 'AF_INET'):
+        interface, which includes the ip address, netmask and broadcast addresses
-        for x in netifaces.interfaces():
+        '''
-            try:
+        import netifaces
-                for c in netifaces.ifaddresses(x).get(netifaces.AF_INET, []):
+        all_ips = defaultdict(list)
-                    all_ips[x].append(c)
+        if hasattr(netifaces, 'AF_INET'):
-            except ValueError:
+            for x in netifaces.interfaces():
-                from calibre import prints
+                try:
-                prints('Failed to get IP addresses for interface', x)
+                    for c in netifaces.ifaddresses(x).get(netifaces.AF_INET, []):
-                import traceback
+                        all_ips[x].append(c)
-                traceback.print_exc()
+                except ValueError:
-    return dict(all_ips)
+                    from calibre import prints
+                    prints('Failed to get IP addresses for interface', x)
+                    import traceback
+                    traceback.print_exc()
+        return dict(all_ips)
+
+    def run(self):
+        global _all_ip_addresses
+#        print 'sleeping'
+#        time.sleep(15)
+#        print 'slept'
+        _all_ip_addresses = self.get_all_ips()
+
+_ip_address_getter_thread = None
+
+def get_all_ips(reinitialize=False):
+    global _all_ip_addresses, _ip_address_getter_thread
+    if not _ip_address_getter_thread or (reinitialize and not
+                                         _ip_address_getter_thread.is_alive()):
+        _all_ip_addresses = dict()
+        _ip_address_getter_thread = AllIpAddressesGetter()
+        _ip_address_getter_thread.setDaemon(True)
+        _ip_address_getter_thread.start()
+    return _all_ip_addresses
 
 def _get_external_ip():
     'Get IP address of interface used to connect to the outside world'