def __init__(self, controller, ui_handler, logger):
QObject.__init__(self)
self.controller = controller
self.data_parser = DataParser(ui_handler, logger)
self.ui_handler = ui_handler
self.tree_controller = ui_handler.tree_controller
self.logger = logger
self.client = None
self.transfer_manager = None
# Init poll timer
self.poll_timer = QTimer(self)
self.poll_timer.timeout.connect(self.thread_poller)
# Init thread params
self.running_threads = []
self.queued_threads = []
self.active_data_worker = None
self.data_workers = deque()
# DBus manager
self.dbus_monitor = DBusMonitor(self, logger)
# Start the thread poller
self.poll_timer.start(100)
class ConnectionManager(QObject):
def __init__(self, controller, ui_handler, logger):
QObject.__init__(self)
self.controller = controller
self.data_parser = DataParser(ui_handler, logger)
self.ui_handler = ui_handler
self.tree_controller = ui_handler.tree_controller
self.logger = logger
self.client = None
self.transfer_manager = None
# Init poll timer
self.poll_timer = QTimer(self)
self.poll_timer.timeout.connect(self.thread_poller)
# Init thread params
self.running_threads = []
self.queued_threads = []
self.active_data_worker = None
self.data_workers = deque()
# DBus manager
self.dbus_monitor = DBusMonitor(self, logger)
# Start the thread poller
self.poll_timer.start(100)
def set_transfer_manager(self, transfer_manager):
self.transfer_manager = transfer_manager
def check_data_workers(self):
# Start next data worker if available
if self.active_data_worker == None:
try:
worker = self.data_workers.popleft()
worker.start()
self.active_data_worker = worker
except IndexError:
self.active_transfer = None
def thread_poller(self):
# Check for completed network threads
if len(self.running_threads) > 0:
removable_network_threads = []
for thread in self.running_threads:
thread.join(0.01)
if not thread.isAlive():
if thread.error != None:
# If tree exists, lets store the request and do it again
# when a connection is available
if self.tree_controller.root_folder != None:
self.queued_threads.append(thread)
# Request a connection only once
if len(self.queued_threads) == 1:
self.request_connection()
if thread.response != None:
if thread.callback_parameters != None:
thread.callback(thread.response, thread.callback_parameters)
else:
thread.callback(thread.response)
removable_network_threads.append(thread)
for removable in removable_network_threads:
self.running_threads.remove(removable)
del removable
# Check for active data worker
if self.active_data_worker != None:
self.active_data_worker.join(0.01)
if not self.active_data_worker.isAlive():
if self.active_data_worker.error != None:
self.logger.error("DataWorker error: " + self.active_data_worker.error)
self.active_data_worker = None
self.check_data_workers()
def request_connection(self):
self.dbus_monitor.request_connection()
def connection_available(self):
return self.dbus_monitor.device_has_networking
def connection_is_wlan(self):
if not self.connection_available():
return False
bearer = self.dbus_monitor.bearer
if bearer == None:
return False
if bearer.startswith("WLAN"):
return True
else:
return False
def set_connected(self, connected):
if connected:
self.ui_handler.hide_loading_ui()
if self.controller.login_done == False:
self.controller.start_trusted_auth()
trusted_login_ui = self.ui_handler.trusted_login_ui
if trusted_login_ui.line_edit_email.text().isEmpty() == False and trusted_login_ui.line_edit_password.text().isEmpty() == False:
self.logger.network("Network connection established, starting authentication")
self.ui_handler.try_trusted_login()
elif self.controller.connected == True and self.client != None:
if len(self.queued_threads) > 0:
self.ui_handler.show_information_ui("Connection established, fetching queued tasks", True)
self.logger.network("Network connection established, starting queued networking")
for queued_thread in self.queued_threads:
worker = NetworkWorker()
worker.clone(queued_thread)
worker.start()
self.running_threads.append(worker)
self.queued_threads = []
else:
self.ui_handler.show_information_ui("Connection established, fetching content", True)
self.logger.network("Network connection established, fetching root metadata")
self.get_account_data()
self.get_metadata("/", "dropbox")
else:
self.ui_handler.show_loading_ui("Waiting for a connection...", True)
def set_client(self, client):
# Set client for usage, we are not connected
self.client = client
self.transfer_manager.set_client(client)
# Get account information
if self.connection_available():
if self.get_account_data():
# Start by fetching sandbox root contents
self.get_metadata("/", "dropbox")
else:
self.ui_handler.show_loading_ui("Waiting for a connection...", True)
self.request_connection()
else:
self.ui_handler.show_loading_ui("Waiting for a connection...", True)
self.request_connection()
def get_account_data(self):
try:
self.data_parser.parse_account_info(self.client.account_info())
return True
except (socket.error, socket.gaierror), err:
return False
