Connect to Openfire Server (Realtime Chatting) with Notification and Broadcast manager

DcOpenFireService.java

import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.graphics.BitmapFactory;
import android.media.RingtoneManager;
import android.net.Uri;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.support.v4.content.LocalBroadcastManager;
import android.support.v7.app.NotificationCompat;

import org.jivesoftware.smack.packet.Message;

import id.mzennis.chatting.ConversationActivity;
import id.mzennis.chatting.model.Profile;
import id.mzennis.chatting.R;
import id.mzennis.chatting.util.PreferenceHelper;

public class DcOpenFireService extends Service implements DcOpenFireSetting.MessagesListener {

    private PreferenceHelper preferenceHelper;
    private DcOpenFireSetting mSetting;
    private LocalBroadcastManager localBroadcastManager;

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    public void init(String hostName) {
        mSetting = new DcOpenFireSetting();
        mSetting.setHostName(hostName);
        mSetting.init();
        mSetting.setMessagesListener(this);
    }

    @Override
    public void onReceiveMessage(Message message) {
        NotificationManager mNotifyMgr = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
        Uri alarmSound = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);

        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
        Intent result = new Intent(this, ConversationActivity.class);
        result.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        result.putExtra(ConversationActivity.class.getSimpleName() + ".from", message.getFrom());
        result.putExtra(ConversationActivity.class.getSimpleName() + ".message", message.getBody());
        builder.setSmallIcon(R.mipmap.ic_launcher_round)
                .setContentTitle("Pesan Masuk dari " + message.getFrom())
                .setContentText(message.getBody());
        builder.setLargeIcon(BitmapFactory.decodeResource(getResources(),R.mipmap.ic_launcher_round));
        builder.setSound(alarmSound);

        PendingIntent intent = PendingIntent.getActivity(this,
                103, result, PendingIntent.FLAG_UPDATE_CURRENT);

        Intent broadcastIntent = new Intent(ConversationActivity.class.getSimpleName());
        broadcastIntent.putExtra(ConversationActivity.class.getSimpleName() + ".message", message.getBody());
        broadcastIntent.putExtra(ConversationActivity.class.getSimpleName() + ".from", message.getFrom());
        localBroadcastManager.sendBroadcast(broadcastIntent);

        builder.setContentIntent(intent);
        builder.setOngoing(true);
        builder.setVibrate(new long[]{100, 100, 100, 100, 100, 100, 100, 100, 100, 100});
        builder.setAutoCancel(true);

        if (mNotifyMgr != null)
            mNotifyMgr.notify(103, builder.build());
    }

    @Override
    public void onCreate() {
        super.onCreate();
        preferenceHelper = new PreferenceHelper(getApplicationContext());
        localBroadcastManager = LocalBroadcastManager.getInstance(this);
    }

    @Override
    public int onStartCommand(final Intent intent, int flags, int startId) {
        String hostName, message = "", to = "";
        Profile profile = null;
        if (intent != null) {
            to = intent.getStringExtra(DcOpenFireService.class.getSimpleName() + ".to");
            message = intent.getStringExtra(DcOpenFireService.class.getSimpleName() + ".message");
            profile = intent.getParcelableExtra(DcOpenFireService.class.getSimpleName() + ".profile");
        }

        if (preferenceHelper == null)
            preferenceHelper = new PreferenceHelper(DcOpenFireService.this);

        hostName = preferenceHelper.getString(PreferenceHelper.DOMAIN);

        if (mSetting == null)
            init(hostName);

        if (!mSetting.isConnected()) {
            mSetting.connect();
            if (profile == null) {
                if (preferenceHelper == null)
                    preferenceHelper = new PreferenceHelper(DcOpenFireService.this);

                profile = preferenceHelper.getObj(PreferenceHelper.USERDATA, Profile.class);
            }

            if (profile != null)
                mSetting.login(profile.getUsername(), profile.getPassword());
        }

        if (mSetting.isConnected()) {
            if (message != null && !message.isEmpty() && to != null && !to.isEmpty()){
                if (profile != null)
                    mSetting.send(message, to);
            }
            mSetting.receive();
        }

        return Service.START_NOT_STICKY;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        mSetting.disconnect();
    }
}

DcOpenFireSetting.java

