Android基于XMPP Smack Openfire下学习开发IM(六)总结

不管学习什么都应该总结

这里我把关于Xmpp的一些方法整理到一个工具类中了

我就分享给大家

XmppConnection.java

[java] view
plaincopy

package com.techrare.utils;

import java.io.BufferedInputStream;

import java.io.BufferedReader;

import java.io.ByteArrayInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.net.URL;

import java.net.URLConnection;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.jivesoftware.smack.ConnectionConfiguration;

import org.jivesoftware.smack.PacketCollector;

import org.jivesoftware.smack.Roster;

import org.jivesoftware.smack.RosterEntry;

import org.jivesoftware.smack.RosterGroup;

import org.jivesoftware.smack.SmackConfiguration;

import org.jivesoftware.smack.XMPPConnection;

import org.jivesoftware.smack.XMPPException;

import org.jivesoftware.smack.filter.AndFilter;

import org.jivesoftware.smack.filter.PacketFilter;

import org.jivesoftware.smack.filter.PacketIDFilter;

import org.jivesoftware.smack.filter.PacketTypeFilter;

import org.jivesoftware.smack.packet.IQ;

import org.jivesoftware.smack.packet.Message;

import org.jivesoftware.smack.packet.Packet;

import org.jivesoftware.smack.packet.Presence;

import org.jivesoftware.smack.packet.Registration;

import org.jivesoftware.smack.provider.PrivacyProvider;

import org.jivesoftware.smack.provider.ProviderManager;

import org.jivesoftware.smack.util.StringUtils;

import org.jivesoftware.smackx.Form;

import org.jivesoftware.smackx.FormField;

import org.jivesoftware.smackx.GroupChatInvitation;

import org.jivesoftware.smackx.OfflineMessageManager;

import org.jivesoftware.smackx.PrivateDataManager;

import org.jivesoftware.smackx.ReportedData;

import org.jivesoftware.smackx.ReportedData.Row;

import org.jivesoftware.smackx.ServiceDiscoveryManager;

import org.jivesoftware.smackx.bytestreams.socks5.provider.BytestreamsProvider;

import org.jivesoftware.smackx.filetransfer.FileTransferManager;

import org.jivesoftware.smackx.filetransfer.OutgoingFileTransfer;

import org.jivesoftware.smackx.muc.DiscussionHistory;

import org.jivesoftware.smackx.muc.HostedRoom;

import org.jivesoftware.smackx.muc.MultiUserChat;

import org.jivesoftware.smackx.packet.ChatStateExtension;

import org.jivesoftware.smackx.packet.LastActivity;

import org.jivesoftware.smackx.packet.OfflineMessageInfo;

import org.jivesoftware.smackx.packet.OfflineMessageRequest;

import org.jivesoftware.smackx.packet.SharedGroupsInfo;

import org.jivesoftware.smackx.packet.VCard;

import org.jivesoftware.smackx.provider.AdHocCommandDataProvider;

import org.jivesoftware.smackx.provider.DataFormProvider;

import org.jivesoftware.smackx.provider.DelayInformationProvider;

import org.jivesoftware.smackx.provider.DiscoverInfoProvider;

import org.jivesoftware.smackx.provider.DiscoverItemsProvider;

import org.jivesoftware.smackx.provider.MUCAdminProvider;

import org.jivesoftware.smackx.provider.MUCOwnerProvider;

import org.jivesoftware.smackx.provider.MUCUserProvider;

import org.jivesoftware.smackx.provider.MessageEventProvider;

import org.jivesoftware.smackx.provider.MultipleAddressesProvider;

import org.jivesoftware.smackx.provider.RosterExchangeProvider;

import org.jivesoftware.smackx.provider.StreamInitiationProvider;

import org.jivesoftware.smackx.provider.VCardProvider;

import org.jivesoftware.smackx.provider.XHTMLExtensionProvider;

import org.jivesoftware.smackx.search.UserSearch;

import org.jivesoftware.smackx.search.UserSearchManager;

import android.graphics.drawable.Drawable;

import android.util.Log;

import com.techrare.listener.TaxiConnectionListener;

