Exemplo n.º 1
0
Arquivo: run.py Projeto: maruen/yowsup
def receive_message(credentials):

    layers = (  EchoLayer,
                (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
                YowReceiptProtocolLayer, YowAckProtocolLayer,
                YowPresenceProtocolLayer)
             ) + YOWSUP_CORE_LAYERS

    stack = YowStack(layers)
    # Setting credentials
    stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)

    # WhatsApp server address
    stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
    stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
    stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())

    stack.setProp(EchoLayer.PROP_CREDENTIALS, credentials)

    # Sending connecting signal
    stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
    try:
        # Program main loop
        stack.loop()
    except AuthError as e:
        print('Authentication error %s' % e.message)
        sys.exit(1)
Exemplo n.º 2
0
    def setUp(self):
        # YowAuthenticatorLayer.__init__(self)
        super(YowAuthenticationProtocolLayer, self).__init__()
        dummyStack = YowStack()
        self.setStack(dummyStack)

        self.credentials = ("dummyusername", bytearray("password", "latin-1"))
        dummyStack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, self.credentials)
Exemplo n.º 3
0
class YowsupMiddleManStack(object):
    def __init__(self, credentials, groups, encryptionEnabled=False):
        if encryptionEnabled:
            from yowsup.layers.axolotl import YowAxolotlLayer

            layers = (
                MiddleManLayer,
                (
                    YowAuthenticationProtocolLayer,
                    YowMessagesProtocolLayer,
                    YowReceiptProtocolLayer,
                    YowAckProtocolLayer,
                    YowMediaProtocolLayer,
                    YowIqProtocolLayer,
                    YowCallsProtocolLayer,
                ),
                YowAxolotlLayer,
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer,
            )
        else:
            layers = (
                MiddleManLayer,
                (
                    YowAuthenticationProtocolLayer,
                    YowMessagesProtocolLayer,
                    YowReceiptProtocolLayer,
                    YowAckProtocolLayer,
                    YowMediaProtocolLayer,
                    YowIqProtocolLayer,
                    YowCallsProtocolLayer,
                ),
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer,
            )

        self.stack = YowStack(layers)
        self.stack.setProp(MiddleManLayer.PROP_GROUPS, groups[0])
        self.stack.setCredentials(credentials)

    def start(self):
        self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
        try:
            self.stack.loop()
        except AuthError as e:
            print("Authentication Error: %s" % e.message)
Exemplo n.º 4
0
class YowsupReceiveStack(object):

    def __init__(self, credentials):
        layers = (ReceiveLayer,
                  (YowAuthenticationProtocolLayer,
                   YowMessagesProtocolLayer,
                   YowReceiptProtocolLayer,
                   YowAckProtocolLayer,
                   YowMediaProtocolLayer),
                  YowAxolotlLayer,
                  YowCoderLayer,
                  YowCryptLayer,
                  YowStanzaRegulator,
                  YowNetworkLayer)

        self.stack = YowStack(layers)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
        self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
        self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
        self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())

    def start(self):
        #print '-------------------------'
        #print 'En el start de YowsupReceiveStack'
        #print '-------------------------'
        self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
        try:
            self.stack.loop(count=4)
            #self.stack.loop(timeout = 0.5, discrete = 0.5)
        except AuthError as e:
            print("Authentication Error: %s" % e.message)
class YowsupMyStack(object):
    def __init__(self, credentials):
        env.CURRENT_ENV = env.S40YowsupEnv()
        layers = (
            MailLayer,
            (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
                YowReceiptProtocolLayer, YowAckProtocolLayer,
                YowMediaProtocolLayer, YowIqProtocolLayer,
                YowPresenceProtocolLayer)
            ) + YOWSUP_CORE_LAYERS

        self.stack = YowStack(layers)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
                credentials)
        self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
                YowConstants.ENDPOINTS[0])
        self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
        self.stack.setProp(YowCoderLayer.PROP_RESOURCE,
                env.CURRENT_ENV.getResource())

    def start(self):
        self.stack.broadcastEvent(
                YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))

        try:
            self.stack.loop()
        except AuthError as e:
            print("Authentication Error: %s" % e.message)
