path: root/activity.py

# Copyright (C) 2012 Cristhofer Travieso <cristhofert97@gmail.com>
# Copyright (C) 2012 Agustin Zubiaga <aguz@sugarlabs.org>

# This program 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; either version 3 of the License, or
# (at your option) any later version.
#
# This program 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 this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

from gi.repository import Gtk

import logging
import telepathy
from dbus.service import signal
from dbus.gobject_service import ExportedGObject
from sugar3.presence import presenceservice
from sugar3.presence.tubeconn import TubeConnection
from sugar3.activity import activity
from sugar3.activity.widgets import StopButton
from sugar3.activity.widgets import ActivityToolbarButton
from sugar3.graphics.toolbarbox import ToolbarBox
from sugar3.graphics.radiotoolbutton import RadioToolButton
from sugar3.graphics.toolbutton import ToolButton

from gettext import gettext as _

# _logger
_logger = logging.getLogger('chart-activity')
_logger.setLevel(logging.DEBUG)
logging.basicConfig()

import game

SERVICE = 'org.sugarlabs.TicTacToe'
IFACE = SERVICE
PATH = '/org/augarlabs/TicTacToe'


class Activity(activity.Activity):
    def __init__(self, handle):
        activity.Activity.__init__(self, handle, True)

        # Canvas
        canvas = game.Canvas()
        self.set_canvas(canvas)

        # Toolbar
        toolbarbox = ToolbarBox()

        activity_button = ActivityToolbarButton(self)
        toolbarbox.toolbar.insert(activity_button, 0)

        separator = Gtk.SeparatorToolItem()
        activity_button.page.insert(separator, -1)

        score_btn = ToolButton()
        score_btn.props.icon_name = 'score'
        activity_button.page.insert(score_btn, -1)
        score_btn.show()

        separator = Gtk.SeparatorToolItem()
        toolbarbox.toolbar.insert(separator, -1)

        # ToolButtons
        new_game_btn = ToolButton()
        new_game_btn.connect('clicked', lambda w: canvas.clear())
        new_game_btn.set_tooltip(_('New Game'))
        new_game_btn.props.icon_name = 'new-game'
        toolbarbox.toolbar.insert(new_game_btn, -1)

        separator = Gtk.SeparatorToolItem()
        separator.set_expand(False)
        separator.set_draw(True)
        toolbarbox.toolbar.insert(separator, -1)

        cross_btn = RadioToolButton()
        cross_btn.connect('clicked', lambda w: canvas.set_mode(
                                                             game.MODE_CROSS))
        cross_btn.set_tooltip(_('Cross'))
        cross_btn.props.icon_name = 'cross'
        toolbarbox.toolbar.insert(cross_btn, -1)

        circle_btn = RadioToolButton()
        circle_btn.connect('clicked', lambda w: canvas.set_mode(
                                                             game.MODE_CIRCLE))
        circle_btn.set_tooltip(_('Circle'))
        circle_btn.props.icon_name = 'circle'
        circle_btn.props.group = cross_btn
        toolbarbox.toolbar.insert(circle_btn, -1)

        canvas.set_mode(game.MODE_CROSS)

        separator = Gtk.SeparatorToolItem()
        toolbarbox.toolbar.insert(separator, -1)

        help_btn = ToolButton()
        help_btn.set_tooltip(_('Help'))
        help_btn.props.icon_name = 'help-icon'
        toolbarbox.toolbar.insert(help_btn, -1)

        separator = Gtk.SeparatorToolItem()
        separator.set_expand(True)
        separator.set_draw(False)
        toolbarbox.toolbar.insert(separator, -1)

        stopbtn = StopButton(self)
        toolbarbox.toolbar.insert(stopbtn, -1)

        self._setup_presence_service()

        self.set_toolbar_box(toolbarbox)
        self.show_all()

    def _setup_presence_service(self):
        """Setup the Presence Service."""
        self.pservice = presenceservice.get_instance()
        self.initiating = None  # sharing (True) or joining (False)

        owner = self.pservice.get_owner()
        self.owner = owner
        self._share = ""
        self.connect('shared', self._shared_cb)
        self.connect('joined', self._joined_cb)

    def _shared_cb(self, activity):
        """Either set up initial share..."""
        self._new_tube_common(True)

    def _joined_cb(self, activity):
        """...or join an exisiting share."""
        self._new_tube_common(False)

    def _new_tube_common(self, sharer):
        """Joining and sharing are mostly the same..."""
        if self.shared_activity is None:
            _logger.debug("Error: Failed to share or join activity ... \
                _shared_activity is null in _shared_cb()")
            return

        self.initiating = sharer
        self.waiting_for_hand = not sharer

        self.conn = self.shared_activity.telepathy_conn
        self.tubes_chan = self.shared_activity.telepathy_tubes_chan
        self.text_chan = self.shared_activity.telepathy_text_chan

        self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].connect_to_signal(
            'NewTube', self._new_tube_cb)

        if sharer:
            _logger.debug('This is my activity: making a tube...')
            self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].OfferDBusTube(
                SERVICE, {})
        else:
            _logger.debug('I am joining an activity: waiting for a tube...')
            self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].ListTubes(
                reply_handler=self._list_tubes_reply_cb,
                error_handler=self._list_tubes_error_cb)

    def _list_tubes_reply_cb(self, tubes):
        """Reply to a list request."""
        for tube_info in tubes:
            self._new_tube_cb(*tube_info)

    def _list_tubes_error_cb(self, e):
        """Log errors."""
        _logger.debug('Error: ListTubes() failed: %s' % (e))

    def _new_tube_cb(self, id, initiator, type, service, params, state):
        """Create a new tube."""
        _logger.debug('New tube: ID=%d initator=%d type=%d service=%s \
params=%r state=%d' % (id, initiator, type, service, params, state))

        if (type == telepathy.TUBE_TYPE_DBUS and service == SERVICE):
            if state == telepathy.TUBE_STATE_LOCAL_PENDING:
                self.tubes_chan[ \
                              telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(id)

            tube_conn = TubeConnection(self.conn,
                self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES], id, \
                group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP])

            self.chattube = ChatTube(tube_conn, self.initiating, \
                self.event_received_cb)

    def _setup_dispatch_table(self):
        """Associate tokens with commands."""
        self._processing_methods = {
            'x': [self._receive_cross, 'get a cross'],
            'o': [self._receive_circle, 'get a circle'],
            }

    def event_received_cb(self, event_message):
        """Data from a tube has arrived."""
        if len(event_message) == 0:
            return
        try:
            command, payload = event_message.split('|', 2)
        except ValueError:
            _logger.debug('Could not split event message %s' % (event_message))
            return
        self._processing_methods[command][0](payload)

    def send_new_cross(self, square):
        self.send_event('x|%s' % square)

    def send_new_circle(self, square):
        self.send_event('o|%s' % square)

    def _receive_new_cross(self, square):
        square = int(square)
        _logger.debug('Receive a new cross %s' % square)

    def _receive_new_circle(self, square):
        square = int(square)
        _logger.debug('Receive a new circle %s' % square)

    def send_event(self, entry):
        """ Send event through the tube. """
        if hasattr(self, 'chattube') and self.chattube is not None:
            self.chattube.SendText(entry)


class ChatTube(ExportedGObject):
    """ Class for setting up tube for sharing """

    def __init__(self, tube, is_initiator, stack_received_cb):
        super(ChatTube, self).__init__(tube, PATH)
        self.tube = tube
        self.is_initiator = is_initiator
        self.stack_received_cb = stack_received_cb
        self.stack = ''

        self.tube.add_signal_receiver(self.send_stack_cb, 'SendText', IFACE,
                                      path=PATH, sender_keyword='sender')

    def send_stack_cb(self, text, sender=None):
        if sender == self.tube.get_unique_name():
            return
        self.stack = text
        self.stack_received_cb(text)

    @signal(dbus_interface=IFACE, signature='s')
    def SendText(self, text):
        self.stack = text