GitLab

at 2019-10-03T21:00:04Z

fix S5B to IBB fallback. Fixes #9692, #9784

Adapt to nbxmpp carbon data changes

Check if Soup is available at startup

Update README.md

Add Soup to runtime requirements

Plugins: Fix registering modules on enabling account

MAM: Simplify _parse_chat_attrs()

This became more simple due to nbxmpp changes

start implementing XEP-0333, chat markers

fix error

Remove chat marker from modules

add missing chat_markers module

Revert "Remove chat marker from modules"

This reverts commit f5377d98af23483244d71196a8e5cfab96111118.

Adapt to nbxmpp changes

- Move displayed event handler from roster to gui interface
- Rename msg_id to message_id

remove not needed change

Fix some errors

Remove breakpoint

Improve code

 - python3-css-parser

 - python3-keyring

 - python3-precis-i18n

+- gir1.2-soup-2.4

 ### Optional Runtime Requirements

         self.received_history_pos = 0

         self.orig_msg = None

+        # For XEP-0333

+        self.last_msg_id = None

+

         self.set_emoticon_popover()

         # Attach speller

         if restored:

             return

+        if message_id:

+            self.last_msg_id = message_id

+

         if kind == 'incoming':

             if not self.type_id == message_control.TYPE_GC or \

             app.config.notify_for_muc(jid) or \

                     event_type.type_, self.contact.jid)

                 event = event_type(text, subject, self, msg_log_id,

+                    message_id=message_id,

                     show_in_roster=show_in_roster,

                     show_in_systray=show_in_systray)

                 app.events.add_event(self.account, full_jid, event)

                 types=type_):

                     # There were events to remove

                     self.redraw_after_event_removed(jid)

+                    # XEP-0333 Send <displayed> tag.

+                    con.get_module('ChatMarkers').send_displayed_marker(

+                        self.get_full_jid(), self.last_msg_id,

+                        self.type_id == message_control.TYPE_GC)

+                    self.last_msg_id = None

             # send chatstate inactive to the one we're leaving

             # and active to the one we visit

             if self.msg_textview.has_text():

             # we are at the end

             if not app.events.remove_events(

                     self.account, jid, types=types_list):

+                con = app.connections[self.account]

                 # There were events to remove

                 self.redraw_after_event_removed(jid)

+                # XEP-0333 Send <displayed> tag.

+                con.get_module('ChatMarkers').send_displayed_marker(

+                    self.get_full_jid(), self.last_msg_id,

+                    self.type_id == message_control.TYPE_GC)

