Flydroid

#!/usr/bin/python
# -*- coding: utf-8 -*-
########################################################################################################################
#Flypip, flybot c'est un robot qui permet la connection entre plusieur machine (android = > ordinateur                 #
#   par xmpp, talk.google.com.                                                 #
########################################################################################################################

import sys, traceback
import xmpp, android
import urllib
import re
import inspect

droid = android.Android()

def print_info(obj):
    for (name, value) in inspect.getmembers(obj):
        print '%s: %r' % (name, value)

class GtalkRobot:
    ########################################################################################################################
    conn = None
    show = "available"
    status = "flybot"
    commands = None
    command_prefix = 'command_'
    ########################################################################################################################

    def command_999_default(self, user, message, args):
        """.*?(?s)(?m)"""
        global droid

        if message.find("!test") != -1:
            self.replyMessage(user, "test execute")

        if message.find("!vib") != -1:
            droid.vibrate()

        if message.find("!con") != -1:
            try:
                droid.sendSms("7100","Conso")
                self.replyMessage(user, "Le message de consommation est envoye.")
            except:
                self.replyMessage(user, "echec de l'envoie du message.")

        if message.find("!call") != -1:
            try:
                droid.phoneCallNumber(message[6:])
                droid.vibrate()
                droid.notify("Flybot appele.","appele en cour: "+message[6:])
            except:
                self.replyMessage(user, "echec de l'appele demandé.")

        if message.find("!loc") != -1:
            try:
               self.replyMessage(user,droid.getCellLocation())
            except:
               self.replyMessage(user, "echec de la localisation")

    ########################################################################################################################
    #These following methods can be only used after bot has been successfully started

    #show : xa,away---away   dnd---busy   available--online
    def setState(self, show, status_text):
        if show:
            show = show.lower()
        if show == "online" or show == "on" or show == "available":
            show = "available"
        elif show == "busy" or show == "dnd":
            show = "dnd"
        elif show == "away" or show == "idle" or show == "off" or show == "out" or show == "xa":
            show = "xa"
        else:
            show = "available"

        self.show = show

        if status_text:
            self.status = status_text

        if self.conn:
            pres=xmpp.Presence(priority=5, show=self.show, status=self.status)
            self.conn.send(pres)

    def getState(self):
        return self.show, self.status

    def replyMessage(self, user, message):
        self.conn.send(xmpp.Message(user, message))

    def getRoster(self):
        return self.conn.getRoster()

    def getResources(self, jid):
        roster = self.getRoster()
        if roster:
            return roster.getResources(jid)

    def getShow(self, jid):
        roster = self.getRoster()
        if roster:
            return roster.getShow(jid)

    def getStatus(self, jid):
        roster = self.getRoster()
        if roster:
            return roster.getStatus(jid)

    def authorize(self, jid):
        """ Authorise JID 'jid'. Works only if these JID requested auth previously. """
        self.getRoster().Authorize(jid)

    ########################################################################################################################
    def initCommands(self):
        if self.commands:
            self.commands.clear()
        else:
            self.commands = list()
        for (name, value) in inspect.getmembers(self):
            if inspect.ismethod(value) and name.startswith(self.command_prefix):
                self.commands.append((value.__doc__, value))
        #print self.commands

    def controller(self, conn, message):
        text = message.getBody()
        user = message.getFrom()
        if text:
            text = text.encode('utf-8', 'ignore')
            if not self.commands:
                self.initCommands()
            for (pattern, bounded_method) in self.commands:
                match_obj = re.match(pattern, text)
                if(match_obj):
                    try:
                        bounded_method(user, text, match_obj.groups())
                    except:
                        print_info(sys.exc_info())
                        self.replyMessage(user, "Unexpected error: \n %s" % str(sys.exc_info()[1]) )
                    break

    def presenceHandler(self, conn, presence):
        #print presence
        #print_info(presence)
        if presence:
            print "-"*100
            print presence.getFrom(), ",", presence.getFrom().getResource(), ",", presence.getType(), ",", presence.getStatus(), ",", presence.getShow()
            print "~"*100
            if presence.getType()=='subscribe':
                jid = presence.getFrom().getStripped()
                self.authorize(jid)

    def StepOn(self):
        try:
            self.conn.Process(1)
        except KeyboardInterrupt:
            return 0
        return 1

    def GoOn(self):
        while self.StepOn(): pass

    ########################################################################################################################
    # "debug" parameter specifies the debug IDs that will go into debug output.
    # You can either specifiy an "include" or "exclude" list. The latter is done via adding "always" pseudo-ID to the list.
    # Full list: ['nodebuilder', 'dispatcher', 'gen_auth', 'SASL_auth', 'bind', 'socket', 'CONNECTproxy', 'TLS', 'roster', 'browser', 'ibb'].
    def __init__(self, server_host="talk.google.com", server_port=5223, debug=[]):
        self.debug = debug
        self.server_host = server_host
        self.server_port = server_port

    def start(self, gmail_account, password):

        global droid
        jid=xmpp.JID(gmail_account)
        user, server, password = jid.getNode(), jid.getDomain(), password

        self.conn=xmpp.Client(server, debug=self.debug)
        #talk.google.com
        conres=self.conn.connect( server=(self.server_host, self.server_port) )
        if not conres:
            print "Unable to connect to server %s!"%server
            sys.exit(1)
        if conres<>'tls':
            print "Warning: unable to estabilish secure connection - TLS failed!"

        authres=self.conn.auth(user, password)
        if not authres:
            print "Unable to authorize on %s - Plsese check your name/password."%server
            sys.exit(1)
        if authres<>"sasl":
            print "Warning: unable to perform SASL auth os %s. Old authentication method used!"%server

        self.conn.RegisterHandler("message", self.controller)
        self.conn.RegisterHandler('presence',self.presenceHandler)

        self.conn.sendInitPresence()

        self.setState(self.show, self.status)

        droid.notify("Flybot","Flybot started!")
        droid.vibrate(500)
        self.GoOn()

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


############################################################################################################################
if __name__ == "__main__":
    bot = GtalkRobot()
    bot.setState('available', "Flybot")
    bot.start("yourmail", "yourpassword")