import android.content.Context;
import android.content.Intent;
import android.os.StrictMode;
import android.text.TextUtils;

import org.jivesoftware.smack.AbstractXMPPConnection;
import org.jivesoftware.smack.ConnectionConfiguration;
import org.jivesoftware.smack.ReconnectionManager;
import org.jivesoftware.smack.SmackException;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.chat.Chat;
import org.jivesoftware.smack.chat.ChatManager;
import org.jivesoftware.smack.chat.ChatManagerListener;
import org.jivesoftware.smack.chat.ChatMessageListener;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.tcp.XMPPTCPConnection;
import org.jivesoftware.smack.tcp.XMPPTCPConnectionConfiguration;

import java.io.IOException;
import id.mzennis.chatting.model.Profile;

public class DcOpenFireSetting {

    private AbstractXMPPConnection connection;
    private MessagesListener messagesListener;

    private String hostName;

    public DcOpenFireSetting() {
    }

    public void setHostName(String hostName) {
        this.hostName = hostName;
    }

    public void init() {
        XMPPTCPConnectionConfiguration.Builder configBuilder = XMPPTCPConnectionConfiguration.builder();
        configBuilder.setHost(hostName);
        configBuilder.setPort(5222);
        configBuilder.setServiceName(hostName);
        configBuilder.setSecurityMode(ConnectionConfiguration.SecurityMode.disabled);
        configBuilder.setDebuggerEnabled(true);
        configBuilder.setSendPresence(true);

        StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
        StrictMode.setThreadPolicy(policy);
        connection = new XMPPTCPConnection(configBuilder.build());
        ReconnectionManager.getInstanceFor(connection).enableAutomaticReconnection();
    }

    public void connect() {
        try {
            connection.connect();
        } catch (SmackException | IOException | XMPPException e) {
            e.printStackTrace();
        }
    }

    public void disconnect() {
        connection.disconnect();
    }

    public void send(String message, String to) {
        if (!TextUtils.isEmpty(to)) {
            Message msg = new Message(to, Message.Type.chat);
            msg.setBody(message);
            try {
                connection.sendPacket(msg);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void login(String user, String password) {
        try {
            connection.login(user, password);
        } catch (XMPPException | SmackException | IOException e) {
            e.printStackTrace();
        }
    }

    public boolean isConnected() {
        return connection.isConnected() && connection.isAuthenticated();
    }

    public void receive() {
        ChatManager.getInstanceFor(connection).addChatListener(new ChatManagerListener() {
            @Override
            public void chatCreated(Chat chat, boolean createdLocally) {
                chat.addMessageListener(new ChatMessageListener() {
                    @Override
                    public void processMessage(Chat chat, Message message) {
                        if (message != null){
                            if (message.getType() == Message.Type.chat
                                    || message.getType() == Message.Type.normal) {
                                if (message.getBody() != null) {
                                    messagesListener.onReceiveMessage(message);
                                }
                            }
                        }
                    }
                });
            }
        });
    }

    public static void startService(Context context, Profile profile, String message, String to) {
        Intent intent = new Intent(context, DcOpenFireService.class);
        intent.putExtra(DcOpenFireService.class.getSimpleName() + ".message", message);
        intent.putExtra(DcOpenFireService.class.getSimpleName() + ".profile", profile);
        intent.putExtra(DcOpenFireService.class.getSimpleName() + ".to", to);
        context.startService(intent);
    }

    public void setMessagesListener(MessagesListener messagesListener) {
        this.messagesListener = messagesListener;
    }

    public interface MessagesListener {
        void onReceiveMessage(Message message);
    }
}

Profile.java

import android.os.Parcel;
import android.os.Parcelable;

public class Profile implements Parcelable {

    private String username;
    private String password;

    public Profile(String username, String password) {
        this.username = username;
        this.password = password;
    }

    protected Profile(Parcel in) {
        username = in.readString();
        password = in.readString();
    }

    public static final Creator<Profile> CREATOR = new Creator<Profile>() {
        @Override
        public Profile createFromParcel(Parcel in) {
            return new Profile(in);
        }

        @Override
        public Profile[] newArray(int size) {
            return new Profile[size];
        }
    };

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel parcel, int i) {
        parcel.writeString(username);
        parcel.writeString(password);
    }
}