利用socket实现聊天-Android端核心代码
实体类与服务端报错一致,包括包名
package loaderman.im.bean; /**
* 一个聊天消息的JavaBean
*
*
*/
public class ChatMsgEntity {
private String name;// 消息来自
private String date;// 消息日期
private String message;// 消息内容
private String img; //头像
private boolean msgType = true;// 是否为收到的消息 public ChatMsgEntity() { } public ChatMsgEntity(String name, String date, String text, String img,
boolean msgType) {
super();
this.name = name;
this.date = date;
this.message = text;
this.img = img;
this.msgType = msgType;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public String getDate() {
return date;
} public void setDate(String date) {
this.date = date;
} public String getMessage() {
return message;
} public void setMessage(String message) {
this.message = message;
} public boolean getMsgType() {
return msgType;
} public void setMsgType(boolean isComMsg) {
msgType = isComMsg;
} public String getImg() {
return img;
} public void setImg(String img) {
this.img = img;
}
}
package loaderman.im.bean; import java.io.Serializable; public class IMMessage implements Serializable {
private String userId;
private String userName;
private String userHeadPhoto;
private int messageType;
private String lastMsgContent;
private String time;
private int noReadCount;
public IMMessage(String userID, String userName, String userHeadPhoto, int messageType, String lastMsgContent, String time) {
this.userId = userID;
this.userName = userName;
this.userHeadPhoto = userHeadPhoto;
this.messageType = messageType;
this.lastMsgContent = lastMsgContent;
this.time = time;
} public IMMessage(String userId, String userName, String userHeadPhoto, int messageType, String lastMsgContent, String time, int noReadCount) {
this.userId = userId;
this.userName = userName;
this.userHeadPhoto = userHeadPhoto;
this.messageType = messageType;
this.lastMsgContent = lastMsgContent;
this.time = time;
this.noReadCount = noReadCount;
} public int getNoReadCount() {
return noReadCount;
} public void setNoReadCount(int noReadCount) {
this.noReadCount = noReadCount;
} public String getUserId() {
return userId;
} public void setUserId(String userId) {
this.userId = userId;
} public String getUserName() {
return userName;
} public void setUserName(String userName) {
this.userName = userName;
} public String getUserHeadPhoto() {
return userHeadPhoto;
} public void setUserHeadPhoto(String userHeadPhoto) {
this.userHeadPhoto = userHeadPhoto;
} public int getMessageType() {
return messageType;
} public void setMessageType(int messageType) {
this.messageType = messageType;
} public String getLastMsgContent() {
return lastMsgContent;
} public void setLastMsgContent(String lastMsgContent) {
this.lastMsgContent = lastMsgContent;
} public String getTime() {
return time;
} public void setTime(String time) {
this.time = time;
}
}
package loaderman.im.bean; import java.io.Serializable; public class OffLineMessage implements Serializable {
private String fromUser;
private String toUser;
private String textMsg;
private int msgType;
private String time; public OffLineMessage() {
} public OffLineMessage(String fromUser, String toUser, String textMsg, int msgType, String time) {
this.fromUser = fromUser;
this.toUser = toUser;
this.textMsg = textMsg;
this.msgType = msgType;
this.time = time;
} public String getFromUser() {
return fromUser;
} public void setFromUser(String fromUser) {
this.fromUser = fromUser;
} public String getToUser() {
return toUser;
} public void setToUser(String toUser) {
this.toUser = toUser;
} public String getTextMsg() {
return textMsg;
} public void setTextMsg(String textMsg) {
this.textMsg = textMsg;
} public int getMsgType() {
return msgType;
} public void setMsgType(int msgType) {
this.msgType = msgType;
}
public String getTime() {
return time;
} public void setTime(String time) {
this.time = time;
}
}
package loaderman.im.bean; import java.io.Serializable; /**
* 文本消息
* */
public class TextMessage implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
private String message; public TextMessage() { } public TextMessage(String message) {
this.message = message;
} public String getMessage() {
return message;
} public void setMessage(String message) {
this.message = message;
}
}
package loaderman.im.bean; import java.io.Serializable; public class User implements Serializable { private String userId;
private String userName; public String getPassword() {
return password;
} public void setPassword(String password) {
this.password = password;
} private String userHeadPhoto;
private String password;
public String getUserId() {
return userId;
} public void setUserId(String userId) {
this.userId = userId;
} public String getUserName() {
return userName;
} public void setUserName(String userName) {
this.userName = userName;
} public String getUserHeadPhoto() {
return userHeadPhoto;
} public void setUserHeadPhoto(String userHeadPhoto) {
this.userHeadPhoto = userHeadPhoto;
} @Override
public String toString() {
return "User{" +
"userId='" + userId + '\'' +
", userName='" + userName + '\'' +
", userHeadPhoto='" + userHeadPhoto + '\'' +
", password='" + password + '\'' +
'}';
}
}
数据库设计
package loaderman.im.dao; import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper; import loaderman.im.Constants;
import loaderman.util.LoggerUtil; /**
* Created by Administrator on 2018/12/7 0007.
*/ public class IMChatOpenHelper extends SQLiteOpenHelper { public IMChatOpenHelper(Context context) {
super(context, Constants.DBNAME, null, 1);
} @Override
public void onCreate(SQLiteDatabase db) {
LoggerUtil.systemOut("建表");
db.execSQL("create table user(id integer primary key autoincrement, userId TEXT, userName TEXT, userHeadPhoto TEXT)");
db.execSQL("create table imchat(id integer primary key autoincrement, userId TEXT, userName TEXT, userHeadPhoto TEXT, messageType integer, lastMsgContent TEXT, time TEXT, noReadCount integer)");
}
//UserId 用户ID UserName 用户名 UserHeadPhoto 用户头像
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { } }
package loaderman.im.dao; import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase; import java.util.ArrayList;
import java.util.List; import loaderman.im.Constants;
import loaderman.im.bean.ChatMsgEntity; public class ChatDB {
private SQLiteDatabase db; public ChatDB(Context context) {
db = context.openOrCreateDatabase(Constants.DBNAME,
Context.MODE_PRIVATE, null);
} public void saveMsg(String userID, ChatMsgEntity entity) {
db.execSQL("CREATE table IF NOT EXISTS _"
+ userID
+ " (_id INTEGER PRIMARY KEY AUTOINCREMENT,name TEXT, img TEXT,date TEXT,isCome TEXT,message TEXT)");
int isCome = 0;
if (entity.getMsgType()) {//如果是收到的消息,保存在数据库的值为1
isCome = 1;
}
db.execSQL(
"insert into _" + userID
+ " (name,img,date,isCome,message) values(?,?,?,?,?)",
new Object[]{entity.getName(), entity.getImg(),
entity.getDate(), isCome, entity.getMessage()});
} public List<ChatMsgEntity> getMsg(String userId) {
List<ChatMsgEntity> list = new ArrayList<ChatMsgEntity>();
db.execSQL("CREATE table IF NOT EXISTS _"
+ userId
+ " (_id INTEGER PRIMARY KEY AUTOINCREMENT,name TEXT, img TEXT,date TEXT,isCome TEXT,message TEXT)");
Cursor c = db.rawQuery("SELECT * from _" + userId + " ORDER BY _id DESC LIMIT 5", null);
while (c.moveToNext()) {
String name = c.getString(c.getColumnIndex("name"));
String img = c.getString(c.getColumnIndex("img"));
String date = c.getString(c.getColumnIndex("date"));
int isCome = c.getInt(c.getColumnIndex("isCome"));
String message = c.getString(c.getColumnIndex("message"));
boolean isComMsg = false;
if (isCome == 1) {
isComMsg = true;
}
ChatMsgEntity entity = new ChatMsgEntity(name, date, message, img,
isComMsg);
list.add(entity);
}
c.close();
return list;
} public void delete(String userId) {
db.execSQL("CREATE table IF NOT EXISTS _"
+ userId
+ " (_id INTEGER PRIMARY KEY AUTOINCREMENT,name TEXT, img TEXT,date TEXT,isCome TEXT,message TEXT)");
db.execSQL("delete from _" + userId);
} public void close() {
if (db != null)
db.close();
}
}
package loaderman.im.dao; import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase; import java.util.ArrayList;
import java.util.List; import loaderman.im.bean.User;
import loaderman.util.LoggerUtil; /**
* Created by Administrator on 2018/12/7 0007.
*/ public class IMUserDao {
private IMChatOpenHelper helper;
private static IMUserDao mInstance;
public IMUserDao(Context context) {
helper = new IMChatOpenHelper(context);
}
public static IMUserDao getInstance(Context ctx) {
//懒汉: 考虑线程安全问题, 两种方式: 1. 给方法加同步锁 synchronized, 效率低; 2. 给创建对象的代码块加同步锁
//读数据不会出现线程安全问题, 写数据会出现线程安全问题
//a, B, C
if (mInstance == null) {
//B, C
synchronized (IMUserDao.class) {
//a
if (mInstance == null) {
mInstance = new IMUserDao(ctx);
}
}
}
return mInstance;
}
public User selectInfo(String userId) {
User u = new User();
SQLiteDatabase db = helper.getReadableDatabase();
Cursor c =db.query("user",null,"userId= ?",new String[]{userId},null,null,null);
// Cursor c = db.rawQuery("select * from user where userId= ? ", new String[] { userId});
if (c.moveToFirst()) {
u.setUserHeadPhoto(c.getString(c.getColumnIndex("userHeadPhoto")));
u.setUserName(c.getString(c.getColumnIndex("userName")));
u.setUserId(userId);
}
return u;
} public void addUser(List<User> list) { SQLiteDatabase db = helper.getWritableDatabase();
for (User u : list) {
ContentValues values = new ContentValues();
values.put("userID", u.getUserId());
values.put("userName", u.getUserName());
values.put("userHeadPhoto", u.getUserHeadPhoto());
long id = db.insert("user", null, values);
if (id == -1) {
LoggerUtil.systemOut("插入失败"); } else {
LoggerUtil.systemOut("插入成功");
}
} db.close();
} public void updateUser(List<User> list) {
if (list.size() > 0) {
delete();
addUser(list);
}
} public List<User> getUser() {
SQLiteDatabase db = helper.getWritableDatabase();
List<User> list = new ArrayList<User>();
Cursor c =db.query("user",null,null,null,null,null,null); while (c.moveToNext()) {
User u = new User();
u.setUserId(c.getString(c.getColumnIndex("userId")));
u.setUserHeadPhoto(c.getString(c.getColumnIndex("userHeadPhoto")));
u.setUserName(c.getString(c.getColumnIndex("userName"))); list.add(u);
}
c.close();
db.close();
return list;
} public void delete() {
try {
SQLiteDatabase db = helper.getWritableDatabase();
int id = db.delete("user", null, null);
if (id==-1){
LoggerUtil.systemOut("删除失败");
}else {
LoggerUtil.systemOut("删除成功");
}
db.close();
}catch (Exception e){
LoggerUtil.systemOut(e.toString());
} }
}
package loaderman.im.dao; import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase; import java.util.ArrayList; import loaderman.im.bean.IMMessage;
import loaderman.util.LoggerUtil; /**
* 消息列表
*/ public class IMUserMessageDao {
private static IMUserMessageDao mInstance;
private String TableName = "imchat";
public Context context;
private final IMChatOpenHelper helper; private IMUserMessageDao(Context ctx) {
this.context = ctx;
helper = new IMChatOpenHelper(context);
} public static IMUserMessageDao getInstance(Context ctx) {
//懒汉: 考虑线程安全问题, 两种方式: 1. 给方法加同步锁 synchronized, 效率低; 2. 给创建对象的代码块加同步锁
//读数据不会出现线程安全问题, 写数据会出现线程安全问题
//a, B, C
if (mInstance == null) {
//B, C
synchronized (IMUserMessageDao.class) {
//a
if (mInstance == null) {
mInstance = new IMUserMessageDao(ctx);
}
}
}
return mInstance;
} public boolean insert(Context context, IMMessage imMessage) {
boolean isSucceed = false;
// 1. 在内存中创建数据库帮助类的对象
// 2. 在磁盘上创建数据库文件
SQLiteDatabase db = helper.getWritableDatabase(); ContentValues values = new ContentValues();
values.put("userId", imMessage.getUserId());
values.put("userName", imMessage.getUserName());
values.put("userHeadPhoto", imMessage.getUserHeadPhoto());
values.put("messageType", imMessage.getMessageType());
values.put("lastMsgContent", imMessage.getLastMsgContent());
values.put("time", imMessage.getTime());
values.put("noReadCount", imMessage.getNoReadCount()); long id = db.insert(TableName, null, values);
if (id == -1) {
LoggerUtil.systemOut("插入失败");
isSucceed = false;
} else {
LoggerUtil.systemOut("插入成功");
isSucceed = true;
}
// 释放资源
db.close();
return isSucceed;
} public boolean update(Context context, IMMessage imMessage) { boolean isSucceed = false;
// 2. 在磁盘上创建数据库文件
SQLiteDatabase db = helper.getWritableDatabase(); ContentValues values = new ContentValues();
values.put("userId", imMessage.getUserId());
values.put("userName", imMessage.getUserName());
values.put("userHeadPhoto", imMessage.getUserHeadPhoto());
values.put("messageType", imMessage.getMessageType());
values.put("lastMsgContent", imMessage.getLastMsgContent());
values.put("time", imMessage.getTime());
values.put("noReadCount", imMessage.getNoReadCount());
int update = db.update(TableName, values, "userId=?", new String[]{imMessage.getUserId()}); // 释放资源
db.close();
return update > 0; }
public boolean updateNoReadNUmByUserId(Context context,String userId){
// 1. 在内存中创建数据库帮助类的对象
// 2. 在磁盘上创建数据库文件
SQLiteDatabase database = helper.getWritableDatabase(); ContentValues values = new ContentValues();
values.put("noReadCount",0);
int update = database.update(TableName, values, "userId=? ", new String[]{userId}); return update>0;
}
public int queryNoReadNumByUserId(Context context,String userId){
// 1. 在内存中创建数据库帮助类的对象
// 2. 在磁盘上创建数据库文件
SQLiteDatabase database = helper.getWritableDatabase();
Cursor cursor = database.query(TableName, null, "userId=? ", new String[]{userId}, null, null, null); if (cursor != null) {
if (!cursor.moveToFirst()) {
//插入
LoggerUtil.systemOut("没有查询到");
return 0;
} else {
//更新
LoggerUtil.systemOut("查询到了");
int noReadCount = cursor.getInt(cursor.getColumnIndex("noReadCount"));
if (noReadCount>=0){
return noReadCount;
} }
} else {
LoggerUtil.systemOut("cursor为空");
return 0;
}
return 0;
}
public boolean queryIsHasUserID(Context context, String userId) {
// 1. 在内存中创建数据库帮助类的对象
// 2. 在磁盘上创建数据库文件
SQLiteDatabase database = helper.getWritableDatabase();
Cursor cursor = database.query(TableName, null, "userId=? ", new String[]{userId}, null, null, null); if (cursor != null) {
if (!cursor.moveToFirst()) {
//插入
LoggerUtil.systemOut("没有查询到");
return false;
} else {
//更新
LoggerUtil.systemOut("查询到了"); return true;
}
} else {
LoggerUtil.systemOut("cursor为空");
return false;
}
} public ArrayList<IMMessage> query(Context context) {
// 1. 在内存中创建数据库帮助类的对象
// 2. 在磁盘上创建数据库文件
SQLiteDatabase database = helper.getWritableDatabase();
Cursor cursor = database.query(TableName, null, null, null, null, null, null);
ArrayList<IMMessage> list = new ArrayList<>(); if (cursor != null) {
LoggerUtil.systemOut("查询个数 " + cursor.getCount());
while (cursor.moveToNext()) {
String user = cursor.getString(cursor.getColumnIndex("userId"));
String nickname = cursor.getString(cursor.getColumnIndex("userName"));
String icon = cursor.getString(cursor.getColumnIndex("userHeadPhoto"));
int type = cursor.getInt(cursor.getColumnIndex("messageType"));
String content = cursor.getString(cursor.getColumnIndex("lastMsgContent"));
String time = cursor.getString(cursor.getColumnIndex("time"));
int noReadCount = cursor.getInt(cursor.getColumnIndex("noReadCount"));
IMMessage imMessage = new IMMessage(user, nickname, icon, type, content, time,noReadCount);
list.add(imMessage);
} cursor.close();
}
database.close();
return list;
} public boolean delete(Context context, String userID) {
boolean isDelete = false;
// 1. 在内存中创建数据库帮助类的对象
// 2. 在磁盘上创建数据库文件
SQLiteDatabase database = helper.getWritableDatabase();
int d = database.delete(TableName, "userId = ?", new String[]{userID});
if (d == 0) {
LoggerUtil.systemOut("删除失败");
isDelete = false;
} else {
LoggerUtil.systemOut("删除成功" + userID);
isDelete = true;
}
// 释放资源
database.close();
return isDelete;
} public boolean deleteAll(Context context) {
boolean isDelete = false;
// 1. 在内存中创建数据库帮助类的对象
// 2. 在磁盘上创建数据库文件
SQLiteDatabase database = helper.getWritableDatabase();
int d = database.delete(TableName, null, null);
if (d == 0) {
LoggerUtil.systemOut("删除失败");
isDelete = false;
} else {
LoggerUtil.systemOut("删除成功");
isDelete = true;
}
// 释放资源
database.close();
return isDelete;
} }
传输对象
package loaderman.im.tran; import java.io.Serializable; /**
* 传输的对象,直接通过Socket传输的最大对象
*
*/
public class TranObject<T> implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L; private TranObjectType type;// 发送的消息类型 private String fromUser;// 来自哪个用户
private String toUser;// 发往哪个用户 private T object;// 传输的对象 public TranObject(TranObjectType type) {
this.type = type;
} public String getFromUser() {
return fromUser;
} public void setFromUser(String fromUser) {
this.fromUser = fromUser;
} public String getToUser() {
return toUser;
} public void setToUser(String toUser) {
this.toUser = toUser;
} public T getObject() {
return object;
} public void setObject(T object) {
this.object = object;
} public TranObjectType getType() {
return type;
} @Override
public String toString() {
return "TranObject [type=" + type + ", fromUser=" + fromUser
+ ", toUser=" + toUser + ", object=" + object + "]";
}
}
package loaderman.im.tran; /**
* 传输对象类型
*
*
*/
public enum TranObjectType {
REGISTER, // 注册
LOGIN, // 用户登录
LOGOUT, // 用户退出登录
FRIENDLOGIN, // 好友上线
FRIENDLOGOUT, // 好友下线
MESSAGE, // 用户发送消息
UNCONNECTED, // 无法连接
FILE, // 传输文件
REFRESH, // 刷新
OFFLINEMESSAGE//离线消息
}
工具类
package loaderman.im.util; import android.app.ActivityManager;
import android.content.Context; import java.util.List; /**
* 判断是否是后台运行
*/ public class AppUtil {
public static boolean isAppOnForeground(Context context) {
// Returns a list of application processes that are running on the
// device ActivityManager activityManager = (ActivityManager) context.getApplicationContext().getSystemService(Context.ACTIVITY_SERVICE);
String packageName = context.getApplicationContext().getPackageName(); List<ActivityManager.RunningAppProcessInfo> appProcesses = activityManager
.getRunningAppProcesses();
if (appProcesses == null)
return false; for (ActivityManager.RunningAppProcessInfo appProcess : appProcesses) {
// The name of the process that this object is associated with.
if (appProcess.processName.equals(packageName)
&& appProcess.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
return true;
}
}
return false;
}
}
package loaderman.im.util; import java.text.SimpleDateFormat;
import java.util.Date; public class MyDate {
public static String getDateCN() {
SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String date = format.format(new Date(System.currentTimeMillis()));
return date;// 2012年10月03日 23:41:31
} public static String getDateEN() {
SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1 = format1.format(new Date(System.currentTimeMillis()));
return date1;// 2012-10-03 23:41:31
} public static String getDate() {
SimpleDateFormat format = new SimpleDateFormat("HH:mm");
String date = format.format(new Date(System.currentTimeMillis()));
return date;
}
}
package loaderman.im.util; import android.app.ActivityManager;
import android.app.Service;
import android.content.Context; import java.util.List;
/**
* 判断服务是否运行
*/
public class ServiceStatusUtil {
//PackageManager, TelephoyManager, DevicePolicyManager, Vibrator, SmsManager, LocationManager
//ActivityManager
public static boolean isServiceRunning(Context ctx, Class<? extends Service> clazz) {
//活动管理器, 管理一切正在运行的东西
ActivityManager am = (ActivityManager) ctx.getSystemService(Context.ACTIVITY_SERVICE);
//获取正在运行的服务, 100表示最多返回100条记录
List<ActivityManager.RunningServiceInfo> runningServices = am.getRunningServices(100);
for (ActivityManager.RunningServiceInfo info : runningServices) {
//遍历所有正在运行的服务,查看有没有我们要找的服务
String className = info.service.getClassName();//获取当前运行服务的类全名称
if (className.equals(clazz.getName())) {
//服务正在运行
return true;
}
}
return false;
}
}
客户端实现
package loaderman.im.client; import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket; import loaderman.util.LoggerUtil; /**
* 客户端
*
*
*/
public class Client { private Socket client;
private ClientThread clientThread;
private String ip;
private int port; public Client(String ip, int port) {
this.ip = ip;
this.port = port;
} public boolean start() {
try {
client = new Socket();
client.setKeepAlive(true);
client.connect(new InetSocketAddress(ip, port), 1000);
if (client.isConnected()) {
System.out.println("Connected......");
clientThread = new ClientThread(client);
clientThread.start();
}
} catch (IOException e) {
e.printStackTrace();
return false;
}
return true;
}
public Socket getSocket(){
return client;
}
// 直接通过client得到读线程
public ClientInputThread getClientInputThread() {
LoggerUtil.systemOut(clientThread.toString());
return clientThread.getIn();
} // 直接通过client得到写线程
public ClientOutputThread getClientOutputThread() {
return clientThread.getOut();
} // 直接通过client停止读写消息
public void setIsStart(boolean isStart) {
clientThread.getIn().setStart(isStart);
clientThread.getOut().setStart(isStart);
} public class ClientThread extends Thread { private ClientInputThread in;
private ClientOutputThread out; public ClientThread(Socket socket) {
in = new ClientInputThread(socket);
out = new ClientOutputThread(socket);
} public void run() {
in.setStart(true);
out.setStart(true);
in.start();
out.start();
} // 得到读消息线程
public ClientInputThread getIn() {
return in;
} // 得到写消息线程
public ClientOutputThread getOut() {
return out;
}
}
}
package loaderman.im.client; import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.Socket; import loaderman.im.bean.TextMessage;
import loaderman.im.tran.TranObject;
import loaderman.util.LoggerUtil; /**
* 客户端读消息线程
* */
public class ClientInputThread extends Thread {
private Socket socket;
private TranObject msg;
private boolean isStart = true;
private ObjectInputStream ois;
private MessageListener messageListener;// 消息监听接口对象 public ClientInputThread(Socket socket) {
this.socket = socket;
try {
ois = new ObjectInputStream(socket.getInputStream());
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 提供给外部的消息监听方法
*
* @param messageListener 消息监听接口对象
*/
public void setMessageListener(MessageListener messageListener) {
this.messageListener = messageListener;
} public void setStart(boolean isStart) {
this.isStart = isStart;
} @Override
public void run() {
try {
while (isStart) {
if (ois != null) {
msg = (TranObject) ois.readObject();
// 每收到一条消息,就调用接口的方法,并传入该消息对象,外部在实现接口的方法时,就可以及时处理传入的消息对象了
// 我不知道我有说明白没有?
LoggerUtil.systemOut("来消息了" + msg.toString());
messageListener.Message(msg);
switch (msg.getType()) {
case MESSAGE: TextMessage tm = (TextMessage) msg.getObject();
String message = tm.getMessage();
LoggerUtil.systemOut(message);
break;
}
} }
ois.close();
if (socket != null)
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
} }
package loaderman.im.client; import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket; import loaderman.im.tran.TranObject;
import loaderman.im.tran.TranObjectType; /**
* 客户端写消息线程
*
* @author way
*/
public class ClientOutputThread extends Thread {
private Socket socket;
private ObjectOutputStream oos;
private boolean isStart = true;
private TranObject msg; public ClientOutputThread(Socket socket) {
this.socket = socket;
try {
oos = new ObjectOutputStream(socket.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
} public void setStart(boolean isStart) {
this.isStart = isStart;
} // 这里处理跟服务器是一样的
public void setMsg(TranObject msg) {
this.msg = msg;
synchronized (this) {
notify();
}
} int length = 0;
double sumL = 0; @Override
public void run() {
try {
while (isStart) {
if (msg != null) { oos.writeObject(msg);
oos.flush(); if (msg.getType() == TranObjectType.LOGOUT) {// 如果是发送下线的消息,就直接跳出循环
break;
} synchronized (this) {
wait();// 发送完消息后,线程进入等待状态
}
} }
if (oos!=null){
oos.close();// 循环结束后,关闭输出流和socket
} if (socket != null){
socket.close();
} } catch (Exception e) {
e.printStackTrace();
}
} }
package loaderman.im.client; import java.util.List; import loadermanim.bean.User;
import loaderman.im.tran.TranObject; /**
* 消息监听接口
*
*
*/
public interface MessageListener {
public List<User> Message(TranObject msg);
}
packageloaderman.im; public class Constants {
public static final String SERVER_IP = "192.168.0.195";// 服务器ip
public static final int SERVER_PORT = 8080;// 服务器端口
public static final int REGISTER_FAIL = 0;//注册失败
public static final String ACTION = "loaderman.message";//消息广播action
public static final String MSGKEY = "message";//消息的key
public static final String IP_PORT = "ipPort";//保存ip、port的xml文件名
public static final String SAVE_USER = "saveUser";//保存用户信息的xml文件名
public static final String BACKKEY_ACTION="loaderman.back";//返回键发送广播的action
public static final int NOTIFY_ID = 0x911;//通知ID
public static final int NOTIFY_ID2 = 0x912;//通知ID
public static final String LoginID = "test";//模拟登录ID
public static final String DBNAME = LoginID+"IM.db";//数据库名称
public static final String Password = "e10adc3949ba59abbe56e057f20f883e";//登录密码 }
消息服务
package loaderman.im; import android.app.ActivityManager;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.media.AudioManager;
import android.media.SoundPool;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Vibrator;
import android.support.v4.app.NotificationCompat;
import android.widget.RemoteViews; import org.greenrobot.eventbus.EventBus; import java.util.List; import loaderman.R;
import loaderman.activity.MainActivity;
import loaderman.constant.ConfigConstants;
import loaderman.event.RefreshChatMessageEvent;
import loaderman.im.bean.ChatMsgEntity;
import loaderman.im.bean.IMMessage;
import loaderman.im.bean.TextMessage;
import loaderman.im.bean.User;
import loaderman.im.client.Client;
import loaderman.im.client.ClientInputThread;
import loaderman.im.client.MessageListener;
import loaderman.im.dao.ChatDB;
import loaderman.im.dao.IMUserDao;
import loaderman.im.dao.IMUserMessageDao;
import loaderman.im.tran.TranObject;
import loaderman.im.tran.TranObjectType;
import loaderman.im.util.MyDate;
import loaderman.im.view.Chat2Activity;
import loaderman.util.LoggerUtil; /**
* 收取消息服务
*/
public class GetMsgService extends Service {
private static final int MSG = 0x001;
private static final int HEART_MSG = 0x002;
private Client client;
private NotificationManager mNotificationManager;
private boolean isStart = false;// 是否与服务器连接上
private Notification mNotification;
private Context mContext = this;
public static SoundPool pool;
public static Vibrator vibrator;
// 收到用户按返回键发出的广播,就显示通知栏
private BroadcastReceiver backKeyReceiver = new BroadcastReceiver() { @Override
public void onReceive(Context context, Intent intent) {
// TODO Auto-generated method stub
// Toast.makeText(context, "进入后台运行", Toast.LENGTH_SHORT).show();
setMsgNotification();
}
};
public NotificationManager manager = null;
private ChatDB chatDB;
boolean isLogin = false;
// 用来更新通知栏消息的handler
private Handler handler = new Handler() {
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG:
IMChatManager imChatManager = IMChatManager.getInstance(GetMsgService.this);
int newMsgNum = imChatManager.getNewMsgNum();// 从全局变量中获取
newMsgNum++;// 每收到一次消息,自增一次
imChatManager.setNewMsgNum(newMsgNum);// 再设置为全局变量
TranObject<TextMessage> textObject = (TranObject<TextMessage>) msg
.getData().getSerializable("msg"); if (textObject != null) {
String form = textObject.getFromUser();// 消息从哪里来
String content = textObject.getObject().getMessage();// 消息内容 boolean has = IMUserMessageDao.getInstance(mContext).queryIsHasUserID(mContext, form);
if (has) {
User user = IMUserDao.getInstance(mContext).selectInfo(form);
int noReadCount = IMUserMessageDao.getInstance(mContext).queryNoReadNumByUserId(mContext, form);
LoggerUtil.systemOut("未读个数" + noReadCount);
IMMessage imMessage = new IMMessage(user.getUserId(), user.getUserName(), user.getUserHeadPhoto(), 0, content, MyDate.getDateEN(), noReadCount + 1);
IMUserMessageDao.getInstance(mContext).update(mContext, imMessage);
} else {
User user = IMUserDao.getInstance(mContext).selectInfo(form);
IMMessage imMessage = new IMMessage(user.getUserId(), user.getUserName(), user.getUserHeadPhoto(), 0, content, MyDate.getDateEN(), 1);
IMUserMessageDao.getInstance(mContext).insert(mContext, imMessage);
}
EventBus.getDefault().post(new RefreshChatMessageEvent());
if (Chat2Activity.ca == null) {
ChatDB chatDB = new ChatDB(mContext);
User user = IMUserDao.getInstance(mContext).selectInfo(form);
ChatMsgEntity entity = new ChatMsgEntity(user.getUserName(),
MyDate.getDateEN(), content, user.getUserHeadPhoto(), true);// 收到的消息
chatDB.saveMsg(form, entity);
} // 更新通知栏 if (manager == null) {
manager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
}
Intent intent = new Intent(mContext, MainActivity.class);
PendingIntent contentIntent = PendingIntent.getActivity(
mContext, 0, intent, 0);
Notification notify = new Notification.Builder(mContext)
.setAutoCancel(true)
.setTicker("有新消息")
.setSmallIcon(R.mipmap.ic_launcher)
.setContentTitle("来自" + form + "的消息")
.setContentText("请点击查看消息,或者进入应用查看详情")
.setDefaults(NotificationCompat.FLAG_ONLY_ALERT_ONCE | Notification.FLAG_AUTO_CANCEL)
.setWhen(System.currentTimeMillis())
.setContentIntent(contentIntent).build();
manager.notify(Constants.NOTIFY_ID2, notify);
// mNotificationManager.notify(Constants.NOTIFY_ID, mNotification);// 通知一下才会生效哦
} break;
case HEART_MSG:
Boolean serverConnetion = IMChatManager.getInstance(mContext).isServerConnetion();
boolean clientStart = IMChatManager.getInstance(mContext).isClientStart();
if (clientStart && serverConnetion) {
LoggerUtil.systemOut("连接正常");
if (!isLogin) {
LoggerUtil.systemOut(ConfigConstants.getUserID(mContext));
if (ConfigConstants.getUserID(mContext).equals("NaN")) {
isLogin = false;
IMChatManager.getInstance(mContext).login(Constants.LoginID, Constants.Password);
} else {
isLogin = true;
}
} } else {
LoggerUtil.systemOut("已经断开连接");
isStart = false;
isLogin = false; if (!isStart){
getServerClientConnection();
} ConfigConstants.logOutRemoveConfig(mContext);
}
handler.sendEmptyMessageDelayed(HEART_MSG, 5000);
break;
default:
break;
}
}
}; public boolean isAppOnForeground(Context context) {
// Returns a list of application processes that are running on the
// device ActivityManager activityManager = (ActivityManager) context.getApplicationContext().getSystemService(Context.ACTIVITY_SERVICE);
String packageName = context.getApplicationContext().getPackageName(); List<ActivityManager.RunningAppProcessInfo> appProcesses = activityManager
.getRunningAppProcesses();
if (appProcesses == null)
return false; for (ActivityManager.RunningAppProcessInfo appProcess : appProcesses) {
// The name of the process that this object is associated with.
if (appProcess.processName.equals(packageName)
&& appProcess.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
return true;
}
}
return false;
} @Override
public IBinder onBind(Intent intent) {
return null;
} @Override
public void onCreate() {// 在onCreate方法里面注册广播接收者
// TODO Auto-generated method stub
super.onCreate();
chatDB = new ChatDB(this);
IntentFilter filter = new IntentFilter();
filter.addAction(Constants.BACKKEY_ACTION);
registerReceiver(backKeyReceiver, filter);
mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
LoggerUtil.systemOut("服务开启了");
client = IMChatManager.getInstance(this).getClient();
IMChatManager.getInstance(this).setmNotificationManager(mNotificationManager);
handler.sendEmptyMessageDelayed(HEART_MSG, 10);
pool = new SoundPool(10, AudioManager.STREAM_SYSTEM, 5);
pool.load(this, R.raw.tishi, 1);
vibrator = (Vibrator) getSystemService(Service.VIBRATOR_SERVICE);
} @Override
public void onStart(Intent intent, int startId) {
super.onStart(intent, startId);
if (!isStart){
getServerClientConnection();
} } private void getServerClientConnection() {
new Thread() {
@Override
public void run() {
isStart = client.start();
IMChatManager.getInstance(GetMsgService.this).setClientStart(isStart);
System.out.println("client 是否开启:" + isStart);
if (isStart) {
ClientInputThread in = client.getClientInputThread();
in.setMessageListener(new MessageListener() { @Override
public List<User> Message(TranObject msg) {
//是在后台运行,就更新通知栏,否则就发送广播给Activity
LoggerUtil.systemOut("服务监听消息");
if (msg.getType() == TranObjectType.MESSAGE) {
if (pool != null && ConfigConstants.getSound(GetMsgService.this)) {
pool.play(1, 1, 1, 0, 0, 1);
} if (vibrator != null && ConfigConstants.getShake(GetMsgService.this)) {
vibrator.vibrate(500);
}
} if (!isAppOnForeground(mContext)) {
LoggerUtil.systemOut("后台运行");
if (msg.getType() == TranObjectType.MESSAGE) {// 只处理文本消息类型
// System.out.println("收到新消息");
// // 把消息对象发送到handler去处理
Message message = handler.obtainMessage();
message.what = MSG;
message.getData().putSerializable("msg",
msg);
handler.sendMessage(message); }
} else {
LoggerUtil.systemOut("前台运行");
Intent broadCast = new Intent();
broadCast.setAction(Constants.ACTION);
broadCast.putExtra(Constants.MSGKEY, msg);
sendBroadcast(broadCast);// 把收到的消息已广播的形式发送出去
}
return null;
}
});
}
} }.start();
} @Override
// 在服务被摧毁时,做一些事情
public void onDestroy() {
super.onDestroy();
LoggerUtil.systemOut("服务关闭");
handler.removeCallbacksAndMessages(null);
if (chatDB != null) {
chatDB.close();
} unregisterReceiver(backKeyReceiver);
mNotificationManager.cancel(Constants.NOTIFY_ID);
// 给服务器发送下线消息
if (isStart) {
IMChatManager.getInstance(this).logout();
} } /**
* 创建通知
*/
private void setMsgNotification() {
int icon = R.mipmap.ic_launcher;
CharSequence tickerText = "";
long when = System.currentTimeMillis();
mNotification = new Notification(icon, tickerText, when); // 放置在"正在运行"栏目中
mNotification.flags = Notification.FLAG_ONGOING_EVENT; RemoteViews contentView = new RemoteViews(mContext.getPackageName(), R.layout.notify_view);
contentView.setTextViewText(R.id.tv1, "点击了解详情或者停止应用");
contentView.setTextViewText(R.id.notify_msg, "风城移动应用正在运行"); // 指定个性化视图
mNotification.contentView = contentView; Intent intent = new Intent(this, MainActivity.class);
PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0,
intent, PendingIntent.FLAG_UPDATE_CURRENT);
// 指定内容意图
mNotification.contentIntent = contentIntent;
mNotificationManager.notify(Constants.NOTIFY_ID, mNotification);
}
}
消息广播
package loaderman.im; import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.media.MediaPlayer;
import android.widget.Toast; import org.greenrobot.eventbus.EventBus; import java.util.ArrayList;
import java.util.List; import loaderman.R;
import loaderman.constant.ConfigConstants;
import loaderman.event.RefreshChatMessageEvent;
import loaderman.event.RefreshFriendListEvent;
import loaderman.im.bean.ChatMsgEntity;
import loaderman.im.bean.IMMessage;
import loaderman.im.bean.OffLineMessage;
import loaderman.im.bean.TextMessage;
import loaderman.im.bean.User;
import loaderman.im.dao.ChatDB;
import loaderman.im.dao.IMUserDao;
import loaderman.im.dao.IMUserMessageDao;
import loaderman.im.tran.TranObject;
import loaderman.im.tran.TranObjectType;
import loaderman.im.util.MyDate;
import loaderman.im.view.Chat2Activity;
import loaderman.util.LoggerUtil;
import loaderman.util.ToastUtil; /**
* Created by Administrator on 2018/12/10 0010.
*/ public class GetMsgReceiver extends BroadcastReceiver {
UpdateMsg updateMsg = null; public GetMsgReceiver(UpdateMsg updateMsg) {
this.updateMsg = updateMsg;
} @Override
public void onReceive(Context context, Intent intent) { TranObject msg = (TranObject) intent
.getSerializableExtra(Constants.MSGKEY); if (msg != null) {//如果不是空,说明是消息广播
LoggerUtil.systemOut("GetMsgReceiver接收广播消息" + msg.toString());
updateMsg.update(msg);// 把收到的消息传递给子类
switch (msg.getType()) {
case MESSAGE:
LoggerUtil.systemOut("来好友消息了");
TextMessage textMsg = (TextMessage) msg.getObject(); boolean has = IMUserMessageDao.getInstance(context).queryIsHasUserID(context, msg.getFromUser());
if (has) {
User user = IMUserDao.getInstance(context).selectInfo(msg.getFromUser());
int noReadCount = IMUserMessageDao.getInstance(context).queryNoReadNumByUserId(context, msg.getFromUser());
LoggerUtil.systemOut("未读个数" + noReadCount);
IMMessage imMessage = new IMMessage(user.getUserId(), user.getUserName(), user.getUserHeadPhoto(), 0, textMsg.getMessage(), MyDate.getDateEN(), noReadCount + 1);
IMUserMessageDao.getInstance(context).update(context, imMessage);
} else {
User user = IMUserDao.getInstance(context).selectInfo(msg.getFromUser());
IMMessage imMessage = new IMMessage(user.getUserId(), user.getUserName(), user.getUserHeadPhoto(), 0, textMsg.getMessage(), MyDate.getDateEN(), 1);
IMUserMessageDao.getInstance(context).insert(context, imMessage);
}
EventBus.getDefault().post(new RefreshChatMessageEvent());
if (Chat2Activity.ca == null) {
ChatDB chatDB = new ChatDB(context);
User user = IMUserDao.getInstance(context).selectInfo(msg.getFromUser());
ChatMsgEntity entity = new ChatMsgEntity(user.getUserName(),
MyDate.getDateEN(), textMsg.getMessage(), user.getUserHeadPhoto(), true);// 收到的消息
chatDB.saveMsg(msg.getFromUser(), entity);
}
break;
case LOGIN:
LoggerUtil.systemOut("登录"); try {
boolean login = (Boolean) msg.getObject();
if (login) {
ConfigConstants.setUserID(context, Constants.LoginID);
LoggerUtil.systemOut("登录成功");
IMChatManager.getInstance(context).getFriendlist(context);
IMChatManager.getInstance(context).getOffLineMessage(context);
ToastUtil.showMsg(context, "登录成功");
} else {
LoggerUtil.systemOut("登录失败");
ToastUtil.showMsg(context, "登录失败");
}
} catch (Exception e) {
try {
LoggerUtil.systemOut(e.toString());
User loginUser = (User) msg.getObject();
if (!loginUser.getUserId().equals(Constants.LoginID)) {
Toast.makeText(context, loginUser.getUserId() + "上线了", Toast.LENGTH_SHORT).show();
MediaPlayer.create(context, R.raw.msg).start();
} } catch (Exception e1) { } } break;
case REFRESH:
LoggerUtil.systemOut("刷新");
if (msg != null && msg.getType() == TranObjectType.REFRESH) {
List<User> list = (List<User>) msg.getObject();
LoggerUtil.systemOut("好友个数 : " + list.size());
if (list.size() > 0) {
IMUserDao.getInstance(context).updateUser(list);// 保存到数据库
}
}
EventBus.getDefault().post(new RefreshFriendListEvent()); break;
case LOGOUT:
LoggerUtil.systemOut("登出"); break;
case OFFLINEMESSAGE:
if (msg != null && msg.getType() == TranObjectType.OFFLINEMESSAGE) {
ArrayList<OffLineMessage> offLineMessage = (ArrayList<OffLineMessage>) msg.getObject(); if (offLineMessage != null && offLineMessage.size() > 0) {
LoggerUtil.systemOut("离线消息个数 : " + offLineMessage.size());
for (int i = 0; i < offLineMessage.size(); i++) {
boolean has1 = IMUserMessageDao.getInstance(context).queryIsHasUserID(context, msg.getFromUser());
if (has1) {
User user = IMUserDao.getInstance(context).selectInfo(msg.getFromUser());
int noReadCount = IMUserMessageDao.getInstance(context).queryNoReadNumByUserId(context, msg.getFromUser());
LoggerUtil.systemOut("未读个数" + noReadCount);
IMMessage imMessage = new IMMessage(user.getUserId(), user.getUserName(), user.getUserHeadPhoto(), 0, offLineMessage.get(i).getTextMsg(),offLineMessage.get(i).getTime(), noReadCount + 1);
IMUserMessageDao.getInstance(context).update(context, imMessage);
} else {
User user = IMUserDao.getInstance(context).selectInfo(msg.getFromUser());
IMMessage imMessage = new IMMessage(user.getUserId(), user.getUserName(), user.getUserHeadPhoto(), 0, offLineMessage.get(i).getTextMsg(),offLineMessage.get(i).getTime(), 1);
IMUserMessageDao.getInstance(context).insert(context, imMessage);
}
EventBus.getDefault().post(new RefreshChatMessageEvent());
if (Chat2Activity.ca == null) {
ChatDB chatDB = new ChatDB(context);
User user = IMUserDao.getInstance(context).selectInfo(msg.getFromUser());
ChatMsgEntity entity = new ChatMsgEntity(user.getUserName(),
offLineMessage.get(i).getTime(), offLineMessage.get(i).getTextMsg(), user.getUserHeadPhoto(), true);// 收到的消息
chatDB.saveMsg(msg.getFromUser(), entity);
} }
}
}
break; }
} else {//如果是空消息,说明是关闭应用的广播 } } public interface UpdateMsg {
void update(TranObject msg);
}
}
package loaderman.im; import android.app.NotificationManager;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo; import java.net.Socket;
import java.util.ArrayList;
import java.util.List; import loaderman.constant.ConfigConstants;
import loaderman.im.bean.TextMessage;
import loaderman.im.bean.User;
import loaderman.im.client.Client;
import loaderman.im.client.ClientOutputThread;
import loaderman.im.tran.TranObject;
import loaderman.im.tran.TranObjectType;
import loaderman.im.util.ServiceStatusUtil;
import loaderman.util.LoggerUtil; import static petrochina.xjyt.fcydyy.MyApplication.context;
/**
* 聊天管理类
*/ public class IMChatManager {
private static final IMChatManager chatManager = new IMChatManager(); private static final Client client =new Client(Constants.SERVER_IP, Constants.SERVER_PORT); /**
* 单例模式
*
*/ public synchronized static IMChatManager getInstance(Context context) { return chatManager;
} //连接
public boolean startIMService(Context context) {
getClient();
if (isNetworkAvailable()) {
Intent service = new Intent(context, GetMsgService.class);
context.startService(service);
return true;
} else {
return false;
}
} //判断连接状态
public boolean isConnection(){
return false;
}
//得到客户端
public Client getClient() { return client; } private boolean isClientStart;// 客户端连接是否启动 //判断客户端是否启动
public boolean isClientStart() {
return isClientStart;
}
//设置客户端启动状态
public void setClientStart(boolean isClientStart) {
this.isClientStart = isClientStart;
} //登录
public boolean login(String userID,String userPassword){
LoggerUtil.systemOut("开始登录");
if (isClientStart()){
Client client = getClient();
ClientOutputThread out = client.getClientOutputThread();
TranObject<User> o = new TranObject<User>(TranObjectType.LOGIN);
User u = new User();
u.setUserId(userID);
u.setPassword(userPassword);
o.setObject(u);
out.setMsg(o);
return true;
}else {
LoggerUtil.systemOut("服务器没有开启");
return false;
} }
//登出
public boolean logout(){
LoggerUtil.systemOut("登出");
if (isClientStart()){
Client client = getClient();
ClientOutputThread out = client.getClientOutputThread();
TranObject<User> o = new TranObject<User>(TranObjectType.LOGOUT);
User u = new User();
u.setUserId(Constants.LoginID);
o.setObject(u);
out.setMsg(o);
// out.setStart(false);
// getClient().getClientInputThread().setStart(false);
return true;
}else {
LoggerUtil.systemOut("服务器没有开启");
return false;
} } public boolean getOffLineMessage(Context context){
if (isClientStart()) {
ClientOutputThread out = getClient()
.getClientOutputThread();
TranObject o = new TranObject(TranObjectType.OFFLINEMESSAGE);
o.setFromUser(ConfigConstants.getUserID(context));
out.setMsg(o);
return true;
}
return false;
} //注册
public boolean register(String userID,String userPassword,String userName){
if (isClientStart()){
Client client = getClient();
ClientOutputThread out = client.getClientOutputThread();
TranObject<User> o = new TranObject<User>(
TranObjectType.REGISTER);
User u = new User();
u.setUserId(userID);
u.setUserName(userName);
u.setPassword(userPassword);
o.setObject(u);
out.setMsg(o);
return true;
}else {
LoggerUtil.systemOut("服务器没有开启");
return false;
} }
//发送消息
public void setMessage(String msgContent,String fromUser ,String toUser) { if (msgContent.length() > 0) {
Client client = getClient();
ClientOutputThread out = client.getClientOutputThread(); if (out != null) {
TranObject<TextMessage> o = new TranObject<TextMessage>(
TranObjectType.MESSAGE);
TextMessage message = new TextMessage();
message.setMessage(msgContent);
o.setObject(message);
o.setFromUser(fromUser);
o.setToUser(toUser);
out.setMsg(o);
}
}
}
//退出
public void exit(Context context){
if (ServiceStatusUtil.isServiceRunning(context,GetMsgService.class)) {
Intent service = new Intent(context, GetMsgService.class);
context.stopService(service);
LoggerUtil.systemOut("服务准备停止");
}else {
LoggerUtil.systemOut("服务已经停止");
}
// close(context);// 父类关闭方法 }
//获取离线消息 //
private NotificationManager mNotificationManager;
private int recentNum = 0;
private int newMsgNum = 0;// 后台运行的消息
public NotificationManager getmNotificationManager() {
return mNotificationManager;
} public void setmNotificationManager(NotificationManager mNotificationManager) {
this.mNotificationManager = mNotificationManager;
}
private List<User> list =new ArrayList<>();
//获取好友列表
public boolean getFriendlist( Context context){
list.clear();
if (isClientStart()) {
ClientOutputThread out = getClient()
.getClientOutputThread();
TranObject o = new TranObject(TranObjectType.REFRESH);
o.setFromUser(ConfigConstants.getUserID(context));
out.setMsg(o);
return true;
}
return false;
}
public int getNewMsgNum() {
return newMsgNum;
} public void setNewMsgNum(int newMsgNum) {
this.newMsgNum = newMsgNum;
}
/**
* 判断手机网络是否可用
*
* @return
*/
private boolean isNetworkAvailable() {
ConnectivityManager mgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo[] info = mgr.getAllNetworkInfo();
if (info != null) {
for (int i = 0; i < info.length; i++) {
if (info[i].getState() == NetworkInfo.State.CONNECTED) {
return true;
}
}
}
return false;
}
/**
* 关闭
*/
public void close(Context context) {
Intent i = new Intent();
i.setAction(Constants.ACTION);
context.sendBroadcast(i); }
/**
* 判断是否断开连接,连接返回true,断开返回false
* @return
*/
public Boolean isServerConnetion(){
Socket socket = getClient().getSocket();
try{
boolean connected = getClient().getSocket().isConnected(); LoggerUtil.systemOut("连接情况"+connected);
// socket.sendUrgentData(0xFF);//发送1个字节的紧急数据,默认情况下,服务器端没有开启紧急数据处理,不影响正常通信
return true;
}catch(Exception se){
LoggerUtil.systemOut("心跳包发送异常"+se.toString());
return false;
}
}
}
利用socket实现聊天-Android端核心代码的更多相关文章
- Java Socket聊天室编程(一)之利用socket实现聊天之消息推送
这篇文章主要介绍了Java Socket聊天室编程(一)之利用socket实现聊天之消息推送的相关资料,非常不错,具有参考借鉴价值,需要的朋友可以参考下 网上已经有很多利用socket实现聊天的例子了 ...
- 【Android端】代码打包成jar包/aar形式
Android端代码打包成jar包和aar形式: 首先,jar包的形式和aar形式有什么区别? 1.打包之后生成的文件地址: *.jar:库/build/intermediates/bundles/d ...
- webrtc学习笔记2(Android端demo代码结构)
最近正在修改webrtc的Android端demo和服务器交互的内容,介绍一下demo的大体结构吧,以便能快速回忆. 环境:Android5.0以上.libjingle_peerconnection_ ...
- Java Socket聊天室编程(二)之利用socket实现单聊聊天室
这篇文章主要介绍了Java Socket聊天室编程(二)之利用socket实现单聊聊天室的相关资料,非常不错,具有参考借鉴价值,需要的朋友可以参考下 在上篇文章Java Socket聊天室编程(一)之 ...
- 【Android端APP 安装包检查】安装包检查具体内容及实现方法
一.安装包检查的具体包含内容有哪些? 1.安装包检查的一般内容包括: 安装包基本信息检查: 文件大小: xx MB 包名: com.xx 名称: xx 本次安装包证书与外网证书对比一致性:是 版本号 ...
- js调用android本地java代码
js调用android本地java代码 当在Android上使用WebView控件开发一个Web应用时,可以创建一个通过Javascript调用Android端java代码的接口.也就是可以通过Jav ...
- Android几行代码实现实时监听微信聊天
实现效果: 实时监听当前聊天页面的最新一条消息,如图: 实现原理: 同样是利用AccessibilityService辅助服务,关于这个服务类还不了解的同学可以先看下我上一篇关于 ...
- Android几行代码实现监听微信聊天
原创作品,转载请注明出处,尊重别人的劳动果实. 2017.2.7更新: *现在适配微信版本更加容易了,只需要替换一个Recourse-ID即可 *可以知道对方发的是小视频还是语音,并获取秒数. *可以 ...
- c++ 网络编程(一)TCP/UDP windows/linux 下入门级socket通信 客户端与服务端交互代码
原文作者:aircraft 原文地址:https://www.cnblogs.com/DOMLX/p/9601511.html c++ 网络编程(一)TCP/UDP 入门级客户端与服务端交互代码 网 ...
随机推荐
- 【python】python 自动发邮件
一.一般发邮件的方法 Python对SMTP支持有smtplib和email两个模块,email负责构造邮件,smtplib负责发送邮件. 注意到构造MIMETEXT对象时,第一个参数就是邮件正文,第 ...
- C++语法备忘
记录一些C++的语法方便日后查看. 1.C++初始化语法 C++中新增加了两种初始化语法,其中大括号初始化器需要C++11以上的实现,使用时可以加等号,也可以不加,而且大括号中可以不包含任何东西,这种 ...
- c# json数据解析——将字符串json格式数据转换成对象或实体类
网络中数据传输经常是xml或者json,现在做的一个项目之前调其他系统接口都是返回的xml格式,刚刚遇到一个返回json格式数据的接口,通过例子由易到难总结一下处理过程,希望能帮到和我一样开始不会的朋 ...
- 下载uhd_images_downloader出现报错
下载uhd_images_downloader出现报错 [INFO] Images destination: /usr/local/share/uhd/images [INFO] No invento ...
- linux实操_定时任务调度
crond任务调度 语法:crontab [选项] -e 编辑crontab定时任务 -i 查询crontab任务 -r 删除当前用户所有的crontab任务 service crond restar ...
- groovy基本语法--JSON
1.groovy提供了对JSON解析的方法 ①JsonSlurper JsonSlurper是一个将JSON文本或阅读器内容解析为Groovy数据的类结构,例如map,列表和原始类型, ...
- mysql查看当前所有数据库中的表大小和元信息information_schema
查看所有mysql数据库表和索引大小 mysql查看当前所有的数据库和索引大小 ,),' mb') as data_size, concat(,),'mb') as index_size from i ...
- 004_linuxC++之_函数的重载
(一)源码下载 (一) 函数的重载:同一个命名函数,通过传入参数的不同,调用不一样的函数 上面程序的运行结果: (二)函数只能通过参数的不一样重载函数,不能通过返回参数的不一样重载函数 运行结果报错 ...
- 详解Kafka: 大数据开发最火的核心技术
详解Kafka: 大数据开发最火的核心技术 架构师技术联盟 2019-06-10 09:23:51 本文共3268个字,预计阅读需要9分钟. 广告 大数据时代来临,如果你还不知道Kafka那你就真 ...
- 51nod 1020
求 $n$ 个数的排列中逆序数为 $k$ 的排列数$f[n][k]$ 表示 $n$ 个数的排列中逆序数为 $k$ 的排列数$f[n][k] = \sum_{i = 0}^{n - 1} f[n - 1 ...