libervia-backend: frontends/src/quick_frontend/quick

comparison frontends/src/quick_frontend/quick_app.py @ 1290:faa1129559b8 frontends_multi_profiles

core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): /!\ not finished, everything is still instable ! - bridge: DBus bridge has been modified to allow blocking call to be called in the same way as asynchronous calls - bridge: calls with a callback and no errback are now possible, default errback log the error - constants: removed hack to manage presence without OrderedDict, as an OrderedDict like class has been implemented in Libervia - core: getLastResource has been removed and replaced by getMainResource (there is a global better management of resources) - various style improvments: use of constants when possible, fixed variable overlaps, import of module instead of direct class import - frontends: printInfo and printMessage methods in (Quick)Chat are more generic (use of extra instead of timestamp) - frontends: bridge creation and option parsing (command line arguments) are now specified by the frontend in QuickApp __init__ - frontends: ProfileManager manage a more complete plug sequence (some stuff formerly manage in contact_list have moved to ProfileManager) - quick_frontend (quick_widgets): QuickWidgetsManager is now iterable (all widgets are then returned), or can return an iterator on a specific class (return all widgets of this class) with getWidgets - frontends: tools.jid can now be used in Pyjamas, with some care - frontends (XMLUI): profile is now managed - core (memory): big improvment on entities cache management (and specially resource management) - core (params/exceptions): added PermissionError - various fixes and improvments, check diff for more details

author	Goffi <goffi@goffi.org>
date	Sat, 24 Jan 2015 01:00:29 +0100
parents	e3a9ea76de35
children	6c7d89843f1b

comparison

equal deleted inserted replaced

-:653f2e2eea31
+:faa1129559b8
 from sat.core.i18n import _
 import sys
 from sat.core.log import getLogger
 log = getLogger(__name__)
 from sat.core import exceptions
-from sat_frontends.bridge.DBus import DBusBridgeFrontend
 from sat_frontends.tools import jid
 from sat_frontends.quick_frontend.quick_widgets import QuickWidgetsManager
 from sat_frontends.quick_frontend import quick_chat
-from optparse import OptionParser
 from sat_frontends.quick_frontend.constants import Const as C
 class ProfileManager(object):
 self.host.setStatusOnline(True, profile=self.profile)
 contact_list.fill()
 #The waiting subscription requests
