├── .travis.yml
├── package.json
├── src
    ├── ios
    │   ├── CordovaMQTTPlugin.m
    │   ├── MQTTClientPersistence.h
    │   └── MQTTAsync.h
    └── android
    │   └── CordovaMqTTPlugin.java
├── LICENSE
├── plugin.xml
├── sampleapp
    ├── index.html
    └── js
    │   └── index.js
├── README.md
└── www
    ├── cordova-plugin-mqtt.js
    └── MQTTEmitter.js


/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | sudo: false
3 | node_js:
4 |   - "4.2"
5 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "cordova-plugin-mqtt",
 3 |   "version": "0.3.8",
 4 |   "description": "Cordova plugin for MQTT (Message Queuing Telemetry Transport) protocol. Supports 3.x protocol. More platforms to be added in coming future.",
 5 |   "cordova": {
 6 |     "id": "cordova-plugin-mqtt",
 7 |     "platforms": [
 8 |       "android"
 9 |     ]
10 |   },
11 |   "repository": {
12 |     "type": "git",
13 |     "url": "https://github.com/arcoirislabs/mqtt-cordova.git"
14 |   },
15 |   "bugs": {
16 |     "url": "https://github.com/arcoirislabs/mqtt-cordova/issues"
17 |   },
18 |   "keywords": [
19 |     "cordova",
20 |     "ecosystem:cordova",
21 |     "mqtt",
22 |     "arcoirislabs"
23 |   ],
24 |   "author": {
25 |     "name": "Arcoiris Labs",
26 |     "email": "amey@arcoirislabs.com"
27 |   },
28 |   "license": "MIT"
29 | }
30 | 


--------------------------------------------------------------------------------
/src/ios/CordovaMQTTPlugin.m:
--------------------------------------------------------------------------------
 1 | /********* CDVCordovaMQTTPlugin.m Cordova Plugin Implementation *******/
 2 | 
 3 | #import <Cordova/CDV.h>
 4 | #import "MQTTAsync.h"
 5 | @interface CDVCordovaMQTTPlugin : CDVPlugin {
 6 |   // Member variables go here.
 7 | }
 8 | 
 9 | - (void)coolMethod:(CDVInvokedUrlCommand*)command;
10 | @end
11 | 
12 | @implementation CDVCordovaMQTTPlugin
13 | 
14 | - (void)coolMethod:(CDVInvokedUrlCommand*)command
15 | {
16 |     CDVPluginResult* pluginResult = nil;
17 |     NSString* echo = [command.arguments objectAtIndex:0];
18 | 
19 |     if (echo != nil && [echo length] > 0) {
20 |         pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:echo];
21 |     } else {
22 |         pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR];
23 |     }
24 | 
25 |     [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
26 | }
27 | 
28 | @end
29 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Arcoiris Labs
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/plugin.xml:
--------------------------------------------------------------------------------
 1 | <?xml version='1.0' encoding='utf-8'?>
 2 | <plugin id="cordova-plugin-mqtt" version="0.3.8" xmlns="http://apache.org/cordova/ns/plugins/1.0" xmlns:android="http://schemas.android.com/apk/res/android">
 3 |     <name>CordovaMqTTPlugin</name>
 4 |     <description>The new MqTT plugin for Cordova</description>
 5 |     <!--
 6 |       Special thanks to @RangerMauve on GitHub to provide us with its own MQTT Emitter library to be integrated with this library. The repo is located at https://github.com/RangerMauve/mqtt-emitter
 7 |       -->
 8 |     <js-module name="MQTTEmitter" src="www/MQTTEmitter.js">
 9 |         <clobbers target="ME" />
10 |     </js-module>
11 |     <asset src="www/mqtt.min.js" target="js/mqtt.min.js" />
12 |     <js-module name="CordovaMqTTPlugin" src="www/cordova-plugin-mqtt.js">
13 |         <clobbers target="cordova.plugins.CordovaMqTTPlugin" />
14 |     </js-module>
15 |     <platform name="android">
16 |         <config-file parent="/*" target="res/xml/config.xml">
17 |             <feature name="CordovaMqTTPlugin">
18 |                 <param name="android-package" value="com.arcoirislabs.plugin.mqtt.CordovaMqTTPlugin" />
19 |             </feature>
20 |         </config-file>
21 |         <config-file parent="/*" target="AndroidManifest.xml"></config-file>
22 |         <framework src="org.eclipse.paho:org.eclipse.paho.client.mqttv3:1.1.0" />
23 |         <source-file src="src/android/CordovaMqTTPlugin.java" target-dir="src/com/arcoirislabs/plugin/mqtt" />
24 |     </platform>
25 |     <platform name="ios">
26 |         <config-file parent="/*" target="config.xml">
27 |             <feature name="CordovaMQTTPlugin"><param name="ios-package" value="CordovaMQTTPlugin" /></feature>
28 |         </config-file>
29 |         <source-file src="src/ios/CordovaMQTTPlugin.m" />
30 |         <header-file src="src/ios/MQTTAsync.h" />
31 | 		<header-file src="src/ios/MQTTClientPersistence.h" />
32 |     </platform>
33 | </plugin>
34 | 


--------------------------------------------------------------------------------
/sampleapp/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <!--
 3 |     
 4 | -->
 5 | <html>
 6 |     <head>
 7 |         
 8 |         <meta http-equiv="Content-Security-Policy" content="default-src 'self' data: gap: https://ssl.gstatic.com 'unsafe-eval'; style-src 'self' 'unsafe-inline'; media-src *">
 9 |         <meta name="format-detection" content="telephone=no">
10 |         <meta name="msapplication-tap-highlight" content="no">
11 |         <meta name="viewport" content="user-scalable=no, initial-scale=1, maximum-scale=1, minimum-scale=1, width=device-width">
12 |         <title>Mqtt Test</title>
13 |     </head>
14 |     <body>
15 |         <div>
16 |             <h4>Connect</h4>
17 |             <p>P.S:- "mqtt://" protocol is not supported by this plugin. Instead use "tcp://" which works with any broker.</p>
18 |             <label for="url">Url:&nbsp;</label><input type="text" id="url" name="url"><br>
19 |             <label for="port">Port:&nbsp;</label><input type="number" id="port" name="port"><br>
20 |             <label for="clientid">Client id</label><input type="text" id="clientId" name="clientid"><br>
21 |             <button id="connect">Connect</button><button id="disconnect" style="display:none">Disconnect</button>
22 |         </div>
23 |         <div>
24 |             <h4>Subscribe</h4>
25 |             <label for="topic_sub">Topic:&nbsp;</label><input type="text" id="topic_sub" name="topic_sub"><br>
26 |             <button id="subscribe">Subscribe</button><button id="unsubscribe" style="display:none">Unsubscribe</button>
27 |         </div>
28 |         <div>
29 |             <h4>Publish</h4>
30 |             <label for="topic_pub">Topic:&nbsp;</label><input type="text" id="topic_pub" name="topic_pub"><br>
31 |             <label for="payload">Payload:&nbsp;</label><input type="text" id="payload" name="payload">
32 |             <button id="publish">Publish</button>
33 |         </div>
34 |         <div>
35 |             <h4>Activity Log</h4>
36 |             <div id="activity"></div>
37 |         </div>    
38 |         <script type="text/javascript" src="cordova.js"></script>
39 |         <script type="text/javascript" src="js/index.js"></script>
40 |     </body>
41 | </html>
42 | 


