QBMessageStatusesManager

QBMessageStatusesManager.java

package com.quickblox.chat;

import com.quickblox.chat.model.QBChatMarkersExtension;
import com.quickblox.chat.model.QBChatMessage;
import com.quickblox.chat.model.QBChatMessageExtension;
import com.quickblox.chat.utils.Utils;

import org.jivesoftware.smack.PacketListener;
import org.jivesoftware.smack.SmackException;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.filter.PacketFilter;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smackx.chatstates.ChatState;
import org.jivesoftware.smackx.chatstates.ChatStateManager;
import org.jivesoftware.smackx.chatstates.packet.ChatStateExtension;

/**
 * Created by igorkhomenko on 9/4/15.
 */
public class QBMessageStatusesManager extends Manager {

    public QBMessageStatusesManager(XMPPConnection connection) {
        super(connection);


        // filter 'read' statuses
        //
        PacketFilter readPacketsFilter = new PacketFilter(){
            public boolean accept(Packet packet) {
                if(!(packet instanceof Message)){
                    return false;
                }
                Message packetMessage = (Message)packet;
                if(!packetMessage.getType().equals(Message.Type.chat)){
                    return false;
                }

                QBChatMarkersExtension chatMarkersExtension = (QBChatMarkersExtension)packetMessage.getExtension(QBChatMarkersExtension.NAMESPACE);
                if(chatMarkersExtension != null){
                    QBChatMarkersExtension.ChatMarker marker = chatMarkersExtension.getMarker();
                    if(marker == QBChatMarkersExtension.ChatMarker.displayed) {
                        return true;
                    }
                }

                return false;
            }
        };
        connection.addPacketListener(new PacketListener() {
            public void processPacket(Packet packet) {
                processReadPacket(packet);
            }
        }, readPacketsFilter);


        // filter 'delivered' statuses
        //
        PacketFilter deliverdPacketsFilter = new PacketFilter(){
            public boolean accept(Packet packet) {
                if(!(packet instanceof Message)){
                    return false;
                }
                Message packetMessage = (Message)packet;
                if(!packetMessage.getType().equals(Message.Type.chat)){
                    return false;
                }

                QBChatMarkersExtension chatMarkersExtension = (QBChatMarkersExtension)packetMessage.getExtension(QBChatMarkersExtension.NAMESPACE);
                if(chatMarkersExtension != null){
                    QBChatMarkersExtension.ChatMarker marker = chatMarkersExtension.getMarker();
                    if(marker == QBChatMarkersExtension.ChatMarker.received) {
                        return true;
                    }
                }

                return false;
            }
        };
        connection.addPacketListener(new PacketListener() {
            public void processPacket(Packet packet) {
                processDeliveredPacket(packet);
            }
        }, deliverdPacketsFilter);


        // filter 'is typing' status
        //
        PacketFilter isTypingPacketsFilter = new PacketFilter() {
            public boolean accept(Packet packet) {
                if(!(packet instanceof Message)){
                    return false;
                }

                Message packetMessage = (Message)packet;
                if(!packetMessage.getType().equals(Message.Type.chat) && !packetMessage.getType().equals(Message.Type.groupchat)){
                    return false;
                }

                ChatStateExtension chatStateExtension = (ChatStateExtension)packetMessage.getExtension(ChatStateManager.NAMESPACE);
                if (chatStateExtension != null) {
                    String name = chatStateExtension.getElementName();
                    ChatState state = ChatState.valueOf(name);
                    if (state == ChatState.composing) {
                        return true;
                    }
                }

                return false;
            }
        };
        connection.addPacketListener(new PacketListener() {
            public void processPacket(Packet packet) {
                processIsTypingPacket(packet);
            }
        }, isTypingPacketsFilter);


        // filter 'stop typing' status
        //
        PacketFilter stopTypingPacketsFilter = new PacketFilter() {
            public boolean accept(Packet packet) {
                if(!(packet instanceof Message)){
                    return false;
                }

                Message packetMessage = (Message)packet;
                if(!packetMessage.getType().equals(Message.Type.chat) && !packetMessage.getType().equals(Message.Type.groupchat)){
                    return false;
                }

                ChatStateExtension chatStateExtension = (ChatStateExtension)packetMessage.getExtension(ChatStateManager.NAMESPACE);
                if (chatStateExtension != null) {
                    String name = chatStateExtension.getElementName();
                    ChatState state = ChatState.valueOf(name);
                    if (state == ChatState.paused) {
                        return true;
                    }
                }

                return false;
            }
        };
        connection.addPacketListener(new PacketListener() {
            public void processPacket(Packet packet) {
                processStopTypingPacket(packet);
            }
        }, stopTypingPacketsFilter);
    }


    ////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////


    private void processReadPacket(Packet packet){
        QBChatMarkersExtension chatMarkersExtension = (QBChatMarkersExtension)packet.getExtension(QBChatMarkersExtension.NAMESPACE);
        if(chatMarkersExtension != null){
            String messageId = chatMarkersExtension.getMessageId();
        }
    }

    private void processDeliveredPacket(Packet packet){
        QBChatMarkersExtension chatMarkersExtension = (QBChatMarkersExtension)packet.getExtension(QBChatMarkersExtension.NAMESPACE);
        if(chatMarkersExtension != null){
            String messageId = chatMarkersExtension.getMessageId();
        }
    }

    private void processIsTypingPacket(Packet packet){
        Integer userId = Utils.parseUserId(packet.getFrom());
    }

    private void processStopTypingPacket(Packet packet){
        Integer userId = Utils.parseUserId(packet.getFrom());
    }


    ////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////


    // Read statuses
    //
    void sendReadStatus(QBChatMessage originMessage) throws SmackException.NotConnectedException {
        sendReadStatus(originMessage.getSenderId(), originMessage.getId(), originMessage.getDialogId());
    }

    void sendReadStatus(Integer senderId, String originMessageID, String dialogId) throws SmackException.NotConnectedException {
        Message asmackMessage = QBChatMessage.buildDeliveredOrReadStatusMessage(false, senderId, originMessageID, dialogId);
        connection().sendPacket(asmackMessage);
    }


    // Delivered statuses
    //
    void sendDeliveredStatus(Message originMessage) {
        Integer senderId = Utils.parseUserId(originMessage.getFrom());
        //
        String elementName = QBChatMessageExtension.ELEMENT_NAME;
        String namespace = QBChatMessageExtension.NAMESPACE;
        QBChatMessageExtension extension = originMessage.getExtension(elementName, namespace);
        String dialogId = null;
        if(extension != null && extension.getProperties() != null){
            dialogId = extension.getProperties().get(Consts.DIALOG_ID);
        }
        //
        Message asmackMessage = QBChatMessage.buildDeliveredOrReadStatusMessage(true, senderId, originMessage.getPacketID(), dialogId);

        try {
            connection().sendPacket(asmackMessage);
        } catch (SmackException.NotConnectedException e) {
            e.printStackTrace();
        }
    }

    void sendDeliveredStatus(QBChatMessage originMessage) {
        Message asmackMessage = QBChatMessage.buildDeliveredOrReadStatusMessage(true, originMessage.getSenderId(),
                originMessage.getId(), originMessage.getDialogId());

        try {
            connection().sendPacket(asmackMessage);
        } catch (SmackException.NotConnectedException e) {
            e.printStackTrace();
        }
    }


    // Is Typing
    //
    void sendChatState(String to, Message.Type type, ChatState chatState) throws SmackException.NotConnectedException{
        Message message = QBChatMessage.buildTypingStatusMessage(to, type, chatState);
        connection().sendPacket(message);
    }
}