Exemplo n.º 6
0
def run(phone, password, config):

    # @TODO check phone, password is set
    credentials = (phone.encode(), password.encode())

    layers = (
        secretary(config),
        (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
        YowAxolotlLayer,
    ) + YOWSUP_CORE_LAYERS

    stack = YowStack(layers)

    # Setting credentials
    stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)

    # Whatsapp server address
    stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])

    # Info about us as WhatsApp client
    stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
    stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())

    # Sending the connect signal
    stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))

    stack.loop()
Exemplo n.º 7
0
class YowsupRobotStack(object):
    def __init__(self, credentials, encryptionEnabled = False,interactionProtocol=None,url=None,flaskApp=None):
        if encryptionEnabled:
            from yowsup.layers.axolotl                     import YowAxolotlLayer
            layers = (
                RobotLayer,
                (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer),
                YowAxolotlLayer,
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer
            )
        else:
            layers = (
                RobotLayer,
                (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer),
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer
            )

        self.stack = YowStack(layers)
        self.stack.setCredentials(credentials)
        self.stack.setProp('url',url)
        self.stack.setProp('flaskApp',flaskApp)

    def start(self):
        self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
        def startThread():
            try:
                self.stack.loop(timeout = 0.5, discrete = 0.5)
            except AuthError as e:
                print("Auth Error, reason %s" % e)
            except KeyboardInterrupt:
                print("\nYowsdown KeyboardInterrupt")
                sys.exit(0)
            except Exception as e:
                print("\nYowsdown General Exception")
                print e
        t1=threading.Thread(target=startThread)
        t1.daemon=True
        t1.start()
Exemplo n.º 8
0
class YowsupSendStack(object):
    def __init__(self, credentials, messages, encryptionEnabled = False):
        """
        :param credentials:
        :param messages: list of (jid, message) tuples
        :param encryptionEnabled:
        :return:
        """
        if encryptionEnabled:
            from yowsup.layers.axolotl                     import YowAxolotlLayer
            layers = (
                SendLayer,
                (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
                YowAxolotlLayer,
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer
            )
        else:
            layers = (
                SendLayer,
                (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer
            )

        self.stack = YowStack(layers)
        self.stack.setProp(SendLayer.PROP_MESSAGES, messages)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
        self.stack.setCredentials(credentials)

    def start(self):
        self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
        try:
            self.stack.loop()
        
        except KeyboardInterrupt as e:
            raise e

        except AuthError as e:
            print("Authentication Error: %s" % e.message)
Exemplo n.º 9
0
class YowsupSyncStack(object):
    def __init__(self, credentials, contacts, encryptionEnabled=False):
        """
        :param credentials:
        :param contacts: list of [jid ]
        :param encryptionEnabled:
        :return:
        """
        if encryptionEnabled:
            from yowsup.layers.axolotl import YowAxolotlLayer

            layers = (
                SyncLayer,
                (YowAuthenticationProtocolLayer, YowContactsIqProtocolLayer, YowReceiptProtocolLayer,
                 YowAckProtocolLayer),
                YowAxolotlLayer,
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer
            )
        else:
            layers = (
                SyncLayer,
                (YowAuthenticationProtocolLayer, YowContactsIqProtocolLayer, YowReceiptProtocolLayer,
                 YowAckProtocolLayer),
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer
            )

        self.stack = YowStack(layers)
        self.stack.setProp(SyncLayer.PROP_CONTACTS, contacts)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
        self.stack.setCredentials(credentials)

    def start(self):
        self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
        try:
            self.stack.loop()
        except AuthError as e:
            print("Authentication Error: {0}".format(e))
Exemplo n.º 10
0
def start_server():
    layers = (
        EchoLayer,
        YowParallelLayer([YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer]),YowAxolotlLayer
    ) + YOWSUP_CORE_LAYERS

    stack = YowStack(layers)
    stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)         #setting credentials
    stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])    #whatsapp server address
    stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
    stack.setProp(YowCoderLayer.PROP_RESOURCE, YowsupEnv.getCurrent().getResource())          #info about us as WhatsApp client

    stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))   #sending the connect signal

    stack.loop()
