Gitingest

Include files under: 50kB

Private Repository NEW

Summary

Repository: coditation/reactnative-xmpp
Files analyzed: 8

Estimated tokens: 10.8k

Download

Directory Structure

Directory structure:

└── coditation-reactnative-xmpp/

    ├── README.md

    ├── index.js

    ├── License

    ├── package.json

    └── lib/

        ├── AsyncStorageBackedQueue.js

        ├── reactnative-xmpp.js

        ├── shim.js

        └── utils.js

Files Content

================================================
FILE: README.md
================================================
# ReactNative-XMPP
XMPP module for React Native

This module is a work in progress and is a barebones XMPP client module at the moment. It should be enough to get some functional XMPP implementation in React Native started. Our development team intends to continue contributing towards further development of the module in coming days and months. Following is a very high level and a draft roadmap for the lib -

- Add unit tests
- Support SASL and Digest-MD5 based Auth. The lib/module currently supports plain auth.
- Implement handling of use-cases such as MUC Invitation, Subscription IQ etc.
- Fork/branch to implement new template driven design
- Achieve feature complete wrt core XMPP spec and XMPP MUC specs

# Using ReactNative-XMPP

- Install rn-nodeify globally (https://github.com/mvayngrib/rn-nodeify) ``` npm install -g rn-nodeify ```
- Install reactnative-xmpp: ``` npm install https://github.com/Coditation/reactnative-xmpp ```
- Run ``` rn-nodeify --install buffer,events,process,stream,util,inherits,fs,path --hack ```
- If you face Sockets Undefined issue somewhere in react-native-socket, do following: Open XCode, remove libTcpSockets.a and re-add it. Run ``` rnpm link react-native-tcp ```


# Sample Code

```
import React, { Component } from 'react';
import {
  AppRegistry,
  StyleSheet,
  Text,
  View
} from 'react-native';

global.Buffer = global.Buffer || require('buffer').Buffer

 var xmpp = require('reactnative-xmpp');
    // Use canonicalHost as the host name on the Jabber server and when you need to connect to any host 
    // other than localhost
    var conf = {login: 'user2',
                password: 'Chelsea@100',
                domain: 'localhost',
                host: 'localhost',
                canonicalHost: 'localhost'};
    var client = new xmpp.Client(conf);


    client.on('ready', function () {
      setTimeout(function () {
        for(var i = 0; i < client.roster.length; i++) {
          console.log(client.roster[i].getAttribute('jid'));

          if(client.roster[i].getAttribute('jid') === 'user3@localhost') {
            client.write('<presence to="'+ client.roster[i].getAttribute('jid') +'" type="subscribe" />');

            client.subscribe(client.roster[i].getAttribute('jid'), 'Friends', null, function(elt) {
              console.log("Subscribe response: " + elt);
            })
          }

        }              
      }, 1000);
    });

    client.on('presence.subscribe',function(element) {
      client.write('<presence to="'+ element.getAttribute('from') +'" type="subscribed" />');
    });

    client.on('ready', function() {
      client.join('testroom@conference.localhost', 'chetans', function(elem) {
        console.log(elem)
      });
    })
    


class reactnativexmpp extends Component {
  render() {
    return (
      <View style={styles.container}>
        <Text style={styles.welcome}>
          Welcome to React Native!
        </Text>
        <Text style={styles.instructions}>
          To get started, edit index.ios.js
        </Text>
        <Text style={styles.instructions}>
          Press Cmd+R to reload,{'\n'}
          Cmd+D or shake for dev menu
        </Text>
      </View>
    );
  }
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    backgroundColor: '#F5FCFF',
  },
  welcome: {
    fontSize: 20,
    textAlign: 'center',
    margin: 10,
  },
  instructions: {
    textAlign: 'center',
    color: '#333333',
    marginBottom: 5,
  },
});

AppRegistry.registerComponent('reactnativexmpp', () => reactnativexmpp);

```



================================================
FILE: index.js
================================================
module.exports = require('./lib/reactnative-xmpp');



================================================
FILE: License
================================================
Copyright for portions of project reactnative-xmpp are held by Thomas 
Debarochez, 2012 as part of project jacasr. All other copyright for project 
reactnative-xmpp are held by Coditation Systems, 2016. All rights reserved.


Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to
deal in the Software without restriction, including without limitation the
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
IN THE SOFTWARE.


================================================
FILE: package.json
================================================
{
  "name": "reactnative-xmpp",
  "version": "1.0.0",
  "private": true,
  "description": "XMPP module for React Native",
  "author": "Coditation Systems",
  "contributors": [
    "Chetan Saundankar <chetan@coditation.com>"
  ],
  "keywords": [
    "xmpp",
    "jabber",
    "ejabberd",
    "chat",
    "react-native",
    "react"
  ],
  "dependencies": {
    "assert": "^1.4.1",
    "asyncstorage-down": "^2.4.1",
    "browserify-zlib": "^0.1.4",
    "console-browserify": "^1.1.0",
    "constants-browserify": "0.0.1",
    "dns.js": "^1.0.1",
    "domain-browser": "^1.1.7",
    "events": "^1.1.1",
    "https-browserify": "0.0.1",
    "node-xml": "^1.0.2",
    "node-xml-lite": "0.0.7",
    "os-browserify": "^0.1.2",
    "path-browserify": "0.0.0",
    "process": "^0.11.5",
    "punycode": "^1.4.1",
    "querystring-es3": "^0.2.1",
    "react": "15.2.1",
    "react-native-crypto": "^2.0.1",
    "react-native-fs": "^1.5.1",
    "react-native-http": "github:tradle/react-native-http#834492d",
    "react-native-level-fs": "^2.0.1",
    "react-native-randombytes": "^2.1.0",
    "react-native-tcp": "https://github.com/swaroop03/react-native-tcp.git",
    "react-native-udp": "^1.2.4",
    "react-native-util": "^1.0.2",
    "readable-stream": "^1.0.33",
    "stream": "0.0.2",
    "stream-browserify": "^1.0.0",
    "timers-browserify": "^1.4.2",
    "tty-browserify": "0.0.0",
    "url": "^0.10.3",
    "vm-browserify": "0.0.4"
  },
  "devDependencies": {
    "rn-nodeify": "^4.0.4"
  },
  "react-native": {
    "zlib": "browserify-zlib",
    "console": "console-browserify",
    "constants": "constants-browserify",
    "crypto": "react-native-crypto",
    "dns": "dns.js",
    "net": "react-native-tcp",
    "domain": "domain-browser",
    "http": "react-native-http",
    "https": "https-browserify",
    "os": "os-browserify",
    "path": "path-browserify",
    "querystring": "querystring-es3",
    "fs": "react-native-level-fs",
    "_stream_transform": "readable-stream/transform",
    "_stream_readable": "readable-stream/readable",
    "_stream_writable": "readable-stream/writable",
    "_stream_duplex": "readable-stream/duplex",
    "_stream_passthrough": "readable-stream/passthrough",
    "dgram": "react-native-udp",
    "stream": "stream-browserify",
    "timers": "timers-browserify",
    "tty": "tty-browserify",
    "vm": "vm-browserify"
  },
  "browser": {
    "zlib": "browserify-zlib",
    "console": "console-browserify",
    "constants": "constants-browserify",
    "crypto": "react-native-crypto",
    "dns": "dns.js",
    "net": "react-native-tcp",
    "domain": "domain-browser",
    "http": "react-native-http",
    "https": "https-browserify",
    "os": "os-browserify",
    "path": "path-browserify",
    "querystring": "querystring-es3",
    "fs": "react-native-level-fs",
    "_stream_transform": "readable-stream/transform",
    "_stream_readable": "readable-stream/readable",
    "_stream_writable": "readable-stream/writable",
    "_stream_duplex": "readable-stream/duplex",
    "_stream_passthrough": "readable-stream/passthrough",
    "dgram": "react-native-udp",
    "stream": "stream-browserify",
    "timers": "timers-browserify",
    "tty": "tty-browserify",
    "vm": "vm-browserify"
  }
}



================================================
FILE: lib/AsyncStorageBackedQueue.js
================================================
import {InteractionManager, Text} from 'react-native';
import {AsyncStorage} from 'react-native';


AsyncStorageBackedQueue = function(config) {
    if('xmpp_client' in config) {
      this.xmpp_client = config.xmpp_client;
    }
    if('retry_interval_sec' in config) {
      this.retry_interval_sec = config.retry_interval_sec;
    }
    if('queue_name' in config) {
      this.queue_name = config.queue_name;
      AsyncStorage.getItem(this.queue_name).then((data) => {
        if(data) {
          this.queue = JSON.parse(data);
        }
      });
    } else {
      throw {
        "messgae": "Queue name missing"
      }
    }
}

AsyncStorageBackedQueue.prototype.queue = []
AsyncStorageBackedQueue.prototype.queue_name = undefined
AsyncStorageBackedQueue.prototype.is_dirty = false
AsyncStorageBackedQueue.prototype.retry_interval_sec = 15;
AsyncStorageBackedQueue.prototype.xmpp_client = undefined;
AsyncStorageBackedQueue.prototype.interval = undefined;


AsyncStorageBackedQueue.prototype.dequeue_element = function(id, id_field) {
  var index = this.queue.map(function(el) {
      return el[id_field];
    }).indexOf(id);
    if(index != -1) {
      var dequeued_element = this.queue.splice(index, 1);
      this._persist_queue();
      return dequeued_element;
    }
    return undefined;
}

AsyncStorageBackedQueue.prototype.queue_element = function(new_element) {
  var element = this.queue.filter((element) => {
    return element.id == new_element.id
  })
  if (element.length > 0) {
    return
  }
  this.queue.push(new_element);
  this.is_dirty = true;
  this._persist_queue();
}


AsyncStorageBackedQueue.prototype.dequeue = function () {
  var element = this.queue.pop();
  this._persist_queue();
  return element;
}

AsyncStorageBackedQueue.prototype.filter = function(filter_fn) {
  var res = this.queue.filter(filter_fn);
  if(res && res.length > 0) {
    return res[0];
  }
}

AsyncStorageBackedQueue.prototype._persist_queue = function() {
  var that = this;
  AsyncStorage.setItem(that.queue_name, JSON.stringify(that.queue),
    () => {
      is_dirty = false;
    },
    (error) => {
      console.log("Error while inserting data");
    });
}

AsyncStorageBackedQueue.prototype._retry_send = function() {
  var that = this;
    this.interval = setInterval(function() {
      InteractionManager.runAfterInteractions(() => {
        that.queue.map(function(el) {
          if((new Date().getTime() - el.send_timestamp) >= that.retry_interval_sec*1000) {
            if(that.xmpp_client) {
              try {
                that.xmpp_client.push(el.to, el.str, el.type, [el.message], true);
              }
              catch(e) {

              }
            }
          }
        });
      });
    }, that.retry_interval_sec*1000);
}

AsyncStorageBackedQueue.prototype.stop_retry_send = function() {
  if (this.interval !== undefined) {
    clearInterval(this.interval)
  }
} 

AsyncStorageBackedQueue.prototype.start_retry = function() {
  this._retry_send();
}

exports.AsyncStorageBackedQueue = AsyncStorageBackedQueue;


================================================
FILE: lib/reactnative-xmpp.js
================================================
import {AsyncStorage} from 'react-native';

var sys     = require('util')
  , tcp     = require('react-native-tcp')
  , events  = require('events').EventEmitter
  , sax = require("node-xml")
  , Element = require('./utils').Element
  , package_properties = require('../package.json')
  , AsyncStorageBackedQueue = require('./AsyncStorageBackedQueue')
  , uuidv5 = require('uuid/v5')
  , XMLParser = require('react-xml-parser');


var NS_SASL = 'urn:ietf:params:xml:ns:xmpp-sasl'
  , NS_BIND = 'urn:ietf:params:xml:ns:xmpp-bind'
  , NS_SESSION = 'urn:ietf:params:xml:ns:xmpp-session'
  , NS_CLIENT = 'jabber:client'
  , NS_XHTML = 'http://www.w3.org/1999/xhtml'
  , NS_XHTML_IM = 'http://jabber.org/protocol/xhtml-im'
  , NS_TLS = 'urn:ietf:params:xml:ns:xmpp-tls'
  , NS_STREAMS = 'http://etherx.jabber.org/streams'
  , NS_ROSTER = 'jabber:iq:roster'
  , NS_VCARD = 'vcard-temp'
  , NS_SOFT_VERSION = 'jabber:iq:version'
  , NS_LAST_SRV_RCV = 'jabber:iq:last'
  , NS_TIME = 'urn:xmpp:time'
  , NS_MUC = 'http://jabber.org/protocol/muc#user'


  , BROCKER_ACK_QUEUE_NAME = 'brocker_ack_queue'
  , END_TO_END_ACK_QUEUE_NAME = 'end_to_end_ack_queue'
  , BROKER_WAITING_STATUS = "BROKER_WAITING"
  , BROCKER_UNACK_STATUS = 'BROCKER_UNACK'
  , BROCKER_ACK_STATUS = 'BROCKER_ACK'
  , BROCKER_FAILED_STATUS = 'BROCKER_FAILED'
  , PARTIAL_RECIPIENT_ACK_STATUS = 'PARTIAL_RECIPIENT_ACK'
  , RECIPIENT_ACK_STATUS = 'RECIPIENT_ACK'
  , UUID_GENERATION_DOMAIN = 'SUNRISEHEALTH.CO'
  , BROCKER_ACKD_MESSAGE = 'brocker_ackd'
  , END_TO_END_PARTIAL_ACKD = 'end_to_end_partial_ackd'
  , END_TO_END_ACKD = 'end_to_end_ackd'


  , conn
  , xml_parser
  , stream_events_manager
  , brocker_ack_enabled
  , end_to_end_ack_enabled
  , brocker_ack_queue
  , end_to_end_ack_queue
  , config


/**
 * == React Native XMPP ==
 * XMPP library for React Native
 *
 **/

/** section: React Native XMPP
 * class Client
 *
 * Here is the XMPP client class. Each instances inherits EventEmiter methods. Events are :
 * - `message`, parameters are : `from`, `message`, `receiver`, `message_type`, `message_id`
 * - `message.sent`, parameters are : `to`, `message`
 * - `presence`, parameters are : `from`, `to`, `status`, `priority`, `type`
 * - `ready`, no parameters : called when session start.
 **/

/**
 * new Client([conf])
 * - conf (Object): hash with following keys :
 `login`, `password`, `domain`, `host`, `port`, `resource`, `status`, 'brocker_ack_enabled,
 ', 'end_to_end_ack_enabled'
 *
 * Example of usage :
 *
 *     var xmpp = require('reactnative-xmpp');
 *     var conf = {login: 'user',
 *                 password: 'pass',
 *                 domain: 'server.com'};
 *     var client = new xmpp.Client(conf);
 *     client.on('message', doSomeStuff);
 *
 *
 **/
Client = function (conf) {

  var self = this, mechanisms = [];

  function setID (attrs) {
    self.id = attrs.id;
  }

  function sasl () {
    try{
      if (mechanisms.indexOf('PLAIN')) {
        self.write("<auth xmlns='" + NS_SASL + "' mechanism='PLAIN'>"
                   + (new Buffer('\x00' + conf.login + '\x00' + conf.password)).toString('base64') + "</auth>", function(e) {
      });
      }
      else {
        self.write("<auth xmlns='" + NS_SASL + "' mechanism='DIGEST-MD5' />", function(e) {
      });
        stream_events_manager.once('end|challenge|' + NS_SASL, onChallengeReceived);
      }
    }catch(e){

    }
  }

  function onChallengeReceived (element) {
    var x = 0;
    // md5dig.processing(element.nodeValue, {username: conf.login,
    //                                       realm: conf.domain,
    //                                       'digest-uri': 'xmpp/' + conf.domain,
    //                                       password: conf.password}, onResponseReady);
  }

  function onResponseReady (response) {
    try{
      self.write("<response xmlns='" + NS_SASL + "'>" + response + "</response>", function(e) {
      });
      stream_events_manager.once('end|failure|' + NS_SASL, onChallengeFailed);
      stream_events_manager.once('end|challenge|' + NS_SASL, onChallengeSuccess);
    }catch(e){

    }
  }

  function onChallengeFailed () {
    //throw new Error('md5-digest challenge failed (bad login/password ?)');
    self.emit('message.error',new Error('md5-digest challenge failed (bad login/password ?)'));
  }

  function onChallengeSuccess () {
    try{
      self.write("<response xmlns='" + NS_SASL + "'/>", function(e) {
      });
    }catch(e){

    }
  }

  function setMechanism (element) {
    mechanisms.push(element.nodeValue);
  }

  function initiateSession () {
    try{
      self.write('<stream:stream to="' + (conf.canonicalHost || conf.host) + '" '
                 + 'xmlns="' + NS_CLIENT + '" '
                 + 'xmlns:stream="' + NS_STREAMS + '" '
                 + 'version="1.0" >', function(e) {
      });
    }catch(e){

    }
  }

  function resourceBindings () {
    self.sendIq({type: 'set'}, '<bind xmlns="' + NS_BIND + '"><resource>' + conf.resource + "</resource></bind>", function(elt) {
      sessionBindings();
    });
  }

  function sessionBindings () {
    self.sendIq({type: 'set'}, '<session xmlns="' + NS_SESSION + '"></session>', function(elt) {
      sendPresenceInformation();
    });
  }

  function sendPresenceInformation () {
    self.getRoster(function () {
      self.setStatus('chat', conf.status);
      self.emit('ready');
    });
  }

  function saveData(data){
    // (function(){
    //   AsyncStorage.getItem("logger1").then((dataLocal) => {
    //     if(dataLocal !== null){
    //       console.log(dataLocal);
    //       dataLocal = JSON.parse(dataLocal)
    //       dataLocal.push(data);
    //     }
    //     else {
    //       dataLocal = new Array();
    //       dataLocal.push(data);
    //     }

    //     console.log("dataLocal Array Local :");
    //     console.log(dataLocal);
    //     if(data === undefined){

    //     }
    //     else {
    //       AsyncStorage.setItem("logger1", JSON.stringify(dataLocal),
    //         () => {
    //           setTimeout(() => {
    //             //_this.checkForNewMessage();
    //           },200);
    //         },
    //         (error) => {
    //           console.log("Error while inserting data");
    //         });
    //       }

    //     });
    // }());
  }

  function onMessageReceive (attrs) {

    function onBodyReceived (element) {
      var data = {}; // create an empty array
      var length = element.parent.children.length;

      if(length > 1){
        for(var i = 0 ; i < (length-1) ; i++){
          data.nodeValue = element.parent.children[length-1].nodeValue;
        }
      }
      else {
        data.nodeValue = element.parent.children[length-1].nodeValue;
      }

      data.fromValue = element.parent.getAttribute("from");
      data.timeStamp = element.parent.getAttribute("timeStamp");
      data.newId = element.parent.getAttribute("newId");

      // var no = Math.floor((Math.random() * 10) + 1);
      //
      // if(no > 5) {
      if (self.brocker_ack_enabled) {
        var dequeued_message = self.brocker_ack_queue.dequeue_element(data.newId, 'id');
        if(dequeued_message) {
          dequeued_message.status = BROCKER_ACK_STATUS;
          // self.end_to_end_ack_queue.queue_element(dequeued_message);
          self.emit(BROCKER_ACKD_MESSAGE, data);
          return
        }
      }
      // }
      saveData(data);
      self.emit('message', element.parent);
    }

    function onHtmlBodyReceived (element) {
      self.emit('html.message', element.parent);
    }

    function onMessageReceived () {
      stream_events_manager.removeListener('end|body|' + NS_XHTML, onHtmlBodyReceived);
      stream_events_manager.removeListener('end|body|' + NS_CLIENT, onBodyReceived);
    }

    stream_events_manager.once('end|body|' + NS_XHTML, onHtmlBodyReceived);
    stream_events_manager.once('end|body|' + NS_CLIENT, onBodyReceived);
    stream_events_manager.once('end|message|' + NS_CLIENT, onMessageReceived);
  }

  function onPresenceReceive (attrs) {
    var status, priority = "";
    if ('type' in attrs && attrs.type == 'unavailable') {
      return;
    }

    function statusReceived (element) {
      status = element.nodeValue;
    }

    function priorityReceived (element) {
      priority = element.nodeValue;
    }

    function presenceReceived (element) {
      if(element.getAttribute('type') !== null && element.getAttribute('type') !== '') {
        self.emit('presence.'+ element.getAttribute('type'), element);
      }

      self.emit('presence.receive', element);
    }

    stream_events_manager.on('end|presence|' + NS_CLIENT, presenceReceived);
    stream_events_manager.on('end|priority|' + NS_CLIENT, priorityReceived);
    stream_events_manager.on('end|status|' + NS_CLIENT, statusReceived);
  }

  function starttls () {
    try{
      self.write('<starttls xmlns="' + NS_TLS + '" />', function(e) {
      });
      stream_events_manager.removeListener('start|mechanisms|' + NS_SASL, sasl);
      stream_events_manager.on('start|proceed|' + NS_TLS, proceedTls);
    }catch(e){

    }
  }

  function proceedTls () {
     conn.setSecure();
    initiateSession();
  }

  function sendSoftVersion () {
    self.sendIq({type: "result", from: self.jid},
                '<query xmlns="jabber:iq:version"><name>' + package_properties.name + '</name><version>' + package_properties.version + '</version></query>');
  }
  function sendLastServerResponse () {
    self.sendIq({type: "result", from: self.jid},
                '<query xmlns="jabber:iq:last" seconds="' + Math.round((+new Date - +self.last_time_received) / 1000) + '" />');
  }
  function sendLocalTime () {
    self.sendIq({type: "result", from: self.jid},
                '<time xmlns="urn:xmpp:time"><tzo>02:00</tzo><utc>' + (new Date).toISOString() + '</utc></time>');
  }
  function iqReceive (elt) {
    var type = elt.getAttribute('type');
    if (type === "set") {
      var query;
      if (query = elt.getElementsByTagNameNS('jabber:iq:roster', 'query')[0]) {
        var contact = query.getElementsByTagNameNS('jabber:iq:roster', 'item')[0]
          , update = false;
        self.roster.forEach(function (item, i) {
          if (item.getAttribute('jid') === contact.getAttribute('jid')) {
            self.roster[i] = contact;
            update = true;
          }
        });
        if (false === update) {
          self.roster.push(contact);
        }
      }
    }
    else {
      self.emit('iq|' + elt.getAttribute('id') + '|' + type, elt);
    }
  }

  function init () {
    //
    self.config = conf;
    self.jid = conf.login + '@' + conf.domain + '/' + conf.resource;
    conn = tcp.createConnection(conf.port || 5222, conf.host);
    self.brocker_ack_enabled = conf.brocker_ack_enabled || false
    self.end_to_end_ack_enabled = conf.end_to_end_ack_enabled || false

    if(self.brocker_ack_enabled) {
      self.brocker_ack_queue = conf.brocker_ack_queue;
    }

    if(self.end_to_end_ack_enabled) {
      var config = {
        'retry_interval_sec':15,
        'queue_name':"end_to_end_ack_queue"
      }
      self.end_to_end_ack_queue = new AsyncStorageBackedQueue.AsyncStorageBackedQueue(config);
    }

    conn.on("disconnect", function (error) {
      // self.emit('close');
    });

    conn.on("connect", function () {
      this.setTimeout(0);
      this.setEncoding("utf8");
      initiateSession();
    });

    conn.on("data", (data) => {
      this.last_time_received = new Date;
      var l = "<?xml version='1.0'?>".length;
      if(typeof data !== 'string') {
        data = data.toString();
      }
      if(typeof data === 'string') {
        if (data.substring(0, l) == "<?xml version='1.0'?>") {
          data = data.substring(l);
        }
        try{
          if(data){
            var parsedData = new XMLParser().parseFromString(data);
            var message_status = parsedData.getElementsByTagName('Status')
            if(message_status.length > 0){
              var group_name = parsedData.attributes.from
              var status_code = message_status[0].attributes.code
              if(status_code == "110" && group_name !== self.jid){
                self.emit('group_joined',group_name);
              }
            }
          }
        } catch(e) {
          console.log(e)
        }
        parser.parseString(data);
      }
    });

    conn.on("error", function (error) {
      var timeout = Math.round(Math.random() * 10 + 5) * 1000;
      //setTimeout(init, timeout);
      self.emit('message.error',error);
    });

    conn.on("close", function (error) {
      self.emit('close',error);
    });

    conn.on("end", function () {
      try{
        this.write('</stream:stream>', function(e) {
        });
      }catch(e){
        return {
          "error":e
        };
      }
      // self.emit('close');
    });
  }


  stream_events_manager = (new events)
    .once('start|stream|' + NS_STREAMS, setID)
    .once('start|success|' + NS_SASL, initiateSession)
    .once('start|bind|' + NS_BIND, resourceBindings)
    .once('start|presence|' + NS_CLIENT, onPresenceReceive)
    .once('end|mechanism|' + NS_CLIENT, setMechanism)
    .once('end|mechanisms|' + NS_SASL, sasl)
    .on('start|message|' + NS_CLIENT, onMessageReceive)
    .on('start|query|' + NS_SOFT_VERSION, sendSoftVersion)
    .on('start|query|' + NS_LAST_SRV_RCV, sendLastServerResponse)
    .on('start|time|' + NS_TIME, sendLocalTime)
    .on('end|iq|' + NS_CLIENT, iqReceive);

  stream_events_manager.setMaxListeners(50);

  if (false && conf && 'tls' in conf && conf.tls) {
    stream_events_manager.on('start|starttls|' + NS_TLS, starttls);
  }
  var parent_node = new Element('root'),
  current_node = null, value = '', cdata = '';


  var parser = new sax.SaxParser(function(cb) {
    cb.onStartDocument(function() {

    });
    cb.onEndDocument(function() {

    });
    cb.onStartElementNS(function(elem, attrs, prefix, uri, namespaces) {
       var name = '';
        name = elem;
        // xml_parser.current_elem = elt;
        if(current_node !== null) {
          parent_node = current_node;
          current_node = new Element(name, parent_node, attrs, prefix, uri);
        } else {
          current_node = new Element(name, parent_node, attrs, prefix, uri);
          parent_node = current_node;
        }
        var params = {};
        for (var key in attrs) {
          params[attrs[key].name] = attrs[key].value;
        }
        if(name === 'optional') name = 'session';
        stream_events_manager.emit('start|' + name + '|' + uri, params);
    });
    cb.onEndElementNS(function(elem, prefix, uri) {
        current_node.nodeValue = value;
        value = '';
        current_node.cdata = cdata;
        cdata = '';
        stream_events_manager.emit('end|' + elem + '|' + uri, current_node);
        current_node = parent_node = current_node.parent;
    });
    cb.onCharacters(function(chars) {
        value += chars;
    });
    cb.onCdata(function(cd) {
        cdata += cd;
    });
    cb.onComment(function(msg) {
        util.log('<COMMENT>'+msg+"</COMMENT>");
    });
    cb.onWarning(function(msg) {
        util.log('<WARNING>'+msg+"</WARNING>");
    });
    cb.onError(function(msg) {
        util.log('<ERROR>'+JSON.stringify(msg)+"</ERROR>");
        // self.emit('close');
    });
  });

  if (!conf || !("login" in conf) || !conf.login || conf.login.length < 1) {
    self.emit('message.error',new Error('Error login missing in the config'));
    //throw "[ error ] login missing in the config";
  }

  conf.status = conf.status || 'ready';
  conf.resource = conf.resource || package_properties.name;

  if ('host' in conf) {
    init();
  }
  else {
    self.emit('message.error',new Error('Host is missing in the config'));
    //throw "[ error] Host is missing in the config";
  }
};

sys.inherits(Client, events);

/**
 * Client#id -> Number
 *
 * Session id send by server.
 **/
Client.prototype.id = 0;

/**
 * Client#jid -> String
 *
 * Client jid : `user@domain/resource` define by configuration in constructor.
 **/
Client.prototype.jid = '';

/**
 * Client#last_time_received -> Date
 *
 * Date object to the last time anything has been received from server.
 **/
Client.prototype.last_time_received = new Date;

/**
 * Client#roster -> Array of Elements
 *
 * Client roster : Contact list.
 **/
Client.prototype.roster = null;

Client.prototype.conf = null;

/**
 * Client#getRoster([callback]) -> Client
 * - callback (Function): a function called with roster in parameter
 *
 * Retrieve roster from server.
 **/
Client.prototype.getRoster = function (cb) {
  if (this.roster === null) {
    var self = this;
    return this.sendIq({type: 'get'}, '<query xmlns="' + NS_ROSTER + '" />', function (elt) {
      if(elt !== undefined)
        self.roster = elt.children[0].children;
      if (typeof cb == 'function') {
        cb(self.roster);
      }
    });
  }
  else {
    if (typeof cb == 'function') {
      cb(this.roster);
    }
  }
  return this;
};

/**
 * Client#getBareJid(jid) -> String
 * - jid (String): jid wich you want remove resource
 *
 * Remove resource information from a jid.
 **/
Client.prototype.getBareJid = function (long_jid) {
  var res = /([^\/]+)\//.exec(long_jid);
  if (res === null) {
    return false;
  }
  return res[1];
};


/**
 * Client#getVCard([to[, callback]]) -> Client
 * - to (String): a jid whose get vCard, if ommitted Client.jid is used
 * - callback (Function): a function called with xml element in parameter
 *
 * Call `callback` function with vCard's `to` as parameter.
 **/
Client.prototype.getVCard = function (to, cb) {
  var opts = {type: 'get'};
  if (to === null) {
    opts.from = jid;
  }
  else {
    opts.to = to;
  }
  this.sendIq(opts, '<vCard xmlns="' + NS_VCARD + '" />', function (element) {
    if (typeof cb == 'function') {
      cb(element.children[0]);
    }
  });
  return this;
};

/**
 * Client#push(to, str[, type]) -> Client
 * - to (String): receiver jid (ex: "john.doe@domain.com") to send message
 * - str (String): the message
 * - type (String): message type, default "chat", could be "groupchat" for MUC
 * - data (String): xml element to be added to the message
 *
 * Send instant message.
 **/
Client.prototype.push = function (to, str, type, data=undefined, is_retry=false, recipients=undefined) {
  var that = this;
  if (type === "groupchat") {
    to = this.getBareJid(to);
  }

  str = escape(str);

  if (!type) {
    type = "chat";
  }

  var raw = '<message from="' + this.jid + '" '
          + ' type="' + type + '"'
          + ' to="' + to + '"'
          + ' newId="' + data[0]["newId"] + '"'
          + ' messageId="' + data[0]["messageId"] + '"'
          + ' timeStamp="' + data[0]["timeStamp"] + '"'
          + ' userColor="' + data[0]["userColor"] + '"'
          + ' isImage="' + data[0]["isImage"] + '"'+ '>'
          + '<body><![CDATA[' + str + ']]></body></message>';
  var messageSent = true
  try{
    if(this.brocker_ack_enabled) {
        if(!is_retry) {
     // Form the message to be stored in the queue
        var queued_message = {
          id: data[0].newId,
          to: to,
          str: str,
          type: type,
          message: data[0],
          status: BROCKER_UNACK_STATUS,
          recipients: recipients,
          recipients_ackd: [],
          send_timestamp: (new Date).getTime()
        };
        this.brocker_ack_queue.queue_element(queued_message);
      }
    }

    var response = this.write(raw, function(e) {
     messageSent = false
    });
    if ("error" in response) {
      messageSent = false
    }
  }catch(e){
    messageSent = false;
    var response = {};
    response.error = e;
    throw {
      "error":"Message delivery failed, please try again later."
    };
  }
  finally{
    data[0].status = BROCKER_UNACK_STATUS
    this.emit('message.sent', to, str, data,messageSent);
    if(messageSent){
      return response;
    }
    //return response;
    // throw {
    //   "error":e
    // };
  }
  // this.emit('message.sent', to, str, data,messageSent);
  //return response;
};

/**
 * Client#pushHtml(to, str[, type]) -> Client
 * - to (String): a jid to send message
 * - str (String): the html message
 * - type (String): html message type, default "chat", could be "groupchat" for MUC
 *
 * Send HTML instant message.
 **/
Client.prototype.pushHtml = function (to, str, type, data = undefined) {
  if (type === "groupchat") {
    to = this.getBareJid(to);
  }

  str = escape(str);

  var raw = '<message from="' + this.jid + '" '
          + 'to="' + to +'" '
          + (typeof type === "string" ? ' type="' + type + '"' : ' type="chat"')
          + '>' + (data ? data : "") + '<body>' + str.replace(/(\<[^\>]+\>|\<\/[^\>]+\>|\<[^\>]+\/\>)/g, '') + '</body>'
          + '<html xmlns="' + NS_XHTML_IM + '">'
          + '<body xmlns="' + NS_XHTML + '">' + str + '</body></html></message>';
  try{
    this.write(raw, function(e) {
    });
  }catch(e){
    return {
      "error":e
    };
  }
  this.emit('html.message.sent', to, str);
  return this;
};

/**
 * Client#sendIq(attrs, content[, cb]) -> Client
 * - attrs (Object): request attributes
 * - content (String): content of request
 * - cb (Function): Callback function
 *
 * Internal use.
 **/
Client.prototype.sendIq = function (attrs, content, cb) {
  if (typeof this.sendIq.nb_req == 'undefined') {
    this.sendIq.nb_req = 0;
  }
  var id;
  id = 'req' + this.sendIq.nb_req++;
  attrs.id = id;
  var buffer = '<iq';
  for (var k in attrs) {
    if (attrs.hasOwnProperty(k)) {
      buffer += ' ' + k + '="' + attrs[k] + '"';
    }
  }
  try{
    this.writeDummy(buffer + '>' + content + '</iq>', function(response){
      if (typeof cb == 'function') {
        cb(response);
      }
    });
  }catch(e){
    return {
      "error":e
    };
  }
  if (typeof cb !== 'function') {
    return this;
  }
  var onReceive = function (elt) {
    this.removeListener('iq|' + id + '|result', onReceive);
    if (typeof cb == 'function') {
      cb(elt);
    }
  };
  this.once('iq|' + id + '|result', cb);
  return this;
};

/**
 * Client#setStatus([show[, status[, priority[, avatar_sha1]]]]) -> Client
 * - status (String): contains non-human-readable XML character data that specifies the particular availability status. Default : "chat".
 * - show (String): detailled description of an availability state. Default : "Interested in chatting".
 * - priority (Number): specify the priority level of the resource.
 * - avatar_sha1 (String): sha1 checksum of the avatar to use
 *
 * Set client status and priority.
 **/
Client.prototype.setStatus = function (show, status, priority, avatar_sha1) {
  var statuses = {"away": "Temporarily away",
                  "chat": "Interested in chatting",
                  "dnd": "Do not disturb",
                  "xa": "Extended away"};
  show = statuses[show] ? show : 'chat';
  status = status !== null ? status : statuses[show];
  priority = !isNaN(priority) ? priority : false;
  var buffer = '<presence from="' + this.jid + '">';
  buffer += '<show>' + show + '</show>';
  if (status) {
    buffer += '<status>' + status + '</status>';
  }
  if (priority) {
    buffer += '<priority>' + priority + '</priority>';
  }
  if (avatar_sha1) {
    buffer += '<x xmlns="vcard-temp:x:update"><photo>' + avatar_sha1 + '</photo></x>';
  }
  buffer += '</presence>';
  try{
    return this.write(buffer, function(e) {
    });
  }catch(e){
    return {
      "error":e
    };
  }
};

/**
 * Client#setVcard(vcard[, callback]) -> Client
 * - vcard (String): xml stream of the vcard
 * - callback (Function): callback with server's response in parameter
 *
 * Setup your vcard
 **/
Client.prototype.setVcard = function (vcard, cb) {
  var opts = {type: 'set'};
  this.sendIq(opts, '<vCard xmlns="' + NS_VCARD + '">' + vcard + '</vCard>', function (element) {
    if (typeof cb == 'function') {
      cb(element.children[0]);
    }
  });
  return this;
};

/**
 * Client#subscribe(to[, group[, name[, callback]]]) -> Client
 * - to (String): a jid to add to roadster
 * - group (String): the group, default "Group"
 * - name (String): Alias, default first argument
 * - callback (Function): callback with server's response in parameter
 *
 * Add somebody to your roster
 **/
Client.prototype.subscribe = function (to, group, name, cb) {
  group = group || 'Group';
  name = name || to;
  if (!(typeof cb === "function")) {
    cb = function () {};
  }
  this.sendIq({type: 'set'}, '<query xmlns="' + NS_ROSTER + '">'
                            +  '<item jid="' + to + '" '
                            +       'name="' + name + '">'
                            +    '<group>' + group + '</group>'
                            +  '</item>'
                            +'</query>', cb);

  try{
    return this.write('<presence to="'+ to +'" type="subscribe" />', function(e) {
    });
  }catch(e){
    return {
      "error":e
    };
  }
};


/**
 * Client#join(room, callback) -> Client
 * - room (String): A jid to add to room
 * - callback (Function): callback with server's response
 *
 * Add somebody to your roster
 **/
Client.prototype.join = function (room, nick, cb) {

  if (!(typeof cb === "function")) {
    cb = function () {};
  }
  try{
    return this.write('<presence from="'+ this.jid +'" to="'+ room + '/' + nick + '"><x xmlns="http://jabber.org/protocol/muc#user"><item affiliation="member" role="participant" /></x></presence>', function(e) {
    });
  }catch(e){
    return {
      "error":e
    };
  }
};

/**
 * Client#write(data) -> client
 * - data (String): raw data to send
 *
 * Write raw datas
 **/
Client.prototype.write = function (data) {
  try{
    conn.write(data);
    return {
      "info":"Message sent successfully"
    }
  }catch(e){
    // return {
    //   "error":e
    // }
    throw {
      "error":"Message delivery failed, please try again later."
    }
  }
  return this;
};

Client.prototype.writeDummy = function (data, cb) {
  try{
    conn.write(data, function(response){
      if (typeof cb == 'function') {
        cb(response);
      }
    });
  }catch(e){
    return {
      "error":e
    }
  }
  return this;
};

Client.prototype.disconnect = function() {
  try {
    conn.end()
  }
  catch(e) {
    return {
      "error":e
    }
  }
  finally {
    conn = null;
  }
}

exports.Client = Client;
exports.AsyncStorageBackedQueue = AsyncStorageBackedQueue.AsyncStorageBackedQueue;
exports.NS_SASL = NS_SASL;
exports.NS_BIND = NS_BIND;
exports.NS_SESSION = NS_SESSION;
exports.NS_CLIENT = NS_CLIENT;
exports.NS_XHTML = NS_XHTML;
exports.NS_XHTML_IM = NS_XHTML_IM;
exports.NS_TLS = NS_TLS;
exports.NS_STREAMS = NS_STREAMS;
exports.NS_ROSTER = NS_ROSTER;
exports.NS_VCARD = NS_VCARD;
exports.NS_SOFT_VERSION = NS_SOFT_VERSION;
exports.NS_LAST_SRV_RCV = NS_LAST_SRV_RCV;
exports.NS_TIME = NS_TIME;
exports.NS_MUC = NS_MUC;
exports.BROCKER_ACK_QUEUE_NAME = BROCKER_ACK_QUEUE_NAME
exports.END_TO_END_ACK_QUEUE_NAME = END_TO_END_ACK_QUEUE_NAME
exports.BROCKER_UNACK_STATUS = BROCKER_UNACK_STATUS
exports.BROCKER_ACK_STATUS = BROCKER_ACK_STATUS
exports.BROCKER_FAILED_STATUS = BROCKER_FAILED_STATUS
exports.PARTIAL_RECIPIENT_ACK_STATUS = PARTIAL_RECIPIENT_ACK_STATUS
exports.RECIPIENT_ACK_STATUS = RECIPIENT_ACK_STATUS
exports.UUID_GENERATION_DOMAIN = UUID_GENERATION_DOMAIN
exports.BROCKER_ACKD_MESSAGE = BROCKER_ACKD_MESSAGE
exports.BROKER_WAITING_STATUS = BROKER_WAITING_STATUS
exports.END_TO_END_PARTIAL_ACKD = END_TO_END_PARTIAL_ACKD
exports.END_TO_END_ACKD = END_TO_END_ACKD



================================================
FILE: lib/shim.js
================================================
if (typeof __dirname === 'undefined') global.__dirname = '/'
if (typeof __filename === 'undefined') global.__filename = ''
if (typeof process === 'undefined') {
  global.process = require('process')
} else {
  var bProcess = require('process')
  for (var p in bProcess) {
    if (!(p in process)) {
      process[p] = bProcess[p]
    }
  }
}

process.browser = false
if (typeof Buffer === 'undefined') global.Buffer = require('buffer').Buffer

// global.location = global.location || { port: 80 }
var isDev = typeof __DEV__ === 'boolean' && __DEV__
process.env['NODE_ENV'] = isDev ? 'development' : 'production'
if (typeof localStorage !== 'undefined') {
  localStorage.debug = isDev ? '*' : ''
}



================================================
FILE: lib/utils.js
================================================

function Element (elem, parent, attrs, prefix, uri) {
  this.name = elem;
  this.attributes = attrs || {};
  this.prefix = prefix || '';
  this.uri = uri || '';
  this.children = [];
  this.nodeValue = '';
  this.cdata = '';
  this.parent = parent;
  if (this.parent) {
    this.parent.children.push(this);
  }
}

Element.prototype.getElementsByTagName = function (tag_name) {
  var tmp = [];
  this.children.forEach(function (node) {
    node.getElementsByTagName(tag_name).forEach(function (match) {
      tmp.push(match);
    });
    if (node.name === tag_name && node.uri === '') {
      tmp.push(node);
    }
  });
  return tmp;
};

Element.prototype.getElementsByTagNameNS = function (ns, tag_name) {
  var tmp = [];
  this.children.forEach(function (node) {
    node.getElementsByTagNameNS(ns, tag_name).forEach(function (match) {
      tmp.push(match);
    })
    if (node.name === tag_name && node.uri === ns) {
      tmp.push(node);
    }
  });
  return tmp;
};

Element.prototype.getAttribute = function (attribute_name) {
  var value = null;
  for (var k = 0; k < this.attributes.length; k++) {
    if (this.attributes[k][0] === attribute_name) {
      return this.attributes[k][1];
    }
  }
  return false;
};

module.exports = {
  "Element": Element
}