impschatgroupmanager.java

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

/*
 * Copyright (C) 2007 Esmertec AG.
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.im.imps;

import java.util.ArrayList;

import com.android.im.engine.Address;
import com.android.im.engine.ChatGroup;
import com.android.im.engine.ChatGroupManager;
import com.android.im.engine.Contact;
import com.android.im.engine.GroupListener;
import com.android.im.engine.GroupMemberListener;
import com.android.im.engine.Invitation;

/**
 * The implementation of ChatGroupManager with IMPS protocol.
 */
public class ImpsChatGroupManager extends ChatGroupManager implements
        ServerTransactionListener {
    private ImpsConnection mConnection;
    private ImpsTransactionManager mTransactionManager;

    ImpsChatGroupManager(ImpsConnection connection) {
        mConnection = connection;

        mTransactionManager = connection.getTransactionManager();
        mTransactionManager.setTransactionListener(ImpsTags.GroupChangeNotice, this);
        mTransactionManager.setTransactionListener(ImpsTags.LeaveGroup_Response, this);
        mTransactionManager.setTransactionListener(ImpsTags.InviteUser_Request, this);
        mTransactionManager.setTransactionListener(ImpsTags.Invite_Response, this);
    }

    @Override
    protected void addGroupMemberAsync(final ChatGroup group, final Contact contact){
        Primitive request = buildAddGroupMemberRequest(group, contact);

        AsyncTransaction tx = new AsyncTransaction(mTransactionManager) {
            @Override
            public void onResponseError(ImpsErrorInfo error) {
                notifyGroupMemberError(group, error);
            }

            @Override
            public void onResponseOk(Primitive response) {
                notifyMemberJoined(group, contact);
            }
        };
        tx.sendRequest(request);
    }

    @Override
    public void createChatGroupAsync(final String name) {
        final ImpsAddress loginUserAddress = mConnection.getSession()
                .getLoginUserAddress();
        final ImpsAddress groupAddress = new ImpsGroupAddress(loginUserAddress, name);

        Primitive primitive = buildCreateGroupRequest(name, groupAddress);

        AsyncTransaction tx = new AsyncTransaction(mTransactionManager) {
            @Override
            public void onResponseError(ImpsErrorInfo error) {
                notifyGroupError(GroupListener.ERROR_CREATING_GROUP, name, error);
            }

            @Override
            public void onResponseOk(Primitive response) {
                // The current user is joined into the group automatically.
                ArrayList<Contact> members = new ArrayList<Contact>();
                members.add(new Contact(loginUserAddress, loginUserAddress
                        .getUser()));

                ChatGroup group = new ChatGroup(groupAddress, name, members,
                        ImpsChatGroupManager.this);
                notifyGroupCreated(group);
            }
        };
        tx.sendRequest(primitive);
    }

    @Override
    public void deleteChatGroupAsync(final ChatGroup group) {
        Primitive request = new Primitive(ImpsTags.DeleteGroup_Request);
        request.addElement(ImpsTags.GroupID, group.getAddress().getFullName());

        AsyncTransaction tx = new AsyncTransaction(mTransactionManager) {
            @Override
            public void onResponseError(ImpsErrorInfo error) {
                notifyGroupError(GroupListener.ERROR_DELETING_GROUP,
                    group.getName(), error);
            }

            @Override
            public void onResponseOk(Primitive response) {
                notifyGroupDeleted(group);
            }
        };
        tx.sendRequest(request);
    }

    @Override
    public void inviteUserAsync(final ChatGroup group, Contact contact) {
        Primitive request = buildInviteUserRequest(group, contact);

        AsyncTransaction tx = new AsyncTransaction(mTransactionManager){
            @Override
            public void onResponseError(ImpsErrorInfo error) {
                notifyGroupMemberError(group, error);
            }

            @Override
            public void onResponseOk(Primitive response) {
                //Do nothing
            }
        };
        tx.sendRequest(request);
    }

    @Override
    public void acceptInvitationAsync(Invitation invitation){
        joinChatGroupAsync(invitation.getGroupAddress());
        sendInvitationResposne(invitation, true);
    }

    @Override
    public void rejectInvitationAsync(Invitation invitation) {
        sendInvitationResposne(invitation, false);
    }

    private void sendInvitationResposne(Invitation invitation, boolean accept) {
        Primitive response = new Primitive(ImpsTags.InviteUser_Response);
        response.addElement(ImpsTags.InviteID, invitation.getInviteID());
        response.addElement(ImpsTags.Acceptance, ImpsUtils.toImpsBool(accept));
        ImpsAddress sender = (ImpsAddress) invitation.getSender();
        response.addElement(sender.toPrimitiveElement());
        AsyncTransaction tx = new AsyncTransaction(mTransactionManager){
            @Override
            public void onResponseError(ImpsErrorInfo error) {
                // Ignore
            }
            @Override
            public void onResponseOk(Primitive res) {
                // Ignore
            }
        };
        tx.sendRequest(response);
    }

    @Override
    public void joinChatGroupAsync(final Address address) {
        Primitive request = buildJoinGroupRequest(address);

        AsyncTransaction tx = new AsyncTransaction(mTransactionManager) {
            @Override
            public void onResponseError(ImpsErrorInfo error) {
                notifyGroupError(GroupListener.ERROR_JOINING_IN_GROUP,
                    address.getScreenName(), error);
            }

            @Override
            public void onResponseOk(Primitive response) {
                ArrayList<Contact> members = new ArrayList<Contact>();
                // FIXME: UserMapList is a child of Joined in version 1.3
                PrimitiveElement userMapping = response
                        .getElement(ImpsTags.UserMapList);
                extractUserMapList(userMapping, members);

                ChatGroup group = new ChatGroup(address, address
                        .getScreenName(), members, ImpsChatGroupManager.this);
                notifyJoinedGroup(group);
            }
        };
        tx.sendRequest(request);
    }

    @Override
    public void leaveChatGroupAsync(final ChatGroup group) {
        Primitive leaveRequest = buildLeaveGroupRequest(group);
        AsyncTransaction tx = new AsyncTransaction(mTransactionManager) {
            @Override
            public void onResponseError(ImpsErrorInfo error) {
                notifyGroupError(GroupListener.ERROR_LEAVING_GROUP,
                    group.getName(), error);
            }

            @Override
            public void onResponseOk(Primitive response) {
                notifyLeftGroup(group);
            }
        };
        tx.sendRequest(leaveRequest);
    }