Exemplo n.º 11
0
def main(messages):
    logging.debug("Starting up...")

    layers = (
        (TextMessageSender, AckReceiver),
        (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
         YowReceiptProtocolLayer, YowAckProtocolLayer)
    ) + YOWSUP_CORE_LAYERS

    stack = YowStack(layers)

    stack.setProp(TextMessageSender.MESSAGES, messages)
    # setting credentials
    stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)
    # whatsapp server address
    stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
    stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
    # info about us as WhatsApp client
    stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())

    # sending the connect signal
    stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))

    stack.loop()  # this is the program mainloop
Exemplo n.º 12
0
    def run(self):
        mess = None
        to = None
        phone = None
        passw = None
        with open(appPath + "/config.cfg") as f:
            for line in f:
                if line.find("phone number:", 0) == 0:
                    phone = line[13:]
                    phone = phone.strip()
                elif line.find("password:"******"send_message_startup:", 0) == 0:
                    mess = line[21:-1]
                    mess = "'" + mess + "'"
                elif line.find("allowed1:", 0) == 0:
                    to = line[9:-1]
                CREDENTIALS = (phone, passw)
        print("/send.py " + to + " " + mess)
        p = subprocess.Popen(appPath + "/send.py " + to + " " + mess, stdout=subprocess.PIPE, shell=True)
        (output, err) = p.communicate()
        while True:
            layers = (
                DaemonLayer,
                (
                    YowAuthenticationProtocolLayer,
                    YowMessagesProtocolLayer,
                    YowReceiptProtocolLayer,
                    YowAckProtocolLayer,
                ),
            ) + YOWSUP_CORE_LAYERS

            stack = YowStack(layers)
            stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)
            stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
            stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
            stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
            stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
            interface = stack.getLayer(6)
            interface.initialize(appPath)
            try:
                stack.loop()
            except:
                pass
Exemplo n.º 13
0
class YowsupEchoStack(object):
    def __init__(self, credentials, encryptionEnabled = False):
        if encryptionEnabled:
            layers = (
                EchoLayer,
                (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer),
                YowAxolotlLayer,
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer
            )
        else:
            env.CURRENT_ENV = env.S40YowsupEnv()
            layers = (
                EchoLayer,
                (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer),
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer
            )

        self.stack = YowStack(layers)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
        self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
        self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
        self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
        

        
    def start(self):
        while True:
            try:
                self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
                self.stack.loop()
            except AuthError as e:
                break
            except Exception as e:
                print(e)
                time.sleep(20)
Exemplo n.º 14
0
    def create_stack(self):
        CREDENTIALS = (PHONE, "F5vqaa/9jCXDDMoTSWysyhOI0BU=")  # replace with your phone and password

        layers = (
            EchoLayer,
            (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
            YowAxolotlLayer,
            YowCoderLayer,
            YowCryptLayer,
            YowStanzaRegulator,
            YowNetworkLayer
        )

        stack = YowStack(layers)
        stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)  # setting credentials
        stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])  # whatsapp server address
        stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
        stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())  # info about us as WhatsApp client

        stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))  # sending the connect signal
        return stack
Exemplo n.º 15
0
class YowsupCliStack(object):
    def __init__(self, credentials):
        self.stack = YowStack(
            (YowsupCliLayer,) + YOWSUP_FULL_STACK
        )
        self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
        self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
        self.stack.setProp(YowCoderLayer.PROP_RESOURCE, YowConstants.RESOURCE)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)

    def start(self):
        print("Yowsup Cli client\n==================\nType /help for available commands\n")
        self.stack.broadcastEvent(YowLayerEvent(YowsupCliLayer.EVENT_START))

        try:
            self.stack.loop(timeout = 0.5, discrete = 0.5)
        except AuthError as e:
            print("Auth Error, reason %s" % e)
        except KeyboardInterrupt:
            print("\nYowsdown")
            sys.exit(0)
Exemplo n.º 16
0
class YowsupListenStack(object):
    def __init__(self, credentials, queue, encryptionEnabled = False):

        ListenLayer.setqueue(queue)

        if encryptionEnabled:
            layers = (
                ListenLayer,
                (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer),
                YowAxolotlLayer,
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer
            )
        else:
            env.CURRENT_ENV = env.S40YowsupEnv()
            layers = (
                ListenLayer,
                (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer),
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer
            )

        self.stack = YowStack(layers)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
        self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
        self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
        self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())

    def start(self):
        self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
        try:
            self.stack.loop()
        except AuthError as e:
            print("Authentication Error: %s" % e.message)
