如何使用Smack在Android XMPP多用户聊天中创建和加入群组

我正在尝试为我的应用程序进行多用户聊天。我已经完成了单用户通信的编码，它工作得很好。我无法在多用户聊天中创建或加入组。下面是我的代码

public class MyXMPP {

public static boolean connected = false;
public boolean loggedin = false;
public static boolean isconnecting = false;
public static boolean isToasted = true;
private boolean chat_created = false;
private String serviceName = "", hostAddress = "";
public static XMPPTCPConnection connection;
public static String loginUser;
public static String passwordUser;
XmppService context;
public static MyXMPP instance = null;
public static boolean instanceCreated = false;
private static ChatHandler chatHandler;
private MultiUserChat mMultiUserChat;
private MultiUserChatManager manager;

public String roomName = "new";
public String serverName = "conference.";

public MyXMPP(XmppService context, String mServiceName, String mHostAddress, String loginUser, String passwordUser) {
    this.serviceName = mServiceName;
    this.hostAddress = mHostAddress;
    this.loginUser = loginUser;
    this.passwordUser = passwordUser;
    this.context = context;
    init();
}

public static MyXMPP getInstance(XmppService context, String mServiceName, String mHostAddress, String user, String pass) {
    if (instance == null) {
        instance = new MyXMPP(context, mServiceName, mHostAddress, user, pass);
        instanceCreated = true;
    }
    return instance;

}

public org.jivesoftware.smack.chat.Chat Mychat;

ChatManagerListenerImpl mChatManagerListener;
MMessageListener mMessageListener;

String text = "";
String mMessage = "", mReceiver = "";

static {
    try {
        Class.forName("org.jivesoftware.smack.ReconnectionManager");
    } catch (ClassNotFoundException ex) {
        // problem loading reconnection manager
    }
}

public void init() {
    mMessageListener = new MMessageListener(context);
    mChatManagerListener = new ChatManagerListenerImpl();
    initialiseConnection();
}

private void initialiseConnection() {

    XMPPTCPConnectionConfiguration.Builder config = XMPPTCPConnectionConfiguration.builder();
    config.setSecurityMode(ConnectionConfiguration.SecurityMode.disabled);
    config.setServiceName(serviceName);
    config.setHost(hostAddress);
    config.setDebuggerEnabled(true);
    XMPPTCPConnection.setUseStreamManagementResumptiodDefault(true);
    XMPPTCPConnection.setUseStreamManagementDefault(true);
    connection = new XMPPTCPConnection(config.build());
    XMPPConnectionListener connectionListener = new XMPPConnectionListener();
    connection.addConnectionListener(connectionListener);

}

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

public void connect(final String caller) {

    AsyncTask<Void, Void, Boolean> connectionThread = new AsyncTask<Void, Void, Boolean>() {
        @Override
        protected synchronized Boolean doInBackground(Void... arg0) {
            if (connection.isConnected())
                return false;
            isconnecting = true;
            if (isToasted)
                new Handler(Looper.getMainLooper()).post(new Runnable() {

                    @Override
                    public void run() {

                        Toast.makeText(context,
                                caller + "=>connecting....",
                                Toast.LENGTH_LONG).show();
                    }
                });
            Log.d("Connect() Function", caller + "=>connecting....");

            try {

                connection.connect();

                ReconnectionManager reconnectionManager = ReconnectionManager.getInstanceFor(connection);
                reconnectionManager.setEnabledPerDefault(false);
                reconnectionManager.enableAutomaticReconnection();

                DeliveryReceiptManager dm = DeliveryReceiptManager
                        .getInstanceFor(connection);
                dm.setAutoReceiptMode(AutoReceiptMode.always);
                dm.addReceiptReceivedListener(new ReceiptReceivedListener() {

                    @Override
                    public void onReceiptReceived(final String fromid,
                                                  final String toid, final String msgid,
                                                  final Stanza packet) {

                    }
                });

                connected = true;

            } catch (IOException e) {
                Log.e("(" + caller + ")", "IOException: " + e.getMessage());
            } catch (SmackException e) {
                Log.e("(" + caller + ")",
                        "SMACKException: " + e.getMessage());
            } catch (XMPPException e) {
                Log.e("connect(" + caller + ")",
                        "XMPPException: " + e.getMessage());

            }
            return isconnecting = false;
        }
    };
    connectionThread.execute();
}

public void login() {

    try {

        connection.login(loginUser, passwordUser);
        Log.i("LOGIN", "Yey! We're connected to the Xmpp server!");


                // Call to create Multi User Chat Group
                join();    

    } catch (XMPPException | SmackException | IOException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }

}

private class ChatManagerListenerImpl implements ChatManagerListener {
    @Override
    public void chatCreated(final org.jivesoftware.smack.chat.Chat chat,
                            final boolean createdLocally) {
        if (!createdLocally)
            chat.addMessageListener(mMessageListener);

    }

}


public int sendMessage(String senderID, String mMessage) {

    if (!chat_created) {
        Mychat = ChatManager.getInstanceFor(connection).createChat(senderID, mMessageListener);
        chat_created = true;
    }
    final Message message = new Message();
    message.setBody(mMessage);
    message.setStanzaId(String.format("%02d", new Random().nextInt(1000)));
    message.setType(Message.Type.chat);
    try {
        if (connection.isAuthenticated()) {
            Mychat.sendMessage(message);
            return 1;
        } else {
            login();
            return 0;
        }
    } catch (SmackException.NotConnectedException e) {

        Log.e("xmpp.SendMessage()", "msg Not sent!-Not Connected!");
        return 0;

    } catch (Exception e) {

        Log.e("xmpp Message Exception", "msg Not sent!" + e.getMessage());
        return 0;
    }

}

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!");