-waitingSub = self.bridge.getWaitingSub(self.profile)
+self.bridge.getWaitingSub(self.profile, callback=self._plug_profile_gotWaitingSub)
-for sub in waitingSub:
-self.host.subscribeHandler(waitingSub[sub], sub, self.profile)
+def _plug_profile_gotWaitingSub(self, waiting_sub):
+for sub in waiting_sub:
-#Now we open the MUC window where we already are:
+self.host.subscribeHandler(waiting_sub[sub], sub, self.profile)
-for room_args in self.bridge.getRoomsJoined(self.profile):
-self.host.roomJoinedHandler(*room_args, profile=self.profile)
+self.bridge.getRoomsJoined(self.profile, callback=self._plug_profile_gotRoomsJoined)
-for subject_args in self.bridge.getRoomsSubjects(self.profile):
+def _plug_profile_gotRoomsJoined(self, rooms_args):
-self.host.roomNewSubjectHandler(*subject_args, profile=self.profile)
+#Now we open the MUC window where we already are:
+for room_args in rooms_args:
-#Finaly, we get the waiting confirmation requests
+self.host.roomJoinedHandler(*room_args, profile=self.profile)
-for confirm_id, confirm_type, data in self.bridge.getWaitingConf(self.profile):
-self.host.askConfirmationHandler(confirm_id, confirm_type, data, self.profile)
+self.bridge.getRoomsSubjects(self.profile, callback=self._plug_profile_gotRoomsSubjects)
+def _plug_profile_gotRoomsSubjects(self, subjects_args):
+for subject_args in subjects_args:
+self.host.roomNewSubjectHandler(*subject_args, profile=self.profile)
+#Presence must be requested after rooms are filled
+self.host.bridge.getPresenceStatuses(self.profile, callback=self._plug_profile_gotPresences)
+def _plug_profile_gotPresences(self, presences):
+def gotEntityData(data, contact):
+for key in ('avatar', 'nick'):
+if key in data:
+self.host.entityDataUpdatedHandler(contact, key, data[key], self.profile)
+for contact in presences:
+for res in presences[contact]:
+jabber_id = ('%s/%s' % (jid.JID(contact).bare, res)) if res else contact
+show = presences[contact][res][0]
+priority = presences[contact][res][1]
+statuses = presences[contact][res][2]
+self.host.presenceUpdateHandler(jabber_id, show, priority, statuses, self.profile)
+self.host.bridge.getEntityData(contact, ['avatar', 'nick'], self.profile, callback=lambda data, contact=contact: gotEntityData(data, contact), errback=lambda failure, contact=contact: log.debug("No cache data for {}".format(contact)))
+#Finaly, we get the waiting confirmation requests
+self.bridge.getWaitingConf(self.profile, callback=self._plug_profile_gotWaitingConf)
+def _plug_profile_gotWaitingConf(self, waiting_confs):
+for confirm_id, confirm_type, data in waiting_confs:
+self.host.askConfirmationHandler(confirm_id, confirm_type, data, self.profile)
+# At this point, profile should be fully plugged
+# and we launch frontend specific method
+self.host.profilePlugged(self.profile)
 def _getParamError(self, ignore):
 log.error(_("Can't get profile parameter"))
 return self._profiles.keys()[0]
 class QuickApp(object):
 """This class contain the main methods needed for the frontend"""
-def __init__(self):
+def __init__(self, create_bridge, check_options=None):
+"""Create a frontend application
+@param create_bridge: method to use to create the Bridge
+@param check_options: method to call to check options (usually command line arguments)
+"""
 ProfileManager.host = self
 self.profiles = ProfilesManager()
 self.contact_lists = {}
 self.widgets = QuickWidgetsManager(self)
-self.check_options()
+if check_options is not None:
+self.options = check_options()
+else:
+self.options = None
 # widgets
-self.visible_widgets = set() # widgets currently visible (must be filled by frontend)
 self.selected_widget = None # widget currently selected (must be filled by frontend)
 ## bridge ##
 try:
-self.bridge = DBusBridgeFrontend()
+self.bridge = create_bridge()
 except exceptions.BridgeExceptionNoService:
 print(_(u"Can't connect to SàT backend, are you sure it's launched ?"))
 sys.exit(1)
 except exceptions.BridgeInitError:
 print(_(u"Can't init bridge"))
 try:
 return self.selected_widget.profile
 except (TypeError, AttributeError):
 return self.profiles.chooseOneProfile()
+@property
+def visible_widgets(self):
+"""widgets currently visible (must be implemented by frontend)"""
+raise NotImplementedError
 def registerSignal(self, functionName, handler=None, iface="core", with_profile=True):
 """Register a handler for a signal
 @param functionName (str): name of the signal to handle
 @param handler (instancemethod): method to call when the signal arrive, None for calling an automatically named handler (functionName + 'Handler')
 @param iface (str): interface of the bridge to use ('core' or 'plugin')
 @param with_profile (boolean): True if the signal concerns a specific profile, in that case the profile name has to be passed by the caller
 """
 if handler is None:
-handler = getattr(self, "%s%s" % (functionName, 'Handler'))
+handler = getattr(self, "{}{}".format(functionName, 'Handler'))
 if not with_profile:
 self.bridge.register(functionName, handler, iface)
 return
 def signalReceived(*args, **kwargs):
 def postInit(self, profile_manager):
 """Must be called after initialization is done, do all automatic task (auto plug profile)
 @param profile_manager: instance of a subclass of Quick_frontend.QuickProfileManager
 """
