SimpleGameTest
org.eclipse.core.resources.prefs
org.eclipse.jdt.core.prefs
BluetoothChatService$AcceptThread.class
BluetoothChatService$ConnectedThread.class
BluetoothChatService$ConnectThread.class
BluetoothChatService.class
simplegametest
BlueToothItems.class
BuildConfig.class
ChessActivity$1.class
ChessActivity$2$1.class
ChessActivity$2.class
ChessActivity$3$1$1.class
ChessActivity$3$1.class
ChessActivity$3$2.class
ChessActivity$3.class
ChessActivity$4.class
ChessActivity.class
ChessBLEActivity$1$1.class
ChessBLEActivity$1.class
ChessBLEActivity$2.class
ChessBLEActivity$3$1.class
ChessBLEActivity$3$2.class
ChessBLEActivity$3.class
ChessBLEActivity$4$1.class
ChessBLEActivity$4.class
ChessBLEActivity$ListenerThread.class
ChessBLEActivity.class
ChessDeviceChoiesActivity$1.class
ChessDeviceChoiesActivity$2.class
ChessDeviceChoiesActivity.class
MainActivity.class
R$attr.class
R$dimen.class
R$drawable.class
R$id.class
R$layout.class
R$menu.class
R$string.class
R$style.class
SnickActivity.class
ActivityHelper$1.class
ActivityHelper$2.class
ActivityHelper$onDialogCallBack.class
ActivityHelper.class
AddressGetter.class
IPUtils.class
JsonBeanUtil.class
MapAnnotation$Map.class
MapAnnotation.class
ScopeAnnotation$Scope.class
ScopeAnnotation.class
MySocket$1.class
MySocket$2.class
MySocket$3.class
MySocket$4.class
MySocket$5.class
MySocket$onSocketCallBack.class
MySocket.class
Server$ConnectCallBack.class
Server.class
ChessView$MyThread.class
ChessView$onStepLisenner.class
ChessView.class
Chess_Item_Base.class
Chess_Status.class
MyGameView$MyThread.class
MyGameView$point.class
MyGameView.class
android-support-v4-aa6f22c36dee0be536cc.jar
drawable-hdpi
ic_launcher.png
drawable-mdpi
ic_launcher.png
drawable-xhdpi
ic_launcher.png
drawable-xxhdpi
ic_launcher.png
AndroidManifest.xml
classes.dex
jarlist.cache
resources.ap_
SimpleGameTest.apk
simplegametest
android-support-v4.jar
drawable-hdpi
ic_launcher.png
drawable-mdpi
ic_launcher.png
drawable-xhdpi
ic_launcher.png
drawable-xxhdpi
ic_launcher.png
activity_main.xml
chessble.xml
deviceitems_choies.xml
list_item_devices.xml
dimens.xml
strings.xml
styles.xml
values-sw600dp
dimens.xml
values-sw720dp-land
dimens.xml
values-v11
styles.xml
values-v14
styles.xml
simplegametest
.classpath
AndroidManifest.xml
ic_launcher-web.png
proguard-project.txt
project.properties
源码说明.txt
* Copyright (C) 2009 The Android Open Source Project
* Licensed under the Apache License, Version 2.0 (the &License&);
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an &AS IS& BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
package bluetooth.
import java.io.IOE
import java.io.InputS
import java.io.OutputS
import java.util.UUID;
import android.annotation.SuppressL
import android.bluetooth.BluetoothA
import android.bluetooth.BluetoothD
import android.bluetooth.BluetoothServerS
import android.bluetooth.BluetoothS
import android.content.C
import android.os.B
import android.os.H
import android.os.M
import android.util.L
import com.example.simplegametest.MainA
* This class does all the work for setting up and managing Bluetooth
* connections with other devices. It has a thread that listens for
* incoming connections, a thread for connecting with a device, and a
* thread for performing data transmissions when connected.
public class BluetoothChatService {
public static final int MESSAGE_STATE_CHANGE = 1;
public static final int MESSAGE_READ = 2;
public static final int MESSAGE_WRITE = 3;
public static final int MESSAGE_DEVICE_NAME = 4;
public static final int MESSAGE_TOAST = 5;
public static final String DEVICE_NAME = &device_name&;
public static final String TOAST = &toast&;
// Intent request codes
private static final int REQUEST_CONNECT_DEVICE_SECURE = 1;
private static final int REQUEST_CONNECT_DEVICE_INSECURE = 2;
private static final int REQUEST_ENABLE_BT = 3;
// Debugging
private static final String TAG = &BluetoothChatService&;
private static final boolean D =
// Name for the SDP record when creating server socket
private static final String NAME_SECURE = &BluetoothChatSecure&;
private static final String NAME_INSECURE = &BluetoothChatInsecure&;
// Unique UUID for this application
//hmuuid==&& d89d5d15-05de-3a88-93f9-d45a5e3fd03d
//kpuuid==&& 8f8f018a--9b06-aeb
private static final UUID MY_UUID_SECURE =
UUID.fromString(&d89d5d15-05de-3a88-93f9-d45a5e3fd03d&);
private static final UUID MY_UUID_INSECURE =
UUID.fromString(&8f8f018a--9b06-aeb&);
// Member fields
private final BluetoothAdapter mA
private static Handler mH
private AcceptThread mSecureAcceptT
private AcceptThread mInsecureAcceptT
private ConnectThread mConnectT
private ConnectedThread mConnectedT
private int mS
// Constants that indicate the current connection state
public static final int STATE_NONE = 0;
// we're doing nothing
public static final int STATE_LISTEN = 1;
// now listening for incoming connections
public static final int STATE_CONNECTING = 2; // now initiating an outgoing connection
public static final int STATE_CONNECTED = 3;
// now connected to a remote device
* Constructor. Prepares a new BluetoothChat session.
* @param context
The UI Activity Context
* @param handler
A Handler to send messages back to the UI Activity
public BluetoothChatService(Context context, Handler handler) {
mAdapter = BluetoothAdapter.getDefaultAdapter();
mState = STATE_NONE;
mHandler =
* Set the current state of the chat connection
* @param state
An integer defining the current connection state
private synchronized void setState(int state) {
if (D) Log.d(TAG, &setState() & + mState + & -& & + state);
// Give the new state to the Handler so the UI Activity can update
mHandler.obtainMessage(BluetoothChat.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();
* Return the current connection state. */
public synchronized int getState() {
* Start the chat service. Specifically start AcceptThread to begin a
* session in listening (server) mode. Called by the Activity onResume() */
public synchronized void start() {
if (D) Log.d(TAG, &start&);
// Cancel any thread attempting to make a connection
if (mConnectThread != null)
mConnectThread.cancel();
mConnectThread =
// Cancel any thread currently running a connection
if (mConnectedThread != null)
mConnectedThread.cancel();
mConnectedThread =
setState(STATE_LISTEN);
// Start the thread to listen on a BluetoothServerSocket
if (mSecureAcceptThread == null)
mSecureAcceptThread = new AcceptThread(true);
mSecureAcceptThread.start();
if (mInsecureAcceptThread == null)
mInsecureAcceptThread = new AcceptThread(false);
mInsecureAcceptThread.start();
* Start the ConnectThread to initiate a connection to a remote device.
* @param device
The BluetoothDevice to connect
* @param secure Socket Security type - Secure (true) , Insecure (false)
public synchronized void connect(BluetoothDevice device, boolean secure) {
if (D) Log.d(TAG, &connect to: & + device);
// Cancel any thread attempting to make a connection
if (mState == STATE_CONNECTING) {
if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread =}
// Cancel any thread currently running a connection
if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread =}
// Start the thread to connect with the given device
mConnectThread = new ConnectThread(device, secure);
mConnectThread.start();
setState(STATE_CONNECTING);
* Start the ConnectedThread to begin managing a Bluetooth connection
* @param socket
The BluetoothSocket on which the connection was made
* @param device
The BluetoothDevice that has been connected
public synchronized void connected(BluetoothSocket socket, BluetoothDevice
device, final String socketType) {
if (D) Log.d(TAG, &connected, Socket Type:& + socketType);
// Cancel the thread that completed the connection
if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread =}
// Cancel any thread currently running a connection
if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread =}
// Cancel the accept thread because we only want to connect to one device
if (mSecureAcceptThread != null) {
mSecureAcceptThread.cancel();
mSecureAcceptThread =
if (mInsecureAcceptThread != null) {
mInsecureAcceptThread.cancel();
mInsecureAcceptThread =
// Start the thread to manage the connection and perform transmissions
mConnectedThread = new ConnectedThread(socket, socketType);
mConnectedThread.start();
// Send the name of the connected device back to the UI Activity
Message msg = mHandler.obtainMessage(MESSAGE_DEVICE_NAME);
Bundle bundle = new Bundle();
bundle.putString(DEVICE_NAME, device.getName());
msg.setData(bundle);
mHandler.sendMessage(msg);
setState(STATE_CONNECTED);
* Stop all threads
public synchronized void stop() {
if (D) Log.d(TAG, &stop&);
if (mConnectThread != null) {
mConnectThread.cancel();
mConnectThread =
if (mConnectedThread != null) {
mConnectedThread.cancel();
mConnectedThread =
if (mSecureAcceptThread != null) {
mSecureAcceptThread.cancel();
mSecureAcceptThread =
if (mInsecureAcceptThread != null) {
mInsecureAcceptThread.cancel();
mInsecureAcceptThread =
setState(STATE_NONE);
* Write to the ConnectedThread in an unsynchronized manner
* @param out The bytes to write
* @see ConnectedThread#write(byte[])
public void write(byte[] out) {
// Create temporary object
ConnectedT
// Synchronize a copy of the ConnectedThread
synchronized (this) {
if (mState != STATE_CONNECTED)
r = mConnectedT
// Perform the write unsynchronized
r.write(out);
* Indicate that the connection attempt failed and notify the UI Activity.
private void connectionFailed() {
// Send a failure message back to the Activity
Message msg = mHandler.obtainMessage(MESSAGE_TOAST);
Bundle bundle = new Bundle();
bundle.putString(TOAST, &Unable to connect device&);
msg.setData(bundle);
mHandler.sendMessage(msg);
// Start the service over to restart listening mode
BluetoothChatService.this.start();
* Indicate that the connection was lost and notify the UI Activity.
private void connectionLost() {
// Send a failure message back to the Activity
Message msg = mHandler.obtainMessage(MESSAGE_TOAST);
Bundle bundle = new Bundle();
bundle.putString(TOAST, &Device connection was lost&);
msg.setData(bundle);
mHandler.sendMessage(msg);
// Start the service over to restart listening mode
BluetoothChatService.this.start();
* This thread runs while listening for incoming connections. It behaves
* like a server-side client. It runs until a connection is accepted
* (or until cancelled).
@SuppressLint(&NewApi&)
private class AcceptThread extends Thread {
// The local server socket
private final BluetoothServerSocket mmServerS
private String mSocketT
public AcceptThread(boolean secure)
BluetoothServerSocket tmp =
mSocketType = secure ? &Secure&:&Insecure&;
// Create a new listening server socket
if (secure) {
tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME_SECURE,
MY_UUID_SECURE);
tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord(
NAME_INSECURE, MY_UUID_INSECURE);
} catch (IOException e) {
Log.e(TAG, &Socket Type: & + mSocketType + &listen() failed&, e);
mmServerSocket =
public void run() {
if (D) Log.d(TAG, &Socket Type: & + mSocketType +
&BEGIN mAcceptThread& + this);
setName(&AcceptThread& + mSocketType);
BluetoothSocket socket =
// Listen to the server socket if we're not connected
while (mState != STATE_CONNECTED) {
// This is a blocking call and will only return on a
// successful connection or an exception
if(mmServerSocket!=null)
socket = mmServerSocket.accept();
} catch (IOException e) {
Log.e(TAG, &Socket Type: & + mSocketType + &accept() failed&, e);
// If a connection was accepted
if (socket != null) {
synchronized (BluetoothChatService.this)
switch (mState) {
case STATE_LISTEN:
case STATE_CONNECTING:
// Situation normal. Start the connected thread.
connected(socket, socket.getRemoteDevice(),
mSocketType);
case STATE_NONE:
case STATE_CONNECTED:
// Either not ready or already connected. Terminate new socket.
socket.close();
} catch (IOException e) {
Log.e(TAG, &Could not close unwanted socket&, e);
if (D) Log.i(TAG, &END mAcceptThread, socket Type: & + mSocketType);
public void cancel() {
if (D) Log.d(TAG, &Socket Type& + mSocketType + &cancel & + this);
mmServerSocket.close();
} catch (IOException e) {
Log.e(TAG, &Socket Type& + mSocketType + &close() of server failed&, e);
* This thread runs while attempting to make an outgoing connection
* with a device. It r the connection either
* succeeds or fails.
@SuppressLint(&NewApi&)
private class ConnectThread extends Thread {
private final BluetoothSocket mmS
private final BluetoothDevice mmD
private String mSocketT
public ConnectThread(BluetoothDevice device, boolean secure) {
mmDevice =
BluetoothSocket tmp =
mSocketType = secure ? &Secure& : &Insecure&;
// Get a BluetoothSocket for a connection with the
// given BluetoothDevice
if (secure) {
tmp = device.createRfcommSocketToServiceRecord(
MY_UUID_SECURE);
tmp = device.createInsecureRfcommSocketToServiceRecord(
MY_UUID_INSECURE);
} catch (IOException e) {
Log.e(TAG, &Socket Type: & + mSocketType + &create() failed&, e);
mmSocket =
public void run() {
Log.i(TAG, &BEGIN mConnectThread SocketType:& + mSocketType);
setName(&ConnectThread& + mSocketType);
// Always cancel discovery because it will slow down a connection
mAdapter.cancelDiscovery();
// Make a connection to the BluetoothSocket
// This is a blocking call and will only return on a
// successful connection or an exception
mmSocket.connect();
} catch (IOException e) {
// Close the socket
mmSocket.close();
} catch (IOException e2) {
Log.e(TAG, &unable to close() & + mSocketType +
& socket during connection failure&, e2);
connectionFailed();
// Reset the ConnectThread because we're done
synchronized (BluetoothChatService.this) {
mConnectThread =
// Start the connected thread
connected(mmSocket, mmDevice, mSocketType);
public void cancel() {
mmSocket.close();
} catch (IOException e) {
Log.e(TAG, &close() of connect & + mSocketType + & socket failed&, e);
* This thread runs during a connection with a remote device.
* It handles all incoming and outgoing transmissions.
private class ConnectedThread extends Thread {
private final BluetoothSocket mmS
private final InputStream mmInS
private final OutputStream mmOutS
public ConnectedThread(BluetoothSocket socket, String socketType) {
Log.d(TAG, &create ConnectedThread: & + socketType);
mmSocket =
InputStream tmpIn =
OutputStream tmpOut =
// Get the BluetoothSocket input and output streams
tmpIn = socket.getInputStream();
tmpOut = socket.getOutputStream();
} catch (IOException e) {
Log.e(TAG, &temp sockets not created&, e);
mmInStream = tmpIn;
mmOutStream = tmpO
public void run() {
Log.i(TAG, &BEGIN mConnectedThread&);
byte[] buffer = new byte[1024];
// Keep listening to the InputStream while connected
while (true&&!stop) {
// Read from the InputStream
bytes = mmInStream.read(buffer);
// Send the obtained bytes to the UI Activity
mHandler.obtainMessage(MESSAGE_READ, bytes, -1, buffer)
.sendToTarget();
} catch (IOException e) {
Log.e(TAG, &disconnected&, e);
connectionLost();
// Start the service over to restart listening mode
BluetoothChatService.this.start();
* Write to the connected OutStream.
* @param buffer
The bytes to write
public void write(byte[] buffer) {
mmOutStream.write(buffer);
// Share the sent message back to the UI Activity
mHandler.obtainMessage(BluetoothChat.MESSAGE_WRITE, -1, -1, buffer)
.sendToTarget();
} catch (IOException e) {
Log.e(TAG, &Exception during write&, e);
public void cancel() {
mmSocket.close();
} catch (IOException e) {
Log.e(TAG, &close() of connect socket failed&, e);
Copyright(C)
OKBASE.NET All Rights Reserved 好库网 版权所有战略合作伙伴:第一时间获取手游新鲜资讯，请在微信公众帐号中搜索“便玩家”或用手机扫描左方二维码，即可获得便玩家每日精华内容推送和最优搜索体验。
12345678910