Exemplo n.º 17
0
def main():
    layers = (
                EchoLayer,
                (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer),
                YowAxolotlLayer,
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer
            )


    thread = MyThread(YowStack(layers))
    try:
        print ("Starting "+sys.argv[1])
        stack = YowStack(layers)

        stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)         #setting credentials
        stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])    #whatsapp server address
        stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
        stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())          #info about us as WhatsApp client

        stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))   #sending the connect signal

        thread = MyThread(stack)
        thread.start()
        stack.loop(timeout = 0.5, discrete = 0.5)
        print("Exit "+sys.argv[1]+"!!")

    except Exception as e:
        print("Error in "+sys.argv[1]+", reason %s" % e)

    finally:
        thread.finish()
        time.sleep(5)
        print("Restart "+sys.argv[1]+"!!")
        #os.system("python run-Executi.py")
        sys.exit(0)
Exemplo n.º 18
0
class YowsupEchoStack(object):
    def __init__(self, credentials):
        layers = (
            EchoLayer,
            (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer),
            YowLoggerLayer,
            YowCoderLayer,
            YowCryptLayer,
            YowStanzaRegulator,
            YowNetworkLayer
        )

        self.stack = YowStack(layers)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
        self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
        self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
        self.stack.setProp(YowCoderLayer.PROP_RESOURCE, YowConstants.RESOURCE)

    def start(self):
        self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
        try:
            self.stack.loop()
        except AuthError as e:
            print("Authentication Error: %s" % e.message)
Exemplo n.º 19
0
def whatsAppClient():
    global globWhatsAppContinue, globWhatsAppRestart
    global globWhatsAppMsgIn, globWhatsAppMsgInAvailable, globWhatsAppMsgInAvailableLock
    global globWhatsAppMsgOut, globWhatsAppMsgOutType, globIWhatsAppImgOut, globWhatsAppMsgOutAvailable, globWhatsAppMsgOutAvailableLock
    global globDoMotionDetection, globWhatsAppSendPicture

    # YowAxolotlLayer added to prevent 'Unimplemented notification type "encrypt"' crash.
    layers=(SendReceiveLayer,)+(YOWSUP_PROTOCOL_LAYERS_FULL,YowAxolotlLayer)+YOWSUP_CORE_LAYERS
    
    stack = YowStack(layers)
    stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials())         #setting credentials
    stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])    #whatsapp server address
    stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
    stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())          #info about us as WhatsApp client
    stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))   #sending the connect signal
    while globWhatsAppContinue:
        try:
            globWhatsAppMsgOutAvailableLock.acquire()
            if globWhatsAppMsgOutAvailable:
                # Copy to keep critical section as short as possible.
                msgOutType = globWhatsAppMsgOutType
                if msgOutType == 'Image':
                    # Copy image to whatsapp_client_img.jpg so this image can be sent without another thread
                    # overwriting the image.
                    imgOut = '/home/pi/DFRobotUploads/whatsapp_client_img.jpg'
                    shutil.copy(globIWhatsAppImgOut, imgOut)
                msgOut = globWhatsAppMsgOut
                globWhatsAppMsgOutAvailable = False
                globWhatsAppMsgOutAvailableLock.release()
                if msgOutType == 'Image':
                    messages = [(["31613484264", imgOut, msgOut])]
                else:
                    messages = [(["31613484264", '', msgOut])]
                stack.setProp(SendReceiveLayer.PROP_MESSAGES,messages)
                stack.broadcastEvent(YowLayerEvent(SendReceiveLayer.EVENT_SEND_MESSAGE))
            else:
                globWhatsAppMsgOutAvailableLock.release()
            # stack.loop() will call asyncore.loop() for an asynchronous I/O (socket) polling loop,
            # to poll for WhatsApp I/O. WhatsApp uses non-SSL data over SSL port 443.
            # The count parameter indicates the number of passes of the polling loop for each I/O channel.
            # The timeout argument sets the timeout parameter for the appropriate select() or poll() call,
            # measured in seconds. It indicates the wait time (blocking) for an I/O channel (file descriptor)
            # to become ready.
            stack.loop(timeout = 1.0, count=1)
            # Sleep to save cpu.
            time.sleep(1.0)
            # Update charging status of batteries.
            own_util.checkCharging()

            # Handle messages.
            msg = receiveWhatsAppMsg()
            if re.search('.*motion.*on.*', msg, re.IGNORECASE):
                globDoMotionDetection = True
                sendWhatsAppMsg('motion detection is on')
            elif re.search('.*motion.*off.*', msg, re.IGNORECASE):
                globDoMotionDetection = False
                sendWhatsAppMsg('motion detection is off')
            elif re.search('picture', msg, re.IGNORECASE):
                globWhatsAppSendPicture = True;
            elif re.search('hi', msg, re.IGNORECASE):
                sendWhatsAppMsg('hi there!')
            elif re.search('.*feel.*', msg, re.IGNORECASE):
                level = own_util.getBatteryLevel()
                if level != 'unknown':
                    if int(level) > 190:
                        sendWhatsAppMsg('I feel great, my energy level is ' + level)
                    elif int(level) > 170:
                        sendWhatsAppMsg('I feel ok, my energy level is ' + level)
                    else:
                        sendWhatsAppMsg('I feel a bit weak, my energy level is ' + level)
                else:
                    sendWhatsAppMsg('I am not sure, my energy level is unknown')
            elif re.search('how are you', msg, re.IGNORECASE):
                sendWhatsAppMsg('I am fine, thx for asking!')
            elif re.search('battery', msg, re.IGNORECASE):
                charging = own_util.checkCharging()
                if charging == True:
                    sendWhatsAppMsg('I am charging, my battery level is ' + own_util.getBatteryLevel())
                else:
                    sendWhatsAppMsg('I am not charging, my battery level is ' + own_util.getBatteryLevel())
            elif re.search('awake', msg, re.IGNORECASE):
                sendWhatsAppMsg('I am awake for ' + own_util.getUptime())
            elif re.search('joke', msg, re.IGNORECASE):
                sendWhatsAppMsg('\'What does your robot do, Sam?\' .......... \'It collects data about the surrounding environment, then discards it and drives into walls\'')
            elif msg != '':
                sendWhatsAppMsg('no comprendo: ' + msg)

        except Exception,e:
            logging.getLogger("MyLog").info('whatsAppClient exception: ' + str(e))
            # Signal to restart this whatsAppClient thread.
            globWhatsAppRestart = True
