public class ConnectXmpp extends Service {

    private String userName;
    private String passWord;
    private MyXMPP xmpp = new MyXMPP();

    public ConnectXmpp() {
    }

    @Override
    public void onCreate() {
        super.onCreate();

    }

    @Override
    public IBinder onBind(Intent intent) {
        return new LocalBinder<ConnectXmpp>(this);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (intent != null) {
            userName = intent.getStringExtra("user");
            passWord = intent.getStringExtra("pwd");
            xmpp.init("test2", "test2");
            xmpp.connectConnection();
        }

        return 0;
    }

    @Override
    public void onDestroy() {
        xmpp.disconnectConnection();
        super.onDestroy();
    }
}

public class LocalBinder <S> extends Binder {
    private final WeakReference<S> mService;
    public LocalBinder(final S service) {
        mService = new WeakReference<S>(service);
    }
    public S getService() {
        return mService.get();
    }
}

public class MyXMPP {

    private static MyXMPP instance = null;
    private static final String DOMAIN = "192.168.1.176";
    private static final int PORT = 5222;
    private String userName = "test2";
    private String passWord = "test2";

    AbstractXMPPConnection connection;
    ChatManager chatmanager;
    Chat newChat;
    XMPPConnectionListener connectionListener = new   XMPPConnectionListener();
    private boolean connected;
    private boolean isToasted;
    private boolean chat_created;
    private boolean loggedin;

    public interface Implementable {
        public void passData(String text);
    }

    public void setImple(Implementable imple) {
        this.imple = imple;
    }

    Implementable imple;

    private void sendToSomeActivity(String text) {
        if (imple != null) {
            imple.passData(text);
        }
    }

    public void setListener(Implementable im) {
        imple = im;
    }


    public MyXMPP() {
        this.imple=imple;
        XMPPTCPConnectionConfiguration.Builder configBuilder = XMPPTCPConnectionConfiguration.builder();

        configBuilder.setSecurityMode(ConnectionConfiguration.SecurityMode.disabled);
        configBuilder.setResource("someResources");
        configBuilder.setServiceName(DOMAIN);
        configBuilder.setPort(PORT);
        connection = new XMPPTCPConnection(configBuilder.build());
        connection.addConnectionListener(connectionListener);
        chatmanager = ChatManager.getInstanceFor(connection);

        newChat = chatmanager.createChat("test@irynas-macbook-air.local", new ChatMessageListener() {
            public void processMessage(Chat chat, Message message) {
                Log.e("Received message: ", String.valueOf(message));
                sendToSomeActivity(String.valueOf(message.getBody()));
            }
        });


    }

    //Initialize
    public void init(String userId, String pwd) {
        this.userName = userId;
        this.passWord = pwd;

        XMPPTCPConnectionConfiguration.Builder configBuilder = XMPPTCPConnectionConfiguration.builder();    configBuilder.setSecurityMode(ConnectionConfiguration.SecurityMode.disabled);
        configBuilder.setResource("someResources");
        configBuilder.setServiceName(DOMAIN);
        configBuilder.setPort(PORT);
        connection = new XMPPTCPConnection(configBuilder.build());
        connection.addConnectionListener(connectionListener);

    }

    // Disconnect Function
    public void disconnectConnection() {

        new Thread(new Runnable() {
            @Override
            public void run() {
                connection.disconnect();
            }
        }).start();
    }

    public void connectConnection() {
        AsyncTask<Void, Void, Boolean> connectionThread = new AsyncTask<Void, Void, Boolean>() {

            @Override
            protected Boolean doInBackground(Void... arg0) {

                // Create a connection
                try {
                    if( !connection.isConnected()){
                    connection.connect();
                    login();
                    }
                    connected = true;

                } catch (IOException e) {
                } catch (SmackException e) {
                    Log.e("SmackException", e.toString());
                } catch (XMPPException e) {
                } catch (IllegalStateException e) {
                    Log.e("MessagingService", "Already Logged in as " + connection.getUser());
                }


                return null;
            }
        };
        connectionThread.execute();
    }

    public void sendMsg(String message) {
        if (connection.isConnected() == true) {
            chatmanager = ChatManager.getInstanceFor(connection);
            newChat = chatmanager.createChat("test@irynas-macbook-air.local", new ChatMessageListener() {
                public void processMessage(Chat chat, Message message) {
                    Log.e("Received message: ", String.valueOf(message));
                    sendToSomeActivity(String.valueOf(message.getBody()));
                }
            });


            try {
                newChat.sendMessage(message);
            } catch (SmackException.NotConnectedException e) {
                e.printStackTrace();
            }
        }
    }