/**

* XmppConnection 工具类

* @author 肖赛SoAi

*

*/

public class XmppConnection {

private int SERVER_PORT = 5222;

private String SERVER_HOST = "127.0.0.1";

private XMPPConnection connection = null;

private String SERVER_NAME = "ubuntuserver4java";

private static XmppConnection xmppConnection = new XmppConnection();

private TaxiConnectionListener connectionListener;

/**

* 单例模式

*

* @return

*/

synchronized public static XmppConnection getInstance() {

return xmppConnection;

}

/**

* 创建连接

*/

public XMPPConnection getConnection() {

if (connection == null) {

openConnection();

}

return connection;

}

/**

* 打开连接

*/

public boolean openConnection() {

try {

if (null == connection || !connection.isAuthenticated()) {

XMPPConnection.DEBUG_ENABLED = true;// 开启DEBUG模式

// 配置连接

ConnectionConfiguration config = new ConnectionConfiguration(

SERVER_HOST, SERVER_PORT, SERVER_NAME);

config.setReconnectionAllowed(true);

config.setSecurityMode(ConnectionConfiguration.SecurityMode.disabled);

config.setSendPresence(true); // 状态设为离线，目的为了取离线消息

config.setSASLAuthenticationEnabled(false); // 是否启用安全验证

config.setTruststorePath("/system/etc/security/cacerts.bks");

config.setTruststorePassword("changeit");

config.setTruststoreType("bks");

connection = new XMPPConnection(config);

connection.connect();// 连接到服务器

// 配置各种Provider，如果不配置，则会无法解析数据

configureConnection(ProviderManager.getInstance());

return true;

}

} catch (XMPPException xe) {

xe.printStackTrace();

connection = null;

}

return false;

}

/**

* 关闭连接

*/

public void closeConnection() {

if(connection!=null){

//移除連接監聽

//connection.removeConnectionListener(connectionListener);

if(connection.isConnected())

connection.disconnect();

connection = null;

}

Log.i("XmppConnection", "關閉連接");

}

/**

* 登录

*

* @param account

* 登录帐号

* @param password

* 登录密码

* @return

*/

public boolean login(String account, String password) {

try {

if (getConnection() == null)

return false;

getConnection().login(account, password);

// 更改在綫狀態

Presence presence = new Presence(Presence.Type.available);

getConnection().sendPacket(presence);

// 添加連接監聽

connectionListener = new TaxiConnectionListener();

getConnection().addConnectionListener(connectionListener);

return true;

} catch (XMPPException xe) {

xe.printStackTrace();

}

return false;

}

/**

* 注册

*

* @param account

* 注册帐号

* @param password

* 注册密码

* @return 1、注册成功 0、服务器没有返回结果2、这个账号已经存在3、注册失败

*/

public String regist(String account, String password) {

if (getConnection() == null)

return "0";

Registration reg = new Registration();

reg.setType(IQ.Type.SET);

reg.setTo(getConnection().getServiceName());

// 注意这里createAccount注册时，参数是UserName，不是jid，是"@"前面的部分。

reg.setUsername(account);

reg.setPassword(password);

// 这边addAttribute不能为空，否则出错。所以做个标志是android手机创建的吧！！！！！

reg.addAttribute("android", "geolo_createUser_android");

PacketFilter filter = new AndFilter(new PacketIDFilter(

reg.getPacketID()), new PacketTypeFilter(IQ.class));

PacketCollector collector = getConnection().createPacketCollector(

filter);

getConnection().sendPacket(reg);

IQ result = (IQ) collector.nextResult(SmackConfiguration

.getPacketReplyTimeout());

// Stop queuing results停止请求results（是否成功的结果）

collector.cancel();

if (result == null) {

Log.e("regist", "No response from server.");

return "0";

} else if (result.getType() == IQ.Type.RESULT) {

Log.v("regist", "regist success.");

return "1";

} else { // if (result.getType() == IQ.Type.ERROR)

if (result.getError().toString().equalsIgnoreCase("conflict(409)")) {

Log.e("regist", "IQ.Type.ERROR: "

+ result.getError().toString());

return "2";

} else {

Log.e("regist", "IQ.Type.ERROR: "

+ result.getError().toString());

return "3";

}

}

}

/**

* 更改用户状态

*/

public void setPresence(int code) {

XMPPConnection con = getConnection();

if (con == null)

return;

Presence presence;

switch (code) {

case 0:

presence = new Presence(Presence.Type.available);

con.sendPacket(presence);

Log.v("state", "设置在线");

break;

case 1:

presence = new Presence(Presence.Type.available);

presence.setMode(Presence.Mode.chat);

con.sendPacket(presence);

Log.v("state", "设置Q我吧");

break;

case 2:

presence = new Presence(Presence.Type.available);

presence.setMode(Presence.Mode.dnd);

con.sendPacket(presence);

Log.v("state", "设置忙碌");

break;

case 3:

presence = new Presence(Presence.Type.available);

presence.setMode(Presence.Mode.away);

con.sendPacket(presence);

Log.v("state", "设置离开");

break;

case 4:

Roster roster = con.getRoster();

Collection<RosterEntry> entries = roster.getEntries();

for (RosterEntry entry : entries) {

presence = new Presence(Presence.Type.unavailable);

presence.setPacketID(Packet.ID_NOT_AVAILABLE);

presence.setFrom(con.getUser());

presence.setTo(entry.getUser());

con.sendPacket(presence);

Log.v("state", presence.toXML());

}

// 向同一用户的其他客户端发送隐身状态

presence = new Presence(Presence.Type.unavailable);

presence.setPacketID(Packet.ID_NOT_AVAILABLE);

presence.setFrom(con.getUser());

presence.setTo(StringUtils.parseBareAddress(con.getUser()));

con.sendPacket(presence);

Log.v("state", "设置隐身");

break;

case 5:

presence = new Presence(Presence.Type.unavailable);

con.sendPacket(presence);

Log.v("state", "设置离线");

break;

default:

break;

}

}

/**

* 获取所有组

*

* @return 所有组集合

*/

public List<RosterGroup> getGroups() {

if (getConnection() == null)

return null;

List<RosterGroup> grouplist = new ArrayList<RosterGroup>();

Collection<RosterGroup> rosterGroup = getConnection().getRoster()

.getGroups();

Iterator<RosterGroup> i = rosterGroup.iterator();

while (i.hasNext()) {

grouplist.add(i.next());

}

return grouplist;

}

/**

* 获取某个组里面的所有好友

*

* @param roster

* @param groupName

* 组名

* @return

*/

public List<RosterEntry> getEntriesByGroup(String groupName) {

if (getConnection() == null)

return null;

List<RosterEntry> Entrieslist = new ArrayList<RosterEntry>();

RosterGroup rosterGroup = getConnection().getRoster().getGroup(

groupName);

Collection<RosterEntry> rosterEntry = rosterGroup.getEntries();

Iterator<RosterEntry> i = rosterEntry.iterator();

while (i.hasNext()) {

Entrieslist.add(i.next());

}

return Entrieslist;

}

/**

* 获取所有好友信息

*

* @return

*/

public List<RosterEntry> getAllEntries() {

if (getConnection() == null)

return null;

List<RosterEntry> Entrieslist = new ArrayList<RosterEntry>();

Collection<RosterEntry> rosterEntry = getConnection().getRoster()

.getEntries();

Iterator<RosterEntry> i = rosterEntry.iterator();

while (i.hasNext()) {

Entrieslist.add(i.next());

}

return Entrieslist;

}

/**

* 获取用户VCard信息

*

* @param connection

* @param user

* @return

* @throws XMPPException

*/

public VCard getUserVCard(String user) {

if (getConnection() == null)

return null;

VCard vcard = new VCard();

try {

vcard.load(getConnection(), user);

} catch (XMPPException e) {

e.printStackTrace();

}

return vcard;

}

/**

* 获取用户头像信息

*

* @param connection

* @param user

* @return

*/

public Drawable getUserImage(String user) {

if (getConnection() == null)

return null;

ByteArrayInputStream bais = null;

try {

VCard vcard = new VCard();

// 加入这句代码，解决No VCard for

ProviderManager.getInstance().addIQProvider("vCard", "vcard-temp",

new org.jivesoftware.smackx.provider.VCardProvider());

if (user == "" || user == null || user.trim().length() <= 0) {

return null;

}

vcard.load(getConnection(), user + "@"

+ getConnection().getServiceName());

if (vcard == null || vcard.getAvatar() == null)

return null;

bais = new ByteArrayInputStream(vcard.getAvatar());

} catch (Exception e) {

e.printStackTrace();

return null;

}

return FormatTools.getInstance().InputStream2Drawable(bais);

}

/**

* 添加一个分组

*

* @param groupName

* @return

*/

public boolean addGroup(String groupName) {

if (getConnection() == null)

return false;

try {

getConnection().getRoster().createGroup(groupName);

Log.v("addGroup", groupName + "創建成功");

return true;

} catch (Exception e) {

e.printStackTrace();

return false;

}

}

/**

* 删除分组

*

* @param groupName

* @return

*/

public boolean removeGroup(String groupName) {

return true;

}

/**

* 添加好友 无分组

*

* @param userName

* @param name

* @return

*/

public boolean addUser(String userName, String name) {

if (getConnection() == null)

return false;

try {

getConnection().getRoster().createEntry(userName, name, null);

return true;

} catch (Exception e) {

e.printStackTrace();

return false;

}

}

/**

* 添加好友 有分组

*

* @param userName

* @param name

* @param groupName

* @return

*/

public boolean addUser(String userName, String name, String groupName) {

if (getConnection() == null)

return false;

try {

Presence subscription = new Presence(Presence.Type.subscribed);

subscription.setTo(userName);

userName += "@" + getConnection().getServiceName();

getConnection().sendPacket(subscription);

getConnection().getRoster().createEntry(userName, name,

new String[] { groupName });

return true;

} catch (Exception e) {

e.printStackTrace();

return false;

}

}

/**

* 删除好友

*

* @param userName

* @return

*/

public boolean removeUser(String userName) {

if (getConnection() == null)

return false;

try {

RosterEntry entry = null;

if (userName.contains("@"))

entry = getConnection().getRoster().getEntry(userName);

else

entry = getConnection().getRoster().getEntry(

userName + "@" + getConnection().getServiceName());

if (entry == null)

entry = getConnection().getRoster().getEntry(userName);

getConnection().getRoster().removeEntry(entry);

return true;

} catch (Exception e) {

e.printStackTrace();

return false;

}

}

/**

* 查询用户

*

* @param userName

* @return

* @throws XMPPException

*/

public List<HashMap<String, String>> searchUsers(String userName) {

if (getConnection() == null)

return null;

HashMap<String, String> user = null;

List<HashMap<String, String>> results = new ArrayList<HashMap<String, String>>();

try {

new ServiceDiscoveryManager(getConnection());

UserSearchManager usm = new UserSearchManager(getConnection());

Form searchForm = usm.getSearchForm(getConnection()

.getServiceName());

Form answerForm = searchForm.createAnswerForm();

answerForm.setAnswer("userAccount", true);

answerForm.setAnswer("userPhote", userName);

ReportedData data = usm.getSearchResults(answerForm, "search"

+ getConnection().getServiceName());

Iterator<Row> it = data.getRows();

Row row = null;

while (it.hasNext()) {

user = new HashMap<String, String>();

row = it.next();

user.put("userAccount", row.getValues("userAccount").next()

.toString());

user.put("userPhote", row.getValues("userPhote").next()

.toString());

results.add(user);

// 若存在，则有返回,UserName一定非空，其他两个若是有设，一定非空

}

} catch (XMPPException e) {

e.printStackTrace();

}

return results;

}

/**

* 修改心情

*

* @param connection

* @param status

*/

public void changeStateMessage(String status) {

if (getConnection() == null)

return;

Presence presence = new Presence(Presence.Type.available);

presence.setStatus(status);

getConnection().sendPacket(presence);

}

/**

* 修改用户头像

*

* @param file

*/

public boolean changeImage(File file) {

if (getConnection() == null)

return false;

try {

VCard vcard = new VCard();

vcard.load(getConnection());

byte[] bytes;

bytes = getFileBytes(file);

String encodedImage = StringUtils.encodeBase64(bytes);

vcard.setAvatar(bytes, encodedImage);

vcard.setEncodedImage(encodedImage);

vcard.setField("PHOTO", "<TYPE>image/jpg</TYPE><BINVAL>"

+ encodedImage + "</BINVAL>", true);

ByteArrayInputStream bais = new ByteArrayInputStream(

vcard.getAvatar());

FormatTools.getInstance().InputStream2Bitmap(bais);

vcard.save(getConnection());

return true;

} catch (Exception e) {

e.printStackTrace();

return false;

}

}

/**

* 文件转字节

*

* @param file

* @return

* @throws IOException

*/

private byte[] getFileBytes(File file) throws IOException {

BufferedInputStream bis = null;

try {

bis = new BufferedInputStream(new FileInputStream(file));

int bytes = (int) file.length();

byte[] buffer = new byte[bytes];

int readBytes = bis.read(buffer);

if (readBytes != buffer.length) {

throw new IOException("Entire file not read");

}

return buffer;

} finally {

if (bis != null) {

bis.close();

}

}

}

/**

* 删除当前用户

*

* @return

*/

public boolean deleteAccount() {

if (getConnection() == null)

return false;

try {

getConnection().getAccountManager().deleteAccount();

return true;

} catch (XMPPException e) {

return false;

}

}

/**

* 修改密码

*

* @return

*/

public boolean changePassword(String pwd) {

if (getConnection() == null)

return false;

try {

getConnection().getAccountManager().changePassword(pwd);

return true;

} catch (XMPPException e) {

return false;

}

}

/**

* 初始化会议室列表

*/

public List<HostedRoom> getHostRooms() {

if (getConnection() == null)

return null;

Collection<HostedRoom> hostrooms = null;

List<HostedRoom> roominfos = new ArrayList<HostedRoom>();

try {

new ServiceDiscoveryManager(getConnection());

hostrooms = MultiUserChat.getHostedRooms(getConnection(),

getConnection().getServiceName());

for (HostedRoom entry : hostrooms) {

roominfos.add(entry);

Log.i("room",

"名字：" + entry.getName() + " - ID:" + entry.getJid());

}

Log.i("room", "服务会议数量:" + roominfos.size());

} catch (XMPPException e) {

e.printStackTrace();

}

return roominfos;

}

/**

* 创建房间

*

* @param roomName

* 房间名称

*/

public MultiUserChat createRoom(String user, String roomName,

String password) {

if (getConnection() == null)

return null;

MultiUserChat muc = null;

try {

// 创建一个MultiUserChat

muc = new MultiUserChat(getConnection(), roomName + "@conference."

+ getConnection().getServiceName());

// 创建聊天室

muc.create(roomName);

// 获得聊天室的配置表单

Form form = muc.getConfigurationForm();

// 根据原始表单创建一个要提交的新表单。

Form submitForm = form.createAnswerForm();

// 向要提交的表单添加默认答复

for (Iterator<FormField> fields = form.getFields(); fields

.hasNext();) {

FormField field = (FormField) fields.next();

if (!FormField.TYPE_HIDDEN.equals(field.getType())

&& field.getVariable() != null) {

// 设置默认值作为答复

submitForm.setDefaultAnswer(field.getVariable());

}

}

// 设置聊天室的新拥有者

List<String> owners = new ArrayList<String>();

owners.add(getConnection().getUser());// 用户JID

submitForm.setAnswer("muc#roomconfig_roomowners", owners);

// 设置聊天室是持久聊天室，即将要被保存下来

submitForm.setAnswer("muc#roomconfig_persistentroom", true);

// 房间仅对成员开放

submitForm.setAnswer("muc#roomconfig_membersonly", false);

// 允许占有者邀请其他人

submitForm.setAnswer("muc#roomconfig_allowinvites", true);

if (!password.equals("")) {

// 进入是否需要密码

submitForm.setAnswer("muc#roomconfig_passwordprotectedroom",

true);

// 设置进入密码

submitForm.setAnswer("muc#roomconfig_roomsecret", password);

}

// 能够发现占有者真实 JID 的角色

// submitForm.setAnswer("muc#roomconfig_whois", "anyone");

// 登录房间对话

submitForm.setAnswer("muc#roomconfig_enablelogging", true);

// 仅允许注册的昵称登录

submitForm.setAnswer("x-muc#roomconfig_reservednick", true);

// 允许使用者修改昵称

submitForm.setAnswer("x-muc#roomconfig_canchangenick", false);

// 允许用户注册房间

submitForm.setAnswer("x-muc#roomconfig_registration", false);

// 发送已完成的表单（有默认值）到服务器来配置聊天室

muc.sendConfigurationForm(submitForm);

} catch (XMPPException e) {

e.printStackTrace();

return null;

}

return muc;

}

/**

* 加入会议室

*

* @param user

* 昵称

* @param password

* 会议室密码

* @param roomsName

* 会议室名

*/

public MultiUserChat joinMultiUserChat(String user, String roomsName,

String password) {

if (getConnection() == null)

return null;

try {

// 使用XMPPConnection创建一个MultiUserChat窗口

MultiUserChat muc = new MultiUserChat(getConnection(), roomsName

+ "@conference." + getConnection().getServiceName());

// 聊天室服务将会决定要接受的历史记录数量

DiscussionHistory history = new DiscussionHistory();

history.setMaxChars(0);

// history.setSince(new Date());

// 用户加入聊天室

muc.join(user, password, history,

SmackConfiguration.getPacketReplyTimeout());

Log.i("MultiUserChat", "会议室【"+roomsName+"】加入成功........");

return muc;

} catch (XMPPException e) {

e.printStackTrace();

Log.i("MultiUserChat", "会议室【"+roomsName+"】加入失败........");

return null;

}

}

/**

* 查询会议室成员名字

*

* @param muc

*/

public List<String> findMulitUser(MultiUserChat muc) {

if (getConnection() == null)

return null;

List<String> listUser = new ArrayList<String>();

Iterator<String> it = muc.getOccupants();

// 遍历出聊天室人员名称

while (it.hasNext()) {

// 聊天室成员名字

String name = StringUtils.parseResource(it.next());

listUser.add(name);

}

return listUser;

}

/**

* 发送文件

*

* @param user

* @param filePath

*/

public void sendFile(String user, String filePath) {

if (getConnection() == null)

return;

// 创建文件传输管理器

FileTransferManager manager = new FileTransferManager(getConnection());

// 创建输出的文件传输

OutgoingFileTransfer transfer = manager

.createOutgoingFileTransfer(user);

// 发送文件

try {

transfer.sendFile(new File(filePath), "You won't believe this!");

} catch (XMPPException e) {

e.printStackTrace();

}

}

/**

* 获取离线消息

*

* @return

*/

public Map<String, List<HashMap<String, String>>> getHisMessage() {

if (getConnection() == null)

return null;

Map<String, List<HashMap<String, String>>> offlineMsgs = null;

try {

OfflineMessageManager offlineManager = new OfflineMessageManager(

getConnection());

Iterator<Message> it = offlineManager.getMessages();

int count = offlineManager.getMessageCount();

if (count <= 0)

return null;

offlineMsgs = new HashMap<String, List<HashMap<String, String>>>();

while (it.hasNext()) {

Message message = it.next();

String fromUser = StringUtils.parseName(message.getFrom());

;

HashMap<String, String> histrory = new HashMap<String, String>();

histrory.put("useraccount",

StringUtils.parseName(getConnection().getUser()));

histrory.put("friendaccount", fromUser);

histrory.put("info", message.getBody());

histrory.put("type", "left");

if (offlineMsgs.containsKey(fromUser)) {

offlineMsgs.get(fromUser).add(histrory);

} else {

List<HashMap<String, String>> temp = new ArrayList<HashMap<String, String>>();

temp.add(histrory);

offlineMsgs.put(fromUser, temp);

}

}

offlineManager.deleteMessages();

} catch (Exception e) {

e.printStackTrace();

}

return offlineMsgs;

}

/**

* 判断OpenFire用户的状态 strUrl :

* url格式 - http://my.openfire.com:9090/plugins/presence
* /status?jid=user1@SERVER_NAME&type=xml

* 返回值 : 0 - 用户不存在; 1 - 用户在线; 2 - 用户离线

* 说明 ：必须要求 OpenFire加载 presence 插件，同时设置任何人都可以访问

*/

public int IsUserOnLine(String user) {

String url = "http://"+SERVER_HOST+":9090/plugins/presence/status?" +

"jid="+ user +"@"+ SERVER_NAME +"&type=xml";

int shOnLineState = 0; // 不存在

try {

URL oUrl = new URL(url);

URLConnection oConn = oUrl.openConnection();

if (oConn != null) {

BufferedReader oIn = new BufferedReader(new InputStreamReader(

oConn.getInputStream()));

if (null != oIn) {

String strFlag = oIn.readLine();

oIn.close();

System.out.println("strFlag"+strFlag);

if (strFlag.indexOf("type=\"unavailable\"") >= 0) {

shOnLineState = 2;

}

if (strFlag.indexOf("type=\"error\"") >= 0) {

shOnLineState = 0;

} else if (strFlag.indexOf("priority") >= 0

|| strFlag.indexOf("id=\"") >= 0) {

shOnLineState = 1;

}

}

}

} catch (Exception e) {

e.printStackTrace();

}

return shOnLineState;

}

/**

* 加入providers的函数 ASmack在/META-INF缺少一个smack.providers 文件

*

* @param pm

*/

public void configureConnection(ProviderManager pm) {

// Private Data Storage

pm.addIQProvider("query", "jabber:iq:private",

new PrivateDataManager.PrivateDataIQProvider());

// Time

try {

pm.addIQProvider("query", "jabber:iq:time",

Class.forName("org.jivesoftware.smackx.packet.Time"));

} catch (ClassNotFoundException e) {

Log.w("TestClient",

"Can't load class for org.jivesoftware.smackx.packet.Time");

}

// Roster Exchange

pm.addExtensionProvider("x", "jabber:x:roster",

new RosterExchangeProvider());

// Message Events

pm.addExtensionProvider("x", "jabber:x:event",

new MessageEventProvider());

// Chat State

pm.addExtensionProvider("active",

"http://jabber.org/protocol/chatstates",

new ChatStateExtension.Provider());

pm.addExtensionProvider("composing",

"http://jabber.org/protocol/chatstates",

new ChatStateExtension.Provider());

pm.addExtensionProvider("paused",

"http://jabber.org/protocol/chatstates",

new ChatStateExtension.Provider());

pm.addExtensionProvider("inactive",

"http://jabber.org/protocol/chatstates",

new ChatStateExtension.Provider());

pm.addExtensionProvider("gone",

"http://jabber.org/protocol/chatstates",

new ChatStateExtension.Provider());

// XHTML

pm.addExtensionProvider("html", "http://jabber.org/protocol/xhtml-im",

new XHTMLExtensionProvider());

// Group Chat Invitations

pm.addExtensionProvider("x", "jabber:x:conference",

new GroupChatInvitation.Provider());

// Service Discovery # Items

pm.addIQProvider("query", "http://jabber.org/protocol/disco#items",

new DiscoverItemsProvider());

// Service Discovery # Info

pm.addIQProvider("query", "http://jabber.org/protocol/disco#info",

new DiscoverInfoProvider());

// Data Forms

pm.addExtensionProvider("x", "jabber:x:data", new DataFormProvider());

// MUC User

pm.addExtensionProvider("x", "http://jabber.org/protocol/muc#user",

new MUCUserProvider());

// MUC Admin

pm.addIQProvider("query", "http://jabber.org/protocol/muc#admin",

new MUCAdminProvider());

// MUC Owner

pm.addIQProvider("query", "http://jabber.org/protocol/muc#owner",

new MUCOwnerProvider());

// Delayed Delivery

pm.addExtensionProvider("x", "jabber:x:delay",

new DelayInformationProvider());

// Version

try {

pm.addIQProvider("query", "jabber:iq:version",

Class.forName("org.jivesoftware.smackx.packet.Version"));

} catch (ClassNotFoundException e) {

// Not sure what's happening here.

}

// VCard

pm.addIQProvider("vCard", "vcard-temp", new VCardProvider());

// Offline Message Requests

pm.addIQProvider("offline", "http://jabber.org/protocol/offline",

new OfflineMessageRequest.Provider());

// Offline Message Indicator

pm.addExtensionProvider("offline",

"http://jabber.org/protocol/offline",

new OfflineMessageInfo.Provider());

// Last Activity

pm.addIQProvider("query", "jabber:iq:last", new LastActivity.Provider());

// User Search

pm.addIQProvider("query", "jabber:iq:search", new UserSearch.Provider());

// SharedGroupsInfo

pm.addIQProvider("sharedgroup",

"http://www.jivesoftware.org/protocol/sharedgroup",

new SharedGroupsInfo.Provider());

// JEP-33: Extended Stanza Addressing

pm.addExtensionProvider("addresses",

"http://jabber.org/protocol/address",

new MultipleAddressesProvider());

// FileTransfer

pm.addIQProvider("si", "http://jabber.org/protocol/si",

new StreamInitiationProvider());

pm.addIQProvider("query", "http://jabber.org/protocol/bytestreams",

new BytestreamsProvider());

// Privacy

pm.addIQProvider("query", "jabber:iq:privacy", new PrivacyProvider());

pm.addIQProvider("command", "http://jabber.org/protocol/commands",

new AdHocCommandDataProvider());

pm.addExtensionProvider("malformed-action",

"http://jabber.org/protocol/commands",

new AdHocCommandDataProvider.MalformedActionError());

pm.addExtensionProvider("bad-locale",

"http://jabber.org/protocol/commands",

new AdHocCommandDataProvider.BadLocaleError());

pm.addExtensionProvider("bad-payload",

"http://jabber.org/protocol/commands",

new AdHocCommandDataProvider.BadPayloadError());

pm.addExtensionProvider("bad-sessionid",

"http://jabber.org/protocol/commands",

new AdHocCommandDataProvider.BadSessionIDError());

pm.addExtensionProvider("session-expired",

"http://jabber.org/protocol/commands",

new AdHocCommandDataProvider.SessionExpiredError());

}

}