Exemplo n.º 20
0
class YowsupSendStack(object):
    def __init__(self, credentials, messages, encryptionEnabled=False):
        """
        :param credentials:
        :param messages: list of (jid, message) tuples
        :param encryptionEnabled:
        :return:
        """
        if encryptionEnabled:
            from yowsup.layers.axolotl import YowAxolotlLayer
            layers = (SendLayer,
                      (YowAuthenticationProtocolLayer,
                       YowMessagesProtocolLayer, YowReceiptProtocolLayer,
                       YowAckProtocolLayer), YowAxolotlLayer, YowLoggerLayer,
                      YowCoderLayer, YowCryptLayer, YowStanzaRegulator,
                      YowNetworkLayer)
        else:
            layers = (SendLayer,
                      (YowAuthenticationProtocolLayer,
                       YowMessagesProtocolLayer, YowReceiptProtocolLayer,
                       YowAckProtocolLayer), YowLoggerLayer, YowCoderLayer,
                      YowCryptLayer, YowStanzaRegulator, YowNetworkLayer)

        self.stack = YowStack(layers)
        self.stack.setProp(SendLayer.PROP_MESSAGES, messages)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
                           credentials)
        self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
                           YowConstants.ENDPOINTS[0])
        self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
        self.stack.setProp(YowCoderLayer.PROP_RESOURCE,
                           env.CURRENT_ENV.getResource())

    def start(self):
        self.stack.broadcastEvent(
            YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
        try:
            self.stack.loop()
        except AuthError as e:
            print("Authentication Error: %s" % e.message)
Exemplo n.º 21
0
class SendMediaStack(object):
    def __init__(self, credentials, messages):
        layers=(SendMediaLayer,)+(YOWSUP_PROTOCOL_LAYERS_FULL,)+YOWSUP_CORE_LAYERS
        self.stack=YowStack(layers)
        self.stack.setProp(SendMediaLayer.PROP_MESSAGES,messages)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE,True)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,credentials)
        self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT,YowConstants.ENDPOINTS[0])
        self.stack.setProp(YowCoderLayer.PROP_DOMAIN,YowConstants.DOMAIN)
        self.stack.setProp(YowCoderLayer.PROP_RESOURCE,env.CURRENT_ENV.getResource())

    def start(self):
        self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
        try:
            self.stack.loop()
        except AuthError as e:
            print("Authentication Error: %s" % e.message)
