smack 4.2 incoming messages

Question

I can send masseges now and my next step is to receive the incoming messages. i was searching for much methods . Most of them are depracted or not available in my version of smack. im using smack 4.2.0. maybe someone could tell me how and where i could implement a listener who catches all incoming messages ? here my code:

MainActivity.class

package com.example.saddam.xmpp3;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import org.jivesoftware.smack.AbstractXMPPConnection;

import org.jxmpp.stringprep.XmppStringprepException;

public class MainActivity extends AppCompatActivity {
    Button b1;
    TextView chat;
    final  connectXmpp con = new connectXmpp();

    public MainActivity() throws XmppStringprepException {
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {


        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        con.execute();

        b1 = (Button) findViewById(R.id.button);
        chat = (TextView) findViewById(R.id.editText);


        b1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                AbstractXMPPConnection conn=con.getConnection();
                con.sendMessage(conn,chat);


            }
        });


    }
    }

connectXmpp.class

import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.tcp.XMPPTCPConnection;
import org.jivesoftware.smack.tcp.XMPPTCPConnectionConfiguration;
import org.jxmpp.jid.EntityBareJid;
import org.jxmpp.jid.impl.JidCreate;
import org.jxmpp.stringprep.XmppStringprepException;


import java.io.IOException;


/**
 * Created by saddam on 08.07.2017.
 */

public class connectXmpp extends AsyncTask<Void,Void,Void> {
    static AbstractXMPPConnection conn2= null;


    final EntityBareJid jid   = JidCreate.entityBareFrom("hss404@im.koderoot.net");

    public connectXmpp() throws XmppStringprepException {
    }

    @Override
    protected Void doInBackground(Void... voids) {

        XMPPTCPConnectionConfiguration config = null;
        try {
            config = XMPPTCPConnectionConfiguration.builder()
                    .setUsernameAndPassword("username", "password")
                    .setXmppDomain("dismail.de")
                    .setHost("dismail.de")
                    .setPort(5222).setKeystoreType(null)
                    .build();
        } catch (XmppStringprepException e) {
            e.printStackTrace();
        }
        conn2 = new XMPPTCPConnection(config);

        try {
            conn2.connect();
            conn2.login();


        } catch (InterruptedException e1) {
            e1.printStackTrace();
        } catch (IOException e1) {
            e1.printStackTrace();
        } catch (SmackException e1) {
            e1.printStackTrace();
        } catch (XMPPException e1) {
            e1.printStackTrace();
        }




        return null;
    }



    @Override
    protected void onProgressUpdate(Void... values) {
        super.onProgressUpdate(values);
    }

    @Override
    protected void onPostExecute(Void aVoid) {
        super.onPostExecute(aVoid);
    }

    public AbstractXMPPConnection getConnection(){
        return conn2;
    }

    public ChatManager getChatMana(AbstractXMPPConnection c){
       ChatManager chatManager = ChatManager.getInstanceFor(c);
        return chatManager;
    }

    public void sendMessage(final AbstractXMPPConnection c, TextView t){
        ChatManager chatManager = null;

        Message newMessage = null;
        chatManager = ChatManager.getInstanceFor(c);

        try {


            Chat chat = chatManager.chatWith(jid);
            newMessage = new Message();
            newMessage.setBody(t.getText().toString());
            chat.send(newMessage);


        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (SmackException.NotConnectedException e) {
            e.printStackTrace();
        }

    }

}

Answer 1

The way you can listen for incoming messages is like this:

    //Declare your stanza listener
    private MessagePacketListener messagePacketListener;

    //In your cotnructor   
    messagePacketListener = new MessagePacketListener(context);

    //Then in your login method register your stanza listener like this
    public void login() throws SmackInvocationException, XmppStringprepException {
        connect();

        try {
            if (!con.isAuthenticated()) {
                setupOmemo(con);
                ....
                con.addSyncStanzaListener(messagePacketListener, new StanzaTypeFilter(Message.class));
                ....
                initOmemo();
            }
        } catch(Exception e) {
            ....
        }
    }

    //Now you have your MessagePacketListener that process the incoming messages
    public class MessagePacketListener implements StanzaListener{
    private Context context;

    MessagePacketListener(Context context) {
        this.context = context;
    }

    @Override
    public void processStanza(Stanza packet) {
        Message msg = (Message)packet;

        //Message that have body
        if(msg.getBodies().size() > 0){
            //Text message
            //Do something with message msg.getBody()
        }
        else{
            //This must be sth like delivery receipt or Chat state msg
        }
    }
}

Answer 2

In Smack 4.2 you can use the following interface: IncomingChatMessageListener.

Sample code:

ChatManager chatManager = ChatManager.getInstanceFor(mConnection);
chatManager.addIncomingListener(new IncomingChatMessageListener() {
            @Override
            public void newIncomingMessage(EntityBareJid from, Message message, Chat chat) {
                // Your code to handle the incoming message
            }
        });

You also have to add the following statement to your XMPPTCPConnectionConfiguration:

.setSendPresence(true)

If the presence is false or not set, then all your incoming messages will be saved in your Offline message storage and the interface will not be triggered.

Hope this helps.