AndroidManifest.xml:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="cn.com.lenew.bluetooth">
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_PRIVILEGED" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
<application
android:allowBackup="true"
android:icon="@mipmap/icon_logo"
android:label="@string/app_name"
android:name=".App"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".activity.MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".activity.ChatActivity"></activity>
<service android:name=".service.ServerService">
<intent-filter>
<action android:name="bid.yangjing.bluetooth.ServerService"/>
</intent-filter>
</service>
<service android:name=".service.MessageService">
<intent-filter>
<action android:name="bid.yangjing.bluetooth.MessageService"/>
</intent-filter>
</service>
</application>
</manifest>
MainActivity.java：
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Build;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ListView;
import android.widget.Toast;
import java.util.ArrayList;
import cn.com.lenew.bluetooth.R;
import cn.com.lenew.bluetooth.adapter.DevicesAdapter;
import cn.com.lenew.bluetooth.bean.BluetoothMessage;
import cn.com.lenew.bluetooth.utils.BluetoothUtils;
import cn.com.lenew.bluetooth.utils.ProgressUtils;
public class MainActivity extends AppCompatActivity implements AdapterView.OnItemClickListener{
public static final String[] permissions = {
"android.permission.BLUETOOTH",
"android.permission.BLUETOOTH_ADMIN",
"android.permission.ACCESS_COARSE_LOCATION",
// "android.permission.WRITE_EXTERNAL_STORAGE",
"android.permission.BLUETOOTH_PRIVILEGED"
};
//
// "android.permission.SYSTEM_ALERT_WINDOW"
// "android.permission.READ_EXTERNAL_STORAGE",
private ListView listView;
private DevicesAdapter adapter;
private ArrayList<BluetoothDevice> list;
private Context mContext;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mContext = this;
if(Build.VERSION.SDK_INT>=23){
requestPermissions(permissions,1);
}
initReceiver();
list = new ArrayList<>();
adapter = new DevicesAdapter(this,list);
listView = (ListView) findViewById(R.id.listview);
listView.setAdapter(adapter);
listView.setOnItemClickListener(this);
if(BluetoothUtils.getInstance(this).isEnabled()){
// ProgressUtils.showProgress(mContext, "正在初始化...");
BluetoothUtils.getInstance(this).scanDevices();
}else {
BluetoothUtils.getInstance(this).enableBluetooth();
}
list.addAll(BluetoothUtils.getInstance(mContext).getAvailableDevices());
adapter.notifyDataSetChanged();
}
public void onClick(View view){
showToast("开始扫描");
list.clear();
list.addAll(BluetoothUtils.getInstance(mContext).getAvailableDevices());
adapter.notifyDataSetChanged();
BluetoothUtils.getInstance(this).scanDevices();
}
private void initReceiver() {
IntentFilter filter = new IntentFilter();
filter.addAction(BluetoothDevice.ACTION_FOUND);
filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
filter.addAction(BluetoothMessage.ACTION_INIT_COMPLETE);
filter.addAction(BluetoothMessage.ACTION_CONNECTED_SERVER);
filter.addAction(BluetoothMessage.ACTION_CONNECT_ERROR);
registerReceiver(receiver, filter);
}
BroadcastReceiver receiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
switch (intent.getAction()){
case BluetoothDevice.ACTION_FOUND:
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
for(int i=0;i<list.size();i++){
if(device.getAddress()==null || device.getAddress().equals(list.get(i).getAddress())){
return;
}
}
list.add(device);
adapter.notifyDataSetChanged();
break;
case BluetoothAdapter.ACTION_DISCOVERY_STARTED:
// showToast("开始扫描");
break;
case BluetoothAdapter.ACTION_DISCOVERY_FINISHED:
// showToast("扫描完成");
break;
case BluetoothMessage.ACTION_INIT_COMPLETE:
ProgressUtils.dismissProgress();
break;
case BluetoothMessage.ACTION_CONNECTED_SERVER:
ProgressUtils.dismissProgress();
String remoteAddress = intent.getStringExtra(BluetoothUtils.EXTRA_REMOTE_ADDRESS);
openChatRoom(remoteAddress);
break;
case BluetoothMessage.ACTION_CONNECT_ERROR:
ProgressUtils.dismissProgress();
showToast(intent.getStringExtra(BluetoothUtils.EXTRA_ERROR_MSG));
break;
}
}
};
private void openChatRoom(String remoteAddress) {
Intent intent = new Intent(mContext,ChatActivity.class);
intent.putExtra("remoteAddress",remoteAddress);
startActivity(intent);
}
@Override
protected void onDestroy() {
unregisterReceiver(receiver);
super.onDestroy();
}
public void showToast(String msg){
Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
}
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
final BluetoothDevice device = list.get(position);
if(BluetoothUtils.getInstance(this).isDiscoverying()){
BluetoothUtils.getInstance(this).cancelScan();
}
BluetoothUtils.getInstance(mContext).connect(device.getAddress());
ProgressUtils.showProgress(mContext,"正在连接，请稍候...");
}
}
BluetoothUtils.java:
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.content.Context;
import android.content.Intent;
import android.os.Handler;
import android.os.Message;
import android.text.TextUtils;
import android.util.Log;
import android.widget.Toast;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.UUID;
import cn.com.lenew.bluetooth.bean.BluetoothMessage;
import cn.com.lenew.bluetooth.database.DBManager;
import cn.com.lenew.bluetooth.service.MessageService;
import cn.com.lenew.bluetooth.service.ServerService;
public class BluetoothUtils {
private static final String PROTOCOL_SCHEME_RFCOMM = "server_name";
private static final String UUIDString = "00001101-0000-1000-8000-00805F9B34FB";
public static final String EXTRA_REMOTE_ADDRESS = "remoteAddress";
public static final String EXTRA_ERROR_MSG = "error_msg";
private static BluetoothUtils instance;
/** 已连接到服务器 */
private static final int CONNECTED_SERVER = 1;
/** 连接服务器出错 */
private static final int CONNECT_SERVER_ERROR = CONNECTED_SERVER + 1;
/** 正在连接服务器 */
private static final int IS_CONNECTING_SERVER = CONNECT_SERVER_ERROR + 1;
/** 等待客户端连接 */
private static final int WAITING_FOR_CLIENT = IS_CONNECTING_SERVER + 1;
/** 已连接客户端 */
private static final int CONNECTED_CLIENT = WAITING_FOR_CLIENT + 1;
/** 连接客户端出错 */
private static final int CONNECT_CLIENT_ERROR = CONNECTED_CLIENT + 1;
private BluetoothAdapter bluetoothAdapter;
private Context mContext;
/**
* socket集合
*/
private HashMap<String, BluetoothSocket> socketMap = new HashMap<>();
/**
* 远程设备集合
*/
// private HashMap<String, BluetoothDevice> remoteDeviceMap = new HashMap<>();
private HashMap<String,ReadThread> readThreadMap = new HashMap<>();
private BluetoothServerSocket mServerSocket;
private Handler linkDetectedHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
if(msg.obj instanceof BluetoothMessage){
BluetoothMessage message = (BluetoothMessage) msg.obj;
Intent intent = new Intent();
intent.setAction(BluetoothMessage.ACTION_RECEIVED_NEW_MSG);
intent.putExtra("msg", message);
mContext.sendOrderedBroadcast(intent, null);
DBManager.save(message);
// mContext.sendBroadcast(intent);
}else {
Intent intent = new Intent();
switch (msg.what){
case WAITING_FOR_CLIENT:
//初始化服务器完成
intent.setAction(BluetoothMessage.ACTION_INIT_COMPLETE);
break;
case IS_CONNECTING_SERVER:
//正在连接服务器
break;
case CONNECTED_CLIENT:
//有客户端连接到自己
break;
case CONNECT_CLIENT_ERROR:
//连接客户端出错
break;
case CONNECT_SERVER_ERROR:
//连接服务器出错
intent.putExtra(EXTRA_ERROR_MSG,(String)msg.obj);
intent.setAction(BluetoothMessage.ACTION_CONNECT_ERROR);
break;
case CONNECTED_SERVER:
intent.putExtra(EXTRA_REMOTE_ADDRESS,(String)msg.obj);
intent.setAction(BluetoothMessage.ACTION_CONNECTED_SERVER);
break;
}
mContext.sendBroadcast(intent);
// String msgContent = (String) msg.obj;
// Toast.makeText(mContext, msgContent, Toast.LENGTH_SHORT).show();
}
}
};
private BluetoothUtils(Context context) {
mContext = context;
if (context == null) {
throw new RuntimeException("Parameter context can not be null !");
}
bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
}
public static BluetoothUtils getInstance(Context context) {
if (instance == null) {
instance = new BluetoothUtils(context);
}
return instance;
}
public void enableBluetooth() {
if (!bluetoothAdapter.isEnabled()) {
// Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
// intent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
// mContext.startActivity(intent);
bluetoothAdapter.enable();
}
}
public void scanDevices() {
if (!bluetoothAdapter.isEnabled()) {
enableBluetooth();
return;
}
bluetoothAdapter.startDiscovery();
startService();
}
private void startService() {
Intent serverIntent = new Intent(mContext, ServerService.class);
mContext.startService(serverIntent);
Intent clientIntent = new Intent(mContext, MessageService.class);
mContext.startService(clientIntent);
}
public boolean isEnabled() {
return bluetoothAdapter.isEnabled();
}
public ArrayList<BluetoothDevice> getAvailableDevices() {
Set<BluetoothDevice> availableDevices = bluetoothAdapter.getBondedDevices();
ArrayList availableList = new ArrayList();
for (Iterator<BluetoothDevice> iterator = availableDevices.iterator(); iterator.hasNext(); ) {
availableList.add(iterator.next());
}
return availableList;
}
public boolean isBonded(BluetoothDevice device) {
Set<BluetoothDevice> availableDevices = bluetoothAdapter.getBondedDevices();
for (Iterator<BluetoothDevice> iterator = availableDevices.iterator(); iterator.hasNext(); ) {
if (device.getAddress().equals(iterator.next().getAddress())) {
return true;
}
}
return false;
}
public boolean isDiscoverying() {
return bluetoothAdapter.isDiscovering();
}
public void cancelScan() {
bluetoothAdapter.cancelDiscovery();
}
//开启客户端
private class ClientThread extends Thread {
private String remoteAddress;
public ClientThread(String remoteAddress) {
this.remoteAddress = remoteAddress;
}
@Override
public void run() {
try {
//创建一个Socket连接：只需要服务器在注册时的UUID号
// socket = device.createRfcommSocketToServiceRecord(BluetoothProtocols.OBEX_OBJECT_PUSH_PROTOCOL_UUID);
BluetoothDevice device = bluetoothAdapter.getRemoteDevice(remoteAddress);
BluetoothSocket socket = device.createRfcommSocketToServiceRecord(UUID.fromString(UUIDString));
// socketMap.put(remoteAddress, socket);
//连接
Message msg2 = new Message();
msg2.obj = "请稍候，正在连接服务器:" + remoteAddress;
msg2.what = IS_CONNECTING_SERVER;
linkDetectedHandler.sendMessage(msg2);
socket.connect();
// socketMap.put(BluetoothMessage.bluetoothAddress, socket);
socketMap.put(remoteAddress, socket);
Message msg = new Message();
// msg.obj = "已经连接上服务端！可以发送信息。";
msg.obj = remoteAddress;
msg.what = CONNECTED_SERVER;
linkDetectedHandler.sendMessage(msg);
//启动接受数据
ReadThread mreadThread = new ReadThread(remoteAddress);
readThreadMap.put(remoteAddress,mreadThread);
mreadThread.start();
} catch (IOException e) {
e.printStackTrace();
socketMap.remove(remoteAddress);
Log.e("connect", e.getMessage(), e);
Message msg = new Message();
msg.obj = "连接服务端异常！断开连接重新试一试。"+e.getMessage();
msg.what = CONNECT_SERVER_ERROR;
linkDetectedHandler.sendMessage(msg);
// remoteDeviceMap.remove(remoteAddress);
}
}
}
//开启服务器
private class ServerThread extends Thread {
@Override
public void run() {
try {
/* 创建一个蓝牙服务器
* 参数分别：服务器名称、UUID */
mServerSocket = bluetoothAdapter.listenUsingRfcommWithServiceRecord(PROTOCOL_SCHEME_RFCOMM, UUID.fromString(UUIDString));
while (true){
Log.d("server", "wait cilent connect...");
Message msg = new Message();
msg.obj = "请稍候，正在等待客户端的连接...";
msg.what = WAITING_FOR_CLIENT;
linkDetectedHandler.sendMessage(msg);
/* 接受客户端的连接请求 */
BluetoothSocket socket = mServerSocket.accept();
socketMap.put(socket.getRemoteDevice().getAddress(), socket);
// remoteDeviceMap.put(socket.getRemoteDevice().getAddress(),socket.getRemoteDevice());
Log.d("server", "accept success !");
Message msg2 = new Message();
String info = "客户端已经连接上！可以发送信息。";
msg2.obj = info;
msg.what = CONNECTED_CLIENT;
linkDetectedHandler.sendMessage(msg2);
//启动接受数据
ReadThread mreadThread = new ReadThread(socket.getRemoteDevice().getAddress());
readThreadMap.put(socket.getRemoteDevice().getAddress(),mreadThread);
mreadThread.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/* 停止服务器 */
private void shutdownServer() {
new Thread() {
@Override
public void run() {
try {
if (startServerThread != null) {
startServerThread.interrupt();
startServerThread = null;
}
Set<String> keySet = socketMap.keySet();
for (Iterator<String> iterator = keySet.iterator(); iterator.hasNext(); ) {
String remoteDeviceAddress = iterator.next();
BluetoothSocket socket = socketMap.get(remoteDeviceAddress);
if (socket != null) {
socket.close();
socketMap.remove(remoteDeviceAddress);
}
ReadThread mreadThread = readThreadMap.get(remoteDeviceAddress);
if (mreadThread != null) {
mreadThread.interrupt();
readThreadMap.remove(remoteDeviceAddress);
}
}
if (mServerSocket != null) {
mServerSocket.close();/* 关闭服务器 */
mServerSocket = null;
}
} catch (IOException e) {
Log.e("server", "mServerSocket.close()", e);
}
}
}.start();
}
/* 停止客户端连接 */
private void shutdownClient() {
new Thread() {
@Override
public void run() {
try {
if (clientConnectThread != null) {
clientConnectThread.interrupt();
clientConnectThread = null;
}
Set<String> keySet = socketMap.keySet();
for (Iterator<String> iterator = keySet.iterator(); iterator.hasNext(); ) {
String remoteDeviceAddress = iterator.next();
BluetoothSocket socket = socketMap.get(remoteDeviceAddress);
if (socket != null) {
socket.close();
socketMap.remove(remoteDeviceAddress);
}
ReadThread mreadThread = readThreadMap.get(remoteDeviceAddress);
if (mreadThread != null) {
mreadThread.interrupt();
readThreadMap.remove(remoteDeviceAddress);
}
}
}catch (Exception e){
Log.d("shutdownCLient", e.getMessage());
}
}
}.start();
}
//发送数据
public void sendMessageHandle(BluetoothMessage msg,String remoteDeviceAddress) {
BluetoothSocket socket = socketMap.get(remoteDeviceAddress);
if (socket == null) {
Toast.makeText(mContext, "正在连接...", Toast.LENGTH_SHORT).show();
connect(remoteDeviceAddress);
return;
}
try {
OutputStream os = socket.getOutputStream();
// os.write(msg.getBytes());
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(msg);
msg.setReceiver(remoteDeviceAddress);
DBManager.save(msg);
} catch (IOException e) {
closeConnection(remoteDeviceAddress);
e.printStackTrace();
}
}
private void closeConnection(String remoteDeviceAddress) {
socketMap.remove(remoteDeviceAddress);
// remoteDeviceMap.remove(remoteDeviceAddress);
readThreadMap.remove(remoteDeviceAddress);
}
//读取数据
private class ReadThread extends Thread {
private String remoteDeviceAddress;
public ReadThread(String remoteDeviceAddress){
this.remoteDeviceAddress = remoteDeviceAddress;
}
@Override
public void run() {
byte[] buffer = new byte[1024];
int bytes;
InputStream mmInStream = null;
BluetoothSocket socket = socketMap.get(remoteDeviceAddress);
try {
mmInStream = socket.getInputStream();
} catch (IOException e1) {
e1.printStackTrace();
}
while (true) {
try {
// Read from the InputStream
// if ((bytes = mmInStream.read(buffer)) > 0) {
// byte[] buf_data = new byte[bytes];
// for (int i = 0; i < bytes; i++) {
// buf_data[i] = buffer[i];
// }
// String s = new String(buf_data);
// Message msg = new Message();
// msg.obj = s;
// msg.what = 1;
// linkDetectedHandler.sendMessage(msg);
// }
ObjectInputStream ois = new ObjectInputStream(mmInStream);
BluetoothMessage message = (BluetoothMessage) ois.readObject();
message.setSender(remoteDeviceAddress);
message.setIsMe(0);
Message msg = new Message();
msg.obj = message;
msg.what = 1;
linkDetectedHandler.sendMessage(msg);
} catch (Exception e) {
try {
// BluetoothMessage.isOpen = false;
closeConnection(remoteDeviceAddress);
mmInStream.close();
} catch (IOException e1) {
e1.printStackTrace();
}
break;
}
}
}
}
private ClientThread clientConnectThread;
public ServerThread startServerThread;
// public void init(String remoteAddress, BluetoothMessage.DeviceType deviceType) {
// BluetoothMessage.deviceType = deviceType;
// BluetoothMessage.bluetoothAddress = remoteAddress;
//
//// if (BluetoothMessage.isOpen) {
//// Toast.makeText(mContext, "连接已经打开，可以通信。如果要再建立连接，请先断开！", Toast.LENGTH_SHORT).show();
//// return;
//// }
// if (BluetoothMessage.deviceType == BluetoothMessage.DeviceType.CLIENT) {
// if (!TextUtils.isEmpty(remoteAddress)) {
// BluetoothDevice remoteDevice = bluetoothAdapter.getRemoteDevice(remoteAddress);
// if (!remoteDeviceMap.containsKey(remoteAddress)) {
// remoteDeviceMap.put(remoteAddress, remoteDevice);
// clientConnectThread = new ClientThread(remoteAddress);
// clientConnectThread.start();
// }
//// BluetoothMessage.isOpen = true;
// } else {
// Toast.makeText(mContext, "address is null !", Toast.LENGTH_SHORT).show();
// }
// } else if (BluetoothMessage.deviceType == BluetoothMessage.DeviceType.SERVER) {
// startServerThread = new ServerThread();
// startServerThread.start();
// BluetoothMessage.isOpen = true;
// }
// }
public void onDestroy() {
// if (BluetoothMessage.deviceType == BluetoothMessage.DeviceType.CLIENT) {
// shutdownClient();
// } else if (BluetoothMessage.deviceType == BluetoothMessage.DeviceType.SERVER) {
// shutdownServer();
// }
// BluetoothMessage.isOpen = false;
// BluetoothMessage.deviceType = BluetoothMessage.DeviceType.NONE;
shutdownClient();
shutdownServer();
}
public void connect(String remoteAddress){
if (!TextUtils.isEmpty(remoteAddress)) {
BluetoothDevice remoteDevice = bluetoothAdapter.getRemoteDevice(remoteAddress);
if (!socketMap.containsKey(remoteAddress)) {
// remoteDeviceMap.put(remoteAddress, remoteDevice);
if(clientConnectThread!=null && clientConnectThread.isAlive()){
return;
}
clientConnectThread = new ClientThread(remoteAddress);
clientConnectThread.start();
}else {
Intent intent = new Intent();
intent.putExtra(EXTRA_REMOTE_ADDRESS,remoteAddress);
intent.setAction(BluetoothMessage.ACTION_CONNECTED_SERVER);
mContext.sendBroadcast(intent);
}
} else {
Toast.makeText(mContext, "address is null !", Toast.LENGTH_SHORT).show();
}
}
public void initServer(){
startServerThread = new ServerThread();
startServerThread.start();
}
public BluetoothAdapter getBluetoothAdapter() {
return bluetoothAdapter;
}
}
MessageService.java：
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.os.IBinder;
import android.support.annotation.Nullable;
import cn.com.lenew.bluetooth.R;
import cn.com.lenew.bluetooth.activity.ChatActivity;
import cn.com.lenew.bluetooth.bean.BluetoothMessage;
public class MessageService extends Service{
private Context mContext;
private NotificationManager notificationManager;
@Nullable
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public void onCreate() {
super.onCreate();
mContext = this;
notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
IntentFilter intentFilter = new IntentFilter(BluetoothMessage.ACTION_RECEIVED_NEW_MSG);
intentFilter.setPriority(990);
registerReceiver(msgReceiver, intentFilter);
}
@Override
public void onDestroy() {
super.onDestroy();
unregisterReceiver(msgReceiver);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
return Service.START_STICKY;
}
public void sendNotification(String content,String remoteAddress,BluetoothMessage message){
Intent chatIntent = new Intent(mContext, ChatActivity.class);
chatIntent.putExtra("remoteAddress",remoteAddress);
chatIntent.putExtra("lastmsg",message);
PendingIntent pendingIntent = PendingIntent.getActivity(mContext, 0, chatIntent, PendingIntent.FLAG_UPDATE_CURRENT);
Notification notification = new Notification.Builder(mContext)
.setContentText(content)
.setContentIntent(pendingIntent)
.setSmallIcon(R.mipmap.icon_logo)
.setAutoCancel(true)
.setContentTitle("您有一条新消息")
.build();
notification.defaults = Notification.DEFAULT_SOUND;
notificationManager.notify(1,notification);
}
BroadcastReceiver msgReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
BluetoothMessage bluetoothMessage = (BluetoothMessage) intent.getSerializableExtra("msg");
bluetoothMessage.setIsMe(0);
String remoteAddress = bluetoothMessage.getSender();
String msgContent;
if(bluetoothMessage.getContent().length()>10){
msgContent = bluetoothMessage.getContent().substring(0,10);
}else {
msgContent = bluetoothMessage.getContent();
}
String msg = bluetoothMessage.getSenderNick()+":"+msgContent;
sendNotification(msg,remoteAddress,bluetoothMessage);
}
}
}
DBManager.java：
import org.xutils.DbManager;
import org.xutils.db.Selector;
import org.xutils.ex.DbException;
import org.xutils.x;
import java.util.List;
import cn.com.lenew.bluetooth.bean.BluetoothMessage;
public class DBManager {
private static DbManager.DaoConfig daoConfig;
public static DbManager.DaoConfig getDaoConfig(){
if(daoConfig==null){
daoConfig = new DbManager.DaoConfig();
daoConfig.setDbVersion(2);
}
return daoConfig;
}
public static void save(Object obj){
try {
x.getDb(DBManager.getDaoConfig()).save(obj);
} catch (DbException e) {
e.printStackTrace();
}
}
public static List<BluetoothMessage> findAll(String remoteAddress) {
try {
Selector<BluetoothMessage> selector = x.getDb(getDaoConfig()).selector(BluetoothMessage.class);
selector.where("sender","=",remoteAddress);
selector.or("receiver","=",remoteAddress);
return selector.findAll();
} catch (DbException e) {
e.printStackTrace();
}
return null;
}
}
项目详细代码：码云地址