Exemplo n.º 22
0
from yowsup.layers.network                     import YowNetworkLayer
from yowsup.layers.protocol_messages           import YowMessagesProtocolLayer
from yowsup.layers.protocol_media              import YowMediaProtocolLayer
from yowsup.layers.stanzaregulator             import YowStanzaRegulator
from yowsup.layers.protocol_receipts           import YowReceiptProtocolLayer
from yowsup.layers.protocol_acks               import YowAckProtocolLayer
from yowsup.layers.logger                      import YowLoggerLayer
from yowsup.layers.axolotl                     import YowAxolotlLayer
from yowsup.common import YowConstants
from yowsup import env

credentials = ('972532351883', 'CXq89zg1QB6UYHRQ2BG0zPbcxlQ=')

if __name__ == "__main__":
    env.CURRENT_ENV = env.S40YowsupEnv()
    layers = (EchoLayer,
              (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer),YowLoggerLayer,
              YowCoderLayer,
              YowCryptLayer,
              YowStanzaRegulator,
              YowNetworkLayer)

    stack = YowStack(layers)
    stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
    stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
    stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
    stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
    
    stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
    stack.loop()
Exemplo n.º 23
0
class Client(object):

    def __init__(self, login, password):
        self.login = login
        self.password = password

    def _send_message(self, to, message, is_media=False):
        layers = (SendLayer,) + (YOWSUP_PROTOCOL_LAYERS_FULL,) + YOWSUP_CORE_LAYERS
        self.stack = YowStack(layers)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, (self.login, self.password))
        self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
        self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
        self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.YowsupEnv.getCurrent().getResource())

        self.stack.setProp(SendLayer.PROP_MESSAGES, [([to, message, is_media])])
        self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
        try:
            self.stack.loop()
        except KeyboardInterrupt:
            pass

    def send_message(self, to, message):
        self._send_message(to, message)

    def send_media(self, to, path):
        self._send_message(to, path, is_media=True)
Exemplo n.º 24
0
def main():
    ''' Console script to start the bot or output default config file. '''
    # Arguments
    parser = argparse.ArgumentParser(
        description=_('Start Tombot, a chatbot for Whatsapp')
        )
    parser.add_argument(
        '-v', '--verbose', help=_("enable debug logging"), action='store_true')
    parser.add_argument(
        '-d', '--dry-run',
        help=_("don't actually start bot, but print config"),
        action='store_true')
    parser.add_argument(
        '-p', '--poke', action='store_true',
        help=_("do everything except connecting (for testing)"))
    parser.add_argument('configfile', help=_("config file location"), nargs='?')
    args = parser.parse_args()
    # Set up logging
    if args.verbose:
        loglevel = logging.DEBUG
    else:
        loglevel = logging.INFO
    logging.basicConfig(
        level=loglevel, format='%(levelname)s - %(name)s - %(message)s')
    # Read configuration
    specpath = os.path.join(os.path.dirname(__file__), 'configspec.ini')
    config = ConfigObj(args.configfile, configspec=specpath)

    if not args.dry_run:
        config.validate(Validator())
        if not args.configfile:
            error = _("You must specify a config file!")
            generate_hint = _("Generate one using 'tombot -d > file.ini'.")
            logging.critical(error)
            logging.critical(generate_hint)
            sys.exit(1)

        # Build scheduler, will be started in the bot's layer once connected
        jobstores = {
            'default' : SQLAlchemyJobStore(url='sqlite:///jobs.sqlite'),
        }
        scheduler = BackgroundScheduler(jobstores=jobstores)

        # Build Yowsup stack
        credentials = (config['Yowsup']['username'], config['Yowsup']['password'])
        bot = TomBotLayer(config, scheduler)
        layers = (
            bot,
            YowParallelLayer([
                YowPresenceProtocolLayer, YowAuthenticationProtocolLayer,
                YowMessagesProtocolLayer, YowIqProtocolLayer, YowReceiptProtocolLayer,
                YowChatstateProtocolLayer, YowAckProtocolLayer, YowGroupsProtocolLayer
                ]),
            YowAxolotlLayer,
        ) + YOWSUP_CORE_LAYERS

        stack = YowStack(layers)
        # Set credentials, server address, info about us as WhatsApp client
        stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
        stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
        stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)

        # Send connect signal if we aren't poking at the bot
        if not args.poke:
            stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))

            stack.loop(timeout=0.5, discrete=0.5)  #this is the program mainloop
        else:
            code.interact(local=locals())
    else:
        # Output config file to stdout
        config.filename = None
        config.validate(Validator(), copy=True)
        output = config.write()
        for line in output:
            print(line)