    public void login() {

        try {
            connection.login(userName, passWord);
        } catch (XMPPException | SmackException | IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
        }
    }

    //Connection Listener to check connection state
    public class XMPPConnectionListener implements ConnectionListener {
        @Override
        public void connected(final XMPPConnection connection) {
            Log.d("xmpp", "Connected!");
            connected = true;
            if (!connection.isAuthenticated()) {
                login();
            }
        }

        @Override
        public void connectionClosed() {
            if (isToasted)
                Log.d("xmpp", "ConnectionCLosed!");
            connected = false;
            chat_created = false;
            loggedin = false;
        }

        @Override
        public void connectionClosedOnError(Exception arg0) {
            if (isToasted)
                Log.d("xmpp", "ConnectionClosedOn Error!");
            connected = false;

            chat_created = false;
            loggedin = false;
        }

        @Override
        public void reconnectingIn(int arg0) {
            Log.d("xmpp", "Reconnectingin " + arg0);
            loggedin = false;
        }

        @Override
        public void reconnectionFailed(Exception arg0) {
            if (isToasted)
                Log.d("xmpp", "ReconnectionFailed!");
            connected = false;

            chat_created = false;
            loggedin = false;
        }

        @Override
        public void reconnectionSuccessful() {
            if (isToasted)
                Log.d("xmpp", "ReconnectionSuccessful");
            connected = true;
            chat_created = false;
            loggedin = false;
        }

        @Override
        public void authenticated(XMPPConnection arg0, boolean arg1) {
            Log.d("xmpp", "Authenticated!");
            loggedin = true;

            chat_created = false;
            new Thread(new Runnable() {

                @Override
                public void run() {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }

                }
            }).start();
        }
    }

    public static MyXMPP getInstance(Implementable imple) {
        if (instance == null) {
            instance = new MyXMPP();
        }
        return instance;
    }
}

public class ConversationActivity extends BaseActivity implements MyXMPP.Implementable, EmojiconsFragment.OnEmojiconBackspaceClickedListener,
        EmojiconGridFragment.OnEmojiconClickedListener {


    @BindView(R.id.btnSend)
    FloatingActionButton btnSend;
    @BindView(R.id.rvChat)
    RecyclerView rvChat;
    MyXMPP myXMPP = new MyXMPP();
    private ChatBubbleAdapter chatBubbleAdapter;
    private ArrayList<ChatMessage> chatMessageList = new ArrayList<>();

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_conversation);
        ButterKnife.bind(this);
        chatBubbleAdapter = new ChatBubbleAdapter(chatMessageList, new OnItemClickListenerMessage() {
            @Override
            public void onItemClick(ChatMessage chatMessage) {
            }
        });

        RecyclerView.LayoutManager mLayoutManager = new LinearLayoutManager(getApplicationContext());
        rvChat.setLayoutManager(mLayoutManager);
        rvChat.setAdapter(chatBubbleAdapter);
        chatBubbleAdapter.notifyDataSetChanged();

        myXMPP.setImple(this);
        myXMPP.connectConnection();

    }

    @OnClick(R.id.btnSend)
    public void send(View view) {
        String message = etMessage.getEditableText().toString();
        sendTextMessage(message, true);
    }


    public  void sendTextMessage(String message, boolean userMessage) {

        if (!message.equalsIgnoreCase("")) {
            final ChatMessage chatMessage = new ChatMessage("Adam", "Jhon",
                    message, "", true);
            chatMessage.setMsgID();
            chatMessage.body = message;
            chatMessage.Date = "2016.11.02";
            chatMessage.Time = "17:15";

            if (userMessage == true) {
                chatMessage.isMine = true;
                myXMPP.sendMsg(message);
            } else {
                chatMessage.isMine = false;

            }
            etMessage.setText("");
            chatMessageList.add(chatMessage);
            chatBubbleAdapter.notifyDataSetChanged();
            rvChat.scrollToPosition(chatMessageList.size()-1);

        }
    }


    @Override
    public void passData(final String text) {

        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                sendTextMessage(text, false);
            }
        });
    }
}

chatmanager = ChatManager.getInstanceFor(connection);

            final ChatMessageListener messageListener = new ChatMessageListener() {
                @Override
                public void processMessage(Chat chat, Message message) {
                    Log.e("Received message: ", String.valueOf(message));
                }
            };

           ChatManagerListener chatManagerListener = new ChatManagerListener() {
                @Override
                public void chatCreated(Chat chat, boolean createdLocally) {
                    chat.addMessageListener(messageListener);
                }
            };
            chatmanager.addChatListener(chatManagerListener);