BluetoothChatService.java
public synchronized void start() :
开启 mAcceptThread 线程,由于样例程序是仅 2 人的聊天过程,故之前先检测 mConnectThread 和 mConnectedThread 是否运行,运行则先退出这些线程。
public synchronized void connect(BluetoothDevice device) :
取消 CONNECTING 和 CONNECTED 状态下的相关线程,然后运行新的 mConnectThread 线程。
public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) :
开启一个 ConnectedThread 来管理对应的当前连接。之前先取消任意现存的 mConnectThread 、 mConnectedThread 、 mAcceptThread 线程,然后开启新 mConnectedThread ,传入当前刚刚接受的 socket 连接。最后通过 Handler 来通知 UI 连接 OK 。
public synchronized void stop() :
停止所有相关线程,设当前状态为 NONE 。
public void write(byte[] out) :
在 STATE_CONNECTED 状态下,调用 mConnectedThread 里的 write 方法,写入 byte 。
private void connectionFailed() :
连接失败的时候处理,通知 ui ,并设为 STATE_LISTEN 状态。
private void connectionLost() :
当连接失去的时候,设为 STATE_LISTEN 状态并通知 ui 。
内部类:
private class AcceptThread extends Thread :
创建监听线程,准备接受新连接。使用阻塞方式,调用 BluetoothServerSocket.accept() 。提供 cancel 方法关闭 socket 。
private class ConnectThread extends Thread :
这是定义的连接线程,专门用来对外发出连接对方蓝牙的请求和处理流程。构造函数里通过 BluetoothDevice.createRfcommSocketToServiceRecord() ,从待连接的 device 产生 BluetoothSocket. 然后在 run 方法中 connect ,成功后调用 BluetoothChatSevice 的 connected() 方法。定义 cancel() 在关闭线程时能够关闭相关 socket 。
private class ConnectedThread extends Thread :
这个是双方蓝牙连接后一直运行的线程。构造函数中设置输入输出流。 Run 方法中使用阻塞模式的 InputStream.read() 循环读取输入流, 然后 post 到 UI 线程中更新聊天消息。也提供了 write() 将聊天消息写入输出流传输至对方,传输成功后回写入 UI 线程。最后 cancel() 关闭连接的 socket 。
BluetoothChatService
1、常量变量
对于设备的监听,连接管理都将由REQUEST_CONNECT_DEVICE来实现,其中又包括三个主要部分,三个进程分别是:
请求连接的监听线程(AcceptThread)
连接一个设备的进程(ConnectThread)
连接之后的管理进程(ConnectedThread)
同样我们先熟悉一下该类的成员变量的作用,定义如下:
-
- private staticfinal String TAG ="BluetoothChatService";
- private static finalboolean D =true;
-
-
- private staticfinal String NAME ="BluetoothChat";
-
-
- private static final UUID MY_UUID = UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");
-
-
- private final BluetoothAdapter mAdapter;
-
- private final Handler mHandler;
-
- private AcceptThread mAcceptThread;
-
- private ConnectThread mConnectThread;
-
- private ConnectedThread mConnectedThread;
-
- private int mState;
-
-
- public staticfinalint STATE_NONE =0;
- public staticfinalint STATE_LISTEN =1;
- public staticfinalint STATE_CONNECTING =2;
- public static finalint STATE_CONNECTED =3;
Debugging为调试相关,NAME 是当我们在创建一个socket监听服务时的一个SDP名称,另外还包括一个状态变量mState,其值则分别是下面的"各种状态"部分,另外还有一个本地蓝牙适配器和三个不同的进程对象,由此可见,本地蓝牙适配器的确是任何蓝牙操作的基础对象,下面我们会分别介绍这些进程的实现。
BluetoothChatService(Context context, Handler handler)_构造函数
首先是初始化操作,即构造函数,代码如下:
- public BluetoothChatService(Context context, Handler handler) {
-
- mAdapter = BluetoothAdapter.getDefaultAdapter();
-
- mState = STATE_NONE;
-
- mHandler = handler;
- }
- public BluetoothChatService(Context context, Handler handler) {
取得本地蓝牙适配器、设置状态为STATE_NONE,设置传递进来的mHandler。接下来需要控制当状态改变之后,我们需要通知UI界面也同时更改状态,下面是得到状态和设置状态的实现部分,如下:
synchronizedvoid setState(int state)
- private synchronizedvoid setState(int state) {
- if (D) Log.d(TAG, "setState() " + mState +" -> " + state);
- mState = state;
-
-
- mHandler.obtainMessage(BluetoothChat.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();
- }
-
- public synchronizedint getState() {
- return mState;
- }
- private synchronized void setState(int state) { if (D) Log.d(TAG, "setState() " + mState + " -> " + state); mState = state;
得到状态没有什么特别的,关键在于设置状态之后需要通过obtainMessage来发送一个消息到Handler,通知UI界面也同时更新其状态,对应的Handler的实现则位于BluetoothChat中的private final Handler mHandler = new Handler()部分,从上面的代码中,我们可以看到关于状态更改的之后会发送一个BluetoothChat.MESSAGE_STATE_CHANGE消息到UI线程中,下面我们看一下UI线程中如何处理这些消息的,代码如下:
UI线程处理消息
- case MESSAGE_STATE_CHANGE:
- if(D) Log.i(TAG, "MESSAGE_STATE_CHANGE: " + msg.arg1);
- switch (msg.arg1) {
- case BluetoothChatService.STATE_CONNECTED:
-
- mTitle.setText(R.string.title_connected_to);
-
- mTitle.append(mConnectedDeviceName);
-
- mConversationArrayAdapter.clear();
- break;
- case BluetoothChatService.STATE_CONNECTING:
-
- mTitle.setText(R.string.title_connecting);
- break;
- case BluetoothChatService.STATE_LISTEN:
- case BluetoothChatService.STATE_NONE:
-
- mTitle.setText(R.string.title_not_connected);
- break;
- }
- break;
- case MESSAGE_STATE_CHANGE: if(D) Log.i(TAG, "MESSAGE_STATE_CHANGE: " + msg.arg1); switch (msg.arg1) { case BluetoothChatService.STATE_CONNECTED:
可以看出,当不同的状态在更改之后会进行不同的设置,但是大多数都是根据不同的状态设置显示了不同的title,当已经链接(STATE_CONNECTED)之后,设置了标题为链接的设备名,并同时还mConversationArrayAdapter进行了清除操作,即清除聊天记录。
start函数来开启一个服务进程_onResume函数调用start操作
现在,初始化操作已经完成了,下面我们可以调用start函数来开启一个服务进程了,也即是在BluetoothChat中的onResume函数中所调用的start操作,其具体实现如下:
- public synchronizedvoid start() {
- if (D) Log.d(TAG, "start");
-
-
- if (mConnectThread !=null) {mConnectThread.cancel(); mConnectThread =null;}
-
-
- if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread =null;}
-
-
- if (mAcceptThread ==null) {
- mAcceptThread = new AcceptThread();
- mAcceptThread.start();
- }
-
- setState(STATE_LISTEN);
- }
- public synchronized void start() { if (D) Log.d(TAG, "start");
操作过程很简单,首先取消另外两个进程,新建一个AcceptThread进程,并启动AcceptThread进程,最后设置状态变为监听(STATE_LISTEN),这时UI界面的title也将更新为监听状态,即等待设备的连接。关于AcceptThread的具体实现如下所示。
新建一个AcceptThread进程
- private class AcceptThreadextends Thread {
-
- private final BluetoothServerSocket mmServerSocket;
-
- public AcceptThread() {
- BluetoothServerSocket tmp = null;
-
-
- try {
- tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
- } catch (IOException e) {
- Log.e(TAG, "listen() failed", e);
- }
- mmServerSocket = tmp;
- }
-
- public void run() {
- if (D) Log.d(TAG, "BEGIN mAcceptThread" +this);
- setName("AcceptThread");
- BluetoothSocket socket = null;
-
-
- while (mState != STATE_CONNECTED) {
- try {
-
-
- socket = mmServerSocket.accept();
- } catch (IOException e) {
- Log.e(TAG, "accept() failed", e);
- break;
- }
-
-
- if (socket != null) {
- synchronized (BluetoothChatService.this) {
- switch (mState) {
- case STATE_LISTEN:
- case STATE_CONNECTING:
-
- connected(socket, socket.getRemoteDevice());
- break;
- case STATE_NONE:
- case STATE_CONNECTED:
-
- try {
- socket.close();
- } catch (IOException e) {
- Log.e(TAG, "Could not close unwanted socket", e);
- }
- break;
- }
- }
- }
- }
- if (D) Log.i(TAG,"END mAcceptThread");
- }
-
- public void cancel() {
- if (D) Log.d(TAG,"cancel " +this);
- try {
- mmServerSocket.close();
- } catch (IOException e) {
- Log.e(TAG, "close() of server failed", e);
- }
- }
- }
- private class AcceptThread extends Thread {
首先通过listenUsingRfcommWithServiceRecord创建一个socket服务,用来监听设备的连接,当进程启动之后直到有设备连接时,这段时间都将通过accept来监听和接收一个连接请求,如果连接无效则调用close来关闭即可,如果连接有效则调用connected进入连接进程,进入连接进程之后会取消当前的监听进程,取消过程则直接调用cancel通过mmServerSocket.close()来关闭即可。下面我们分析连接函数connect的实现,如下:
connect(BluetoothDevice device) _连接
- public synchronizedvoid connect(BluetoothDevice device) {
- if (D) Log.d(TAG, "connect to: " + device);
-
-
- if (mState == STATE_CONNECTING) {
- if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread =null;}
- }
-
-
- if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread =null;}
-
-
- mConnectThread = new ConnectThread(device);
- mConnectThread.start();
- setState(STATE_CONNECTING);
- }
- public synchronized void connect(BluetoothDevice device) { if (D) Log.d(TAG, "connect to: " + device);
同样,首先关闭其他两个进程,然后新建一个ConnectThread进程,并启动,通知UI界面状态更改为正在连接的状态(STATE_CONNECTING)。具体的连接进程由ConnectThread来实现,如下:
ConnectThread
- private class ConnectThreadextends Thread {
-
- private final BluetoothSocket mmSocket;
-
- private final BluetoothDevice mmDevice;
-
- public ConnectThread(BluetoothDevice device) {
- mmDevice = device;
- BluetoothSocket tmp = null;
-
-
- try {
- tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
- } catch (IOException e) {
- Log.e(TAG, "create() failed", e);
- }
- mmSocket = tmp;
- }
-
- public void run() {
- Log.i(TAG, "BEGIN mConnectThread");
- setName("ConnectThread");
-
-
- mAdapter.cancelDiscovery();
-
-
- try {
-
- mmSocket.connect();
- } catch (IOException e) {
-
- connectionFailed();
-
- try {
- mmSocket.close();
- } catch (IOException e2) {
- Log.e(TAG, "unable to close() socket during connection failure", e2);
- }
-
- BluetoothChatService.this.start();
- return;
- }
-
-
- synchronized (BluetoothChatService.this) {
- mConnectThread = null;
- }
-
-
- connected(mmSocket, mmDevice);
- }
-
- public void cancel() {
- try {
- mmSocket.close();
- } catch (IOException e) {
- Log.e(TAG, "close() of connect socket failed", e);
- }
- }
- }
- private class ConnectThread extends Thread {
在创建该进程时,就已经知道当前需要被连接的蓝牙设备,然后通过createRfcommSocketToServiceRecord可以构建一个蓝牙设备的BluetoothSocket对象,当进入连接状态时,就可以调用cancelDiscovery来取消蓝牙的可见状态,然后通过调用connect函数进行链接操作,如果出现异常则表示链接失败,则调用connectionFailed函数通知UI进程更新界面的显示为链接失败状态,然后关闭BluetoothSocket,调用start函数重新开启一个监听服务AcceptThread,对于链接失败的处理实现如下:
- private void connectionFailed() {
- setState(STATE_LISTEN);
-
-
- Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_TOAST);
- Bundle bundle = new Bundle();
- bundle.putString(BluetoothChat.TOAST, "Unable to connect device");
- msg.setData(bundle);
- mHandler.sendMessage(msg);
- }
- private void connectionFailed() { setState(STATE_LISTEN);
首先更改状态为STATE_LISTEN,然后发送一个Message带UI界面,通知UI更新,显示一个Toast告知用户,当BluetoothChat中的mHandler接收到BluetoothChat.TOAST消息时,就会直接更新UI界面的显示,如果连接成功则将调用connected函数进入连接管理进程,其实现如下:
- public synchronizedvoid connected(BluetoothSocket socket, BluetoothDevice device) {
- if (D) Log.d(TAG, "connected");
-
-
- if (mConnectThread !=null) {mConnectThread.cancel(); mConnectThread =null;}
-
-
- if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread =null;}
-
-
- if (mAcceptThread !=null) {mAcceptThread.cancel(); mAcceptThread =null;}
-
-
- mConnectedThread = new ConnectedThread(socket);
- mConnectedThread.start();
-
-
- Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_DEVICE_NAME);
- Bundle bundle = new Bundle();
- bundle.putString(BluetoothChat.DEVICE_NAME, device.getName());
- msg.setData(bundle);
- mHandler.sendMessage(msg);
-
- setState(STATE_CONNECTED);
- }
- public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) { if (D) Log.d(TAG, "connected");
首先,关闭所有的进程,构建一个ConnectedThread进程,并准备一个Message消息,就设备名称(BluetoothChat.DEVICE_NAME)也发送到UI进程,因为UI进程需要显示当前连接的设备名称,当UI进程收到BluetoothChat.MESSAGE_DEVICE_NAME消息时就会更新相应的UI界面,就是设置窗口的title,这里我们就不贴出代码了,下面我们分析一下ConnectedThread的实现,代码如下:
- private class ConnectedThread extends Thread {
-
- private final BluetoothSocket mmSocket;
-
- private final InputStream mmInStream;
- private final OutputStream mmOutStream;
-
- public ConnectedThread(BluetoothSocket socket) {
- Log.d(TAG, "create ConnectedThread");
- mmSocket = socket;
- InputStream tmpIn = null;
- OutputStream tmpOut = null;
-
-
- try {
- tmpIn = socket.getInputStream();
- tmpOut = socket.getOutputStream();
- } catch (IOException e) {
- Log.e(TAG, "temp sockets not created", e);
- }
-
- mmInStream = tmpIn;
- mmOutStream = tmpOut;
- }
-
- public void run() {
- Log.i(TAG, "BEGIN mConnectedThread");
- byte[] buffer = newbyte[1024];
- int bytes;
-
-
- while (true) {
- try {
-
- bytes = mmInStream.read(buffer);
-
-
- mHandler.obtainMessage(BluetoothChat.MESSAGE_READ, bytes, -1, buffer)
- .sendToTarget();
- } catch (IOException e) {
-
- Log.e(TAG, "disconnected", e);
- connectionLost();
- break;
- }
- }
- }
-
-
-
-
-
- public void write(byte[] buffer) {
- try {
- mmOutStream.write(buffer);
-
-
- mHandler.obtainMessage(BluetoothChat.MESSAGE_WRITE, -1, -1, buffer)
- .sendToTarget();
- } catch (IOException e) {
- Log.e(TAG, "Exception during write", e);
- }
- }
-
- public void cancel() {
- try {
- mmSocket.close();
- } catch (IOException e) {
- Log.e(TAG, "close() of connect socket failed", e);
- }
- }
- }
- private class ConnectedThread extends Thread {
连接之后的主要操作就是发送和接收聊天消息了,因为需要通过其输入(出)流来操作具体信息,进程会一直从输入流中读取信息,并通过obtainMessage函数将读取的信息以BluetoothChat.MESSAGE_READ命令发送到UI进程,到UI进程收到是,就需要将其显示到消息列表之中,同时对于发送消息,需要实行写操作write,其操作就是将要发送的消息写入到输出流mmOutStream中,并且以BluetoothChat.MESSAGE_WRITE命令的方式发送到UI进程中,进行同步更新,如果在读取消息时失败或者产生了异常,则表示连接丢失,这是就调用connectionLost函数来处理连接丢失,代码如下:
- private void connectionLost() {
- setState(STATE_LISTEN);
-
-
- Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_TOAST);
- Bundle bundle = new Bundle();
- bundle.putString(BluetoothChat.TOAST, "Device connection was lost");
- msg.setData(bundle);
- mHandler.sendMessage(msg);
- }
- private void connectionLost() { setState(STATE_LISTEN);
操作同样简单,首先改变状态为STATE_LISTEN,然后BluetoothChat.MESSAGE_TOAST命令发送一个消息Message到UI进程,通知UI进程更新显示画面即可。对于写操作,是调用了BluetoothChatService.write来实现,其实现代码如下:
-
- public void write(byte[] out) {
-
- ConnectedThread r;
-
- synchronized (this) {
-
- if (mState != STATE_CONNECTED)return;
- r = mConnectedThread;
- }
-
- r.write(out);
- }
其实就是检测,当前的状态是否处于已经链接状态STATE_CONNECTED,然后调用ConnectedThread 进程中的write操作,来完成消息的发送。因此这时我们可以回过头来看BluetoothChat中的sendMessage的实现了,如下所示:
- private void sendMessage(String message) {
-
- if (mChatService.getState() != BluetoothChatService.STATE_CONNECTED) {
- Toast.makeText(this, R.string.not_connected, Toast.LENGTH_SHORT).show();
- return;
- }
-
-
- if (message.length() >0) {
-
- byte[] send = message.getBytes();
- mChatService.write(send);
-
-
- mOutStringBuffer.setLength(0);
- mOutEditText.setText(mOutStringBuffer);
- }
- }
- private void sendMessage(String message) {
同样首先检测了当前的状态是否为已经连接状态,然后对要发送的消息是否为null进行了判断,如果为空则不需要发送,否则调用mChatService.write(即上面所说的ConnectedThread 中的wirte操作)来发送消息。然后一个小的细节就是设置编辑框的内容为null即可。最后我们可以看一下在BluetoothChat中如何处理这些接收到的消息,主要位于mHandler中的handleMessage函数中,对于状态改变的消息我们已经分析过了,下面是其他几个消息的处理:
- case MESSAGE_WRITE:
- byte[] writeBuf = (byte[]) msg.obj;
-
- String writeMessage = new String(writeBuf);
- mConversationArrayAdapter.add("Me: " + writeMessage);
- break;
- case MESSAGE_READ:
- byte[] readBuf = (byte[]) msg.obj;
-
- String readMessage = new String(readBuf,0, msg.arg1);
- mConversationArrayAdapter.add(mConnectedDeviceName+": " + readMessage);
- break;
- case MESSAGE_DEVICE_NAME:
-
- mConnectedDeviceName = msg.getData().getString(DEVICE_NAME);
- Toast.makeText(getApplicationContext(), "Connected to "
- + mConnectedDeviceName, Toast.LENGTH_SHORT).show();
- break;
- case MESSAGE_TOAST:
-
- Toast.makeText(getApplicationContext(), msg.getData().getString(TOAST),
- Toast.LENGTH_SHORT).show();
- break;
- case MESSAGE_WRITE: byte[] writeBuf = (byte[]) msg.obj;
分别是读取消息和写消息(发送消息),对于一些信息提示消息MESSAGE_TOAST,则通过Toast显示出来即可。如果消息是设备名称MESSAGE_DEVICE_NAME,则提示用户当前连接的设备的名称。对于写消息(MESSAGE_WRITE)和读消息(MESSAGE_READ)我们就不重复了,大家看看代码都已经加入了详细的注释了。
最后当我们在需要停止这些进程时就看有直接调用stop即可,具体实现如下:
-
- public synchronizedvoid stop() {
- if (D) Log.d(TAG,"stop");
- if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread =null;}
- if (mConnectedThread !=null) {mConnectedThread.cancel(); mConnectedThread =null;}
- if (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread =null;}
-
- setState(STATE_NONE);
- }
分别检测三个进程是否为null,然后调用各自的cancel函数来取消进程,最后不要忘记将状态恢复到STATE_NONE即可。
总结
终于完成了对蓝牙聊天程序的实现和分析,该示例程序比较全面,基本上包括了蓝牙编程的各个方面,希望通过这几篇文章的问题,能够帮助大家理解在Ophone平台上进行蓝牙编程,同时将蓝牙技术运用到其他应用程序中实现应用程序的网络化,联机性。或许你有更多的用处。
http://blog.csdn.net/zhanghua1121/article/details/9331373
![](https://img-blog.csdn.net/20160729152018060?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
![](https://img-blog.csdn.net/20160729152037232?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
![](https://img-blog.csdn.net/20160729152053534?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
![](https://img-blog.csdn.net/20160729152111514?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
![](https://img-blog.csdn.net/20160729152130389?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
![](https://img-blog.csdn.net/20160729152152342?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
![](https://img-blog.csdn.net/20160729152216583?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
![](https://img-blog.csdn.net/20160729152230786?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
![](https://img-blog.csdn.net/20160729152250703?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
![](https://img-blog.csdn.net/20160729152310381?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
![](https://img-blog.csdn.net/20160729152325178?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
![](https://img-blog.csdn.net/20160729152343366?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
![](https://img-blog.csdn.net/20160729152357304?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
![](https://img-blog.csdn.net/20160729152410710?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
http://www.docin.com/p-1310632033.html