        System.out.println("-------------ConnectionCLosed!----------------");
        instance = null;
        connected = false;
        chat_created = false;
        loggedin = false;
    }

    @Override
    public void connectionClosedOnError(Exception arg0) {

        Log.d("xmpp", "ConnectionClosedOn Error!");
        connected = false;
        instance = null;
        chat_created = false;
        loggedin = false;
    }

    @Override
    public void reconnectingIn(int arg0) {

        Log.d("xmpp", "Reconnectingin " + arg0);

        System.out.println("----------prem Reconnectingin----------------" + arg0);

        loggedin = false;
    }

    @Override
    public void reconnectionFailed(Exception arg0) {

        Log.d("xmpp", "ReconnectionFailed!");
        connected = false;
        instance = null;
        chat_created = false;
        loggedin = false;
    }

    @Override
    public void reconnectionSuccessful() {

        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;

        ChatManager.getInstanceFor(connection).addChatListener(
                mChatManagerListener);

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

            @Override
            public void run() {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        }).start();

    }
}

private class MMessageListener implements ChatMessageListener {

    public MMessageListener(Context contxt) {
    }

    @Override
    public void processMessage(final org.jivesoftware.smack.chat.Chat chat,
                               final Message message) {
        Log.i("MyXMPP_MESSAGE_LISTENER", "Xmpp message received: '"
                + message);

        if (message.getType() == Message.Type.chat
                && message.getBody() != null) {
            System.out.println("-----------xmpp message-------------" + message.getBody());

            // Here I am receiving messages which would be handled later
        }
    }

}


public boolean join(){
  try {
        MultiUserChatManager multiUserChatManager = MultiUserChatManager.getInstanceFor(connection);
        MultiUserChat multiUserChat = multiUserChatManager.getMultiUserChat(roomName + "@" + serverName + ServiceConstant.XMPP_HOST_URL);
        multiUserChat.addMessageListener(new MessageListener() {
            @Override
            public void processMessage(Message message) {
                Log.i("MyXMPP_MESSAGE_LISTENER", "Xmpp message received: '"
                        + message);


            }
        });

       // Getting Error at the below line. 
       multiUserChat.createOrJoin(loginUser);

      return true;


    }catch (Exception e){
        e.printStackTrace();
    }

    return false;
}

