chatsessionadapter.java

Android平台上即时通讯聊天工具源代码。 支持手机聊天。

        Uri oldChatUri = mChatURI;
        Uri oldMessageUri = mMessageURI;
        init(group);
        copyHistoryMessages(oldParticipant);

        mContentResolver.delete(oldMessageUri, NON_CHAT_MESSAGE_SELECTION, null);
        mContentResolver.delete(oldChatUri, null, null);

        mListenerAdapter.notifyChatSessionConverted();
        mConvertingToGroupChat = false;
    }

    private void copyHistoryMessages(Contact oldParticipant) {
        List<Message> historyMessages = mAdaptee.getHistoryMessages();
        int total = historyMessages.size();
        int start = total > MAX_HISTORY_COPY_COUNT ? total - MAX_HISTORY_COPY_COUNT : 0;
        for (int i = start; i < total; i++) {
            Message msg = historyMessages.get(i);
            boolean incoming = msg.getFrom().equals(oldParticipant.getAddress());
            String contact = incoming ? oldParticipant.getName() : null;
            long time = msg.getDateTime().getTime();
            insertMessageInDb(contact, msg.getBody(), time,
                    incoming ? Im.MessageType.INCOMING : Im.MessageType.OUTGOING);
        }
    }

    void insertOrUpdateChat(String message) {
        ContentValues values = new ContentValues(2);

        values.put(Im.Chats.LAST_MESSAGE_DATE, System.currentTimeMillis());
        values.put(Im.Chats.LAST_UNREAD_MESSAGE, message);
        // ImProvider.insert() will replace the chat if it already exist.
        mContentResolver.insert(mChatURI, values);
    }

    private long insertGroupContactInDb(ChatGroup group) {
        // Insert a record in contacts table
        ContentValues values = new ContentValues(4);
        values.put(Im.Contacts.USERNAME, group.getAddress().getFullName());
        values.put(Im.Contacts.NICKNAME, group.getName());
        values.put(Im.Contacts.CONTACTLIST, ContactListManagerAdapter.FAKE_TEMPORARY_LIST_ID);
        values.put(Im.Contacts.TYPE, Im.Contacts.TYPE_GROUP);

        Uri contactUri = ContentUris.withAppendedId(ContentUris.withAppendedId(
                Im.Contacts.CONTENT_URI, mConnection.mProviderId), mConnection.mAccountId);
        long id = ContentUris.parseId(mContentResolver.insert(contactUri, values));

        ArrayList<ContentValues> memberValues = new ArrayList<ContentValues>();
        Contact self = mConnection.getLoginUser();
        for (Contact member : group.getMembers()) {
            if (!member.equals(self)) { // avoid to insert the user himself
                ContentValues memberValue = new ContentValues(2);
                memberValue.put(Im.GroupMembers.USERNAME,
                        member.getAddress().getFullName());
                memberValue.put(Im.GroupMembers.NICKNAME,
                        member.getName());
                memberValues.add(memberValue);
            }
        }
        if (!memberValues.isEmpty()) {
            ContentValues[] result = new ContentValues[memberValues.size()];
            memberValues.toArray(result);
            Uri memberUri = ContentUris.withAppendedId(Im.GroupMembers.CONTENT_URI, id);
            mContentResolver.bulkInsert(memberUri, result);
        }
        return id;
    }

    void insertGroupMemberInDb(Contact member) {
        ContentValues values1 = new ContentValues(2);
        values1.put(Im.GroupMembers.USERNAME, member.getAddress().getFullName());
        values1.put(Im.GroupMembers.NICKNAME, member.getName());
        ContentValues values = values1;

        long groupId = ContentUris.parseId(mChatURI);
        Uri uri = ContentUris.withAppendedId(Im.GroupMembers.CONTENT_URI, groupId);
        mContentResolver.insert(uri, values);

        insertMessageInDb(member.getName(), null, System.currentTimeMillis(),
                Im.MessageType.PRESENCE_AVAILABLE);
    }

    void deleteGroupMemberInDb(Contact member) {
        String where = Im.GroupMembers.USERNAME + "=?";
        String[] selectionArgs = { member.getAddress().getFullName() };
        long groupId = ContentUris.parseId(mChatURI);
        Uri uri = ContentUris.withAppendedId(Im.GroupMembers.CONTENT_URI, groupId);
        mContentResolver.delete(uri, where, selectionArgs);

        insertMessageInDb(member.getName(), null, System.currentTimeMillis(),
                Im.MessageType.PRESENCE_UNAVAILABLE);
    }

    void insertPresenceUpdatesMsg(String contact, Presence presence) {
        int status = presence.getStatus();

        Integer previousStatus = mContactStatusMap.get(contact);
        if (previousStatus != null && previousStatus == status) {
            // don't insert the presence message if it's the same status
            // with the previous presence update notification
            return;
        }

        mContactStatusMap.put(contact, status);
        int messageType;
        switch (status) {
            case Presence.AVAILABLE:
                messageType = Im.MessageType.PRESENCE_AVAILABLE;
                break;

            case Presence.AWAY:
            case Presence.IDLE:
                messageType = Im.MessageType.PRESENCE_AWAY;
                break;

            case Presence.DO_NOT_DISTURB:
                messageType = Im.MessageType.PRESENCE_DND;
                break;

            default:
                messageType = Im.MessageType.PRESENCE_UNAVAILABLE;
                break;
        }

        if(mIsGroupChat) {
            insertMessageInDb(contact, null, System.currentTimeMillis(), messageType);
        } else {
            insertMessageInDb(null, null, System.currentTimeMillis(), messageType);
        }
    }

    void removeMessageInDb(int type) {
        mContentResolver.delete(mMessageURI, Im.BaseMessageColumns.TYPE + "=?",
                new String[]{Integer.toString(type)});
    }

    Uri insertMessageInDb(String contact, String body, long time, int type) {
        return insertMessageInDb(contact, body, time, type, 0/*No error*/);
    }

    Uri insertMessageInDb(String contact, String body, long time, int type, int errCode) {
        ContentValues values = new ContentValues(mIsGroupChat ? 4 : 3);
        values.put(Im.BaseMessageColumns.BODY, body);
        values.put(Im.BaseMessageColumns.DATE, time);
        values.put(Im.BaseMessageColumns.TYPE, type);
        values.put(Im.BaseMessageColumns.ERROR_CODE, errCode);
        if (mIsGroupChat) {
            values.put(Im.BaseMessageColumns.CONTACT, contact);
        }

        return mContentResolver.insert(mMessageURI, values);
    }

    class ListenerAdapter extends RemoteListenerManager<IChatListener>
            implements MessageListener, GroupMemberListener {

        public void onIncomingMessage(ChatSession ses, final Message msg) {
            String body = msg.getBody();
            String username = msg.getFrom().getFullName();
            String nickname = getNickName(username);
            long time = msg.getDateTime().getTime();
            if(mIsGroupChat) {
                insertOrUpdateChat(nickname + ": " + body);
            } else {
                insertOrUpdateChat(body);
            }
            insertMessageInDb(nickname, body, time, Im.MessageType.INCOMING);
            boolean notified = notifyRemoteListeners(new ListenerInvocation<IChatListener>() {
                public void invoke(IChatListener remoteListener)
                        throws RemoteException {
                    remoteListener.onIncomingMessage(ChatSessionAdapter.this,
                            msg);
                }
            });
            if (!notified) {
                mStatusBarNotifier.notifyChat(mConnection.getProviderId(),
                        mConnection.getAccountId(), getId(), username, nickname, body);
            }
        }

        public void onSendMessageError(ChatSession ses, final Message msg,
                final ImErrorInfo error) {
            insertMessageInDb(null, null, System.currentTimeMillis(),
                    Im.MessageType.OUTGOING, error.getCode());

            notifyRemoteListeners(new ListenerInvocation<IChatListener>() {
                public void invoke(IChatListener remoteListener)
                        throws RemoteException {
                    remoteListener.onSendMessageError(ChatSessionAdapter.this,
                            msg, error);
                }
            });
        }

        public void onMemberJoined(ChatGroup group, final Contact contact) {
            insertGroupMemberInDb(contact);

            notifyRemoteListeners(new ListenerInvocation<IChatListener>() {
                public void invoke(IChatListener remoteListener)
                        throws RemoteException {
                    remoteListener.onContactJoined(ChatSessionAdapter.this,
                            contact);
                }
            });
        }

        public void onMemberLeft(ChatGroup group, final Contact contact) {
            deleteGroupMemberInDb(contact);

            notifyRemoteListeners(new ListenerInvocation<IChatListener>() {
                public void invoke(IChatListener remoteListener)
                        throws RemoteException {
                    remoteListener.onContactLeft(ChatSessionAdapter.this,
                            contact);
                }
            });
        }

        public void onError(ChatGroup group, final ImErrorInfo error) {
            // TODO: insert an error message?
            notifyRemoteListeners(new ListenerInvocation<IChatListener>() {
                public void invoke(IChatListener remoteListener)
                        throws RemoteException {
                    remoteListener.onInviteError(ChatSessionAdapter.this,
                            error);
                }
            });
        }

        public void notifyChatSessionConverted() {
            notifyRemoteListeners(new ListenerInvocation<IChatListener>() {
                public void invoke(IChatListener remoteListener)
                        throws RemoteException {
                    remoteListener.onConvertedToGroupChat(ChatSessionAdapter.this);
                }
            });
        }
    }

    class ChatConvertor implements GroupListener, GroupMemberListener {
        private ChatGroupManager mGroupMgr;
        private String mGroupName;

        public ChatConvertor() {
            mGroupMgr = mConnection.mGroupManager;
        }

        public void convertToGroupChat() {
            mGroupMgr.addGroupListener(this);
            mGroupName = "G" + System.currentTimeMillis();
            mGroupMgr.createChatGroupAsync(mGroupName);
        }

        public void onGroupCreated(ChatGroup group) {
            if (mGroupName.equalsIgnoreCase(group.getName())) {
                mGroupMgr.removeGroupListener(this);
                group.addMemberListener(this);
                mGroupMgr.inviteUserAsync(group, (Contact)mAdaptee.getParticipant());
            }
        }

        public void onMemberJoined(ChatGroup group, Contact contact) {
            if (mAdaptee.getParticipant().equals(contact)) {
                onConvertToGroupChatSuccess(group);
            }

            mContactStatusMap.put(contact.getName(), contact.getPresence().getStatus());
        }

        public void onGroupDeleted(ChatGroup group) {
        }

        public void onGroupError(int errorType, String groupName, ImErrorInfo error) {
        }

        public void onJoinedGroup(ChatGroup group) {
        }

        public void onLeftGroup(ChatGroup group) {
        }

        public void onError(ChatGroup group, ImErrorInfo error) {
        }

        public void onMemberLeft(ChatGroup group, Contact contact) {
            mContactStatusMap.remove(contact.getName());
        }
    }
}