-if self.options.profile:
+if self.options and self.options.profile:
 profile_manager.autoconnect([self.options.profile])
-def check_options(self):
+def profilePlugged(self, profile):
-"""Check command line options"""
+"""Method called when the profile is fully plugged, to launch frontend specific workflow
-usage = _("""
-%prog [options]
+@param profile(unicode): %(doc_profile)s
+"""
-%prog --help for options list
+pass
-""")
-parser = OptionParser(usage=usage) # TODO: use argparse
-parser.add_option("-p", "--profile", help=_("Select the profile to use"))
-(self.options, args) = parser.parse_args()
-if self.options.profile:
-self.options.profile = self.options.profile.decode('utf-8')
-return args
 def asyncConnect(self, profile, callback=None, errback=None):
 if not callback:
 callback = lambda dummy: None
 if not errback:
 def plugging_profiles(self):
 """Method to subclass to manage frontend specific things to do
 will be called when profiles are choosen and are to be plugged soon
 """
-raise NotImplementedError
+pass
 def unplug_profile(self, profile):
 """Tell the application to not follow anymore the profile"""
 if not profile in self.profiles:
 raise ValueError("The profile [{}] is not plugged".format(profile))
 self.profiles.remove(profile)
 def clear_profile(self):
 self.profiles.clear()
+def addContactList(self, profile):
+"""Method to subclass to add a contact list widget
+will be called on each profile session build
+@return: a ContactList widget
+"""
+return NotImplementedError
 def newWidget(self, widget):
 raise NotImplementedError
 def connectedHandler(self, profile):
 """called when the connection is made"""
 chat_widget.newMessage(from_jid, target, msg, type_, extra, profile)
 def sendMessage(self, to_jid, message, subject='', mess_type="auto", extra={}, callback=None, errback=None, profile_key=C.PROF_KEY_NONE):
 if callback is None:
-callback = lambda: None
+callback = lambda dummy=None: None # FIXME: optional argument is here because pyjamas doesn't support callback without arg with json proxy
 if errback is None:
 errback = lambda failure: self.showDialog(failure.fullname, failure.message, "error")
 self.bridge.sendMessage(to_jid, message, subject, mess_type, extra, profile_key, callback=callback, errback=errback)
 def newAlertHandler(self, msg, title, alert_type, profile):
 @param from_jid_s: JID of the contact who sent his state, or '@ALL@'
 @param state: new state (string)
 @profile: current profile
 """
 from_jid = jid.JID(from_jid_s) if from_jid_s != C.ENTITY_ALL else C.ENTITY_ALL
-for widget in self.visible_widgets:
+for widget in self.widgets.getWidgets(quick_chat.QuickChat):
-if isinstance(widget, quick_chat.QuickChat):
+if from_jid == C.ENTITY_ALL or from_jid.bare == widget.target.bare:
-if from_jid == C.ENTITY_ALL or from_jid.bare == widget.target.bare:
+widget.updateChatState(from_jid, state)
-widget.updateChatState(from_jid, state)
 def _subscribe_cb(self, answer, data):
 entity, profile = data
 if answer:
 self.bridge.subscription("subscribed", entity.bare, profile_key=profile)
 if key == "nick":
 if entity in self.contact_lists[profile]:
 self.contact_lists[profile].setCache(entity, 'nick', value)
 elif key == "avatar":
 if entity in self.contact_lists[profile]:
-filename = self.bridge.getAvatarFile(value)
+def gotFilename(filename):
 self.contact_lists[profile].setCache(entity, 'avatar', filename)
+self.bridge.getAvatarFile(value, callback=gotFilename)
 def askConfirmationHandler(self, confirm_id, confirm_type, data, profile):
 raise NotImplementedError
 def actionResultHandler(self, type, id, data, profile):

Mercurial > libervia-backend

comparison frontends/src/quick_frontend/quick_app.py @ 1290:faa1129559b8 frontends_multi_profiles