/**

* 判断OpenFire用户的状态 strUrl :

* url格式 - http://my.openfire.com:9090/plugins/presence
* /status?jid=user1@SERVER_NAME&type=xml

* 返回值 : 0 - 用户不存在; 1 - 用户在线; 2 - 用户离线

* 说明 ：必须要求 OpenFire加载 presence 插件，同时设置任何人都可以访问

*/

public int IsUserOnLine(String user) {

String url = "http://"+SERVER_HOST+":9090/plugins/presence/status?" +

"jid="+ user +"@"+ SERVER_NAME +"&type=xml";

int shOnLineState = 0; // 不存在

try {

URL oUrl = new URL(url);

URLConnection oConn = oUrl.openConnection();

if (oConn != null) {

BufferedReader oIn = new BufferedReader(new InputStreamReader(

oConn.getInputStream()));

if (null != oIn) {

String strFlag = oIn.readLine();

oIn.close();

System.out.println("strFlag"+strFlag);

if (strFlag.indexOf("type=\"unavailable\"") >= 0) {

shOnLineState = 2;

}

if (strFlag.indexOf("type=\"error\"") >= 0) {

shOnLineState = 0;

} else if (strFlag.indexOf("priority") >= 0

|| strFlag.indexOf("id=\"") >= 0) {

shOnLineState = 1;

}

}

}

} catch (Exception e) {

e.printStackTrace();

}

return shOnLineState;

}

调用该工具类的方法很简单，用了一个单例模式，里面的方法都可以用相同的方法调用

[java] view
plaincopy

XmppConnection.getInstance().login(username,password)