--------------------------------------------------------------------------------
/sampleapp/js/index.js:
--------------------------------------------------------------------------------
  1 | 
  2 | var connect = false;
  3 | var app = {
  4 |     // Application Constructor
  5 |     initialize: function() {
  6 |         this.bindEvents();
  7 |     },
  8 |     // Bind Event Listeners
  9 |     //
 10 |     // Bind any events that are required on startup. Common events are:
 11 |     // 'load', 'deviceready', 'offline', and 'online'.
 12 |     bindEvents: function() {
 13 |         document.addEventListener('deviceready', this.onDeviceReady, false);
 14 |     },
 15 |     // deviceready Event Handler
 16 |     //
 17 |     // The scope of 'this' is the event. In order to call the 'receivedEvent'
 18 |     // function, we must explicitly call 'app.receivedEvent(...);'
 19 |     onDeviceReady: function() {
 20 |         app.receivedEvent('deviceready');
 21 |     },
 22 |     // Update DOM on a Received Event
 23 |     receivedEvent: function(id) {
 24 |         document.getElementById("connect").addEventListener('touchend',function(ev){
 25 |             cordova.plugins.CordovaMqTTPlugin.connect({
 26 |                 url:document.getElementById("url").value, //a public broker used for testing purposes only. Try using a self hosted broker for production.
 27 |                 port:document.getElementById("port").value,
 28 |                 clientId:document.getElementById("clientId").value,
 29 |                 success:function(s){
 30 |                     connect = true;
 31 |                     console.log(JSON.stringify(s));
 32 |                     document.getElementById("connect").style.display = "none";
 33 |                     document.getElementById("disconnect").style.display = "block";
 34 |                     document.getElementById("activity").innerHTML += "--> Success: you are connected to, "+document.getElementById("url").value+":"+document.getElementById("port").value+"<br>"
 35 |                 },
 36 |                 error:function(e){
 37 |                     connect = false;
 38 |                     document.getElementById("activity").innerHTML += "--> Error: something is wrong,\n "+JSON.stringify(e)+"<br>";
 39 |                     document.getElementById("connect").style.display = "block";
 40 |                     document.getElementById("disconnect").style.display = "none";
 41 |                     alert("err!! something is wrong. check the console")
 42 |                     console.log(e);
 43 |                 },
 44 |                 onConnectionLost:function (){
 45 |                   connect = false;
 46 |                     document.getElementById("activity").innerHTML += "--> You got disconnected";
 47 |                     document.getElementById("connect").style.display = "block";
 48 |                     document.getElementById("disconnect").style.display = "none";
 49 |                 }
 50 |             })
 51 |         });
 52 |         document.getElementById("disconnect").addEventListener('touchend',function(e){
 53 |             document.getElementById("connect").style.display = "block";
 54 |             document.getElementById("disconnect").style.display = "none";
 55 |             cordova.plugins.CordovaMqTTPlugin.disconnect({
 56 |               success:function(s){
 57 |                 connect = false;
 58 |                 document.getElementById("connect").style.display = "block";
 59 |                 document.getElementById("disconnect").style.display = "none";
 60 |                 document.getElementById("activity").innerHTML += "--> Success: you are now disconnected"+"<br>"
 61 |               },
 62 |               error:function(e){
 63 |                 document.getElementById("activity").innerHTML += "--> Error: something is wrong, "+e+"<br>";
 64 |                 document.getElementById("connect").style.display = "none";
 65 |                 document.getElementById("disconnect").style.display = "block";
 66 |                 //alert("err!! something is wrong. check the console")
 67 |                 console.log(e);
 68 |               }
 69 |             });
 70 |         });
 71 |         document.getElementById("subscribe").addEventListener('touchend',function(ev){
 72 |             if (!connect) {
 73 |               alert("First establish connection then try to subscribe");
 74 |             } else {
 75 |               cordova.plugins.CordovaMqTTPlugin.subscribe({
 76 |                 topic:document.getElementById("topic_sub").value,
 77 |                 qos:0,
 78 |                 success:function(s){
 79 |                   document.getElementById("subscribe").style.display = "none";
 80 |                   document.getElementById("unsubscribe").style.display = "block";
 81 |                   document.getElementById("activity").innerHTML += "--> Success: you are subscribed to the topic, "+document.getElementById("topic_sub").value+"<br>"
 82 |                   //get your payload here
 83 |                   //Deprecated method
 84 |                   document.addEventListener(document.getElementById("topic_sub").value,function (e) {
 85 |                       e.preventDefault();
 86 | 
 87 |                       document.getElementById("activity").innerHTML += "--> Payload for"+e.topic+" topic: "+JSON.stringify(e.payload)+"<br>"
 88 |                   });
 89 | 
 90 |                   cordova.plugins.CordovaMqTTPlugin.listen(document.getElementById("topic_sub").value,function (payload,params,topic,topic_pattern) {
 91 |                       //params will be an empty object if topic pattern is NOT used. 
 92 |                       document.getElementById("activity").innerHTML += "--> Payload for"+topic+" topic: "+JSON.stringify(payload)+"<br>"
 93 |                   })
 94 |                 },
 95 |                 error:function(e){
 96 |                   document.getElementById("activity").innerHTML += "--> Error: something is wrong when subscribing to this topic, "+e+"<br>";
 97 |                   document.getElementById("subscribe").style.display = "block";
 98 |                   document.getElementById("unsubscribe").style.display = "none";
 99 |                   //alert("err!! something is wrong. check the console")
100 |                   console.log(e);
101 |                 }
102 |               });
103 |             }
104 |         });
105 |         document.getElementById("unsubscribe").addEventListener('touchend',function(ev){
106 |             cordova.plugins.CordovaMqTTPlugin.unsubscribe({
107 |               topic:document.getElementById("topic_sub").value,
108 |               success:function(s){
109 |                 document.removeEventListener(document.getElementById("topic_sub").value);
110 |                 document.getElementById("unsubscribe").style.display = "none";
111 |                 document.getElementById("subscribe").style.display = "block";
112 |                 document.getElementById("activity").innerHTML += "--> Success: you are unsubscribed to the topic, "+document.getElementById("topic_sub").value+"<br>"
113 |                 document.getElementById("topic_sub").value = "";
114 |               },
115 |               error:function(e){
116 |                 document.getElementById("activity").innerHTML += "--> Error: something is wrong, "+e+"<br>";
117 |                 document.getElementById("subscribe").style.display = "block";
118 |                 document.getElementById("unsubscribe").style.display = "none";
119 |                 //alert("err!! something is wrong. check the console")
120 |                 console.log(e);
121 |               }
122 |             });
123 |         });
124 |         document.getElementById("publish").addEventListener('touchend',function(ev){
125 |           if (!connect) {
126 |             alert("First establish connection then try to publish")
127 |           } else {
128 |             cordova.plugins.CordovaMqTTPlugin.publish({
129 |               topic:document.getElementById("topic_pub").value,
130 |               payload:document.getElementById("payload").value,
131 |               qos:0,
132 |               retain:false,
133 |               success:function(s){
134 |                 document.getElementById("activity").innerHTML += "--> Success: you have published to the topic, "+document.getElementById("topic_sub").value+"<br>";
135 |               },
136 |               error:function(e){
137 |                 document.getElementById("activity").innerHTML += "--> Error: something is wrong, "+e+"<br>";
138 |                 //alert("err!! something is wrong. check the console")
139 |                 console.log(e);
140 |               }
141 |             });
142 |           }
143 |         });
144 |         console.log('Received Event: ' + id);
145 |     },
146 |     append:function (id,s) {
147 |       // it is just a string append function. Nothing to do with the MQTT functions
148 |       var node = document.createElement("p");                 // Create a <li> node
149 |       var textnode = document.createTextNode(s);         // Create a text node
150 |       node.appendChild(textnode);                              // Append the text to <li>
151 |       document.getElementById(id).appendChild(node);     // Append <li> to <ul> with id="myList"
152 |     }
153 | };
154 | 
155 | app.initialize();
156 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # cordova-plugin-mqtt
  2 | 
  3 | [![npm version](https://badge.fury.io/js/cordova-plugin-mqtt.svg)](https://badge.fury.io/js/cordova-plugin-mqtt)
  4 | [![Join the chat at https://gitter.im/arcoirislabs/cordova-plugin-mqtt](https://badges.gitter.im/arcoirislabs/cordova-plugin-mqtt.svg)](https://gitter.im/arcoirislabs/cordova-plugin-mqtt?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  5 | 
  6 | Important Notice
  7 | 
  8 | This project is not abandoned or inactive. On 20th Feb 2019, major updates will be pushed. 
  9 | 
 10 | Updates:
 11 | 
 12 | 1. Native Support for iOS & Windows (UWP only)
 13 | 2. New API
 14 | 3. SSL/TLS support on Android, iOS & Windows
 15 | 4. Better config validation.
 16 | 5. Resolution of bugs
 17 | 
 18 | 
 19 | cordova-plugin-mqtt is plugin for building MQTT client for multiple platforms in Apache Cordova. Currently Android platform is present and next support is planned for iOS & Windows Phone.
 20 | 
 21 | ### Cordova platform support
 22 | 5.x (CLI)
 23 | 4.x (Cordova Android) & above.
 24 | 
 25 | ### Note
 26 | From v0.3.x, the eventListner implementation shall be deprecated. Kindly take a note of this.
 27 | 
 28 | ### Installation
 29 | 
 30 | Install plugins via plugin repository or GitHub
 31 | 
 32 | ```sh
 33 | $ cordova plugin add cordova-plugin-mqtt
 34 | ```
 35 | 
 36 | ```sh
 37 | $ cordova plugin add https://github.com/arcoirislabs/cordova-plugin-mqtt.git
 38 | ```
 39 | 
 40 | ### Changelog
 41 | 
 42 | 1. Adding temporary support to iOS platform until a stable native support arrives. 
 43 | 
 44 | ### Documentation
 45 | 
 46 | [UPDATE]
 47 | 
 48 | We have written a tutorial for this plugin over [here](https://medium.com/@arcoirislabs/using-mqtt-on-apache-cordova-564d4fab526b). Kindly check out before you start developing. Cheers
 49 | ##### Methods
 50 | 1. [connect](#connect)
 51 | 2. [publish](#publish)
 52 | 3. [subscribe](#subscribe)
 53 | 4. [unsubscribe](#unsubscribe)
 54 | 5. [disconnect](#disconnect)
 55 | 6. [router](#router)
 56 | 7. [listen](#listen)
 57 | 
 58 | ##### Events
 59 | Default listeners you can program anywhere for following events
 60 |  - connected
 61 |  - disconnected
 62 |  - failure (connection)
 63 |  - subscribed
 64 |  - not subscribed
 65 |  - published
 66 |  - not published
 67 | 
 68 | For example you can configure the event in this way
 69 | 
 70 |  ```javascript
 71 |  //Deprecated
 72 |  document.addEventListener("connected",function(e){
 73 |   console.log(e.type)
 74 |  },false)
 75 | ```
 76 | 
 77 | 
 78 | ##### connect
 79 | To connect to a broker. This plugin doesn't supports mqtt:// protocol. Use tcp:// instead.
 80 | 
 81 | ```javascript
 82 | cordova.plugins.CordovaMqTTPlugin.connect({
 83 |     url:"tcp://test.mosquitto.org", //a public broker used for testing purposes only. Try using a self hosted broker for production.
 84 |     port:1883,
 85 |     clientId:"YOUR_USER_ID_LESS_THAN_24_CHARS",
 86 |     connectionTimeout:3000,
 87 |     willTopicConfig:{
 88 |         qos:0, //default is 0
 89 |         retain:true, //default is true
 90 |         topic:"<will topic>",
 91 |         payload:"<will topic message>"
 92 |     },
 93 |     username:"uname",
 94 |     password:'pass',
 95 |     keepAlive:60,
 96 |     isBinaryPayload: false, //setting this 'true' will make plugin treat all data as binary and emit ArrayBuffer instead of string on events
 97 |     success:function(s){
 98 |         console.log("connect success");
 99 |     },
100 |     error:function(e){
101 |         console.log("connect error");
102 |     },
103 |     onConnectionLost:function (){
104 |         console.log("disconnect");
105 |     },
106 |     routerConfig:{
107 |         router:routerObject //instantiated router object
108 |         publishMethod:"emit", //refer your custom router documentation to get the emitter/publishing function name. The parameter should be a string and not a function.
109 |         useDefaultRouter:false //Set false to use your own topic router implementation. Set true to use the stock topic router implemented in the plugin.
110 |     }
111 | })
112 | ```
113 | 
114 | ##### publish
115 | To publish to a channel. You can use this function.
116 | 
117 | ```javascript
118 | cordova.plugins.CordovaMqTTPlugin.publish({
119 |    topic:"sampletopic",
120 |    payload:"hello from the plugin",
121 |    qos:0,
122 |    retain:false,
123 |    success:function(s){
124 | 
125 |    },
126 |    error:function(e){
127 | 
128 |    }
129 | })
130 | ```
131 | In order to debug the publish call you can either go for callbacks in the function or events. Once published the function will call the "published" event & the success callback else the function will call both "not published" event & error callback.
132 | 
133 | ##### subscribe
134 | To subscribe to a channel. You can use this function. You can also use wildcard based subscription using following ways
135 | 
136 | ```javascript
137 | //Simple subscribe
138 | cordova.plugins.CordovaMqTTPlugin.subscribe({
139 |    topic:"sampletopic",
140 |    qos:0,
141 |   success:function(s){
142 | 
143 |   },
144 |   error:function(e){
145 | 
146 |   }
147 | });
148 | 
149 | //Single level wildcard subscribe
150 | cordova.plugins.CordovaMqTTPlugin.subscribe({
151 |    topic:"/+/sampletopic",
152 |    qos:0,
153 |   success:function(s){
154 | 
155 |   },
156 |   error:function(e){
157 | 
158 |   }
159 | });
160 | 
161 | //multi level wildcard subscribe
162 | cordova.plugins.CordovaMqTTPlugin.subscribe({
163 |    topic:"/sampletopic/#",
164 |    qos:0,
165 |   success:function(s){
166 | 
167 |   },
168 |   error:function(e){
169 | 
170 |   }
171 | });
172 | 
173 | //Using both kinds of wildcards
174 | 
175 | cordova.plugins.CordovaMqTTPlugin.subscribe({
176 |    topic:"/+/sampletopic/#",
177 |    qos:0,
178 |   success:function(s){
179 | 
180 |   },
181 |   error:function(e){
182 | 
183 |   }
184 | })
185 | ```
186 | The success callback can notify you once you are successfully subscribed, so it will be called only once. The onPublish method is deprecated.
187 | If you want to read the payload, you can listen to the event by the name of the topic. For example if you have subscribed to the topic called "sampletopic". You can read the payload in this way.
188 | 
189 | #####Update:-
190 | We are introducing topic pattern support to listen to certain topics in a way the developer wishes to. This topic pattern helps developer to make a common listener to different topics sharing same levels using single and multi-level wildcards.
191 | 
192 | ```javascript
193 |  //Deprecated
194 |  document.addEventListener("sampletopic",function(e){
195 |   console.log(e.payload)
196 |  },false);
197 | 
198 |  //New way to listen to topics
199 |  cordova.plugins.CordovaMqTTPlugin.listen("/topic/+singlewc/#multiwc",function(payload,params){
200 |   //Callback:- (If the user has published to /topic/room/hall)
201 |   //payload : contains payload data
202 |   //params : {singlewc:room,multiwc:hall}
203 | })
204 | ```
205 | 
206 | ##### unsubscribe
207 | 
208 | To unsubscribe to a channel. You can use this function.
209 | 
210 | ```javascript
211 | cordova.plugins.CordovaMqTTPlugin.unsubscribe({
212 |    topic:"sampletopic",
213 |   success:function(s){
214 | 
215 |   },
216 |   error:function(e){
217 | 
218 |   }
219 | })
220 | ```
221 | This function will also fire the unsubscribe event which yiu can listen to using the document.addEventListener function. Also the event listener for the topic is removed automatically once the client successfully unsubscibes.
222 | 
223 | 
224 | ##### disconnect
225 | 
226 | To disconnect yourself from a server, use following function
227 | ```javascript
228 | cordova.plugins.CordovaMqTTPlugin.disconnect({
229 |   success:function(s){
230 | 
231 |   },
232 |   error:function(e){
233 | 
234 |   }
235 | })
236 | ```
237 | 
238 | ##### router
239 | 
240 | This function provides you the access to all the topic router functions you have used. If you have used a the stock topic router you can access the payload for a topic by this method.
241 | ```javascript
242 | //Declare this function in any scope to access the router function "on" to receive the payload for certain topic
243 | cordova.plugins.CordovaMqTTPlugin.router.on("/topic/+singlewc/#multiwc",function(payload,params){
244 |   //Callback:- (If the user has published to /topic/room/hall)
245 |   //payload : contains payload data
246 |   //params : {singlewc:room,multiwc:hall}
247 | });
248 | 
249 | //To get a callback on topic subscribe/unsubscribe event, you can listen by this method
250 | cordova.plugins.CordovaMqTTPlugin.router.onadd(function(topic){
251 | 
252 | });
253 | cordova.plugins.CordovaMqTTPlugin.router.onremove(function(topic){
254 | 
255 | });
256 | ```
257 | 
258 | ##### listen
259 | 
260 | This function lets you listen to certain topic pattern specifically constructed by topic patters as shown below.
261 | ```javascript
262 | //Declare this function in any scope to access the router function "on" to receive the payload for certain topic
263 | cordova.plugins.CordovaMqTTPlugin.listen("/topic/+singlewc/#multiwc",function(payload,params){
264 |   //Callback:- (If the user has published to /topic/room/hall)
265 |   //payload : contains payload data
266 |   //params : {singlewc:room,multiwc:hall}
267 | });
268 | 
269 | 
270 | ```
271 | 
272 | ### Todos
273 | 
274 |  - Add a stable iOS support in v0.3.0
275 |  - Plan support for new platform (Windows Phone)
276 |  - Add background service support in Android version to save the payload related from certain topics in a DB when the app is in background.
277 | 
278 | 
279 | License
280 | ----
281 | 
282 | MIT
283 | 


--------------------------------------------------------------------------------
/src/ios/MQTTClientPersistence.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 |  * Copyright (c) 2009, 2012 IBM Corp.
  3 |  *
  4 |  * All rights reserved. This program and the accompanying materials
  5 |  * are made available under the terms of the Eclipse Public License v1.0
  6 |  * and Eclipse Distribution License v1.0 which accompany this distribution. 
  7 |  *
  8 |  * The Eclipse Public License is available at 
  9 |  *    http://www.eclipse.org/legal/epl-v10.html
 10 |  * and the Eclipse Distribution License is available at 
 11 |  *   http://www.eclipse.org/org/documents/edl-v10.php.
 12 |  *
 13 |  * Contributors:
 14 |  *    Ian Craggs - initial API and implementation and/or initial documentation
 15 |  *******************************************************************************/
 16 | 
 17 | /**
 18 |  * @file
 19 |  * \brief This structure represents a persistent data store, used to store 
 20 |  * outbound and inbound messages, in order to achieve reliable messaging.
 21 |  *
 22 |  * The MQTT Client persists QoS1 and QoS2 messages in order to meet the
 23 |  * assurances of delivery associated with these @ref qos levels. The messages 
 24 |  * are saved in persistent storage
 25 |  * The type and context of the persistence implementation are specified when 
 26 |  * the MQTT client is created (see MQTTClient_create()). The default 
 27 |  * persistence type (::MQTTCLIENT_PERSISTENCE_DEFAULT) uses a file system-based
 28 |  * persistence mechanism. The <i>persistence_context</i> argument passed to 
 29 |  * MQTTClient_create() when using the default peristence is a string 
 30 |  * representing the location of the persistence directory. If the context 
 31 |  * argument is NULL, the working directory will be used. 
 32 |  *
 33 |  * To use memory-based persistence, an application passes 
 34 |  * ::MQTTCLIENT_PERSISTENCE_NONE as the <i>persistence_type</i> to 
 35 |  * MQTTClient_create(). This can lead to message loss in certain situations, 
 36 |  * but can be appropriate in some cases (see @ref qos).
 37 |  *
 38 |  * Client applications can provide their own persistence mechanism by passing
 39 |  * ::MQTTCLIENT_PERSISTENCE_USER as the <i>persistence_type</i>. To implement a
 40 |  * custom persistence mechanism, the application must pass an initialized
 41 |  * ::MQTTClient_persistence structure as the <i>persistence_context</i> 
 42 |  * argument to MQTTClient_create().
 43 |  *
 44 |  * If the functions defined return an ::MQTTCLIENT_PERSISTENCE_ERROR then the 
 45 |  * state of the persisted data should remain as it was prior to the function 
 46 |  * being called. For example, if Persistence_put() returns 
 47 |  * ::MQTTCLIENT_PERSISTENCE_ERROR, then it is assumed tha tthe persistent store
 48 |  * does not contain the data that was passed to the function. Similarly,  if 
 49 |  * Persistence_remove() returns ::MQTTCLIENT_PERSISTENCE_ERROR then it is 
 50 |  * assumed that the data to be removed is still held in the persistent store.
 51 |  *
 52 |  * It is up to the persistence implementation to log any error information that
 53 |  * may be required to diagnose a persistence mechanism failure.
 54 |  */
 55 | 
 56 | /// @cond EXCLUDE
 57 | #if !defined(MQTTCLIENTPERSISTENCE_H)
 58 | #define MQTTCLIENTPERSISTENCE_H
 59 | /// @endcond
 60 | 
 61 | /**
 62 |   * This <i>persistence_type</i> value specifies the default file system-based 
 63 |   * persistence mechanism (see MQTTClient_create()).
 64 |   */
 65 | #define MQTTCLIENT_PERSISTENCE_DEFAULT 0
 66 | /**
 67 |   * This <i>persistence_type</i> value specifies a memory-based 
 68 |   * persistence mechanism (see MQTTClient_create()).
 69 |   */
 70 | #define MQTTCLIENT_PERSISTENCE_NONE 1
 71 | /**
 72 |   * This <i>persistence_type</i> value specifies an application-specific 
 73 |   * persistence mechanism (see MQTTClient_create()).
 74 |   */
 75 | #define MQTTCLIENT_PERSISTENCE_USER 2
 76 | 
 77 | /** 
 78 |   * Application-specific persistence functions must return this error code if 
 79 |   * there is a problem executing the function. 
 80 |   */
 81 | #define MQTTCLIENT_PERSISTENCE_ERROR -2
 82 | 
 83 | /**
 84 |   * @brief Initialize the persistent store.
 85 |   * 
 86 |   * Either open the existing persistent store for this client ID or create a new
 87 |   * one if one doesn't exist. If the persistent store is already open, return 
 88 |   * without taking any action.
 89 |   *
 90 |   * An application can use the same client identifier to connect to many
 91 |   * different servers. The <i>clientid</i> in conjunction with the 
 92 |   * <i>serverURI</i> uniquely identifies the persistence store required.
 93 |   *
 94 |   * @param handle The address of a pointer to a handle for this persistence 
 95 |   * implementation. This function must set handle to a valid reference to the 
 96 |   * persistence following a successful return. 
 97 |   * The handle pointer is passed as an argument to all the other
 98 |   * persistence functions. It may include the context parameter and/or any other
 99 |   * data for use by the persistence functions.
100 |   * @param clientID The client identifier for which the persistent store should 
101 |   * be opened.
102 |   * @param serverURI The connection string specified when the MQTT client was
103 |   * created (see MQTTClient_create()).
104 |   * @param context A pointer to any data required to initialize the persistent
105 |   * store (see ::MQTTClient_persistence).
106 |   * @return Return 0 if the function completes successfully, otherwise return
107 |   * ::MQTTCLIENT_PERSISTENCE_ERROR.
108 |   */
109 | typedef int (*Persistence_open)(void** handle, const char* clientID, const char* serverURI, void* context);
110 | 
111 | /**
112 |   * @brief Close the persistent store referred to by the handle.
113 |   *
114 |   * @param handle The handle pointer from a successful call to 
115 |   * Persistence_open().
116 |   * @return Return 0 if the function completes successfully, otherwise return
117 |   * ::MQTTCLIENT_PERSISTENCE_ERROR.
118 |   */
119 | typedef int (*Persistence_close)(void* handle); 
120 | 
121 | /**
122 |   * @brief Put the specified data into the persistent store.
123 |   *
124 |   * @param handle The handle pointer from a successful call to 
125 |   * Persistence_open().
126 |   * @param key A string used as the key for the data to be put in the store. The
127 |   * key is later used to retrieve data from the store with Persistence_get().
128 |   * @param bufcount The number of buffers to write to the persistence store.
129 |   * @param buffers An array of pointers to the data buffers associated with 
130 |   * this <i>key</i>.
131 |   * @param buflens An array of lengths of the data buffers. <i>buflen[n]</i> 
132 |   * gives the length of <i>buffer[n]</i>.
133 |   * @return Return 0 if the function completes successfully, otherwise return
134 |   * ::MQTTCLIENT_PERSISTENCE_ERROR.
135 |   */
136 | typedef int (*Persistence_put)(void* handle, char* key, int bufcount, char* buffers[], int buflens[]);
137 | 
138 | /**
139 |   * @brief Retrieve the specified data from the persistent store. 
140 |   *
141 |   * @param handle The handle pointer from a successful call to 
142 |   * Persistence_open().
143 |   * @param key A string that is the key for the data to be retrieved. This is 
144 |   * the same key used to save the data to the store with Persistence_put().
145 |   * @param buffer The address of a pointer to a buffer. This function sets the
146 |   * pointer to point at the retrieved data, if successful.
147 |   * @param buflen The address of an int that is set to the length of 
148 |   * <i>buffer</i> by this function if successful.
149 |   * @return Return 0 if the function completes successfully, otherwise return
150 |   * ::MQTTCLIENT_PERSISTENCE_ERROR.
151 |   */
152 | typedef int (*Persistence_get)(void* handle, char* key, char** buffer, int* buflen);
153 | 
154 | /**
155 |   * @brief Remove the data for the specified key from the store.
156 |   *
157 |   * @param handle The handle pointer from a successful call to 
158 |   * Persistence_open().
159 |   * @param key A string that is the key for the data to be removed from the
160 |   * store. This is the same key used to save the data to the store with 
161 |   * Persistence_put().
162 |   * @return Return 0 if the function completes successfully, otherwise return
163 |   * ::MQTTCLIENT_PERSISTENCE_ERROR.
164 |   */
165 | typedef int (*Persistence_remove)(void* handle, char* key);
166 | 
167 | /**
168 |   * @brief Returns the keys in this persistent data store.
169 |   *
170 |   * @param handle The handle pointer from a successful call to 
171 |   * Persistence_open().
172 |   * @param keys The address of a pointer to pointers to strings. Assuming
173 |   * successful execution, this function allocates memory to hold the returned
174 |   * keys (strings used to store the data with Persistence_put()). It also 
175 |   * allocates memory to hold an array of pointers to these strings. <i>keys</i>
176 |   * is set to point to the array of pointers to strings.
177 |   * @param nkeys A pointer to the number of keys in this persistent data store. 
178 |   * This function sets the number of keys, if successful.
179 |   * @return Return 0 if the function completes successfully, otherwise return
180 |   * ::MQTTCLIENT_PERSISTENCE_ERROR.
181 |   */
182 | typedef int (*Persistence_keys)(void* handle, char*** keys, int* nkeys);
183 | 
184 | /**
185 |   * @brief Clears the persistence store, so that it no longer contains any 
186 |   * persisted data.
187 |   *
188 |   * @param handle The handle pointer from a successful call to 
189 |   * Persistence_open().
190 |   * @return Return 0 if the function completes successfully, otherwise return
191 |   * ::MQTTCLIENT_PERSISTENCE_ERROR.
192 |   */
193 | typedef int (*Persistence_clear)(void* handle);
194 | 
195 | /**
196 |   * @brief Returns whether any data has been persisted using the specified key.
197 |   *
198 |   * @param handle The handle pointer from a successful call to 
199 |   * Persistence_open().
200 |   * @param key The string to be tested for existence in the store.
201 |   * @return Return 0 if the key was found in the store, otherwise return
202 |   * ::MQTTCLIENT_PERSISTENCE_ERROR.
203 |   */
204 | typedef int (*Persistence_containskey)(void* handle, char* key);
205 | 
206 | /**
207 |   * @brief A structure containing the function pointers to a persistence 
208 |   * implementation and the context or state that will be shared across all 
209 |   * the persistence functions.
210 |   */
211 | typedef struct {
212 |   /** 
213 |     * A pointer to any data required to initialize the persistent store.
214 |     */
215 | 	void* context;
216 |   /** 
217 |     * A function pointer to an implementation of Persistence_open().
218 |     */
219 | 	Persistence_open popen;
220 |   /** 
221 |     * A function pointer to an implementation of Persistence_close().
222 |     */
223 | 	Persistence_close pclose;
224 |   /**
225 |     * A function pointer to an implementation of Persistence_put().
226 |     */
227 | 	Persistence_put pput;
228 |   /** 
229 |     * A function pointer to an implementation of Persistence_get().
230 |     */
231 | 	Persistence_get pget;
232 |   /** 
233 |     * A function pointer to an implementation of Persistence_remove().
234 |     */
235 | 	Persistence_remove premove;
236 |   /** 
237 |     * A function pointer to an implementation of Persistence_keys().
238 |     */
239 | 	Persistence_keys pkeys;
240 |   /** 
241 |     * A function pointer to an implementation of Persistence_clear().
242 |     */
243 | 	Persistence_clear pclear;
244 |   /** 
245 |     * A function pointer to an implementation of Persistence_containskey().
246 |     */
247 | 	Persistence_containskey pcontainskey;
248 | } MQTTClient_persistence;
249 | 
250 | #endif
251 | 


--------------------------------------------------------------------------------
/www/cordova-plugin-mqtt.js:
--------------------------------------------------------------------------------
  1 | /*
  2 | Adding new router config.
  3 | routerConfig:{
  4 |     router:type Object
  5 |     publishMethod:type String,
  6 |     useDefaultRouter:type Boolean
  7 | }*/
  8 | var exec = require('cordova/exec'), cordova = require('cordova'),
  9 | base64 = require('cordova/base64'),
 10 | channel = require('cordova/channel'),
 11 |     utils = require('cordova/utils');
 12 |     var url,uname,pass,iscls,router,mqtt,isBinaryPayload = null;
 13 |     var isDefault,useJS = true;
 14 |     exports.connect = function(args){
 15 |         //SSL support is coming soon
 16 |         //var urgx = //(^(tcp|ssl|local)&?:\/\/[^\@_?!]+[^\s]+[^\.]+\:\d{2,})/g;
 17 |         var urgx = /(^(tcp|local)&?:\/\/[^\@_?!]+[^\s]+[^\.]+\:\d{2,})/g;
 18 |         if (args.port!==undefined) {
 19 |             url = args.url+":"+args.port;
 20 |         } else{
 21 |             url = args.url;
 22 |         }
 23 |         if (args.willTopicConfig!==undefined) {
 24 |             if(args.willTopicConfig.retain===undefined){
 25 |                 args.willTopicConfig.retain = true;
 26 |             }
 27 |         } else {
 28 |             args.willTopicConfig = {};
 29 |         }
 30 |         if (args.isCleanSession===undefined) {
 31 |             iscls = true;
 32 |         } else {
 33 |             iscls = args.isCleanSession;
 34 |         }
 35 |         if (args.isBinaryPayload===undefined) {
 36 |             isBinaryPayload = false;
 37 |         } else {
 38 |             isBinaryPayload = args.isBinaryPayload;
 39 |         }
 40 |         if (args.routerConfig!==undefined) {
 41 |             if(Object.keys(args.routerConfig).length>0){
 42 |                 if (!args.routerConfig.useDefaultRouter&&args.routerConfig.useDefaultRouter!==undefined) {
 43 |                     if(args.routerConfig.router!==undefined){
 44 |                         router = args.routerConfig.router;
 45 |                         isDefault = useDefaultRouter;
 46 |                     } else{
 47 |                         console.error("Please set your topic router object");
 48 |                     }
 49 |                 } else {
 50 |                     //using default topic router
 51 |                     router = new ME();
 52 |                 }
 53 | 
 54 |             }else{
 55 |                 //setting mqtt-emitter instance as default router
 56 |                 router = new ME();
 57 |             }
 58 |         } else {
 59 |             router = new ME();
 60 |         }
 61 |         if(url.length>0&&urgx.exec(url)!==null){
 62 |             if (cordova.platformId === "android") {
 63 |                 exec(function(cd){
 64 |                     //console.log("data",cd);
 65 |                     switch(cd.call){
 66 |                         case "connected":
 67 |                             delete cd.call;
 68 |                             if(args.success!==undefined){
 69 |                                 args.success(cd);
 70 |                             }
 71 |                             //cordova.fireDocumentEvent("connected",cd);
 72 |                             console.warn("Cordova Plugin Warning: The eventListner implmentation to read the published payloads shall be discontinued from the 0.3.0 version. Kindly take a note of this change.");
 73 |                             break;
 74 |                         case "disconnected":
 75 |                             delete cd.call;
 76 |                             if(args.error!==undefined){
 77 |                                 args.error(cd);
 78 |                             }
 79 |                             //cordova.fireDocumentEvent("disconnected",cd);
 80 |                             break;
 81 |                         case "failure":
 82 |                             delete cd.call;
 83 |                             if(args.onConnectionLost!==undefined){
 84 |                                 args.onConnectionLost(cd);
 85 |                             }
 86 |                             //cordova.fireDocumentEvent("failure",cd);
 87 |                             break;
 88 |                         case "onPublish":
 89 |                             delete cd.call;
 90 |                             var payload = isBinaryPayload ? base64.toArrayBuffer(cd.payload) : cd.payload;
 91 |                             if(args.onPublish!==undefined){
 92 |                                 args.onPublish(cd.topic,payload);
 93 |                             }
 94 |                             if(router!==null){
 95 |                                 if (args.routerConfig!==undefined) {
 96 |                                     if (args.routerConfig.publishMethod!==undefined) {
 97 |                                         router[args.routerConfig.publishMethod](cd.topic,payload);
 98 |                                     }
 99 | 
100 |                                 } else {
101 |                                     router.emit(cd.topic,payload);
102 |                                 }
103 | 
104 |                             }
105 |                             //cordova.fireDocumentEvent(cd.topic,cd);
106 |                             break;
107 |                         default:
108 |                             console.log(cd);
109 |                             break;
110 |                     }
111 |                 }, function(e){
112 |                     console.error(e);
113 |                 }, "CordovaMqTTPlugin", "connect", [url,args.clientId,(args.keepAlive === undefined ? 60000 : args.keepAlive),iscls,args.connectionTimeout||30,args.username, args.password,args.willTopicConfig.topic,args.willTopicConfig.payload,args.willTopicConfig.qos||0,(args.willTopicConfig.retain === undefined ? true : args.willTopicConfig.retain),args.version||"3.1.1",isBinaryPayload,args.willTopicConfig.payload instanceof ArrayBuffer]);
114 |             } else {
115 | 
116 |                 if (args.url.split("tcp://").length > 1) {
117 |                     client = new Paho.MQTT.Client(args.url.split("tcp://")[1], Number(args.wsPort ? args.wsPort : args.port), args.urlPath||"/ws", args.clientId);
118 |                 }
119 |                 // if (args.url.split("local://").length > 1) {
120 |                 //     client = new Paho.MQTT.Client(args.url.split("local://")[1], Number(args.wsPort), args.urlPath||"/ws", args.clientId);
121 |                 // }
122 |                 client.onConnectionLost = function (cd) {
123 |                     client = null;
124 |                     if(args.error!==undefined){
125 |                         args.error(cd);
126 |                     }
127 |                 };
128 |                 client.onMessageArrived = function (payload) {
129 |                     var preparedPayload = isBinaryPayload ? payload.payloadBytes : payload.payloadString;
130 |                     if(args.onPublish!==undefined){
131 |                         args.onPublish(payload.destinationName,preparedPayload);
132 |                     }
133 |                     if(router!==null){
134 |                         if (args.routerConfig!==undefined) {
135 |                             if (args.routerConfig.publishMethod!==undefined) {
136 |                                 router[args.routerConfig.publishMethod](payload.destinationName,preparedPayload);
137 |                             }
138 | 
139 |                         } else {
140 |                             router.emit(payload.destinationName,preparedPayload);
141 |                         }
142 | 
143 |                     }
144 |                 };
145 |                 var connOpts = {};
146 |                 connOpts.userName = args.username||"";
147 |                 connOpts.password = args.password||"";
148 |                 connOpts.onSuccess = function (cd) {
149 |                     if(args.success!==undefined){
150 |                         args.success(cd);
151 |                     }
152 |                 };
153 |                 connOpts.onFailure = function (cd) {
154 |                     client = null;
155 |                     if(args.error!==undefined){
156 |                         args.error(cd);
157 |                     }
158 |                 };
159 |                 connOpts.timeout = args.connectionTimeout||30;
160 |                 connOpts.keepAliveInterval = (args.keepAlive === undefined) ? 60000 : args.keepAlive;
161 |                 connOpts.cleanSession = iscls;
162 |                 //connOpts.mqttVersion = args.version||"3.1.1";
163 |                 //console.log("will",args.willTopicConfig);
164 |                 if (args.willTopicConfig.topic !== undefined) {
165 |                     var willMsg = new Paho.MQTT.Message(args.willTopicConfig.payload);
166 |                     willMsg.destinationName = args.willTopicConfig.topic;
167 |                     willMsg.qos = args.willTopicConfig.qos||0;
168 |                     willMsg.retained = (args.willTopicConfig.retain === undefined) ? true : args.willTopicConfig.retain;
169 |                     connOpts.willMessage = willMsg;
170 |                 }
171 |                 client.connect(connOpts);
172 |             }
173 | 
174 |         } else{
175 |             console.error("Please provide the URL to connect. If entered then please check the URL format. We support only tcp:// & local:// protocols");
176 |         }
177 | 
178 |     };
179 |     exports.publish = function(args){
180 |         (args.retain===undefined) ? (args.retain=false) : "";
181 |         if(args.topic.length>0){
182 |             if (cordova.platformId === "android") {
183 |                 exec(function(data){
184 |                     //console.log("data",data);
185 |                     //cordova.fireDocumentEvent(data);
186 |                     switch(data.call){
187 |                         case "success":
188 |                             delete data.call;
189 |                             if(args.success !== undefined){
190 |                                 args.success(data);
191 |                             }
192 | 
193 |                             break;
194 |                         case "failure":
195 |                             delete data.call;
196 |                             if(args.success !== undefined){
197 |                                 args.error(data);
198 |                             }
199 |                             break;
200 |                     }
201 |                 }, function(e){
202 |                     if(args.error !== undefined){
203 |                         args.error(e);
204 |                     }
205 |                 }, "CordovaMqTTPlugin", "publish", [args.topic,args.payload,args.qos||0,args.retain,args.payload instanceof ArrayBuffer]);
206 |             } else {
207 |                 var message = new Paho.MQTT.Message(args.payload);
208 |                 message.destinationName = args.topic;
209 |                 message.qos = args.qos;
210 |                 message.retained = args.retain;
211 |                 if (client !== null) {
212 |                     client.send(message);
213 |                 }
214 |             }
215 | 
216 |         } else{
217 |             console.error("Please provide a topic string in topic argument");
218 |         }
219 |     };
220 |     exports.subscribe = function(args){
221 |         (args.retain===undefined) ? args.retain=false : args.retain=true;
222 |         if(args.topic.length>0){
223 |             if (cordova.platformId === "android") {
224 |                 exec(function(data){
225 |                     //console.log("data",data);
226 |                     switch(data.call){
227 |                         case "success":
228 |                             delete data.call;
229 |                             if (args.success!==undefined) {
230 |                                 args.success(data);
231 |                             }
232 |                             break;
233 |                         case "failure":
234 |                             delete data.call;
235 |                             if (args.error!==undefined) {
236 |                                 args.error(data);
237 |                             }
238 | 
239 |                             break;
240 |                     }
241 |                 }, function(e){
242 |                     console.error(e);
243 |                     args.error(e);
244 |                 }, "CordovaMqTTPlugin", "subscribe", [args.topic,args.qos||0]);
245 |             } else {
246 |                 if (client !== null) {
247 |                     client.subscribe(args.topic,{
248 |                         qos:args.qos||0,
249 |                         onSuccess:function(cd,data){
250 |                             if (args.success!==undefined) {
251 |                                 args.success(data);
252 |                             }
253 |                         },
254 |                         onFailure:function (cd,data) {
255 |                             if (args.error!==undefined) {
256 |                                 args.error(data);
257 |                             }
258 |                         }
259 |                     });
260 |                 }
261 |             }
262 | 
263 |         } else{
264 |             console.error("Please provide a topic string in topic argument");
265 |         }
266 | 
267 |     };
268 |     exports.unsubscribe = function(args){
269 |         if(args.topic.length > 0){
270 |             if (cordova.platformId === "android") {
271 |                 exec(function(data){
272 |                     console.log("data",data);
273 |                     switch(data.call){
274 |                         case "success":
275 |                             delete data.call;
276 |                             if (args.success!==undefined) {
277 |                                 args.success(data);
278 |                             }
279 |                             if (router!==null) {
280 |                                 router.removeListener(args.topic);
281 |                             }
282 |                             break;
283 |                         case "failure":
284 |                             delete data.call;
285 |                             if (args.error!==undefined) {
286 |                                 args.error(data);
287 |                             }
288 |                             break;
289 |                     }
290 |                 }, function(e){
291 |                     console.error(e);
292 |                     args.error(e);
293 |                 }, "CordovaMqTTPlugin", "unsubscribe", [args.topic]);
294 |             } else {
295 |                 if (client !== null) {
296 |                     client.unsubscribe(args.topic,{
297 |                         timeout:args.timeout||5000,
298 |                         onSuccess:function(cd,data){
299 |                             if (args.success!==undefined) {
300 |                                 args.success(data);
301 |                             }
302 |                         },
303 |                         onFailure:function (cd,data) {
304 |                             if (args.error!==undefined) {
305 |                                 args.error(data);
306 |                             }
307 |                         }
308 |                     });
309 |                 }
310 |             }
311 | 
312 |         } else{
313 |             console.error("Please provide a topic string in topic argument");
314 |         }
315 |     };
316 |     exports.disconnect = function(args){
317 |         if (cordova.platformId === "android") {
318 |             exec(function(data){
319 |                 console.log("data",data);
320 |                 switch(data.call){
321 |                     case "success":
322 |                         delete data.call;
323 |                         if (args.success!==undefined) {
324 |                             args.success(data);
325 |                         }
326 |                         break;
327 |                     case "failure":
328 |                         delete data.call;
329 |                         if (args.error!==undefined) {
330 |                             args.error(data);
331 |                         }
332 |                         break;
333 |                 }
334 |             }, function(e){
335 |                 console.error(e);
336 |                 args.error(e);
337 |             }, "CordovaMqTTPlugin", "disconnect", []);
338 |         } else {
339 |             if (client !== null) {
340 |                 client.disconnect();
341 |             }
342 |         }
343 |     };
344 |     exports.router = function() {
345 |         if (router!==null) {
346 |             return router;
347 |         } else {
348 |             console.error("Router object seems to be destroyed");
349 |         }
350 |     };
351 |     exports.listen = function (topic,cb) {
352 |         if (router!==null) {
353 |             router.on(topic,cb);
354 |         } else {
355 |             console.error("Router object seems to be destroyed");
356 |         }
357 |     };
358 | 


--------------------------------------------------------------------------------
/www/MQTTEmitter.js:
--------------------------------------------------------------------------------
  1 | !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.MQTTEmitter=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
  2 | "use strict";
  3 | /*
  4 |  mqtt-emitter by RangerMauve. Version 0.0.2
  5 | */
  6 | 
  7 | var mqtt_regex = require("mqtt-regex");
  8 | var MQTTStore = require("mqtt-store");
  9 | 
 10 | module.exports = MQTTEmitter;
 11 | 
 12 | /**
 13 |  * Creates a new MQTTEmitter instance
 14 |  */
 15 | function MQTTEmitter() {
 16 | 	this._listeners = new MQTTStore();
 17 | 	this._regexes = [];
 18 | }
 19 | 
 20 | // Inherit the PatternEmitter methods and stuff
 21 | MQTTEmitter.prototype = Object.create({
 22 | 	addListener: addListener,
 23 | 	on: addListener,
 24 | 	once: once,
 25 | 	removeListener: removeListener,
 26 | 	removeAllListeners: removeAllListeners,
 27 | 	listeners: listeners,
 28 | 	emit: emit,
 29 | 	onadd: onadd,
 30 | 	onremove: onremove,
 31 | });
 32 | 
 33 | /**
 34 |  * Listen for MQTT messages that match a given pattern.
 35 |  * @see {@link https://github.com/RangerMauve/mqtt-regex|mqtt-regex}
 36 |  * @param  {String}      topic   MQTT topic pattern with optional placeholders
 37 |  * @param  {Function}    handler Callback which takes the MQTT payload and topic params
 38 |  * @return {MQTTEmitter}         Returns self for use in chaining
 39 |  */
 40 | function addListener(topic, handler) {
 41 | 	var matcher = mqtt_regex(topic);
 42 | 	var topic_string = matcher.topic;
 43 | 
 44 | 	var listeners = this._listeners.get(topic_string);
 45 | 	if (!listeners) {
 46 | 		listeners = this._listeners.set(topic_string, []);
 47 | 	}
 48 | 
 49 | 	var is_new = (listeners.length === 0);
 50 | 
 51 | 	listeners.push({
 52 | 		fn: handler,
 53 | 		params: matcher.exec,
 54 | 		pattern: topic
 55 | 	});
 56 | 
 57 | 	if (is_new) this.onadd(topic_string);
 58 | 
 59 | 	return this;
 60 | }
 61 | 
 62 | /**
 63 |  * Adds a one time listener for the event
 64 |  * @param  {String}      topic   Topic pattern to listen on
 65 |  * @param  {Function}    handler Function to call the next time this topic appears
 66 |  * @return {MQTTEmitter}         Returns self for use in chaining
 67 |  */
 68 | function once(topic, handler) {
 69 | 	var self = this;
 70 | 	once_handler.handler = handler;
 71 | 	this.on(topic, once_handler);
 72 | 
 73 | 	return this;
 74 | 
 75 | 	function once_handler(data, params) {
 76 | 		handler.call(self, data, params);
 77 | 		self.removeListener(topic, once_handler);
 78 | 	}
 79 | }
 80 | 
 81 | /**
 82 |  * Removes an existing listener
 83 |  * @param  {String}      topic   Topic pattern to unsubscribe from
 84 |  * @param  {Function}    handler Handler that was used originally
 85 |  * @return {MQTTEmitter}         Returns self for use in chaining
 86 |  */
 87 | function removeListener(topic, handler) {
 88 | 	var matcher = mqtt_regex(topic);
 89 | 	var topic_string = matcher.topic;
 90 | 	var listeners = this._listeners.get(topic_string);
 91 | 
 92 | 	if (!listeners || !listeners.length) return this;
 93 | 
 94 | 	var has_filtered = false;
 95 | 	var filtered_listeners = listeners.filter(function (listener) {
 96 | 		if (has_filtered) return true;
 97 | 
 98 | 		var matches = (listener.fn === handler);
 99 | 		if (!matches) return true;
100 | 
101 | 		has_filtered = true;
102 | 		return false;
103 | 	});
104 | 
105 | 	if (!filtered_listeners.length) this.onremove(topic_string);
106 | 
107 | 	if (has_filtered)
108 | 		this._listeners.set(topic_string, filtered_listeners);
109 | 
110 | 	return this;
111 | }
112 | 
113 | /**
114 |  * Removes all listeners for this type of topic.
115 |  * @param  {String}      topic Topic pattern to unsubscribe from
116 |  * @return {MQTTEmitter}       Returns self for use in chaining
117 |  */
118 | function removeAllListeners(topic) {
119 | 	if (topic) {
120 | 		var matcher = mqtt_regex(topic);
121 | 		var topic_string = matcher.topic;
122 | 		var listeners = this._listeners.get(topic_string);
123 | 
124 | 		if (!listeners.length) return this;
125 | 
126 | 		this._listeners.set(topic_string, []);
127 | 		this.onremove(topic_string);
128 | 
129 | 	} else {
130 | 		this._listeners = new MQTTStore();
131 | 	}
132 | 
133 | 	return this;
134 | }
135 | 
136 | /**
137 |  * Returns an array of listeners that match this topic
138 |  * @param  {String} topic The topic pattern to get listeners for
139 |  * @return {Array}        Array of handler functions
140 |  */
141 | function listeners(topic) {
142 | 	var matcher = mqtt_regex(topic);
143 | 	var topic_string = matcher.topic;
144 | 
145 | 	return (this._listeners.get(topic_string) || []).map(function (listener) {
146 | 		return listener.fn;
147 | 	});
148 | }
149 | 
150 | /**
151 |  * Process a new MQTT event and dispatch it to relevant listeners
152 |  * @param  {String}  topic   The raw MQTT topic string recieved from a connection
153 |  * @param  {Any}     payload This is the payload from the MQTT topic event
154 |  * @return {Boolean}         Returns true if there were any listeners called for this topic
155 |  */
156 | function emit(topic, payload) {
157 | 	var matcher = mqtt_regex(topic);
158 | 	var topic_string = matcher.topic;
159 | 	var matching = this._listeners.match(topic_string);
160 | 	if (!matching.length) return false;
161 | 
162 | 	matching.forEach(function (listeners) {
163 | 		listeners.forEach(function (listener) {
164 | 			var params = listener.params(topic);
165 | 			listener.fn(payload, params, topic, listener.pattern);
166 | 		});
167 | 	});
168 | 
169 | 	return true;
170 | }
171 | 
172 | /**
173 |  * Hook for reacting to new MQTT topics
174 |  * @param {String} topic MQTT topic that is being subscribed to
175 |  */
176 | function onadd(topic) {
177 | 	// Detect when new topics are added, maybe
178 | 	// Can be useful for auto-subscribing on actual MQTT connection
179 | }
180 | 
181 | /**
182 |  * Hook for reacting to removed MQTT topics
183 |  * @param  {String} topic MQTT topiuc that is being unsubscribed from
184 |  */
185 | function onremove(topic) {
186 | 	// Detect when topics are no longer listened to here
187 | 	// Can be useful for auto-unsubscribing on an actual MQTT connection
188 | }
189 | 
190 | },{"mqtt-regex":2,"mqtt-store":4}],2:[function(require,module,exports){
191 | /*
192 | 	The MIT License (MIT)
193 | 
194 | 	Copyright (c) 2014 RangerMauve
195 | 
196 | 	Permission is hereby granted, free of charge, to any person obtaining a copy
197 | 	of this software and associated documentation files (the "Software"), to deal
198 | 	in the Software without restriction, including without limitation the rights
199 | 	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
200 | 	copies of the Software, and to permit persons to whom the Software is
201 | 	furnished to do so, subject to the following conditions:
202 | 
203 | 	The above copyright notice and this permission notice shall be included in all
204 | 	copies or substantial portions of the Software.
205 | 
206 | 	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
207 | 	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
208 | 	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
209 | 	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
210 | 	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
211 | 	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
212 | 	SOFTWARE.
213 | */
214 | 
215 | var escapeRegex = require('escape-string-regexp');
216 | 
217 | module.exports = parse;
218 | 
219 | /**
220 |  * Parses topic string with parameters
221 |  * @param topic Topic string with optional params
222 |  * @returns {Object} Compiles a regex for matching topics, getParams for getting params, and exec for doing both
223 |  */
224 | function parse(topic) {
225 | 	var tokens = tokenize(topic).map(process_token);
226 | 	var result = {
227 | 		regex: make_regex(tokens),
228 | 		getParams: make_pram_getter(tokens),
229 | 		topic: make_clean_topic(tokens)
230 | 	};
231 | 	result.exec = exec.bind(result);
232 | 	return result;
233 | };
234 | 
235 | /**
236 |  * Matches regex against topic, returns params if successful
237 |  * @param topic Topic to match
238 |  */
239 | function exec(topic) {
240 | 	var regex = this.regex;
241 | 	var getParams = this.getParams;
242 | 	var match = regex.exec(topic);
243 | 	if (match) return getParams(match);
244 | }
245 | 
246 | // Split the topic into consumable tokens
247 | function tokenize(topic) {
248 | 	return topic.split("/");
249 | }
250 | 
251 | // Processes token and determines if it's a `single`, `multi` or `raw` token
252 | // Each token contains the type, an optional parameter name, and a piece of the regex
253 | // The piece can have a different syntax for when it is last
254 | function process_token(token, index, tokens) {
255 | 	var last = (index === (tokens.length - 1));
256 | 	if (token[0] === "+") return process_single(token, last);
257 | 	else if (token[0] === "#") return process_multi(token, last);
258 | 	else return process_raw(token, last);
259 | }
260 | 
261 | // Processes a token for single paths (prefixed with a +)
262 | function process_single(token) {
263 | 	var name = token.slice(1);
264 | 	return {
265 | 		type: "single",
266 | 		name: name,
267 | 		piece: "([^/#+]+/)",
268 | 		last: "([^/#+]+/?)"
269 | 	};
270 | }
271 | 
272 | // Processes a token for multiple paths (prefixed with a #)
273 | function process_multi(token, last) {
274 | 	if (!last) throw new Error("# wildcard must be at the end of the pattern");
275 | 	var name = token.slice(1);
276 | 	return {
277 | 		type: "multi",
278 | 		name: name,
279 | 		piece: "((?:[^/#+]+/)*)",
280 | 		last: "((?:[^/#+]+/?)*)"
281 | 	}
282 | }
283 | 
284 | // Processes a raw string for the path, no special logic is expected
285 | function process_raw(token) {
286 | 	var token = escapeRegex(token);
287 | 	return {
288 | 		type: "raw",
289 | 		piece: token + "/",
290 | 		last: token + "/?"
291 | 	};
292 | }
293 | 
294 | // Turn a topic pattern into a regular MQTT topic
295 | function make_clean_topic(tokens) {
296 | 	return tokens.map(function (token) {
297 | 		if (token.type === "raw") return token.piece.slice(0, -1);
298 | 		else if (token.type === "single") return "+";
299 | 		else if (token.type === "multi") return "#";
300 | 		else return ""; // Wat
301 | 	}).join("/");
302 | }
303 | 
304 | // Generates the RegExp object from the tokens
305 | function make_regex(tokens) {
306 | 	var str = tokens.reduce(function (res, token, index) {
307 | 			var is_last = (index == (tokens.length - 1));
308 | 			var before_multi = (index === (tokens.length - 2)) && (last(tokens).type == "multi");
309 | 			return res + ((is_last || before_multi) ? token.last : token.piece);
310 | 		},
311 | 		"");
312 | 	return new RegExp("^" + str + "$");
313 | }
314 | 
315 | // Generates the function for getting the params object from the regex results
316 | function make_pram_getter(tokens) {
317 | 	return function (results) {
318 | 		// Get only the capturing tokens
319 | 		var capture_tokens = remove_raw(tokens);
320 | 		var res = {};
321 | 
322 | 		// If the regex didn't actually match, just return an empty object
323 | 		if (!results) return res;
324 | 
325 | 		// Remove the first item and iterate through the capture groups
326 | 		results.slice(1).forEach(function (capture, index) {
327 | 			// Retreive the token description for the capture group
328 | 			var token = capture_tokens[index];
329 | 			var param = capture;
330 | 			// If the token doesn't have a name, continue to next group
331 | 			if (!token.name) return;
332 | 
333 | 			// If the token is `multi`, split the capture along `/`, remove empty items
334 | 			if (token.type === "multi") {
335 | 				param = capture.split("/");
336 | 				if (!last(param))
337 | 					param = remove_last(param);
338 | 				// Otherwise, remove any trailing `/`
339 | 			} else if (last(capture) === "/")
340 | 				param = remove_last(capture);
341 | 			// Set the param on the result object
342 | 			res[token.name] = param;
343 | 		});
344 | 		return res;
345 | 	}
346 | }
347 | 
348 | // Removes any tokens of type `raw`
349 | function remove_raw(tokens) {
350 | 	return tokens.filter(function (token) {
351 | 		return (token.type !== "raw");
352 | 	})
353 | }
354 | 
355 | // Gets the last item or character
356 | function last(items) {
357 | 	return items[items.length - 1];
358 | }
359 | 
360 | // Returns everything but the last item or character
361 | function remove_last(items) {
362 | 	return items.slice(0, items.length - 1);
363 | }
364 | 
365 | },{"escape-string-regexp":3}],3:[function(require,module,exports){
366 | 'use strict';
367 | 
368 | var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
369 | 
370 | module.exports = function (str) {
371 | 	if (typeof str !== 'string') {
372 | 		throw new TypeError('Expected a string');
373 | 	}
374 | 
375 | 	return str.replace(matchOperatorsRe, '\\$&');
376 | };
377 | 
378 | },{}],4:[function(require,module,exports){
379 | module.exports = MQTTStore;
380 | 
381 | function MQTTStore() {
382 | 	if (!(this instanceof MQTTStore))
383 | 		return new MQTTStore();
384 | 	this.tree = {
385 | 		children: {}
386 | 	};
387 | }
388 | 
389 | MQTTStore.prototype = {
390 | 	tree: null,
391 | 	get: get,
392 | 	query: query,
393 | 	match: match,
394 | 	set: set
395 | };
396 | 
397 | function get(key) {
398 | 	return get_one(split(key), this.tree);
399 | }
400 | 
401 | function query(key) {
402 | 	return get_all(split(key), this.tree);
403 | }
404 | 
405 | function match(key) {
406 | 	return get_matching(split(key), this.tree);
407 | }
408 | 
409 | function set(key, value) {
410 | 	set_one(split(key), this.tree, value);
411 | 	return value;
412 | }
413 | 
414 | function remove_one(path, tree) {
415 | 	if (!path.length) return;
416 | 	var next = path[0];
417 | 	if (!(next in tree.children)) return;
418 | 	return remove_one(path.slice(1), tree);
419 | }
420 | 
421 | function set_one(path, tree, value) {
422 | 	if (!path.length) return tree.value = value;
423 | 	var next = path[0];
424 | 	var children = tree.children;
425 | 	var next_tree = children[next];
426 | 	if (!next_tree)
427 | 		next_tree = children[next] = {
428 | 			children: {}
429 | 		};
430 | 	set_one(path.slice(1), tree.children[next], value);
431 | }
432 | 
433 | function get_one(path, tree) {
434 | 	if (!path.length) return tree.value;
435 | 	var next = path[0];
436 | 	var next_tree = tree.children[next];
437 | 	if (!next_tree) return undefined;
438 | 	return get_one(path.slice(1), next_tree);
439 | }
440 | 
441 | function get_all(path, tree) {
442 | 	if (!path.length) {
443 | 		var value = tree.value;
444 | 		if (value !== undefined) return [value];
445 | 		return [];
446 | 	}
447 | 
448 | 	var next = path[0];
449 | 
450 | 	if (next === "+") return values(tree.children)
451 | 		.map(get_all.bind(null, path.slice(1)))
452 | 		.reduce(flatten, []);
453 | 
454 | 	if (next === "#") return all_values(tree);
455 | 
456 | 	var next_tree = tree.children[next];
457 | 	if (!next_tree) return [];
458 | 	return get_all(path.slice(1), next_tree);
459 | }
460 | 
461 | function get_matching(path, tree) {
462 | 	if (!path.length) {
463 | 		var results = [];
464 | 		var value = tree.value;
465 | 		if (value !== undefined) results.push(value);
466 | 		var multi = tree.children["#"];
467 | 		if (multi && multi.value)
468 | 			results.push(multi.value);
469 | 		return results;
470 | 	}
471 | 
472 | 	var multi = tree.children["#"];
473 | 	var single = tree.children["+"];
474 | 
475 | 	var next = path[0];
476 | 	var next_tree = tree.children[next];
477 | 
478 | 	var rest = path.slice(1);
479 | 
480 | 	var results = [];
481 | 
482 | 	if (multi && multi.value)
483 | 		results.push(multi.value);
484 | 
485 | 	return results.concat([single, next_tree]
486 | 		.reduce(function (all, subtree) {
487 | 			if (subtree) return all.concat(get_matching(rest, subtree));
488 | 			return all;
489 | 		}, []));
490 | }
491 | 
492 | function all_values(tree) {
493 | 	return values(tree.children).map(function (subtree) {
494 | 		var all = all_values(subtree);
495 | 		var current = subtree.value;
496 | 		if (current !== undefined)
497 | 			all.push(current);
498 | 		return all;
499 | 	}).reduce(flatten, []);
500 | }
501 | 
502 | function keys(object) {
503 | 	return Object.keys(object);
504 | }
505 | 
506 | function values(object) {
507 | 	return keys(object).map(function (key) {
508 | 		return object[key];
509 | 	});
510 | }
511 | 
512 | function flatten(prev, current) {
513 | 	return prev.concat(current);
514 | }
515 | 
516 | function split(path) {
517 | 	return path.split("/");
518 | }
519 | 
520 | },{}]},{},[1])(1)
521 | });


--------------------------------------------------------------------------------
/src/android/CordovaMqTTPlugin.java:
--------------------------------------------------------------------------------
  1 | package com.arcoirislabs.plugin.mqtt;
  2 | 
  3 | import android.util.Base64;
  4 | import android.util.Log;
  5 | 
  6 | import org.apache.cordova.CallbackContext;
  7 | import org.apache.cordova.CordovaPlugin;
  8 | import org.apache.cordova.PluginResult;
  9 | import org.eclipse.paho.client.mqttv3.IMqttActionListener;
 10 | import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
 11 | import org.eclipse.paho.client.mqttv3.IMqttToken;
 12 | import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
 13 | import org.eclipse.paho.client.mqttv3.MqttCallback;
 14 | import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
 15 | import org.eclipse.paho.client.mqttv3.MqttException;
 16 | import org.eclipse.paho.client.mqttv3.MqttMessage;
 17 | import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
 18 | import org.json.JSONArray;
 19 | import org.json.JSONException;
 20 | import org.json.JSONObject;
 21 | 
 22 | /**
 23 |  * This class echoes a string called from JavaScript.
 24 |  */
 25 | public class CordovaMqTTPlugin extends CordovaPlugin {
 26 |     CallbackContext syncCB,asyncCB;
 27 |     MqttAsyncClient client;
 28 |     boolean connected;
 29 |     @Override
 30 |     public boolean execute(String action, final JSONArray args, CallbackContext callbackContext) throws JSONException {
 31 |         if(action.equals("connect")){
 32 |             this.asyncCB = callbackContext;
 33 | //            if (connection== null){
 34 | //
 35 | //            }else{
 36 | //                sendOnceUpdate("already connected");
 37 | //            }
 38 | 
 39 |             cordova.getThreadPool().execute(new Runnable() {
 40 |                 @Override
 41 |                 public void run() {
 42 |                     try {
 43 |                         connect(args.getString(0), args.getString(1), args.getInt(2), args.getBoolean(3), args.getInt(4), args.getString(5), args.getString(6), args.getString(7), args.getString(8), args.getInt(9), args.getBoolean(10), args.getString(11), args.getBoolean(12), args.getBoolean(13));
 44 |                     } catch (JSONException e) {
 45 |                         e.printStackTrace();
 46 |                     }
 47 |                 }
 48 |             });
 49 |             return true;
 50 |         }
 51 |         if(action.equals("publish")){
 52 |             this.syncCB = callbackContext;
 53 | //            if (connection!= null){
 54 | //
 55 | //            }else{
 56 | //                sendOnceUpdate("already connected");
 57 | //            }
 58 |             cordova.getActivity().runOnUiThread(new Runnable() {
 59 |                 @Override
 60 |                 public void run() {
 61 |                     try {
 62 |                         publish(args);
 63 |                     } catch (JSONException e) {
 64 |                         e.printStackTrace();
 65 |                     }
 66 |                 }
 67 |             });
 68 |             return true;
 69 |         }
 70 |         if(action.equals("subscribe")){
 71 | 
 72 |             this.syncCB = callbackContext;
 73 |             cordova.getActivity().runOnUiThread(new Runnable() {
 74 |                 @Override
 75 |                 public void run() {
 76 |                     try {
 77 |                         subscribe(args);
 78 |                     } catch (JSONException e) {
 79 |                         e.printStackTrace();
 80 |                     }
 81 |                 }
 82 |             });
 83 |             return true;
 84 |         }
 85 |         if(action.equals("disconnect")){
 86 |             this.syncCB = callbackContext;
 87 |             cordova.getActivity().runOnUiThread(new Runnable() {
 88 |                 @Override
 89 |                 public void run() {
 90 |                     disconnect();
 91 |                 }
 92 |             });
 93 |             return true;
 94 |         }
 95 |         if(action.equals("unsubscribe")){
 96 |             this.syncCB = callbackContext;
 97 |             cordova.getActivity().runOnUiThread(new Runnable() {
 98 |                 @Override
 99 |                 public void run() {
100 |                     try {
101 |                         unsubscribe(args);
102 |                     } catch (JSONException e) {
103 |                         e.printStackTrace();
104 |                     }
105 |                 }
106 |             });
107 |             return true;
108 |         }
109 | 
110 |         return false;
111 |     }
112 | 
113 |     private void connect(String url,String cid,int ka,boolean cleanSess,int connTimeOut,String uname, String pass,String willTopic,String willPayload,int willQos,boolean willRetain,String version,boolean isBinaryPayload,boolean isBinaryWillPayload) {
114 |         MemoryPersistence persistence = new MemoryPersistence();
115 |         final MqttConnectOptions connOpts = new MqttConnectOptions();
116 |         connected = false;
117 |         try {
118 |             //Log.i("mqttalabs", "client id is " + cid);
119 |             if (cid==null){
120 |                 cid = client.generateClientId();
121 |             }
122 |             connOpts.setCleanSession(cleanSess);
123 |             connOpts.setKeepAliveInterval(ka);
124 |             Log.i("mqttalabs", "username " + uname +" . Password is " + pass);
125 | 
126 |             client = new MqttAsyncClient(url, cid, persistence);
127 |             client.setCallback(new MqttCallback() {
128 |                 @Override
129 |                 public void connectionLost(Throwable cause) {
130 |                     connected = false;
131 |                     Log.i("mqttalabs", cause.toString());
132 |                     JSONObject dis = new JSONObject();
133 |                     try {
134 |                         dis.put("type", "connectionLost");
135 |                         dis.put("message", cause.toString());
136 |                         dis.put("call", "disconnected");
137 |                         dis.put("connectionStatus", client.isConnected());
138 |                         sendUpdate(dis);
139 |                     } catch (JSONException e) {
140 |                         e.printStackTrace();
141 |                     }
142 |                 }
143 |                 @Override
144 |                 public void messageArrived(String topic, MqttMessage message) throws Exception {
145 |                     //Log.i("mqttalabs", "topic is " + topic + ". payload is " + message.toString());
146 |                     JSONObject dis = new JSONObject();
147 |                     try {
148 |                         dis.put("type", "messageArrived");
149 |                         dis.put("topic", topic);
150 |                         if (isBinaryPayload) {
151 |                             dis.put("payload", Base64.encodeToString(message.getPayload(), Base64.DEFAULT));
152 |                         } else {
153 |                             dis.put("payload", message.toString());
154 |                         }
155 |                         dis.put("call", "onPublish");
156 |                         dis.put("connectionStatus", client.isConnected());
157 |                         dis.put("qos",message.getQos());
158 |                         dis.put("isRetained",message.isRetained());
159 |                         dis.put("isDuplicate",message.isDuplicate());
160 |                         sendUpdate(dis);
161 |                     } catch (JSONException e) {
162 |                         e.printStackTrace();
163 |                     }
164 |                 }
165 | 
166 |                 @Override
167 |                 public void deliveryComplete(IMqttDeliveryToken token) {
168 |                     try {
169 |                         token.waitForCompletion();
170 |                     } catch (MqttException e) {
171 |                         e.printStackTrace();
172 |                     }
173 |                 }
174 |             });
175 |             if (willTopic!=null&&willPayload!=null&&willQos>-1){
176 |                 byte[] willPayloadBytes;
177 |                 if (isBinaryWillPayload) {
178 |                     willPayloadBytes = Base64.decode(willPayload, Base64.DEFAULT);
179 |                 } else {
180 |                     willPayloadBytes = willPayload.getBytes();
181 |                 }
182 |                 connOpts.setWill(willTopic,willPayloadBytes,willQos,willRetain);
183 |             }
184 | 
185 |             if(uname.toString()=="null"&&pass.toString()=="null"){
186 |                 Log.i("mqttalabs","not applying creds");
187 | 
188 |             }else{
189 |                 Log.i("mqttalabs","applying creds");
190 |                 connOpts.setUserName(uname);
191 |                 connOpts.setPassword(pass.toCharArray());
192 |             }
193 |             //connOpts.setMqttVersion(MqttConnectOptions.MQTT_VERSION_3_1);
194 |             connOpts.setConnectionTimeout(connTimeOut);
195 |             client.connect(connOpts, null, new IMqttActionListener() {
196 |                 @Override
197 |                 public void onSuccess(IMqttToken asyncActionToken) {
198 |                     connected = true;
199 |                     JSONObject dis = new JSONObject();
200 |                     try {
201 |                         dis.put("type", "connected");
202 |                         dis.put("call", "connected");
203 |                         dis.put("response", "connected");
204 |                         dis.put("connectionStatus", client.isConnected());
205 |                         sendUpdate(dis);
206 |                     } catch (JSONException e) {
207 |                         e.printStackTrace();
208 |                     }
209 |                 }
210 | 
211 |                 @Override
212 |                 public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
213 |                     connected = false;
214 |                     JSONObject dis = new JSONObject();
215 |                     try {
216 |                         dis.put("type", "failure");
217 |                         dis.put("call", "failure");
218 |                         dis.put("response", "fail to connect");
219 |                         dis.put("message", exception.toString());
220 |                         dis.put("connectionStatus", client.isConnected());
221 |                         sendUpdate(dis);
222 |                     } catch (JSONException e) {
223 |                         e.printStackTrace();
224 |                     }
225 | 
226 |                 }
227 |             });
228 |         } catch (MqttException e) {
229 |             e.printStackTrace();
230 |         }
231 |     }
232 |     private void publish(JSONArray args) throws JSONException {
233 |         final MqttMessage payload = new MqttMessage();
234 |         boolean binaryPayload = args.getBoolean(4);
235 |         if (binaryPayload) {
236 |             payload.setPayload(Base64.decode(args.getString(1), Base64.DEFAULT));
237 |         } else {
238 |             payload.setPayload(args.getString(1).getBytes());
239 |         }
240 |         payload.setQos(args.getInt(2));
241 |         payload.setRetained(args.getBoolean(3));
242 |         Log.i("mqttalabs", "Topic is " + args.getString(0) + ". Payload is " + args.getString(1));
243 |         try {
244 |             if (client!=null){
245 |                 client.publish(args.getString(0), payload, null, new IMqttActionListener() {
246 |                     @Override
247 |                     public void onSuccess(IMqttToken asyncActionToken) {
248 |                         JSONObject dis = new JSONObject();
249 |                         try {
250 |                             dis.put("type", "publish");
251 |                             dis.put("call", "success");
252 |                             dis.put("response", "published");
253 |                             dis.put("isPayloadDuplicate", payload.isDuplicate());
254 |                             dis.put("qos", payload.getQos());
255 |                             dis.put("connectionStatus", client.isConnected());
256 |                             sendOnceUpdate(dis);
257 |                         } catch (JSONException e) {
258 |                             e.printStackTrace();
259 |                         }
260 |                     }
261 |                     @Override
262 |                     public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
263 |                         JSONObject dis = new JSONObject();
264 |                         try {
265 |                             dis.put("type", "publish");
266 |                             dis.put("call", "failure");
267 |                             dis.put("response", "not published");
268 |                             dis.put("isPayloadDuplicate", payload.isDuplicate());
269 |                             dis.put("qos", payload.getQos());
270 |                             dis.put("connectionStatus", client.isConnected());
271 |                             sendOnceUpdate(dis);
272 |                         } catch (JSONException e) {
273 |                             e.printStackTrace();
274 |                         }
275 |                     }
276 |                 });
277 |             }else{
278 |                 Log.e("mqttalabs","client var is null");
279 |             }
280 | 
281 |         } catch (MqttException e) {
282 |             e.printStackTrace();
283 |         }
284 | 
285 |     }
286 |     private void subscribe(final JSONArray args) throws JSONException {
287 |         try {
288 |             client.subscribe(args.getString(0), args.getInt(1), null, new IMqttActionListener() {
289 |                 @Override
290 |                 public void onSuccess(IMqttToken asyncActionToken) {
291 |                     JSONObject dis = new JSONObject();
292 |                     try {
293 |                         dis.put("type", "subscribe");
294 |                         dis.put("call", "success");
295 |                         dis.put("response", "subscribed to " + args.getString(0));
296 |                         dis.put("connectionStatus", client.isConnected());
297 |                         sendOnceUpdate(dis);
298 |                     } catch (JSONException e) {
299 |                         e.printStackTrace();
300 |                     }
301 |                 }
302 | 
303 |                 @Override
304 |                 public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
305 |                     JSONObject dis = new JSONObject();
306 |                     try {
307 |                         dis.put("type", "subscribe");
308 |                         dis.put("call", "failure");
309 |                         dis.put("response", "subscribed to " + args.getString(0));
310 |                         dis.put("message", exception.getMessage());
311 |                         dis.put("connectionStatus", client.isConnected());
312 |                         sendOnceUpdate(dis);
313 |                     } catch (JSONException e) {
314 |                         e.printStackTrace();
315 |                     }
316 |                 }
317 |             });
318 |         } catch (MqttException e) {
319 |             e.printStackTrace();
320 |         }
321 |     }
322 |     private void disconnect(){
323 |         try {
324 | 
325 |             client.disconnect(4, null, new IMqttActionListener() {
326 |                 @Override
327 |                 public void onSuccess(IMqttToken asyncActionToken) {
328 |                     try {
329 |                         JSONObject res = new JSONObject();
330 |                         try {
331 |                             res.put("type","disconnect");
332 |                             res.put("call","success");
333 |                             res.put("connectionStatus",client.isConnected());
334 |                             sendOnceUpdate(res);
335 |                         } catch (JSONException e) {
336 |                             e.printStackTrace();
337 |                         }
338 |                         asyncActionToken.waitForCompletion();
339 |                     } catch (MqttException e) {
340 |                         e.printStackTrace();
341 |                     }
342 |                     Log.i("mqttalabs","disconnected");
343 |                 }
344 | 
345 |                 @Override
346 |                 public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
347 |                     Log.i("mqttalabs"," cannot disconnect --> "+ exception.getMessage());
348 |                     try {
349 |                         JSONObject res = new JSONObject();
350 |                         try {
351 |                             res.put("type","disconnect");
352 |                             res.put("call","failure");
353 |                             res.put("connectionStatus",client.isConnected());
354 |                             res.put("message",exception.toString());
355 |                             sendOnceUpdate(res);
356 |                         } catch (JSONException e) {
357 |                             e.printStackTrace();
358 |                         }
359 |                         asyncActionToken.waitForCompletion();
360 |                     } catch (MqttException e) {
361 |                         e.printStackTrace();
362 |                     }
363 |                 }
364 |             });
365 |         } catch (MqttException e) {
366 |             e.printStackTrace();
367 |         }
368 |     }
369 |     private void unsubscribe(final JSONArray args) throws JSONException {
370 |         try {
371 |             client.unsubscribe(args.getString(0), null, new IMqttActionListener() {
372 |                 @Override
373 |                 public void onSuccess(IMqttToken asyncActionToken) {
374 |                     try {
375 |                         JSONObject res = new JSONObject();
376 |                         try {
377 |                             res.put("type","unsubscribe");
378 |                             res.put("call","success");
379 |                             res.put("connectionStatus",client.isConnected());
380 |                             res.put("unsubscribedTopic",args.getString(0));
381 |                             sendOnceUpdate(res);
382 |                         } catch (JSONException e) {
383 |                             e.printStackTrace();
384 |                         }
385 |                         asyncActionToken.waitForCompletion();
386 |                     } catch (MqttException e) {
387 |                         e.printStackTrace();
388 |                     }
389 |                 }
390 | 
391 |                 @Override
392 |                 public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
393 |                     try {
394 |                         JSONObject res = new JSONObject();
395 |                         try {
396 |                             res.put("type","unsubscribe");
397 |                             res.put("call","failure");
398 |                             res.put("connectionStatus",client.isConnected());
399 |                             res.put("unsubscribedTopic",args.getString(0));
400 |                             res.put("message",exception.toString());
401 |                             sendOnceUpdate(res);
402 |                         } catch (JSONException e) {
403 |                             e.printStackTrace();
404 |                         }
405 |                         asyncActionToken.waitForCompletion();
406 |                     } catch (MqttException e) {
407 |                         e.printStackTrace();
408 |                     }
409 |                 }
410 |             });
411 |         } catch (MqttException e) {
412 |             e.printStackTrace();
413 |         }
414 |     }
415 |     private void sendOnceUpdate(JSONObject message){
416 |         if (syncCB != null) {
417 |             PluginResult result = new PluginResult(PluginResult.Status.OK,message);
418 |             result.setKeepCallback(false);
419 |             syncCB.sendPluginResult(result);
420 | 
421 |             Log.i("mqttalabs","\nfor subscribe the callback id is "+syncCB.getCallbackId());
422 |         }
423 |     }
424 |     private void sendUpdate(JSONObject message){
425 |         if (asyncCB != null) {
426 |             PluginResult result = new PluginResult(PluginResult.Status.OK,message);
427 |             result.setKeepCallback(true);
428 |             asyncCB.sendPluginResult(result);
429 | 
430 |             Log.i("mqttalabs","\nfor subscribe the callback id is "+asyncCB.getCallbackId());
431 |         }
432 |     }
433 | 
434 | }
435 | 


--------------------------------------------------------------------------------
/src/ios/MQTTAsync.h:
--------------------------------------------------------------------------------
   1 | /*******************************************************************************
   2 |  * Copyright (c) 2009, 2016 IBM Corp.
   3 |  *
   4 |  * All rights reserved. This program and the accompanying materials
   5 |  * are made available under the terms of the Eclipse Public License v1.0
   6 |  * and Eclipse Distribution License v1.0 which accompany this distribution. 
   7 |  *
   8 |  * The Eclipse Public License is available at 
   9 |  *    http://www.eclipse.org/legal/epl-v10.html
  10 |  * and the Eclipse Distribution License is available at 
  11 |  *   http://www.eclipse.org/org/documents/edl-v10.php.
  12 |  *
  13 |  * Contributors:
  14 |  *    Ian Craggs - initial API and implementation 
  15 |  *    Ian Craggs, Allan Stockdill-Mander - SSL connections
  16 |  *    Ian Craggs - multiple server connection support
  17 |  *    Ian Craggs - MQTT 3.1.1 support
  18 |  *    Ian Craggs - fix for bug 444103 - success/failure callbacks not invoked
  19 |  *    Ian Craggs - automatic reconnect and offline buffering (send while disconnected)
  20 |  *******************************************************************************/
  21 | 
  22 | /********************************************************************/
  23 | 
  24 | /**
  25 |  * @cond MQTTAsync_main
  26 |  * @mainpage Asynchronous MQTT client library for C
  27 |  * 
  28 |  * &copy; Copyright IBM Corp. 2009, 2016
  29 |  * 
  30 |  * @brief An Asynchronous MQTT client library for C.
  31 |  *
  32 |  * An MQTT client application connects to MQTT-capable servers. 
  33 |  * A typical client is responsible for collecting information from a telemetry 
  34 |  * device and publishing the information to the server. It can also subscribe 
  35 |  * to topics, receive messages, and use this information to control the 
  36 |  * telemetry device.
  37 |  * 
  38 |  * MQTT clients implement the published MQTT v3 protocol. You can write your own
  39 |  * API to the MQTT protocol using the programming language and platform of your 
  40 |  * choice. This can be time-consuming and error-prone.
  41 |  * 
  42 |  * To simplify writing MQTT client applications, this library encapsulates
  43 |  * the MQTT v3 protocol for you. Using this library enables a fully functional 
  44 |  * MQTT client application to be written in a few lines of code.
  45 |  * The information presented here documents the API provided
  46 |  * by the Asynchronous MQTT Client library for C.
  47 |  * 
  48 |  * <b>Using the client</b><br>
  49 |  * Applications that use the client library typically use a similar structure:
  50 |  * <ul>
  51 |  * <li>Create a client object</li>
  52 |  * <li>Set the options to connect to an MQTT server</li>
  53 |  * <li>Set up callback functions</li>
  54 |  * <li>Connect the client to an MQTT server</li>
  55 |  * <li>Subscribe to any topics the client needs to receive</li>
  56 |  * <li>Repeat until finished:</li>
  57 |  *     <ul>
  58 |  *     <li>Publish any messages the client needs to</li>
  59 |  *     <li>Handle any incoming messages</li>
  60 |  *     </ul>
  61 |  * <li>Disconnect the client</li>
  62 |  * <li>Free any memory being used by the client</li>
  63 |  * </ul>
  64 |  * Some simple examples are shown here:
  65 |  * <ul>
  66 |  * <li>@ref publish</li>
  67 |  * <li>@ref subscribe</li>
  68 |  * </ul>
  69 |  * Additional information about important concepts is provided here:
  70 |  * <ul>
  71 |  * <li>@ref async</li>
  72 |  * <li>@ref wildcard</li>
  73 |  * <li>@ref qos</li>
  74 |  * <li>@ref tracing</li>
  75 |  * </ul>
  76 |  * @endcond
  77 |  */
  78 |  
  79 |  
  80 | /// @cond EXCLUDE
  81 | #if defined(__cplusplus)
  82 |  extern "C" {
  83 | #endif
  84 | 
  85 | #if !defined(MQTTASYNC_H)
  86 | #define MQTTASYNC_H
  87 | 
  88 | #if defined(WIN32) || defined(WIN64)
  89 |   #define DLLImport __declspec(dllimport)
  90 |   #define DLLExport __declspec(dllexport)
  91 | #else
  92 |   #define DLLImport extern
  93 |   #define DLLExport  __attribute__ ((visibility ("default")))
  94 | #endif
  95 | 
  96 | #include <stdio.h>
  97 | /// @endcond
  98 | 
  99 | #if !defined(NO_PERSISTENCE)
 100 | #include "MQTTClientPersistence.h"
 101 | #endif
 102 | 
 103 | /**
 104 |  * Return code: No error. Indicates successful completion of an MQTT client
 105 |  * operation.
 106 |  */
 107 | #define MQTTASYNC_SUCCESS 0
 108 | /**
 109 |  * Return code: A generic error code indicating the failure of an MQTT client
 110 |  * operation.
 111 |  */
 112 | #define MQTTASYNC_FAILURE -1
 113 | 
 114 | /* error code -2 is MQTTAsync_PERSISTENCE_ERROR */
 115 | 
 116 | #define MQTTASYNC_PERSISTENCE_ERROR -2
 117 | 
 118 | /**
 119 |  * Return code: The client is disconnected.
 120 |  */
 121 | #define MQTTASYNC_DISCONNECTED -3
 122 | /**
 123 |  * Return code: The maximum number of messages allowed to be simultaneously 
 124 |  * in-flight has been reached.
 125 |  */
 126 | #define MQTTASYNC_MAX_MESSAGES_INFLIGHT -4
 127 | /**
 128 |  * Return code: An invalid UTF-8 string has been detected.
 129 |  */
 130 | #define MQTTASYNC_BAD_UTF8_STRING -5
 131 | /**
 132 |  * Return code: A NULL parameter has been supplied when this is invalid.
 133 |  */
 134 | #define MQTTASYNC_NULL_PARAMETER -6
 135 | /**
 136 |  * Return code: The topic has been truncated (the topic string includes
 137 |  * embedded NULL characters). String functions will not access the full topic.
 138 |  * Use the topic length value to access the full topic.
 139 |  */
 140 | #define MQTTASYNC_TOPICNAME_TRUNCATED -7
 141 | /**
 142 |  * Return code: A structure parameter does not have the correct eyecatcher
 143 |  * and version number.
 144 |  */
 145 | #define MQTTASYNC_BAD_STRUCTURE -8
 146 | /**
 147 |  * Return code: A qos parameter is not 0, 1 or 2
 148 |  */
 149 | #define MQTTASYNC_BAD_QOS -9
 150 | /**
 151 |  * Return code: All 65535 MQTT msgids are being used
 152 |  */
 153 | #define MQTTASYNC_NO_MORE_MSGIDS -10
 154 | /**
 155 |  * Return code: the request is being discarded when not complete
 156 |  */
 157 | #define MQTTASYNC_OPERATION_INCOMPLETE -11
 158 | /**
 159 |  * Return code: no more messages can be buffered
 160 |  */
 161 | #define MQTTASYNC_MAX_BUFFERED_MESSAGES -12
 162 | 
 163 | /**
 164 |  * Default MQTT version to connect with.  Use 3.1.1 then fall back to 3.1
 165 |  */
 166 | #define MQTTVERSION_DEFAULT 0
 167 | /**
 168 |  * MQTT version to connect with: 3.1
 169 |  */
 170 | #define MQTTVERSION_3_1 3
 171 | /**
 172 |  * MQTT version to connect with: 3.1.1
 173 |  */
 174 | #define MQTTVERSION_3_1_1 4
 175 | /**
 176 |  * Bad return code from subscribe, as defined in the 3.1.1 specification
 177 |  */
 178 | #define MQTT_BAD_SUBSCRIBE 0x80
 179 | 
 180 | /**
 181 |  * A handle representing an MQTT client. A valid client handle is available
 182 |  * following a successful call to MQTTAsync_create().
 183 |  */
 184 | typedef void* MQTTAsync;
 185 | /**
 186 |  * A value representing an MQTT message. A token is returned to the
 187 |  * client application when a message is published. The token can then be used to
 188 |  * check that the message was successfully delivered to its destination (see
 189 |  * MQTTAsync_publish(), 
 190 |  * MQTTAsync_publishMessage(), 
 191 |  * MQTTAsync_deliveryComplete(), and
 192 |  * MQTTAsync_getPendingTokens()).
 193 |  */
 194 | typedef int MQTTAsync_token;
 195 | 
 196 | /**
 197 |  * A structure representing the payload and attributes of an MQTT message. The
 198 |  * message topic is not part of this structure (see MQTTAsync_publishMessage(),
 199 |  * MQTTAsync_publish(), MQTTAsync_receive(), MQTTAsync_freeMessage()
 200 |  * and MQTTAsync_messageArrived()).
 201 |  */
 202 | typedef struct
 203 | {
 204 | 	/** The eyecatcher for this structure.  must be MQTM. */
 205 | 	char struct_id[4];
 206 | 	/** The version number of this structure.  Must be 0 */
 207 | 	int struct_version;
 208 | 	/** The length of the MQTT message payload in bytes. */
 209 | 	int payloadlen;
 210 | 	/** A pointer to the payload of the MQTT message. */
 211 | 	void* payload;
 212 | 	/** 
 213 |      * The quality of service (QoS) assigned to the message. 
 214 |      * There are three levels of QoS:
 215 |      * <DL>
 216 |      * <DT><B>QoS0</B></DT>
 217 |      * <DD>Fire and forget - the message may not be delivered</DD>
 218 |      * <DT><B>QoS1</B></DT>
 219 |      * <DD>At least once - the message will be delivered, but may be 
 220 |      * delivered more than once in some circumstances.</DD>
 221 |      * <DT><B>QoS2</B></DT>
 222 |      * <DD>Once and one only - the message will be delivered exactly once.</DD>
 223 |      * </DL>
 224 |      */
 225 | 	int qos;
 226 | 	/** 
 227 |      * The retained flag serves two purposes depending on whether the message
 228 |      * it is associated with is being published or received. 
 229 |      * 
 230 |      * <b>retained = true</b><br>
 231 |      * For messages being published, a true setting indicates that the MQTT 
 232 |      * server should retain a copy of the message. The message will then be 
 233 |      * transmitted to new subscribers to a topic that matches the message topic.
 234 |      * For subscribers registering a new subscription, the flag being true
 235 |      * indicates that the received message is not a new one, but one that has
 236 |      * been retained by the MQTT server.
 237 |      *
 238 |      * <b>retained = false</b> <br>
 239 |      * For publishers, this ndicates that this message should not be retained 
 240 |      * by the MQTT server. For subscribers, a false setting indicates this is 
 241 |      * a normal message, received as a result of it being published to the 
 242 |      * server.
 243 |      */
 244 | 	int retained;
 245 | 	/** 
 246 |       * The dup flag indicates whether or not this message is a duplicate. 
 247 |       * It is only meaningful when receiving QoS1 messages. When true, the
 248 |       * client application should take appropriate action to deal with the
 249 |       * duplicate message.
 250 |       */
 251 | 	int dup;
 252 | 	/** The message identifier is normally reserved for internal use by the
 253 |       * MQTT client and server. 
 254 |       */
 255 | 	int msgid;
 256 | } MQTTAsync_message;
 257 | 
 258 | #define MQTTAsync_message_initializer { {'M', 'Q', 'T', 'M'}, 0, 0, NULL, 0, 0, 0, 0 }
 259 | 
 260 | /**
 261 |  * This is a callback function. The client application
 262 |  * must provide an implementation of this function to enable asynchronous 
 263 |  * receipt of messages. The function is registered with the client library by
 264 |  * passing it as an argument to MQTTAsync_setCallbacks(). It is
 265 |  * called by the client library when a new message that matches a client
 266 |  * subscription has been received from the server. This function is executed on
 267 |  * a separate thread to the one on which the client application is running.
 268 |  * @param context A pointer to the <i>context</i> value originally passed to 
 269 |  * MQTTAsync_setCallbacks(), which contains any application-specific context.
 270 |  * @param topicName The topic associated with the received message.
 271 |  * @param topicLen The length of the topic if there are one
 272 |  * more NULL characters embedded in <i>topicName</i>, otherwise <i>topicLen</i>
 273 |  * is 0. If <i>topicLen</i> is 0, the value returned by <i>strlen(topicName)</i>
 274 |  * can be trusted. If <i>topicLen</i> is greater than 0, the full topic name
 275 |  * can be retrieved by accessing <i>topicName</i> as a byte array of length 
 276 |  * <i>topicLen</i>. 
 277 |  * @param message The MQTTAsync_message structure for the received message. 
 278 |  * This structure contains the message payload and attributes.
 279 |  * @return This function must return a boolean value indicating whether or not
 280 |  * the message has been safely received by the client application. Returning 
 281 |  * true indicates that the message has been successfully handled.  
 282 |  * Returning false indicates that there was a problem. In this 
 283 |  * case, the client library will reinvoke MQTTAsync_messageArrived() to 
 284 |  * attempt to deliver the message to the application again.
 285 |  */
 286 | typedef int MQTTAsync_messageArrived(void* context, char* topicName, int topicLen, MQTTAsync_message* message);
 287 | 
 288 | /**
 289 |  * This is a callback function. The client application
 290 |  * must provide an implementation of this function to enable asynchronous 
 291 |  * notification of delivery of messages to the server. The function is 
 292 |  * registered with the client library by passing it as an argument to MQTTAsync_setCallbacks(). 
 293 |  * It is called by the client library after the client application has 
 294 |  * published a message to the server. It indicates that the necessary 
 295 |  * handshaking and acknowledgements for the requested quality of service (see 
 296 |  * MQTTAsync_message.qos) have been completed. This function is executed on a
 297 |  * separate thread to the one on which the client application is running.
 298 |  * @param context A pointer to the <i>context</i> value originally passed to 
 299 |  * MQTTAsync_setCallbacks(), which contains any application-specific context.
 300 |  * @param token The ::MQTTAsync_token associated with
 301 |  * the published message. Applications can check that all messages have been 
 302 |  * correctly published by matching the tokens returned from calls to
 303 |  * MQTTAsync_send() and MQTTAsync_sendMessage() with the tokens passed
 304 |  * to this callback. 
 305 |  */
 306 | typedef void MQTTAsync_deliveryComplete(void* context, MQTTAsync_token token);
 307 | 
 308 | /**
 309 |  * This is a callback function. The client application
 310 |  * must provide an implementation of this function to enable asynchronous 
 311 |  * notification of the loss of connection to the server. The function is 
 312 |  * registered with the client library by passing it as an argument to  
 313 |  * MQTTAsync_setCallbacks(). It is called by the client library if the client
 314 |  * loses its connection to the server. The client application must take 
 315 |  * appropriate action, such as trying to reconnect or reporting the problem. 
 316 |  * This function is executed on a separate thread to the one on which the 
 317 |  * client application is running.
 318 |  * @param context A pointer to the <i>context</i> value originally passed to 
 319 |  * MQTTAsync_setCallbacks(), which contains any application-specific context.
 320 |  * @param cause The reason for the disconnection.
 321 |  * Currently, <i>cause</i> is always set to NULL.
 322 |  */
 323 | typedef void MQTTAsync_connectionLost(void* context, char* cause);
 324 | 
 325 | 
 326 | /**
 327 |  * This is a callback function, which will be called when the client
 328 |  * library successfully connects.  This is superfluous when the connection
 329 |  * is made in response to a MQTTAsync_connect call, because the onSuccess
 330 |  * callback can be used.  It is intended for use when automatic reconnect
 331 |  * is enabled, so that when a reconnection attempt succeeds in the background,
 332 |  * the application is notified and can take any required actions.
 333 |  * @param context A pointer to the <i>context</i> value originally passed to
 334 |  * MQTTAsync_setCallbacks(), which contains any application-specific context.
 335 |  * @param cause The reason for the disconnection.
 336 |  * Currently, <i>cause</i> is always set to NULL.
 337 |  */
 338 | typedef void MQTTAsync_connected(void* context, char* cause);
 339 | 
 340 | 
 341 | 
 342 | /** The data returned on completion of an unsuccessful API call in the response callback onFailure. */
 343 | typedef struct
 344 | {
 345 | 	/** A token identifying the failed request. */
 346 | 	MQTTAsync_token token;
 347 | 	/** A numeric code identifying the error. */
 348 | 	int code;
 349 | 	/** Optional text explaining the error. Can be NULL. */
 350 | 	char* message;
 351 | } MQTTAsync_failureData;
 352 | 
 353 | /** The data returned on completion of a successful API call in the response callback onSuccess. */
 354 | typedef struct
 355 | {
 356 | 	/** A token identifying the successful request. Can be used to refer to the request later. */
 357 | 	MQTTAsync_token token;
 358 | 	/** A union of the different values that can be returned for subscribe, unsubscribe and publish. */
 359 | 	union
 360 | 	{
 361 | 		/** For subscribe, the granted QoS of the subscription returned by the server. */
 362 | 		int qos;                     
 363 | 		/** For subscribeMany, the list of granted QoSs of the subscriptions returned by the server. */
 364 | 		int* qosList;     
 365 | 		/** For publish, the message being sent to the server. */
 366 | 		struct
 367 | 		{          
 368 | 			MQTTAsync_message message;
 369 | 			char* destinationName;
 370 | 		} pub;
 371 | 		/* For connect, the server connected to, MQTT version used, and sessionPresent flag */
 372 | 		struct
 373 | 		{
 374 | 			char* serverURI;
 375 | 			int MQTTVersion;
 376 | 			int sessionPresent;
 377 | 		} connect;
 378 | 	} alt;
 379 | } MQTTAsync_successData;
 380 | 
 381 | /**
 382 |  * This is a callback function. The client application
 383 |  * must provide an implementation of this function to enable asynchronous 
 384 |  * notification of the successful completion of an API call. The function is 
 385 |  * registered with the client library by passing it as an argument in  
 386 |  * ::MQTTAsync_responseOptions. 
 387 |  * @param context A pointer to the <i>context</i> value originally passed to 
 388 |  * ::MQTTAsync_responseOptions, which contains any application-specific context.
 389 |  * @param response Any success data associated with the API completion.
 390 |  */
 391 | typedef void MQTTAsync_onSuccess(void* context, MQTTAsync_successData* response);
 392 | 
 393 | /**
 394 |  * This is a callback function. The client application
 395 |  * must provide an implementation of this function to enable asynchronous 
 396 |  * notification of the unsuccessful completion of an API call. The function is 
 397 |  * registered with the client library by passing it as an argument in  
 398 |  * ::MQTTAsync_responseOptions. 
 399 |  * @param context A pointer to the <i>context</i> value originally passed to 
 400 |  * ::MQTTAsync_responseOptions, which contains any application-specific context.
 401 |  * @param response Any failure data associated with the API completion.
 402 |  */
 403 | typedef void MQTTAsync_onFailure(void* context,  MQTTAsync_failureData* response);
 404 | 
 405 | typedef struct
 406 | {
 407 | 	/** The eyecatcher for this structure.  Must be MQTR */
 408 | 	char struct_id[4];
 409 | 	/** The version number of this structure.  Must be 0 */
 410 | 	int struct_version;	
 411 | 	/** 
 412 |     * A pointer to a callback function to be called if the API call successfully
 413 |     * completes.  Can be set to NULL, in which case no indication of successful
 414 |     * completion will be received.
 415 |     */
 416 | 	MQTTAsync_onSuccess* onSuccess;
 417 | 	/** 
 418 |     * A pointer to a callback function to be called if the API call fails.
 419 |     * Can be set to NULL, in which case no indication of unsuccessful
 420 |     * completion will be received.
 421 |     */
 422 | 	MQTTAsync_onFailure* onFailure;
 423 | 	/**
 424 | 	* A pointer to any application-specific context. The
 425 |     * the <i>context</i> pointer is passed to success or failure callback functions to
 426 |     * provide access to the context information in the callback.
 427 |     */
 428 | 	void* context; 
 429 | 	MQTTAsync_token token;   /* output */
 430 | } MQTTAsync_responseOptions;
 431 | 
 432 | #define MQTTAsync_responseOptions_initializer { {'M', 'Q', 'T', 'R'}, 0, NULL, NULL, 0, 0 }
 433 | 
 434 | 
 435 | /**
 436 |  * This function sets the global callback functions for a specific client.
 437 |  * If your client application doesn't use a particular callback, set the 
 438 |  * relevant parameter to NULL. Any necessary message acknowledgements and
 439 |  * status communications are handled in the background without any intervention
 440 |  * from the client application.  If you do not set a messageArrived callback
 441 |  * function, you will not be notified of the receipt of any messages as a 
 442 |  * result of a subscription. 
 443 |  * 
 444 |  * <b>Note:</b> The MQTT client must be disconnected when this function is 
 445 |  * called. 
 446 |  * @param handle A valid client handle from a successful call to
 447 |  * MQTTAsync_create(). 
 448 |  * @param context A pointer to any application-specific context. The
 449 |  * the <i>context</i> pointer is passed to each of the callback functions to
 450 |  * provide access to the context information in the callback.
 451 |  * @param cl A pointer to an MQTTAsync_connectionLost() callback
 452 |  * function. You can set this to NULL if your application doesn't handle
 453 |  * disconnections.
 454 |  * @param ma A pointer to an MQTTAsync_messageArrived() callback
 455 |  * function.  You can set this to NULL if your application doesn't handle
 456 |  * receipt of messages.
 457 |  * @param dc A pointer to an MQTTAsync_deliveryComplete() callback
 458 |  * function. You can set this to NULL if you do not want to check 
 459 |  * for successful delivery.
 460 |  * @return ::MQTTASYNC_SUCCESS if the callbacks were correctly set,
 461 |  * ::MQTTASYNC_FAILURE if an error occurred.
 462 |  */
 463 | DLLExport int MQTTAsync_setCallbacks(MQTTAsync handle, void* context, MQTTAsync_connectionLost* cl,
 464 | 									MQTTAsync_messageArrived* ma, MQTTAsync_deliveryComplete* dc);
 465 | 
 466 | 
 467 | /**
 468 |  * Sets the MQTTAsync_connected() callback function for a client.
 469 |  * @param handle A valid client handle from a successful call to
 470 |  * MQTTAsync_create(). 
 471 |  * @param context A pointer to any application-specific context. The
 472 |  * the <i>context</i> pointer is passed to each of the callback functions to
 473 |  * provide access to the context information in the callback.
 474 |  * @param co A pointer to an MQTTAsync_connected() callback
 475 |  * function.  NULL removes the callback setting.
 476 |  * @return ::MQTTASYNC_SUCCESS if the callbacks were correctly set,
 477 |  * ::MQTTASYNC_FAILURE if an error occurred.
 478 |  */
 479 | DLLExport int MQTTAsync_setConnected(MQTTAsync handle, void* context, MQTTAsync_connected* co);
 480 | 
 481 | 
 482 | /**
 483 |  * Reconnects a client with the previously used connect options.  Connect
 484 |  * must have previously been called for this to work.
 485 |  * @param handle A valid client handle from a successful call to
 486 |  * MQTTAsync_create(). 
 487 |  * @return ::MQTTASYNC_SUCCESS if the callbacks were correctly set,
 488 |  * ::MQTTASYNC_FAILURE if an error occurred.
 489 |  */
 490 | DLLExport int MQTTAsync_reconnect(MQTTAsync handle);
 491 | 		
 492 | 
 493 | /**
 494 |  * This function creates an MQTT client ready for connection to the 
 495 |  * specified server and using the specified persistent storage (see 
 496 |  * MQTTAsync_persistence). See also MQTTAsync_destroy().
 497 |  * @param handle A pointer to an ::MQTTAsync handle. The handle is
 498 |  * populated with a valid client reference following a successful return from
 499 |  * this function.  
 500 |  * @param serverURI A null-terminated string specifying the server to
 501 |  * which the client will connect. It takes the form <i>protocol://host:port</i>.
 502 |  * <i>protocol</i> must be <i>tcp</i> or <i>ssl</i>. For <i>host</i>, you can 
 503 |  * specify either an IP address or a host name. For instance, to connect to
 504 |  * a server running on the local machines with the default MQTT port, specify
 505 |  * <i>tcp://localhost:1883</i>.
 506 |  * @param clientId The client identifier passed to the server when the
 507 |  * client connects to it. It is a null-terminated UTF-8 encoded string. 
 508 |  * ClientIDs must be no longer than 23 characters according to the MQTT 
 509 |  * specification.
 510 |  * @param persistence_type The type of persistence to be used by the client:
 511 |  * <br>
 512 |  * ::MQTTCLIENT_PERSISTENCE_NONE: Use in-memory persistence. If the device or 
 513 |  * system on which the client is running fails or is switched off, the current
 514 |  * state of any in-flight messages is lost and some messages may not be 
 515 |  * delivered even at QoS1 and QoS2.
 516 |  * <br>
 517 |  * ::MQTTCLIENT_PERSISTENCE_DEFAULT: Use the default (file system-based) 
 518 |  * persistence mechanism. Status about in-flight messages is held in persistent
 519 |  * storage and provides some protection against message loss in the case of 
 520 |  * unexpected failure.
 521 |  * <br>
 522 |  * ::MQTTCLIENT_PERSISTENCE_USER: Use an application-specific persistence
 523 |  * implementation. Using this type of persistence gives control of the 
 524 |  * persistence mechanism to the application. The application has to implement
 525 |  * the MQTTClient_persistence interface.
 526 |  * @param persistence_context If the application uses 
 527 |  * ::MQTTCLIENT_PERSISTENCE_NONE persistence, this argument is unused and should
 528 |  * be set to NULL. For ::MQTTCLIENT_PERSISTENCE_DEFAULT persistence, it
 529 |  * should be set to the location of the persistence directory (if set 
 530 |  * to NULL, the persistence directory used is the working directory).
 531 |  * Applications that use ::MQTTCLIENT_PERSISTENCE_USER persistence set this
 532 |  * argument to point to a valid MQTTClient_persistence structure.
 533 |  * @return ::MQTTASYNC_SUCCESS if the client is successfully created, otherwise
 534 |  * an error code is returned.
 535 |  */
 536 | DLLExport int MQTTAsync_create(MQTTAsync* handle, const char* serverURI, const char* clientId,
 537 | 		int persistence_type, void* persistence_context);
 538 | 
 539 | typedef struct
 540 | {
 541 | 	/** The eyecatcher for this structure.  must be MQCO. */
 542 | 	const char struct_id[4];
 543 | 	/** The version number of this structure.  Must be 0 */
 544 | 	int struct_version;
 545 | 	/** Whether to allow messages to be sent when the client library is not connected. */
 546 | 	int sendWhileDisconnected;
 547 | 	/** the maximum number of messages allowed to be buffered while not connected. */
 548 | 	int maxBufferedMessages;
 549 | } MQTTAsync_createOptions;
 550 | 
 551 | #define MQTTAsync_createOptions_initializer { {'M', 'Q', 'C', 'O'}, 0, 0, 100 }
 552 | 
 553 | 
 554 | DLLExport int MQTTAsync_createWithOptions(MQTTAsync* handle, const char* serverURI, const char* clientId,
 555 | 		int persistence_type, void* persistence_context, MQTTAsync_createOptions* options);
 556 | 
 557 | /**
 558 |  * MQTTAsync_willOptions defines the MQTT "Last Will and Testament" (LWT) settings for
 559 |  * the client. In the event that a client unexpectedly loses its connection to
 560 |  * the server, the server publishes the LWT message to the LWT topic on
 561 |  * behalf of the client. This allows other clients (subscribed to the LWT topic)
 562 |  * to be made aware that the client has disconnected. To enable the LWT
 563 |  * function for a specific client, a valid pointer to an MQTTAsync_willOptions 
 564 |  * structure is passed in the MQTTAsync_connectOptions structure used in the
 565 |  * MQTTAsync_connect() call that connects the client to the server. The pointer
 566 |  * to MQTTAsync_willOptions can be set to NULL if the LWT function is not 
 567 |  * required.
 568 |  */
 569 | typedef struct
 570 | {
 571 | 	/** The eyecatcher for this structure.  must be MQTW. */
 572 | 	const char struct_id[4];
 573 | 	/** The version number of this structure.  Must be 0 */
 574 | 	int struct_version;
 575 | 	/** The LWT topic to which the LWT message will be published. */
 576 | 	const char* topicName;
 577 | 	/** The LWT payload. */
 578 | 	const char* message;
 579 | 	/**
 580 |       * The retained flag for the LWT message (see MQTTAsync_message.retained).
 581 |       */
 582 | 	int retained;
 583 | 	/** 
 584 |       * The quality of service setting for the LWT message (see 
 585 |       * MQTTAsync_message.qos and @ref qos).
 586 |       */
 587 | 	int qos;
 588 | } MQTTAsync_willOptions;
 589 | 
 590 | #define MQTTAsync_willOptions_initializer { {'M', 'Q', 'T', 'W'}, 0, NULL, NULL, 0, 0 }
 591 | 
 592 | /**
 593 | * MQTTAsync_sslProperties defines the settings to establish an SSL/TLS connection using the 
 594 | * OpenSSL library. It covers the following scenarios:
 595 | * - Server authentication: The client needs the digital certificate of the server. It is included
 596 | *   in a store containting trusted material (also known as "trust store").
 597 | * - Mutual authentication: Both client and server are authenticated during the SSL handshake. In 
 598 | *   addition to the digital certificate of the server in a trust store, the client will need its own 
 599 | *   digital certificate and the private key used to sign its digital certificate stored in a "key store".
 600 | * - Anonymous connection: Both client and server do not get authenticated and no credentials are needed 
 601 | *   to establish an SSL connection. Note that this scenario is not fully secure since it is subject to
 602 | *   man-in-the-middle attacks.
 603 | */
 604 | typedef struct 
 605 | {
 606 | 	/** The eyecatcher for this structure.  Must be MQTS */
 607 | 	const char struct_id[4];
 608 | 	/** The version number of this structure.  Must be 0 */
 609 | 	int struct_version;	
 610 | 	
 611 | 	/** The file in PEM format containing the public digital certificates trusted by the client. */
 612 | 	const char* trustStore;
 613 | 
 614 | 	/** The file in PEM format containing the public certificate chain of the client. It may also include
 615 | 	* the client's private key. 
 616 | 	*/
 617 | 	const char* keyStore;
 618 | 	
 619 | 	/** If not included in the sslKeyStore, this setting points to the file in PEM format containing
 620 | 	* the client's private key.
 621 | 	*/
 622 | 	const char* privateKey;
 623 | 	/** The password to load the client's privateKey if encrypted. */
 624 | 	const char* privateKeyPassword;
 625 |  
 626 | 	/**
 627 | 	* The list of cipher suites that the client will present to the server during the SSL handshake. For a 
 628 | 	* full explanation of the cipher list format, please see the OpenSSL on-line documentation:
 629 | 	* http://www.openssl.org/docs/apps/ciphers.html#CIPHER_LIST_FORMAT
 630 | 	* If this setting is ommitted, its default value will be "ALL", that is, all the cipher suites -excluding
 631 | 	* those offering no encryption- will be considered.
 632 | 	* This setting can be used to set an SSL anonymous connection ("aNULL" string value, for instance).
 633 | 	*/
 634 | 	const char* enabledCipherSuites;    
 635 | 
 636 |     /** True/False option to enable verification of the server certificate **/
 637 |     int enableServerCertAuth;
 638 |   
 639 | } MQTTAsync_SSLOptions;
 640 | 
 641 | #define MQTTAsync_SSLOptions_initializer { {'M', 'Q', 'T', 'S'}, 0, NULL, NULL, NULL, NULL, NULL, 1 }
 642 | 
 643 | /**
 644 |  * MQTTAsync_connectOptions defines several settings that control the way the
 645 |  * client connects to an MQTT server.  Default values are set in 
 646 |  * MQTTAsync_connectOptions_initializer.
 647 |  */
 648 | typedef struct
 649 | {
 650 | 	/** The eyecatcher for this structure.  must be MQTC. */
 651 | 	const char struct_id[4];
 652 | 	/** The version number of this structure.  Must be 0, 1, 2, 3 or 4.  
 653 | 	  * 0 signifies no SSL options and no serverURIs
 654 | 	  * 1 signifies no serverURIs 
 655 |       * 2 signifies no MQTTVersion
 656 |       * 3 signifies no automatic reconnect options
 657 | 	  */
 658 | 	int struct_version;
 659 | 	/** The "keep alive" interval, measured in seconds, defines the maximum time
 660 |       * that should pass without communication between the client and the server
 661 |       * The client will ensure that at least one message travels across the
 662 |       * network within each keep alive period.  In the absence of a data-related 
 663 | 	  * message during the time period, the client sends a very small MQTT 
 664 |       * "ping" message, which the server will acknowledge. The keep alive 
 665 |       * interval enables the client to detect when the server is no longer 
 666 | 	  * available without having to wait for the long TCP/IP timeout.
 667 | 	  * Set to 0 if you do not want any keep alive processing.
 668 | 	  */
 669 | 	int keepAliveInterval;
 670 | 	/** 
 671 |       * This is a boolean value. The cleansession setting controls the behaviour
 672 |       * of both the client and the server at connection and disconnection time.
 673 |       * The client and server both maintain session state information. This
 674 |       * information is used to ensure "at least once" and "exactly once"
 675 |       * delivery, and "exactly once" receipt of messages. Session state also
 676 |       * includes subscriptions created by an MQTT client. You can choose to
 677 |       * maintain or discard state information between sessions. 
 678 |       *
 679 |       * When cleansession is true, the state information is discarded at 
 680 |       * connect and disconnect. Setting cleansession to false keeps the state 
 681 |       * information. When you connect an MQTT client application with 
 682 |       * MQTTAsync_connect(), the client identifies the connection using the 
 683 |       * client identifier and the address of the server. The server checks 
 684 |       * whether session information for this client
 685 |       * has been saved from a previous connection to the server. If a previous 
 686 |       * session still exists, and cleansession=true, then the previous session 
 687 |       * information at the client and server is cleared. If cleansession=false,
 688 |       * the previous session is resumed. If no previous session exists, a new
 689 |       * session is started.
 690 | 	  */
 691 | 	int cleansession;
 692 | 	/** 
 693 |       * This controls how many messages can be in-flight simultaneously. 
 694 | 	  */
 695 | 	int maxInflight;		
 696 | 	/** 
 697 |       * This is a pointer to an MQTTAsync_willOptions structure. If your 
 698 |       * application does not make use of the Last Will and Testament feature, 
 699 |       * set this pointer to NULL.
 700 |       */
 701 | 	MQTTAsync_willOptions* will;
 702 | 	/** 
 703 |       * MQTT servers that support the MQTT v3.1 protocol provide authentication
 704 |       * and authorisation by user name and password. This is the user name 
 705 |       * parameter. 
 706 |       */
 707 | 	const char* username;	
 708 | 	/** 
 709 |       * MQTT servers that support the MQTT v3.1 protocol provide authentication
 710 |       * and authorisation by user name and password. This is the password 
 711 |       * parameter.
 712 |       */
 713 | 	const char* password;
 714 | 	/**
 715 |       * The time interval in seconds to allow a connect to complete.
 716 |       */
 717 | 	int connectTimeout;
 718 | 	/**
 719 | 	 * The time interval in seconds
 720 | 	 */
 721 | 	int retryInterval;
 722 | 	/** 
 723 |       * This is a pointer to an MQTTAsync_SSLOptions structure. If your 
 724 |       * application does not make use of SSL, set this pointer to NULL.
 725 |       */
 726 | 	MQTTAsync_SSLOptions* ssl;
 727 | 	/** 
 728 |       * A pointer to a callback function to be called if the connect successfully
 729 |       * completes.  Can be set to NULL, in which case no indication of successful
 730 |       * completion will be received.
 731 |       */
 732 | 	MQTTAsync_onSuccess* onSuccess;
 733 | 	/** 
 734 |       * A pointer to a callback function to be called if the connect fails.
 735 |       * Can be set to NULL, in which case no indication of unsuccessful
 736 |       * completion will be received.
 737 |       */
 738 | 	MQTTAsync_onFailure* onFailure;
 739 | 	/**
 740 | 	  * A pointer to any application-specific context. The
 741 |       * the <i>context</i> pointer is passed to success or failure callback functions to
 742 |       * provide access to the context information in the callback.
 743 |       */
 744 | 	void* context;
 745 | 	/**
 746 | 	  * The number of entries in the serverURIs array.
 747 | 	  */
 748 | 	int serverURIcount;
 749 | 	/**
 750 | 	  * An array of null-terminated strings specifying the servers to
 751 |       * which the client will connect. Each string takes the form <i>protocol://host:port</i>.
 752 |       * <i>protocol</i> must be <i>tcp</i> or <i>ssl</i>. For <i>host</i>, you can 
 753 |       * specify either an IP address or a domain name. For instance, to connect to
 754 |       * a server running on the local machines with the default MQTT port, specify
 755 |       * <i>tcp://localhost:1883</i>.
 756 |       */    
 757 | 	char* const* serverURIs;
 758 | 	/**
 759 |       * Sets the version of MQTT to be used on the connect.
 760 |       * MQTTVERSION_DEFAULT (0) = default: start with 3.1.1, and if that fails, fall back to 3.1
 761 |       * MQTTVERSION_3_1 (3) = only try version 3.1
 762 |       * MQTTVERSION_3_1_1 (4) = only try version 3.1.1
 763 | 	  */
 764 | 	int MQTTVersion;
 765 | 	/**
 766 | 	  * Reconnect automatically in the case of a connection being lost?
 767 | 	  */
 768 | 	int automaticReconnect;
 769 | 	/**
 770 | 	  * Minimum retry interval in seconds.  Doubled on each failed retry.
 771 | 	  */
 772 | 	int minRetryInterval;
 773 | 	/**
 774 | 	  * Maximum retry interval in seconds.  The doubling stops here on failed retries.
 775 | 	  */
 776 | 	int maxRetryInterval;
 777 | } MQTTAsync_connectOptions;
 778 | 
 779 | 
 780 | #define MQTTAsync_connectOptions_initializer { {'M', 'Q', 'T', 'C'}, 4, 60, 1, 10, NULL, NULL, NULL, 30, 0,\
 781 | NULL, NULL, NULL, NULL, 0, NULL, 0, 0, 1, 60}
 782 | 
 783 | /**
 784 |   * This function attempts to connect a previously-created client (see
 785 |   * MQTTAsync_create()) to an MQTT server using the specified options. If you
 786 |   * want to enable asynchronous message and status notifications, you must call
 787 |   * MQTTAsync_setCallbacks() prior to MQTTAsync_connect().
 788 |   * @param handle A valid client handle from a successful call to 
 789 |   * MQTTAsync_create(). 
 790 |   * @param options A pointer to a valid MQTTAsync_connectOptions
 791 |   * structure.
 792 |   * @return ::MQTTASYNC_SUCCESS if the client connect request was accepted. 
 793 |   * If the client was unable to connect to the server, an error code is
 794 |   * returned via the onFailure callback, if set.
 795 |   * Error codes greater than 0 are returned by the MQTT protocol:<br><br>
 796 |   * <b>1</b>: Connection refused: Unacceptable protocol version<br>
 797 |   * <b>2</b>: Connection refused: Identifier rejected<br>
 798 |   * <b>3</b>: Connection refused: Server unavailable<br>
 799 |   * <b>4</b>: Connection refused: Bad user name or password<br>
 800 |   * <b>5</b>: Connection refused: Not authorized<br>
 801 |   * <b>6-255</b>: Reserved for future use<br>
 802 |   */
 803 | DLLExport int MQTTAsync_connect(MQTTAsync handle, const MQTTAsync_connectOptions* options);
 804 | 
 805 | 
 806 | typedef struct
 807 | {
 808 | 	/** The eyecatcher for this structure. Must be MQTD. */
 809 | 	const char struct_id[4];
 810 | 	/** The version number of this structure.  Must be 0 or 1.  0 signifies no SSL options */
 811 | 	int struct_version;
 812 | 	/**
 813 |       * The client delays disconnection for up to this time (in 
 814 |       * milliseconds) in order to allow in-flight message transfers to complete.
 815 |       */
 816 | 	int timeout;
 817 | 	/** 
 818 |     * A pointer to a callback function to be called if the disconnect successfully
 819 |     * completes.  Can be set to NULL, in which case no indication of successful
 820 |     * completion will be received.
 821 |     */
 822 | 	MQTTAsync_onSuccess* onSuccess;
 823 | 	/** 
 824 |     * A pointer to a callback function to be called if the disconnect fails.
 825 |     * Can be set to NULL, in which case no indication of unsuccessful
 826 |     * completion will be received.
 827 |     */
 828 | 	MQTTAsync_onFailure* onFailure;
 829 | 	/**
 830 | 	* A pointer to any application-specific context. The
 831 |     * the <i>context</i> pointer is passed to success or failure callback functions to
 832 |     * provide access to the context information in the callback.
 833 |     */
 834 | 	void* context;         
 835 | } MQTTAsync_disconnectOptions;
 836 | 
 837 | #define MQTTAsync_disconnectOptions_initializer { {'M', 'Q', 'T', 'D'}, 0, 0, NULL, NULL, NULL }
 838 | 
 839 | 
 840 | /**
 841 |   * This function attempts to disconnect the client from the MQTT
 842 |   * server. In order to allow the client time to complete handling of messages
 843 |   * that are in-flight when this function is called, a timeout period is 
 844 |   * specified. When the timeout period has expired, the client disconnects even
 845 |   * if there are still outstanding message acknowledgements.
 846 |   * The next time the client connects to the same server, any QoS 1 or 2 
 847 |   * messages which have not completed will be retried depending on the 
 848 |   * cleansession settings for both the previous and the new connection (see 
 849 |   * MQTTAsync_connectOptions.cleansession and MQTTAsync_connect()).
 850 |   * @param handle A valid client handle from a successful call to 
 851 |   * MQTTAsync_create(). 
 852 |   * @param options The client delays disconnection for up to this time (in 
 853 |   * milliseconds) in order to allow in-flight message transfers to complete.
 854 |   * @return ::MQTTASYNC_SUCCESS if the client successfully disconnects from 
 855 |   * the server. An error code is returned if the client was unable to disconnect
 856 |   * from the server
 857 |   */
 858 | DLLExport int MQTTAsync_disconnect(MQTTAsync handle, const MQTTAsync_disconnectOptions* options);
 859 | 
 860 | 
 861 | /**
 862 |   * This function allows the client application to test whether or not a
 863 |   * client is currently connected to the MQTT server.
 864 |   * @param handle A valid client handle from a successful call to 
 865 |   * MQTTAsync_create(). 
 866 |   * @return Boolean true if the client is connected, otherwise false.
 867 |   */
 868 | DLLExport int MQTTAsync_isConnected(MQTTAsync handle);
 869 | 
 870 | 
 871 | /**
 872 |   * This function attempts to subscribe a client to a single topic, which may 
 873 |   * contain wildcards (see @ref wildcard). This call also specifies the 
 874 |   * @ref qos requested for the subscription
 875 |   * (see also MQTTAsync_subscribeMany()).
 876 |   * @param handle A valid client handle from a successful call to 
 877 |   * MQTTAsync_create(). 
 878 |   * @param topic The subscription topic, which may include wildcards.
 879 |   * @param qos The requested quality of service for the subscription.
 880 |   * @param response A pointer to a response options structure. Used to set callback functions.
 881 |   * @return ::MQTTASYNC_SUCCESS if the subscription request is successful. 
 882 |   * An error code is returned if there was a problem registering the 
 883 |   * subscription. 
 884 |   */
 885 | DLLExport int MQTTAsync_subscribe(MQTTAsync handle, const char* topic, int qos, MQTTAsync_responseOptions* response);
 886 | 
 887 | 
 888 | /**
 889 |   * This function attempts to subscribe a client to a list of topics, which may
 890 |   * contain wildcards (see @ref wildcard). This call also specifies the 
 891 |   * @ref qos requested for each topic (see also MQTTAsync_subscribe()). 
 892 |   * @param handle A valid client handle from a successful call to 
 893 |   * MQTTAsync_create(). 
 894 |   * @param count The number of topics for which the client is requesting 
 895 |   * subscriptions.
 896 |   * @param topic An array (of length <i>count</i>) of pointers to 
 897 |   * topics, each of which may include wildcards.
 898 |   * @param qos An array (of length <i>count</i>) of @ref qos
 899 |   * values. qos[n] is the requested QoS for topic[n].
 900 |   * @param response A pointer to a response options structure. Used to set callback functions.
 901 |   * @return ::MQTTASYNC_SUCCESS if the subscription request is successful. 
 902 |   * An error code is returned if there was a problem registering the 
 903 |   * subscriptions. 
 904 |   */
 905 | DLLExport int MQTTAsync_subscribeMany(MQTTAsync handle, int count, char* const* topic, int* qos, MQTTAsync_responseOptions* response);
 906 | 
 907 | /** 
 908 |   * This function attempts to remove an existing subscription made by the 
 909 |   * specified client.
 910 |   * @param handle A valid client handle from a successful call to 
 911 |   * MQTTAsync_create(). 
 912 |   * @param topic The topic for the subscription to be removed, which may 
 913 |   * include wildcards (see @ref wildcard).
 914 |   * @param response A pointer to a response options structure. Used to set callback functions.
 915 |   * @return ::MQTTASYNC_SUCCESS if the subscription is removed. 
 916 |   * An error code is returned if there was a problem removing the 
 917 |   * subscription. 
 918 |   */
 919 | DLLExport int MQTTAsync_unsubscribe(MQTTAsync handle, const char* topic, MQTTAsync_responseOptions* response);
 920 | 
 921 | /** 
 922 |   * This function attempts to remove existing subscriptions to a list of topics
 923 |   * made by the specified client.
 924 |   * @param handle A valid client handle from a successful call to 
 925 |   * MQTTAsync_create(). 
 926 |   * @param count The number subscriptions to be removed.
 927 |   * @param topic An array (of length <i>count</i>) of pointers to the topics of
 928 |   * the subscriptions to be removed, each of which may include wildcards.
 929 |   * @param response A pointer to a response options structure. Used to set callback functions.
 930 |   * @return ::MQTTASYNC_SUCCESS if the subscriptions are removed. 
 931 |   * An error code is returned if there was a problem removing the subscriptions.
 932 |   */
 933 | DLLExport int MQTTAsync_unsubscribeMany(MQTTAsync handle, int count, char* const* topic, MQTTAsync_responseOptions* response);
 934 | 
 935 | 
 936 | /** 
 937 |   * This function attempts to publish a message to a given topic (see also
 938 |   * ::MQTTAsync_sendMessage()). An ::MQTTAsync_token is issued when 
 939 |   * this function returns successfully. If the client application needs to 
 940 |   * test for successful delivery of messages, a callback should be set  
 941 |   * (see ::MQTTAsync_onSuccess() and ::MQTTAsync_deliveryComplete()).
 942 |   * @param handle A valid client handle from a successful call to 
 943 |   * MQTTAsync_create(). 
 944 |   * @param destinationName The topic associated with this message.
 945 |   * @param payloadlen The length of the payload in bytes.
 946 |   * @param payload A pointer to the byte array payload of the message.
 947 |   * @param qos The @ref qos of the message.
 948 |   * @param retained The retained flag for the message.
 949 |   * @param response A pointer to an ::MQTTAsync_responseOptions structure. Used to set callback functions.
 950 |   * This is optional and can be set to NULL.
 951 |   * @return ::MQTTASYNC_SUCCESS if the message is accepted for publication. 
 952 |   * An error code is returned if there was a problem accepting the message.
 953 |   */
 954 | DLLExport int MQTTAsync_send(MQTTAsync handle, const char* destinationName, int payloadlen, void* payload, int qos, int retained,
 955 | 																 MQTTAsync_responseOptions* response);
 956 | 
 957 | 
 958 | /** 
 959 |   * This function attempts to publish a message to a given topic (see also
 960 |   * MQTTAsync_publish()). An ::MQTTAsync_token is issued when 
 961 |   * this function returns successfully. If the client application needs to 
 962 |   * test for successful delivery of messages, a callback should be set  
 963 |   * (see ::MQTTAsync_onSuccess() and ::MQTTAsync_deliveryComplete()).
 964 |   * @param handle A valid client handle from a successful call to 
 965 |   * MQTTAsync_create(). 
 966 |   * @param destinationName The topic associated with this message.
 967 |   * @param msg A pointer to a valid MQTTAsync_message structure containing 
 968 |   * the payload and attributes of the message to be published.
 969 |   * @param response A pointer to an ::MQTTAsync_responseOptions structure. Used to set callback functions.
 970 |   * @return ::MQTTASYNC_SUCCESS if the message is accepted for publication. 
 971 |   * An error code is returned if there was a problem accepting the message.
 972 |   */
 973 | DLLExport int MQTTAsync_sendMessage(MQTTAsync handle, const char* destinationName, const MQTTAsync_message* msg, MQTTAsync_responseOptions* response);
 974 | 
 975 | 
 976 | /**
 977 |   * This function sets a pointer to an array of tokens for 
 978 |   * messages that are currently in-flight (pending completion). 
 979 |   *
 980 |   * <b>Important note:</b> The memory used to hold the array of tokens is 
 981 |   * malloc()'d in this function. The client application is responsible for 
 982 |   * freeing this memory when it is no longer required.
 983 |   * @param handle A valid client handle from a successful call to 
 984 |   * MQTTAsync_create(). 
 985 |   * @param tokens The address of a pointer to an ::MQTTAsync_token. 
 986 |   * When the function returns successfully, the pointer is set to point to an 
 987 |   * array of tokens representing messages pending completion. The last member of
 988 |   * the array is set to -1 to indicate there are no more tokens. If no tokens
 989 |   * are pending, the pointer is set to NULL.
 990 |   * @return ::MQTTASYNC_SUCCESS if the function returns successfully.
 991 |   * An error code is returned if there was a problem obtaining the list of
 992 |   * pending tokens.
 993 |   */
 994 | DLLExport int MQTTAsync_getPendingTokens(MQTTAsync handle, MQTTAsync_token **tokens);
 995 | 
 996 | /**
 997 |  * Tests whether a request corresponding to a token is complete.
 998 |  *
 999 |  * @param handle A valid client handle from a successful call to
1000 |  * MQTTAsync_create().
1001 |  * @param token An ::MQTTAsync_token associated with a request.
1002 |  * @return 1 if the request has been completed, 0 if not.
1003 |  */
1004 | #define MQTTASYNC_TRUE 1
1005 | DLLExport int MQTTAsync_isComplete(MQTTAsync handle, MQTTAsync_token token);
1006 | 
1007 | 
1008 | /**
1009 |  * Waits for a request corresponding to a token to complete.
1010 |  *
1011 |  * @param handle A valid client handle from a successful call to
1012 |  * MQTTAsync_create().
1013 |  * @param token An ::MQTTAsync_token associated with a request.
1014 |  * @param timeout the maximum time to wait for completion, in milliseconds
1015 |  * @return ::MQTTASYNC_SUCCESS if the request has been completed in the time allocated,
1016 |  *  ::MQTTASYNC_FAILURE if not.
1017 |  */
1018 | DLLExport int MQTTAsync_waitForCompletion(MQTTAsync handle, MQTTAsync_token token, unsigned long timeout);
1019 | 
1020 | 
1021 | /**
1022 |   * This function frees memory allocated to an MQTT message, including the 
1023 |   * additional memory allocated to the message payload. The client application
1024 |   * calls this function when the message has been fully processed. <b>Important 
1025 |   * note:</b> This function does not free the memory allocated to a message 
1026 |   * topic string. It is the responsibility of the client application to free 
1027 |   * this memory using the MQTTAsync_free() library function.
1028 |   * @param msg The address of a pointer to the ::MQTTAsync_message structure 
1029 |   * to be freed.
1030 |   */
1031 | DLLExport void MQTTAsync_freeMessage(MQTTAsync_message** msg);
1032 | 
1033 | /**
1034 |   * This function frees memory allocated by the MQTT C client library, especially the
1035 |   * topic name. This is needed on Windows when the client libary and application
1036 |   * program have been compiled with different versions of the C compiler.  It is
1037 |   * thus good policy to always use this function when freeing any MQTT C client-
1038 |   * allocated memory.
1039 |   * @param ptr The pointer to the client library storage to be freed.
1040 |   */
1041 | DLLExport void MQTTAsync_free(void* ptr);
1042 | 
1043 | /** 
1044 |   * This function frees the memory allocated to an MQTT client (see
1045 |   * MQTTAsync_create()). It should be called when the client is no longer 
1046 |   * required.
1047 |   * @param handle A pointer to the handle referring to the ::MQTTAsync 
1048 |   * structure to be freed.
1049 |   */
1050 | DLLExport void MQTTAsync_destroy(MQTTAsync* handle);
1051 | 
1052 | 
1053 | 
1054 | enum MQTTASYNC_TRACE_LEVELS 
1055 | {
1056 | 	MQTTASYNC_TRACE_MAXIMUM = 1,
1057 | 	MQTTASYNC_TRACE_MEDIUM,
1058 | 	MQTTASYNC_TRACE_MINIMUM,
1059 | 	MQTTASYNC_TRACE_PROTOCOL,
1060 | 	MQTTASYNC_TRACE_ERROR,
1061 | 	MQTTASYNC_TRACE_SEVERE,
1062 | 	MQTTASYNC_TRACE_FATAL,
1063 | };
1064 | 
1065 | 
1066 | /** 
1067 |   * This function sets the level of trace information which will be 
1068 |   * returned in the trace callback.
1069 |   * @param level the trace level required 
1070 |   */
1071 | DLLExport void MQTTAsync_setTraceLevel(enum MQTTASYNC_TRACE_LEVELS level);
1072 | 
1073 | 
1074 | /** 
1075 |   * This is a callback function prototype which must be implemented if you want 
1076 |   * to receive trace information.
1077 |   * @param level the trace level of the message returned
1078 |   * @param meesage the trace message.  This is a pointer to a static buffer which
1079 |   * will be overwritten on each call.  You must copy the data if you want to keep
1080 |   * it for later.  
1081 |   */
1082 | typedef void MQTTAsync_traceCallback(enum MQTTASYNC_TRACE_LEVELS level, char* message);
1083 | 
1084 | /** 
1085 |   * This function sets the trace callback if needed.  If set to NULL, 
1086 |   * no trace information will be returned.  The default trace level is 
1087 |   * MQTTASYNC_TRACE_MINIMUM.  
1088 |   * @param callback a pointer to the function which will handle the trace information 
1089 |   */
1090 | DLLExport void MQTTAsync_setTraceCallback(MQTTAsync_traceCallback* callback);
1091 | 
1092 | 
1093 | typedef struct
1094 | {
1095 | 	const char* name;
1096 | 	const char* value;
1097 | } MQTTAsync_nameValue;
1098 | 
1099 | /** 
1100 |   * This function returns version information about the library.    
1101 |   * no trace information will be returned.  The default trace level is 
1102 |   * MQTTASYNC_TRACE_MINIMUM
1103 |   * @return an array of strings describing the library.  The last entry is a NULL pointer. 
1104 |   */
1105 | DLLExport MQTTAsync_nameValue* MQTTAsync_getVersionInfo();
1106 | 
1107 | 
1108 | /**
1109 |   * @cond MQTTAsync_main
1110 |   * @page async Threading 
1111 |   * The client application runs on several threads.
1112 |   * Processing of handshaking and maintaining
1113 |   * the network connection is performed in the background.
1114 |   * This API is thread safe: functions may be called by multiple application
1115 |   * threads.
1116 |   * Notifications of status and message reception are provided to the client
1117 |   * application using callbacks registered with the library by the call to
1118 |   * MQTTAsync_setCallbacks() (see MQTTAsync_messageArrived(), 
1119 |   * MQTTAsync_connectionLost() and MQTTAsync_deliveryComplete()).
1120 |   * In addition, some functions allow success and failure callbacks to be set
1121 |   * for individual requests, in the ::MQTTAsync_responseOptions structure.  Applications
1122 |   * can be written as a chain of callback functions. Note that it is a theoretically
1123 |   * possible but unlikely event, that a success or failure callback could be called
1124 |   * before function requesting the callback has returned.  In this case the token
1125 |   * delivered in the callback would not yet be known to the application program (see
1126 |   * Race condition for MQTTAsync_token in MQTTAsync.c
1127 |   * https://bugs.eclipse.org/bugs/show_bug.cgi?id=444093)
1128 |   *
1129 |   * @page wildcard Subscription wildcards
1130 |   * Every MQTT message includes a topic that classifies it. MQTT servers use 
1131 |   * topics to determine which subscribers should receive messages published to
1132 |   * the server.
1133 |   * 
1134 |   * Consider the server receiving messages from several environmental sensors. 
1135 |   * Each sensor publishes its measurement data as a message with an associated
1136 |   * topic. Subscribing applications need to know which sensor originally 
1137 |   * published each received message. A unique topic is thus used to identify 
1138 |   * each sensor and measurement type. Topics such as SENSOR1TEMP, 
1139 |   * SENSOR1HUMIDITY, SENSOR2TEMP and so on achieve this but are not very 
1140 |   * flexible. If additional sensors are added to the system at a later date, 
1141 |   * subscribing applications must be modified to receive them. 
1142 |   *
1143 |   * To provide more flexibility, MQTT supports a hierarchical topic namespace. 
1144 |   * This allows application designers to organize topics to simplify their 
1145 |   * management. Levels in the hierarchy are delimited by the '/' character, 
1146 |   * such as SENSOR/1/HUMIDITY. Publishers and subscribers use these 
1147 |   * hierarchical topics as already described.
1148 |   *
1149 |   * For subscriptions, two wildcard characters are supported:
1150 |   * <ul>
1151 |   * <li>A '#' character represents a complete sub-tree of the hierarchy and 
1152 |   * thus must be the last character in a subscription topic string, such as 
1153 |   * SENSOR/#. This will match any topic starting with SENSOR/, such as 
1154 |   * SENSOR/1/TEMP and SENSOR/2/HUMIDITY.</li>
1155 |   * <li> A '+' character represents a single level of the hierarchy and is 
1156 |   * used between delimiters. For example, SENSOR/+/TEMP will match 
1157 |   * SENSOR/1/TEMP and SENSOR/2/TEMP.</li>
1158 |   * </ul>
1159 |   * Publishers are not allowed to use the wildcard characters in their topic 
1160 |   * names.
1161 |   *
1162 |   * Deciding on your topic hierarchy is an important step in your system design.
1163 |   *
1164 |   * @page qos Quality of service
1165 |   * The MQTT protocol provides three qualities of service for delivering 
1166 |   * messages between clients and servers: "at most once", "at least once" and 
1167 |   * "exactly once". 
1168 |   *
1169 |   * Quality of service (QoS) is an attribute of an individual message being 
1170 |   * published. An application sets the QoS for a specific message by setting the
1171 |   * MQTTAsync_message.qos field to the required value.
1172 |   *
1173 |   * A subscribing client can set the maximum quality of service a server uses
1174 |   * to send messages that match the client subscriptions. The 
1175 |   * MQTTAsync_subscribe() and MQTTAsync_subscribeMany() functions set this 
1176 |   * maximum. The QoS of a message forwarded to a subscriber thus might be 
1177 |   * different to the QoS given to the message by the original publisher. 
1178 |   * The lower of the two values is used to forward a message.
1179 |   *
1180 |   * The three levels are:
1181 |   *
1182 |   * <b>QoS0, At most once:</b> The message is delivered at most once, or it 
1183 |   * may not be delivered at all. Its delivery across the network is not 
1184 |   * acknowledged. The message is not stored. The message could be lost if the 
1185 |   * client is disconnected, or if the server fails. QoS0 is the fastest mode of 
1186 |   * transfer. It is sometimes called "fire and forget".
1187 |   *
1188 |   * The MQTT protocol does not require servers to forward publications at QoS0 
1189 |   * to a client. If the client is disconnected at the time the server receives
1190 |   * the publication, the publication might be discarded, depending on the 
1191 |   * server implementation.
1192 |   * 
1193 |   * <b>QoS1, At least once:</b> The message is always delivered at least once. 
1194 |   * It might be delivered multiple times if there is a failure before an 
1195 |   * acknowledgment is received by the sender. The message must be stored 
1196 |   * locally at the sender, until the sender receives confirmation that the 
1197 |   * message has been published by the receiver. The message is stored in case 
1198 |   * the message must be sent again.
1199 |   * 
1200 |   * <b>QoS2, Exactly once:</b> The message is always delivered exactly once. 
1201 |   * The message must be stored locally at the sender, until the sender receives
1202 |   * confirmation that the message has been published by the receiver. The 
1203 |   * message is stored in case the message must be sent again. QoS2 is the 
1204 |   * safest, but slowest mode of transfer. A more sophisticated handshaking 
1205 |   * and acknowledgement sequence is used than for QoS1 to ensure no duplication
1206 |   * of messages occurs.
1207 |   
1208 |  
1209 |   * @page publish Publication example
1210 | @code
1211 | #include "stdio.h"
1212 | #include "stdlib.h"
1213 | #include "string.h"
1214 | #include "MQTTAsync.h"
1215 | 
1216 | #define ADDRESS     "tcp://localhost:1883"
1217 | #define CLIENTID    "ExampleClientPub"
1218 | #define TOPIC       "MQTT Examples"
1219 | #define PAYLOAD     "Hello World!"
1220 | #define QOS         1
1221 | #define TIMEOUT     10000L
1222 | 
1223 | volatile MQTTAsync_token deliveredtoken;
1224 | 
1225 | int finished = 0;
1226 | 
1227 | void connlost(void *context, char *cause)
1228 | {
1229 | 	MQTTAsync client = (MQTTAsync)context;
1230 | 	MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
1231 | 	int rc;
1232 | 
1233 | 	printf("\nConnection lost\n");
1234 | 	printf("     cause: %s\n", cause);
1235 | 
1236 | 	printf("Reconnecting\n");
1237 | 	conn_opts.keepAliveInterval = 20;
1238 | 	conn_opts.cleansession = 1;
1239 | 	if ((rc = MQTTAsync_connect(client, &conn_opts)) != MQTTASYNC_SUCCESS)
1240 | 	{
1241 | 		printf("Failed to start connect, return code %d\n", rc);
1242 |  		finished = 1;
1243 | 	}
1244 | }
1245 | 
1246 | 
1247 | void onDisconnect(void* context, MQTTAsync_successData* response)
1248 | {
1249 | 	printf("Successful disconnection\n");
1250 | 	finished = 1;
1251 | }
1252 | 
1253 | 
1254 | void onSend(void* context, MQTTAsync_successData* response)
1255 | {
1256 | 	MQTTAsync client = (MQTTAsync)context;
1257 | 	MQTTAsync_disconnectOptions opts = MQTTAsync_disconnectOptions_initializer;
1258 | 	int rc;
1259 | 
1260 | 	printf("Message with token value %d delivery confirmed\n", response->token);
1261 | 
1262 | 	opts.onSuccess = onDisconnect;
1263 | 	opts.context = client;
1264 | 
1265 | 	if ((rc = MQTTAsync_disconnect(client, &opts)) != MQTTASYNC_SUCCESS)
1266 | 	{
1267 | 		printf("Failed to start sendMessage, return code %d\n", rc);
1268 | 		exit(-1);	
1269 | 	}
1270 | }
1271 | 
1272 | 
1273 | void onConnectFailure(void* context, MQTTAsync_failureData* response)
1274 | {
1275 | 	printf("Connect failed, rc %d\n", response ? response->code : 0);
1276 | 	finished = 1;
1277 | }
1278 | 
1279 | 
1280 | void onConnect(void* context, MQTTAsync_successData* response)
1281 | {
1282 | 	MQTTAsync client = (MQTTAsync)context;
1283 | 	MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
1284 | 	MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
1285 | 	int rc;
1286 | 
1287 | 	printf("Successful connection\n");
1288 | 	
1289 | 	opts.onSuccess = onSend;
1290 | 	opts.context = client;
1291 | 
1292 | 	pubmsg.payload = PAYLOAD;
1293 | 	pubmsg.payloadlen = strlen(PAYLOAD);
1294 | 	pubmsg.qos = QOS;
1295 | 	pubmsg.retained = 0;
1296 | 	deliveredtoken = 0;
1297 | 
1298 | 	if ((rc = MQTTAsync_sendMessage(client, TOPIC, &pubmsg, &opts)) != MQTTASYNC_SUCCESS)
1299 | 	{
1300 | 		printf("Failed to start sendMessage, return code %d\n", rc);
1301 |  		exit(-1);	
1302 | 	}
1303 | }
1304 | 
1305 | 
1306 | int main(int argc, char* argv[])
1307 | {
1308 | 	MQTTAsync client;
1309 | 	MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
1310 | 	MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
1311 | 	MQTTAsync_token token;
1312 | 	int rc;
1313 | 
1314 | 	MQTTAsync_create(&client, ADDRESS, CLIENTID, MQTTCLIENT_PERSISTENCE_NONE, NULL);
1315 | 
1316 | 	MQTTAsync_setCallbacks(client, NULL, connlost, NULL, NULL);
1317 | 
1318 | 	conn_opts.keepAliveInterval = 20;
1319 | 	conn_opts.cleansession = 1;
1320 | 	conn_opts.onSuccess = onConnect;
1321 | 	conn_opts.onFailure = onConnectFailure;
1322 | 	conn_opts.context = client;
1323 | 	if ((rc = MQTTAsync_connect(client, &conn_opts)) != MQTTASYNC_SUCCESS)
1324 | 	{
1325 | 		printf("Failed to start connect, return code %d\n", rc);
1326 | 		exit(-1);	
1327 | 	}
1328 | 
1329 | 	printf("Waiting for publication of %s\n"
1330 |          "on topic %s for client with ClientID: %s\n",
1331 |          PAYLOAD, TOPIC, CLIENTID);
1332 | 	while (!finished)
1333 | 		#if defined(WIN32) || defined(WIN64)
1334 | 			Sleep(100);
1335 | 		#else
1336 | 			usleep(10000L);
1337 | 		#endif
1338 | 
1339 | 	MQTTAsync_destroy(&client);
1340 |  	return rc;
1341 | }
1342 |   
1343 |   * @endcode
1344 |   * @page subscribe Subscription example
1345 | @code
1346 | #include "stdio.h"
1347 | #include "stdlib.h"
1348 | #include "string.h"
1349 | #include "MQTTAsync.h"
1350 | 
1351 | #define ADDRESS     "tcp://localhost:1883"
1352 | #define CLIENTID    "ExampleClientSub"
1353 | #define TOPIC       "MQTT Examples"
1354 | #define PAYLOAD     "Hello World!"
1355 | #define QOS         1
1356 | #define TIMEOUT     10000L
1357 | 
1358 | volatile MQTTAsync_token deliveredtoken;
1359 | 
1360 | int disc_finished = 0;
1361 | int subscribed = 0;
1362 | int finished = 0;
1363 | 
1364 | void connlost(void *context, char *cause)
1365 | {
1366 | 	MQTTAsync client = (MQTTAsync)context;
1367 | 	MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
1368 | 	int rc;
1369 | 
1370 | 	printf("\nConnection lost\n");
1371 | 	printf("     cause: %s\n", cause);
1372 | 
1373 | 	printf("Reconnecting\n");
1374 | 	conn_opts.keepAliveInterval = 20;
1375 | 	conn_opts.cleansession = 1;
1376 | 	if ((rc = MQTTAsync_connect(client, &conn_opts)) != MQTTASYNC_SUCCESS)
1377 | 	{
1378 | 		printf("Failed to start connect, return code %d\n", rc);
1379 | 	    finished = 1;
1380 | 	}
1381 | }
1382 | 
1383 | 
1384 | int msgarrvd(void *context, char *topicName, int topicLen, MQTTAsync_message *message)
1385 | {
1386 |     int i;
1387 |     char* payloadptr;
1388 | 
1389 |     printf("Message arrived\n");
1390 |     printf("     topic: %s\n", topicName);
1391 |     printf("   message: ");
1392 | 
1393 |     payloadptr = message->payload;
1394 |     for(i=0; i<message->payloadlen; i++)
1395 |     {
1396 |         putchar(*payloadptr++);
1397 |     }
1398 |     putchar('\n');
1399 |     MQTTAsync_freeMessage(&message);
1400 |     MQTTAsync_free(topicName);
1401 |     return 1;
1402 | }
1403 | 
1404 | 
1405 | void onDisconnect(void* context, MQTTAsync_successData* response)
1406 | {
1407 | 	printf("Successful disconnection\n");
1408 | 	disc_finished = 1;
1409 | }
1410 | 
1411 | 
1412 | void onSubscribe(void* context, MQTTAsync_successData* response)
1413 | {
1414 | 	printf("Subscribe succeeded\n");
1415 | 	subscribed = 1;
1416 | }
1417 | 
1418 | void onSubscribeFailure(void* context, MQTTAsync_failureData* response)
1419 | {
1420 | 	printf("Subscribe failed, rc %d\n", response ? response->code : 0);
1421 | 	finished = 1;
1422 | }
1423 | 
1424 | 
1425 | void onConnectFailure(void* context, MQTTAsync_failureData* response)
1426 | {
1427 | 	printf("Connect failed, rc %d\n", response ? response->code : 0);
1428 | 	finished = 1;
1429 | }
1430 | 
1431 | 
1432 | void onConnect(void* context, MQTTAsync_successData* response)
1433 | {
1434 | 	MQTTAsync client = (MQTTAsync)context;
1435 | 	MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
1436 | 	MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
1437 | 	int rc;
1438 | 
1439 | 	printf("Successful connection\n");
1440 | 
1441 | 	printf("Subscribing to topic %s\nfor client %s using QoS%d\n\n"
1442 |            "Press Q<Enter> to quit\n\n", TOPIC, CLIENTID, QOS);
1443 | 	opts.onSuccess = onSubscribe;
1444 | 	opts.onFailure = onSubscribeFailure;
1445 | 	opts.context = client;
1446 | 
1447 | 	deliveredtoken = 0;
1448 | 
1449 | 	if ((rc = MQTTAsync_subscribe(client, TOPIC, QOS, &opts)) != MQTTASYNC_SUCCESS)
1450 | 	{
1451 | 		printf("Failed to start subscribe, return code %d\n", rc);
1452 | 		exit(-1);	
1453 | 	}
1454 | }
1455 | 
1456 | 
1457 | int main(int argc, char* argv[])
1458 | {
1459 | 	MQTTAsync client;
1460 | 	MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
1461 | 	MQTTAsync_disconnectOptions disc_opts = MQTTAsync_disconnectOptions_initializer;
1462 | 	MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
1463 | 	MQTTAsync_token token;
1464 | 	int rc;
1465 | 	int ch;
1466 | 
1467 | 	MQTTAsync_create(&client, ADDRESS, CLIENTID, MQTTCLIENT_PERSISTENCE_NONE, NULL);
1468 | 
1469 | 	MQTTAsync_setCallbacks(client, NULL, connlost, msgarrvd, NULL);
1470 | 
1471 | 	conn_opts.keepAliveInterval = 20;
1472 | 	conn_opts.cleansession = 1;
1473 | 	conn_opts.onSuccess = onConnect;
1474 | 	conn_opts.onFailure = onConnectFailure;
1475 | 	conn_opts.context = client;
1476 | 	if ((rc = MQTTAsync_connect(client, &conn_opts)) != MQTTASYNC_SUCCESS)
1477 | 	{
1478 | 		printf("Failed to start connect, return code %d\n", rc);
1479 | 		exit(-1);	
1480 | 	}
1481 | 
1482 | 	while	(!subscribed)
1483 | 		#if defined(WIN32) || defined(WIN64)
1484 | 			Sleep(100);
1485 | 		#else
1486 | 			usleep(10000L);
1487 | 		#endif
1488 | 
1489 | 	if (finished)
1490 | 		goto exit;
1491 | 
1492 | 	do 
1493 | 	{
1494 | 		ch = getchar();
1495 | 	} while (ch!='Q' && ch != 'q');
1496 | 
1497 | 	disc_opts.onSuccess = onDisconnect;
1498 | 	if ((rc = MQTTAsync_disconnect(client, &disc_opts)) != MQTTASYNC_SUCCESS)
1499 | 	{
1500 | 		printf("Failed to start disconnect, return code %d\n", rc);
1501 | 		exit(-1);	
1502 | 	}
1503 |  	while	(!disc_finished)
1504 | 		#if defined(WIN32) || defined(WIN64)
1505 | 			Sleep(100);
1506 | 		#else
1507 | 			usleep(10000L);
1508 | 		#endif
1509 | 
1510 | exit:
1511 | 	MQTTAsync_destroy(&client);
1512 |  	return rc;
1513 | }
1514 |               
1515 |   * @endcode
1516 | * @page tracing Tracing
1517 |   * 
1518 |   * Runtime tracing can be controlled by environment variables or API calls.
1519 |   *
1520 |   * #### Environment variables
1521 |   *
1522 |   * Tracing is switched on by setting the MQTT_C_CLIENT_TRACE environment variable.  
1523 |   * A value of ON, or stdout, prints to stdout, any other value is interpreted as a file name to use.
1524 |   *
1525 |   * The amount of trace detail is controlled with the MQTT_C_CLIENT_TRACE_LEVEL environment
1526 |   * variable - valid values are ERROR, PROTOCOL, MINIMUM, MEDIUM and MAXIMUM
1527 |   * (from least to most verbose).
1528 |   *
1529 |   * The variable MQTT_C_CLIENT_TRACE_MAX_LINES limits the number of lines of trace that are output
1530 |   * to a file.  Two files are used at most, when they are full, the last one is overwritten with the
1531 |   * new trace entries.  The default size is 1000 lines.
1532 |   *
1533 |   * #### Trace API calls
1534 |   *
1535 |   * MQTTAsync_traceCallback() is used to set a callback function which is called whenever trace
1536 |   * information is available.  This will be the same information as that printed if the
1537 |   * environment variables were used to control the trace.  
1538 |   *
1539 |   * The MQTTAsync_setTraceLevel() calls is used to set the maximum level of trace entries that will be
1540 |   * passed to the callback function.  The levels are:
1541 |   * 1. ::MQTTASYNC_TRACE_MAXIMUM
1542 |   * 2. ::MQTTASYNC_TRACE_MEDIUM
1543 |   * 3. ::MQTTASYNC_TRACE_MINIMUM
1544 |   * 4. ::MQTTASYNC_TRACE_PROTOCOL
1545 |   * 5. ::MQTTASYNC_TRACE_ERROR
1546 |   * 6. ::MQTTASYNC_TRACE_SEVERE
1547 |   * 7. ::MQTTASYNC_TRACE_FATAL
1548 |   *
1549 |   * Selecting ::MQTTASYNC_TRACE_MAXIMUM will cause all trace entries at all levels to be returned. 
1550 |   * Choosing ::MQTTASYNC_TRACE_ERROR will cause ERROR, SEVERE and FATAL trace entries to be returned
1551 |   * to the callback function.
1552 |   *
1553 |   * ### MQTT Packet Tracing
1554 |   * 
1555 |   * A feature that can be very useful is printing the MQTT packets that are sent and received.  To 
1556 |   * achieve this, use the following environment variable settings:
1557 |   * @code
1558 |     MQTT_C_CLIENT_TRACE=ON
1559 |     MQTT_C_CLIENT_TRACE_LEVEL=PROTOCOL
1560 |   * @endcode
1561 |   * The output you should see looks like this:
1562 |   * @code
1563 |     20130528 155936.813 3 stdout-subscriber -> CONNECT cleansession: 1 (0)
1564 |     20130528 155936.813 3 stdout-subscriber <- CONNACK rc: 0
1565 |     20130528 155936.813 3 stdout-subscriber -> SUBSCRIBE msgid: 1 (0)
1566 |     20130528 155936.813 3 stdout-subscriber <- SUBACK msgid: 1
1567 |     20130528 155941.818 3 stdout-subscriber -> DISCONNECT (0)
1568 |   * @endcode
1569 |   * where the fields are:
1570 |   * 1. date
1571 |   * 2. time
1572 |   * 3. socket number
1573 |   * 4. client id
1574 |   * 5. direction (-> from client to server, <- from server to client)
1575 |   * 6. packet details
1576 |   *
1577 |   * ### Default Level Tracing
1578 |   * 
1579 |   * This is an extract of a default level trace of a call to connect:
1580 |   * @code
1581 |     19700101 010000.000 (1152206656) (0)> MQTTClient_connect:893
1582 |     19700101 010000.000 (1152206656)  (1)> MQTTClient_connectURI:716
1583 |     20130528 160447.479 Connecting to serverURI localhost:1883
1584 |     20130528 160447.479 (1152206656)   (2)> MQTTProtocol_connect:98
1585 |     20130528 160447.479 (1152206656)    (3)> MQTTProtocol_addressPort:48
1586 |     20130528 160447.479 (1152206656)    (3)< MQTTProtocol_addressPort:73
1587 |     20130528 160447.479 (1152206656)    (3)> Socket_new:599
1588 |     20130528 160447.479 New socket 4 for localhost, port 1883
1589 |     20130528 160447.479 (1152206656)     (4)> Socket_addSocket:163
1590 |     20130528 160447.479 (1152206656)      (5)> Socket_setnonblocking:73
1591 |     20130528 160447.479 (1152206656)      (5)< Socket_setnonblocking:78 (0)
1592 |     20130528 160447.479 (1152206656)     (4)< Socket_addSocket:176 (0)
1593 |     20130528 160447.479 (1152206656)     (4)> Socket_error:95
1594 |     20130528 160447.479 (1152206656)     (4)< Socket_error:104 (115)
1595 |     20130528 160447.479 Connect pending
1596 |     20130528 160447.479 (1152206656)    (3)< Socket_new:683 (115)
1597 |     20130528 160447.479 (1152206656)   (2)< MQTTProtocol_connect:131 (115)
1598 |   * @endcode
1599 |   * where the fields are:
1600 |   * 1. date
1601 |   * 2. time
1602 |   * 3. thread id
1603 |   * 4. function nesting level
1604 |   * 5. function entry (>) or exit (<)
1605 |   * 6. function name : line of source code file
1606 |   * 7. return value (if there is one)
1607 |   *
1608 |   * ### Memory Allocation Tracing
1609 |   * 
1610 |   * Setting the trace level to maximum causes memory allocations and frees to be traced along with 
1611 |   * the default trace entries, with messages like the following:
1612 |   * @code
1613 |     20130528 161819.657 Allocating 16 bytes in heap at file /home/icraggs/workspaces/mqrtc/mqttv3c/src/MQTTPacket.c line 177 ptr 0x179f930
1614 | 
1615 |     20130528 161819.657 Freeing 16 bytes in heap at file /home/icraggs/workspaces/mqrtc/mqttv3c/src/MQTTPacket.c line 201, heap use now 896 bytes
1616 |   * @endcode
1617 |   * When the last MQTT client object is destroyed, if the trace is being recorded 
1618 |   * and all memory allocated by the client library has not been freed, an error message will be
1619 |   * written to the trace.  This can help with fixing memory leaks.  The message will look like this:
1620 |   * @code
1621 |     20130528 163909.208 Some memory not freed at shutdown, possible memory leak
1622 |     20130528 163909.208 Heap scan start, total 880 bytes
1623 |     20130528 163909.208 Heap element size 32, line 354, file /home/icraggs/workspaces/mqrtc/mqttv3c/src/MQTTPacket.c, ptr 0x260cb00
1624 |     20130528 163909.208   Content           
1625 |     20130528 163909.209 Heap scan end
1626 |   * @endcode
1627 |   * @endcond
1628 |   */
1629 | 
1630 | 
1631 | #endif
1632 | 
1633 | #ifdef __cplusplus
1634 |      }
1635 | #endif
1636 | 


--------------------------------------------------------------------------------