公共类MyXMPP{
公共静态布尔连接=false；
公共布尔loggedin=false；
公共静态布尔值断开连接=false；
公共静态布尔值isToasted=true；
私有布尔chat_created=false；
私有字符串serviceName=“”，hostAddress=“”；
公共静态XMPPTCP连接；
公共静态字符串登录用户；
公共静态字符串密码用户；
XmppService上下文；
公共静态MyXMPP实例=null；
公共静态布尔值instanceCreated=false；
私有静态聊天处理程序聊天处理程序；
私有多用户聊天mmmultiuserchat；
私有多用户聊天管理器；
公共字符串roomName=“new”；
公共字符串serverName=“会议。”；
公共MyXMPP（XmppService上下文、字符串mServiceName、字符串mHostAddress、字符串loginUser、字符串passwordUser）{
this.serviceName=mServiceName；
this.hostAddress=mHostAddress；
this.loginUser=loginUser；
this.passwordUser=passwordUser；
this.context=上下文；
init（）；
}
公共静态MyXMPP getInstance（XmppService上下文、字符串mServiceName、字符串mHostAddress、字符串用户、字符串传递）{
if（实例==null）{
实例=新的MyXMPP（上下文、mServiceName、mHostAddress、用户、pass）；
instanceCreated=true；
}
返回实例；
}
public org.jivesoftware.smack.chat.chat Mychat；
ChatManagerListenerImpl mChatManagerListener；
格利斯滕夫人；
字符串文本=”；
字符串mMessage=“”，mReceiver=“”；
静止的{
试一试{
Class.forName（“org.jivesoftware.smack.ReconnectionManager”）；
}捕获（ClassNotFoundException ex）{
//加载重新连接管理器时出现问题
}
}
公共void init（）{
mMessageListener=新的mMessageListener（上下文）；
mChatManagerListener=new ChatManagerListenerImpl（）；
initialiseConnection（）；
}
私有void initialiseConnection（）{
XMPPTCPConnectionConfiguration.Builder config=XMPPTCPConnectionConfiguration.Builder（）；
config.setSecurityMode（ConnectionConfiguration.SecurityMode.disabled）；
config.setServiceName（serviceName）；
config.setHost（主机地址）；
config.setDebuggerEnabled（true）；
XMPPTCPConnection.setUseStreamManagementResumptiodDefault（true）；
XMPPTCPConnection.setUseStreamManagementDefault（true）；
连接=新的XMPPTCPConnection（config.build（））；
XMPPConnectionListener connectionListener=新的XMPPConnectionListener（）；
connection.addConnectionListener（connectionListener）；
}
公共空间断开连接（）{
新线程（newrunnable（））{
@凌驾
公开募捐{
连接断开（）；
}
}).start（）；
}
公共void connect（最终字符串调用方）{
AsyncTask connectionThread=新建AsyncTask（）{
@凌驾
受保护的同步布尔doInBackground（无效…arg0）{
if（connection.isConnected（））
返回false；
断开连接=正确；
如果（iStosted）
新的处理程序（Looper.getMainLooper（））.post（新的Runnable（））{
@凌驾
公开募捐{
Toast.makeText（上下文，
调用者+“=>正在连接…”，
Toast.LENGTH_LONG）.show（）；
}
});
d（“Connect（）函数”，调用者+”=>connecting…）；
试一试{
connection.connect（）；
ReconnectionManager ReconnectionManager=ReconnectionManager.getInstanceFor（连接）；
reconnectionManager.setEnabledPerDefault（false）；
reconnectionManager.enableAutomaticReconnection（）；
DeliveryReceiptManager dm=DeliveryReceiptManager
.getInstanceFor（连接）；
dm.setAutoReceiptMode（AutoReceiptMode.always）；
dm.addReceiptReceivedListener（新的ReceiptReceivedListener（）{
@凌驾
接收到公共void onReceiptReceived（来自ID的最终字符串，
最终字符串toid，最终字符串msgid，
最后一节（数据包）{
}
});
连接=真；
}捕获（IOE异常）{
Log.e（“（“+caller+”），“IOException:”+e.getMessage（））；
}捕捉（SmackException e）{
Log.e（“（“+caller+”），
“SMACKException:”+e.getMessage（））；
}捕获（XMPPException e）{
Log.e（“连接（“+调用方+”），
“XMPPException:”+e.getMessage（））；
}
返回isconnecting=false；
}
};
connectionThread.execute（）；
}
公共无效登录（）{
试一试{
connection.login（登录用户、密码用户）；
i（“登录”，“是的！我们已连接到Xmpp服务器！”）；
//调用以创建多用户聊天组
join（）；
}捕获（XMPPException | smakexception | ioe异常）{
e、 printStackTrace（）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
私有类ChatManagerListenerImpl实现ChatManagerListener{
@凌驾
创建公共无效聊天室（最终org.jivesoftware.smack.chat.chat聊天室，
最终布尔值（局部创建）{
如果（！createdLocally）
addMessageListener（mMessageListener）；
}
}
public int sendMessage（字符串senderID、字符串mMessage）{
如果（！chat_已创建）{
Mychat=ChatManager.getInstanceFor（连接）.createChat（senderID，mMessageListener）；
chat_created=true；
}
最终消息消息=新消息
final MultiUserChatManager multiUserChatManager = 
             MultiUserChatManager.getInstanceFor(abstractXMPPConnection);
final MultiUserChat multiUserChat = 
             multiUserChatManager.getMultiUserChat(
             JidCreate.entityBareFrom(groupChatRoomName + 
                          "@conference." + SERVICE_URL));
multiUserChat.create(Resourcepart.from((groupChatRoomName))
               .getConfigFormManager()
               .submitConfigurationForm();