Exemplo n.º 25
0
Arquivo: run.py Projeto: maruen/yowsup
def send_message(destination, message):

    ''' destination is <phone number> without '+'
        and with country code of type string,
        message is string
        e.g send_message('11133434343','hello')
    '''
    messages = [(destination, message)]
    layers = (EchoLayer,
              (YowAuthenticationProtocolLayer,
               YowMessagesProtocolLayer,
               YowReceiptProtocolLayer,
               YowAckProtocolLayer,
               YowPresenceProtocolLayer)
              ) + YOWSUP_CORE_LAYERS
    stack = YowStack(layers)
    stack.setProp(EchoLayer.PROP_MESSAGES, messages)
    stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
    # Setting credentials
    stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)

    # WhatsApp server address
    stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
    stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)              
    stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())

    # Sending connecting signal
    stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
    try:
        # Program main loop
        stack.loop()
    except AuthError as e:
        print('Authentication error %s' % e.message)
        sys.exit(1)
Exemplo n.º 26
0
class YowsupSyncStack(object):
    def __init__(self, credentials, contacts, encryptionEnabled = False):
        """
        :param credentials:
        :param contacts: list of [jid ]
        :param encryptionEnabled:
        :return:
        """
        if encryptionEnabled:
            layers = (
                SyncLayer,
                (YowAuthenticationProtocolLayer, YowContactsIqProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
                YowAxolotlLayer,
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer
            )
        else:
            env.CURRENT_ENV = env.S40YowsupEnv()
            layers = (
                SyncLayer,
                (YowAuthenticationProtocolLayer, YowContactsIqProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
                YowLoggerLayer,
                YowCoderLayer,
                YowCryptLayer,
                YowStanzaRegulator,
                YowNetworkLayer
            )

        self.stack = YowStack(layers)
        self.stack.setProp(SyncLayer.PROP_CONTACTS, contacts)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
        self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
        self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
        self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())

    def start(self):
        self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
        try:
            self.stack.loop()
        except AuthError as e:
            print("Authentication Error: %s" % e.message)
Exemplo n.º 27
0
class Whatsapp():
    def __init__(self, smarthome, account, password, trusted=None, logic='Whatsapp', cli_mode='False'):
# Set Plugin Attributes
        self._sh = smarthome
        self._credentials = (account, password.encode('utf-8'))
        self._trusted = trusted
        self._logic = logic
        self._run = False
        if cli_mode == 'True':
            self._cli_mode = True
            return
        else:
            self._cli_mode = False
# Yowsup Layers
        self._layers = (
            SmarthomeLayer,
            YowParallelLayer((YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowIbProtocolLayer, YowIqProtocolLayer, YowNotificationsProtocolLayer, YowPresenceProtocolLayer)),
            YowCoderLayer,
#            YowLoggerLayer,
            YowCryptLayer,
            YowStanzaRegulator,
            YowNetworkLayer)

# Yowsup Properties
        self._stack = YowStack(self._layers)
        self._stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, self._credentials)
        self._stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
        self._stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
        self._stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())

# Connect Yowsup
        self._stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))