+                self.last_msg_id = None

     def _on_scrollbar_button_release(self, scrollbar, event):

         if event.get_button()[1] != 1:

         We just removed a 'printed_*' event, redraw contact in roster or

         gc_roster and titles in roster and msg_win

         """

+        if not self.parent_win: # minimized groupchat

+            return

         self.parent_win.redraw_tab(self)

         self.parent_win.show_title()

         # TODO : get the contact and check get_show_in_roster()

     nbxmpp.NS_BYTESTREAM,

     nbxmpp.NS_FILE,

     nbxmpp.NS_MUC,

+    nbxmpp.NS_CHATMARKERS,

     nbxmpp.NS_COMMANDS,

     nbxmpp.NS_DISCO_INFO,

     nbxmpp.NS_LAST,

                 obj.session.last_send = time.time()

                 msg_iq.setThread(obj.session.thread_id)

+        if obj.message:

+            msg_iq.setMarkable()

+

         self._push_stanza_message_outgoing(obj, msg_iq)

     def _push_stanza_message_outgoing(self, obj, msg_iq):

         msg_iq.setID(obj.stanza_id)

         if obj.message:

             msg_iq.setOriginID(obj.stanza_id)

+            msg_iq.setMarkable()

         if obj.correct_id:

             msg_iq.setTag('replace', attrs={'id': obj.correct_id},

 class PrintedChatEvent(Event):

     type_ = 'printed_chat'

     def __init__(self, message, subject, control, msg_log_id, time_=None,

-    show_in_roster=False, show_in_systray=True):

+    message_id=None, show_in_roster=False, show_in_systray=True):

         Event.__init__(self, time_, show_in_roster=show_in_roster,

             show_in_systray=show_in_systray)

         self.message = message

         self.subject = subject

         self.control = control

         self.msg_log_id = msg_log_id

+        self.message_id = message_id

 class PrintedGcMsgEvent(PrintedChatEvent):

     type_ = 'printed_gc_msg'

             'session-terminate': [],

             'transport-info': [self.__on_transport_info],

             'transport-replace': [self.__on_transport_replace],

-            'transport-accept': [],

+            'transport-accept': [self.__on_transport_replace],

             'transport-reject': [],

             'iq-result': [],

             'iq-error': [],

     def __on_iq_result(self, stanza, content, error, action):

         log.info("__on_iq_result")

-        if self.state == State.NOT_STARTED:

+        if self.state in (State.NOT_STARTED, State.CAND_RECEIVED):

             self.__state_changed(State.INITIALIZED)

         elif self.state == State.CAND_SENT_AND_RECEIVED:

             if not self.nominated_cand['our-cand'] and \

             'transport-info':       [self.__ack, self.__broadcast],

             'transport-replace':    [self.__ack, self.__broadcast,

                                      self.__on_transport_replace], #TODO

-            'transport-accept':     [self.__ack], #TODO

+            'transport-accept':     [self.__ack, self.__on_session_accept,

+                                     self.__on_content_accept,

+                                     self.__broadcast],

             'transport-reject':     [self.__ack], #TODO

             'iq-result':            [self.__broadcast],

             'iq-error':             [self.__on_error],

         Currently used for transport replacement

         '''

         content = self.contents[(creator, name)]

-        transport.set_sid(content.transport.sid)

-        transport.set_file_props(content.transport.file_props)

+        file_props = content.transport.file_props

+        file_props.transport_sid = transport.sid

+        transport.set_file_props(file_props)

         content.transport = transport

         # The content will have to be resend now that it is modified

         content.sent = False

                     # Anyway, content's transport is not modifiable yet

                     pass

                 elif transport_ns == nbxmpp.NS_JINGLE_IBB:

-                    transport = JingleTransportIBB()

+                    transport = JingleTransportIBB(node=content.getTag(

+                        'transport'))

                     self.modify_content(creator, name, transport)

                     self.state = JingleStates.PENDING

                     self.contents[(creator, name)].state = State.TRANSPORT_REPLACE

                     self.__ack(stanza, jingle, error, action)

-                    self.__session_accept()

+                    self.__transport_accept(transport)

                 else:

                     stanza, jingle = self.__make_jingle('transport-reject')

                     content = jingle.setTag('content', attrs={'creator': creator,

                                                                    conn=self.connection,

                                                                    jingle_session=self,

                                                                    media=media))

+

+    def __transport_accept(self, transport):

+        assert self.state != JingleStates.ENDED

+        stanza, jingle = self.__make_jingle('transport-accept')

+        self.__append_contents(jingle)

+        self.__broadcast(stanza, jingle, None, 'transport-accept')

+        self.connection.connection.send(stanza)

+        self.collect_iq_id(stanza.getID())

+        self.state = JingleStates.ACTIVE
     'bookmarks',

     'caps',

     'carbons',

+    'chat_markers',

     'chatstates',

     'delimiter',

     'discovery',

+# This file is part of Gajim.

+#

+# Gajim is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published

+# by the Free Software Foundation; version 3 only.

+#

+# Gajim is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with Gajim.  If not, see <http://www.gnu.org/licenses/>.

+

+# Chat Markers (XEP-0333)

+

+import nbxmpp

+from nbxmpp.structs import StanzaHandler

+

+from gajim.common import app

+from gajim.common.nec import NetworkEvent

+from gajim.common.modules.base import BaseModule

+

+

+class ChatMarkers(BaseModule):

+

+    _nbxmpp_extends = 'ChatMarkers'

+

+    def __init__(self, con):

+        BaseModule.__init__(self, con)

+

+        self.handlers = [

+            StanzaHandler(name='message',

+                          callback=self._process_read_state_sync,

+                          ns=nbxmpp.NS_CHATMARKERS,

+                          priority=47),

+            StanzaHandler(name='message',

+                          callback=self._process_chat_marker,

+                          ns=nbxmpp.NS_CHATMARKERS,

+                          priority=48),

+        ]

+

+    def _process_read_state_sync(self, _con, _stanza, properties):

+        if not properties.is_marker:

+            return

+

+        if not properties.marker.is_displayed:

+            return

+

+        if properties.type.is_error:

+            return

+

+        if properties.is_mam_message:

+            return

+

+        if properties.type.is_groupchat:

+            manager = self._con.get_module('MUC').get_manager()

+            muc_data = manager.get(properties.muc_jid)

+            if muc_data is None:

+                return

+

+            if properties.muc_nickname != muc_data.nick:

+                return

+

+        elif not properties.is_carbon_message or not properties.carbon.is_sent:

+            return

+

+        self._log.info('Read state sync: %s %s',

+                       properties.jid,

+                       properties.marker.id)

+

+        app.nec.push_outgoing_event(

+            NetworkEvent('read-state-sync',

+                         account=self._account,

+                         jid=properties.jid,

+                         properties=properties,

+                         type=properties.type,

+                         is_muc_pm=properties.is_muc_pm,

+                         marker_id=properties.marker.id))

+

+        raise nbxmpp.NodeProcessed

+

+    def _process_chat_marker(self, _con, _stanza, properties):

+        if not properties.is_marker:

+            return

+        # TODO: Implement showing displayed state in ConversationsTextview

+        raise nbxmpp.NodeProcessed

+

+    def send_marker(self, jid, marker, id_, is_gc):

+        if is_gc:

+            message = nbxmpp.Message(to=jid, typ='groupchat')

+        else:

+            message = nbxmpp.Message(to=jid, typ='chat')

+        message.setTag(marker, namespace=nbxmpp.NS_CHATMARKERS,

+            attrs={'id': id_})

+        self._nbxmpp().send(message)

+

+    def send_displayed_marker(self, jid, id_, is_gc):

+        self.send_marker(jid, 'displayed', id_, is_gc)

+

+

+def get_instance(*args, **kwargs):

+    return ChatMarkers(*args, **kwargs), 'ChatMarkers'
         if groupchat:

             event_attrs.update(self._parse_gc_attrs(properties))

         else:

-            event_attrs.update(self._parse_chat_attrs(stanza, properties))

+            event_attrs.update(self._parse_chat_attrs(properties))

         stanza_id, message_id = self._get_unique_id(properties)

                 'real_jid': real_jid,

                 'kind': KindConstant.GC_MSG}

-    def _parse_chat_attrs(self, stanza, properties):

-        frm = properties.jid

-        to = stanza.getTo()

-        if frm.bareMatch(self._con.get_own_jid()):

-            with_ = to

+    def _parse_chat_attrs(self, properties):

+        if properties.from_.bareMatch(self._con.get_own_jid()):

             kind = KindConstant.CHAT_MSG_SENT

         else:

-            with_ = frm

             kind = KindConstant.CHAT_MSG_RECV

-        return {'with_': with_,

+        return {'with_': properties.jid,

                 'nick': None,

                 'kind': kind}

             stanza=stanza,

             account=self._account))

-        forwarded = properties.carbon_type is not None

-        sent = properties.carbon_type == 'sent'

-        if sent:

+        if properties.is_carbon_message and properties.carbon.is_sent:

             # Ugly, we treat the from attr as the remote jid,

             # to make that work with sent carbons we have to do this.

             # TODO: Check where in Gajim and plugins we depend on that behavior

             'id_': properties.id,

             'encrypted': False,

             'additional_data': additional_data,

-            'forwarded': forwarded,

-            'sent': sent,

+            'forwarded': properties.is_carbon_message,

+            'sent': properties.is_carbon_message and properties.carbon.is_sent,

             'fjid': fjid,

             'jid': jid,

             'resource': resource,

 def _init_gtk():

     import gi

-    gi.require_version('GLib', '2.0')

-    gi.require_version('Gio', '2.0')

-    gi.require_version('Gtk', '3.0')

-    gi.require_version('Gdk', '3.0')

-    gi.require_version('GObject', '2.0')

-    gi.require_version('Pango', '1.0')

+    try:

+        gi.require_version('GLib', '2.0')

+        gi.require_version('Gio', '2.0')

+        gi.require_version('Gtk', '3.0')

+        gi.require_version('Gdk', '3.0')

+        gi.require_version('GObject', '2.0')

+        gi.require_version('Pango', '1.0')

+        gi.require_version('Soup', '2.4')

+    except ValueError as error:

+        sys.exit('Missing dependency: %s' % error)

     from gi.repository import Gtk

     gtk_ver = '%s.%s.%s' % (Gtk.get_major_version(),

     def on_private_message(self, nick, sent, msg, tim, xhtml, session,

                            msg_log_id=None, encrypted=False,

-                           displaymarking=None):

+                           displaymarking=None, message_id=None):

+

         # Do we have a queue?

         fjid = self.room_jid + '/' + nick

                                session=session,

                                form_node=None,

                                displaymarking=displaymarking,

-                               sent_forwarded=sent)

+                               sent_forwarded=sent,

+                               message_id=message_id)

+

         app.events.add_event(self.account, fjid, event)

         autopopup = app.config.get('autopopup')

                 self.on_private_message(

                     nick, obj.sent, obj.msgtxt, obj.timestamp,

                     obj.xhtml, self.session, msg_log_id=obj.msg_log_id,

-                    encrypted=obj.encrypted, displaymarking=obj.displaymarking)

+                    encrypted=obj.encrypted, displaymarking=obj.displaymarking,

+                    message_id=obj.message_id)

     def _nec_ping(self, obj):

         if self.contact.jid != obj.contact.room_jid:

         if ctrl and ctrl.session and len(obj.contact_list) > 1:

             ctrl.remove_session(ctrl.session)

+    def handle_event_read_state_sync(self, event):

+        if event.type.is_groupchat:

+            control = self.get_groupchat_control(event.account,

+                                                 event.jid.getBare())

+            if control is None:

+                log.warning('Groupchat control not found')

+                return

+

+            jid = event.jid.getBare()

+            types = ['printed_gc_msg', 'printed_marked_gc_msg']

+

+        else:

+            types = ['chat', 'pm', 'printed_chat', 'printed_pm']

+            jid = event.jid.getBare()

+            if event.is_muc_pm:

+                jid = event.jid

+

+            control = app.interface.msg_win_mgr.get_control(jid, event.account)

+

+        # Compare with control.last_msg_id.

+        events_ = app.events.get_events(event.account, jid, types)

+        if not events_:

+            log.warning('No Events')

+            return

+

+        if events_[-1].message_id != event.marker_id:

+            return

+

+        if not app.events.remove_events(event.account, jid, types=types):

+            # There were events to remove

+            if control is not None:

+                control.redraw_after_event_removed(event.jid)

+

     def handle_event_msgerror(self, obj):

         #'MSGERROR' (account, (jid, error_code, error_msg, msg, time[session]))

         account = obj.conn.name

             'unsubscribed-presence-received': [

                 self.handle_event_unsubscribed_presence],

             'zeroconf-name-conflict': [self.handle_event_zc_name_conflict],

+            'read-state-sync': [self.handle_event_read_state_sync],

         }

     def register_core_handlers(self):

 ### Methods for opening new messages controls

 ################################################################################

+    def get_groupchat_control(self, account, room_jid):

+        control = self.minimized_controls[account].get(room_jid)

+        if control is None:

+            control = self.msg_win_mgr.get_gc_control(room_jid, account)

+        return control

+

     def show_groupchat(self, account, room_jid):

         minimized_control = self.minimized_controls[account].get(room_jid)

         if minimized_control is not None:

         '''

         for plugin in self.plugins:

             if not plugin.active:

-                return

+                continue

             if not hasattr(plugin, 'modules'):

-                return

+                continue

             for module in plugin.modules:

                 instance, name = module.get_instance(con)

Philipp Hörist pushed to branch chat_markers at gajim / gajim

Commits:

16 changed files:

Changes: