MQTT send message from main thread

Question

I have simple MQTT subscriber implemented in MqttHelper class that works fine and receives subscriptions. But how I should deal when I need to send message to server from main program. I have method publish that works fine from IMqttActionListener but how to send text from main program on button pressed event?

package com.kkk.mqtt.helpers;

import android.content.Context;
import android.util.Log;

import org.eclipse.paho.android.service.MqttAndroidClient;
import org.eclipse.paho.client.mqttv3.DisconnectedBufferOptions;
import org.eclipse.paho.client.mqttv3.IMqttActionListener;
import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.IMqttToken;
import org.eclipse.paho.client.mqttv3.MqttCallbackExtended;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;

import java.io.UnsupportedEncodingException;

public class MqttHelper {
    public MqttAndroidClient mqttAndroidClient;

    final String serverUri = "tcp://tailor.cloudmqtt.com:16424";

    final String clientId = "ExampleAndroidClient";
    public final String subscriptionTopic = "sensor";

    final String username = "xxx";
    final String password = "yyy";



    public MqttHelper(Context context){
        mqttAndroidClient = new MqttAndroidClient(context, serverUri, clientId);

        mqttAndroidClient.setCallback(new MqttCallbackExtended() {
            @Override
            public void connectComplete(boolean b, String s) {
                Log.w("mqtt", s);
            }

            @Override
            public void connectionLost(Throwable throwable) {

            }

            @Override
            public void messageArrived(String topic, MqttMessage mqttMessage) throws Exception {
                Log.w("Mqtt", mqttMessage.toString());
            }

            @Override
            public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {

            }
        });
        connect();
    }

    public void setCallback(MqttCallbackExtended callback) {
        mqttAndroidClient.setCallback(callback);
    }


    public void publish(String topic, String info)
    {


        byte[] encodedInfo = new byte[0];
        try {
            encodedInfo = info.getBytes("UTF-8");
            MqttMessage message = new MqttMessage(encodedInfo);
            mqttAndroidClient.publish(topic, message);
            Log.e ("Mqtt", "publish done");
        } catch (UnsupportedEncodingException | MqttException e) {
            e.printStackTrace();
            Log.e ("Mqtt", e.getMessage());
        }catch (Exception e) {
            Log.e ("Mqtt", "general exception "+e.getMessage());
        }

    }

    private void connect(){
        Log.w("Mqtt", "connect start " );
        MqttConnectOptions mqttConnectOptions = new MqttConnectOptions();
        mqttConnectOptions.setAutomaticReconnect(true);
        mqttConnectOptions.setCleanSession(false);
        mqttConnectOptions.setUserName(username);
        mqttConnectOptions.setPassword(password.toCharArray());

        try {

            mqttAndroidClient.connect(mqttConnectOptions, null, new IMqttActionListener()
            {
                @Override
                public void onSuccess(IMqttToken asyncActionToken) {
                    Log.w("Mqtt", "onSuccess " );
                    DisconnectedBufferOptions disconnectedBufferOptions = new DisconnectedBufferOptions();
                    disconnectedBufferOptions.setBufferEnabled(true);
                    disconnectedBufferOptions.setBufferSize(100);
                    disconnectedBufferOptions.setPersistBuffer(false);
                    disconnectedBufferOptions.setDeleteOldestMessages(false);
                    mqttAndroidClient.setBufferOpts(disconnectedBufferOptions);
                    subscribeToTopic();
                    publish(MqttHelper.this.subscriptionTopic,"information");
                }

                @Override
                public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
                    Log.w("Mqtt", "Failed to connect to: " + serverUri + exception.toString());
                }
            });


        } catch (MqttException ex){
            ex.printStackTrace();
        }
    }


    private void subscribeToTopic() {
        try {
            mqttAndroidClient.subscribe(subscriptionTopic, 0, null, new IMqttActionListener() {
                @Override
                public void onSuccess(IMqttToken asyncActionToken) {
                    Log.w("Mqtt","Subscribed!");
                }

                @Override
                public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
                    Log.w("Mqtt", "Subscribed fail!");
                }
            });

        } catch (MqttException ex) {
            System.err.println("Exception whilst subscribing");
            ex.printStackTrace();
        }
    }
}

Code that starts MQTT subscriber:

private void startMqtt() {
    mqttHelper = new MqttHelper(getApplicationContext());
    mqttHelper.setCallback(new MqttCallbackExtended()
    {
        @Override
        public void connectComplete(boolean b, String s) {
            Log.w("Mqtt", "Connect complete"+ s );
        }

        @Override
        public void connectionLost(Throwable throwable) {
            Log.w("Mqtt", "Connection lost" );
        }

        @Override
        public void messageArrived(String topic, MqttMessage mqttMessage) throws Exception {
            Log.w("Mqtt", mqttMessage.toString());
            dataReceived.setText(mqttMessage.toString());
        }

        @Override
        public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {
            Log.w("Mqtt", "Delivery complete" );

        }
    });
    Log.w("Mqtt", "will publish");


}

Answer 1

Paho does not run on the UI thread, but it may asynchronously call back to the UI thread.

Just let an Activity or Fragment implement the MqttCallbackExtended interface:

public class SomeActivity extends AppCompatActivity implements MqttCallbackExtended { 

    ...

    @Override
    public void connectComplete(boolean reconnect, String serverURI) {
        Log.d("Mqtt", "Connect complete > " + serverURI);
    }

    @Override
    public void connectionLost(Throwable cause) {
        Log.d("Mqtt", "Connection lost");
    }

    @Override
    public void messageArrived(String topic, MqttMessage message) throws Exception {
        Log.d("Mqtt", "Received > " + topic + " > " + message.toString());
    }

    @Override
    public void deliveryComplete(IMqttDeliveryToken token) {
        Log.d("Mqtt", "Delivery complete");
    }
}

And construct the MqttHelper with SomeActivity as it's MqttCallbackExtended listener :

public MqttHelper(Context context, MqttCallbackExtended listener) {
    this.mqttAndroidClient = new MqttAndroidClient(context, serverUri, clientId);
    this.mqttAndroidClient.setCallback(listener);
}

For example:

this.mqttHelper = new MqttHelper(this);
this.mqttHelper.setCallback(this);

this.mqttHelper.publish("Java", "SomeActivity will handle the callbacks.");

Handling these in Application is problematic, because Application has no UI and it's Context has no Theme . But for classes extending Activity , Fragment , DialogFragment , RecyclerView.Adapter , etc. it makes senses to implement the callback interface , when wanting to interact with their UI.

---

For reference, MqttCallbackExtended extends MqttCallback .

Answer 2

Another Solution:

1. Create a MQTTService class that extends android.app.Service .
   Android Service class works in the main thread . So if you want to use another thread , you can use MqttAsyncClient simply.

2. You will receive messages from the broker in another thread automatically (not main thread) in messageArrived() using callback method.
   

3. Pass Data/command from the application UI (Activity-Fragment,...) to the MQTTService by EventBus library simply.

4. Again use the EventBus in the messageArrived() callback method to pass the received data from the broker to the desired section of your application.
   Please note that in this step if your destination is an application UI, you have to use @Subscribe(threadMode = ThreadMode.MAIN) in the destination to get data in the main thread.
   

Sample Code:

public class MQTTService extends Service {

    private MqttAsyncClient mqttClient;
    private String serverURI;

     @Override
    public void onCreate() { 
        //do your initialization here
        serverURI = "tcp://yourBrokerUrlOrIP:yourBrokerPort";
        EventBus.getDefault().register(this);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
      init();
      connect();
    }



    private void init() {
         mqttClient = new MqttAsyncClient(serverURI, yourClientId, new MemoryPersistence())
         mqttClient.setCallback(new MqttCallback() {
            @Override
            public void connectionLost(Throwable cause) {
            }

            @Override
            public void messageArrived(String topic, MqttMessage message) throws Exception {
               //now you will receive messages from the broker in another thread automatically (not UI Thread).
               //You can do your logic here. for example pass the received data to the different sections of the application:
               EventBus.getDefault().post(new YourPOJO(topic, message, ...));
            }

            @Override
            public void deliveryComplete(IMqttDeliveryToken token) {
            }
        });
    }

    private MqttConnectOptions getOptions(){
        MqttConnectOptions options = new MqttConnectOptions();
        options.setKeepAliveInterval(...);
        options.setMqttVersion(MqttConnectOptions.MQTT_VERSION_3_1_1);
        options.setAutomaticReconnect(true);
        options.setCleanSession(false);
        options.setUserName(...);
        options.setPassword(...);
        //options.setWill(...);
        //your other configurations
        return options;
    }

    private void connect() {
        try {
            IMqttToken token = mqttClient.connect(getOptions(), null, new IMqttActionListener() {
                @Override
                public void onSuccess(IMqttToken asyncActionToken) {
                    //do works after successful connection
                }

                @Override
                public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
                }
            });

        } catch (MqttException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onDestroy() {
        EventBus.getDefault().unregister(this);
        mqttClient.close();
        mqttClient.disconnect();
    }

    //this method receives your command from the different application sections
    //you can simply create different "MqttCommandPOJO" classes for different purposes
    @Subscribe
    public void receiveFromApp1(MqttCommandPOJO1 pojo1) {
        //do your logic(1). For example:
        //publish or subscribe something to the broker (QOS=1 is a good choice).
    }

    @Subscribe
    public void receiveFromApp2(MqttCommandPOJO2 pojo2) {
        //do your logic(2). For example:
        //publish or subscribe something to the broker (QOS=1 is a good choice).
    }

}

Now You can simply receive the data passed from the MQTTService in every section of your application.

For example:

public class MainActivity extends AppCompatActivity {
    ...

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void receiveFromMQTTService(YourPojo pojo){
       //Do your logic. For example update the UI.
    }
}

Another links:
General instructions

Best wishes