# Get SmarthomeLayer and set this Plugin
        self._SmarthomeLayer = self._stack.getLayer(len(self._stack._YowStack__stack) - 1)
        self._SmarthomeLayer.setPlugin(self)

    def run(self):
        self._run = True
        if self._cli_mode == True:
            return
        try:
            self._stack.loop(timeout = 0.5, discrete = 0.5)
        except AuthError as e:
            logger.info("Authentication Error!")

    def stop(self):
        self._run = False
        if self._cli_mode == True:
            return
        logger.info("Shutting Down WhatsApp Client")
        disconnectEvent = YowLayerEvent(YowNetworkLayer.EVENT_STATE_DISCONNECT)
        self._stack.broadcastEvent(disconnectEvent)

    def parse_item(self, item):
        return None

    def parse_logic(self, logic):
        pass

    def __call__(self, message, phoneNumber=None):
        if phoneNumber == None:
            try:
                phoneNumber = self._trusted.split(' ')[0]
            except AttributeError:
                logger.error("Error sending Whatsapp Message")
            except IndentationError:
                logger.error("Error sending Whatsapp Message")
        if self._cli_mode == True:
            subprocess.call(['/usr/local/bin/yowsup-cli', 'demos', '-l', self._credentials[0] + ':' + self._credentials[1].decode(), '-s', phoneNumber, message])
            return
        self._SmarthomeLayer.sendMsg(message, phoneNumber)

    def message_received(self, message, sender):
        try:
            self._sh.trigger(name=self._logic, value=message, source=sender.split('@')[0])
        except AttributeError:
            logger.error("Error receiving Whatsapp Message")
        except IndentationError:
            logger.error("Error receiving Whatsapp Message")
Exemplo n.º 28
0
class YowsupSendVCardStack(object):
    def __init__(self, credentials, to):
        """
        :param credentials:
        :param to:
        :param encryptionEnabled:
        :return:
        """
        layers = (
            SendVCardLayer,
            (YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer),
            YowLoggerLayer,
            YowCoderLayer,
            YowCryptLayer,
            YowStanzaRegulator,
            YowNetworkLayer
        )

        self.stack = YowStack(layers)
        self.stack.setProp(SendVCardLayer.PROP_TO, to)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
        self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
        self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
        self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
        self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())

    def start(self):
        self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
        try:
            self.stack.loop()
        except AuthError as e:
            print("Authentication Error: %s" % e.message)
Exemplo n.º 29
0
from yowsup.layers.protocol_receipts           import YowReceiptProtocolLayer
from yowsup.layers.protocol_acks               import YowAckProtocolLayer
from yowsup.layers.network                     import YowNetworkLayer
from yowsup.layers.coder                       import YowCoderLayer
from yowsup.layers.protocol_iq                 import YowIqProtocolLayer
from yowsup.stacks import YowStack
from yowsup.common import YowConstants
from yowsup.layers import YowLayerEvent
from yowsup.stacks import YowStack, YOWSUP_CORE_LAYERS
from yowsup.layers.axolotl                     import YowAxolotlLayer
from yowsup.env import YowsupEnv


CREDENTIALS = ("CC9999999999", "password-here") # replace with your phone and password

if __name__==  "__main__":
    layers = (
        EchoLayer,
        YowParallelLayer([YowAuthenticationProtocolLayer, YowIqProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer]),YowAxolotlLayer
    ) + YOWSUP_CORE_LAYERS

    stack = YowStack(layers)
    stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)         #setting credentials
    stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])    #whatsapp server address
    stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)              
    stack.setProp(YowCoderLayer.PROP_RESOURCE, YowsupEnv.getCurrent().getResource())          #info about us as WhatsApp client

    stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))   #sending the connect signal

    stack.loop() #this is the program mainloop
Exemplo n.º 30
0
        YowParallelLayer(
            [YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer,
             YowMediaProtocolLayer, YowPresenceProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer]),
        AxolotlReceivelayer,
        AxolotlControlLayer,
        AxolotlSendLayer,
        YowLoggerLayer,
        YowCoderLayer,
        YowCryptLayer,
        YowStanzaRegulator,
        YowNetworkLayer
    ) + YOWSUP_CORE_LAYERS

    stack = YowStack(layers)
    # Setting credentials
    stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)

    # WhatsApp server address
    stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
    stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
    stack.setProp(YowCoderLayer.PROP_RESOURCE, YowsupEnv.getCurrent().getResource())

    # Sending connecting signal
    stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
    print('Iniciado.')
    try:
        # Program main loop
        stack.loop()
    except KeyboardInterrupt as e:
        print('Saindo...')
else: