简介
通过蓝牙传输文件，其实现流程是怎样的？这里从JAVA/JNI/HAL三个角度分析
注：
服务端为BluetoothServerSocket
以BluetoothSocket创建为案例 -- 7.1代码
JAVA -- Bluetooth.apk
packages/apps/Bluetooth
frameworks/base/core/java/android/bluetooth
1.关键方法
BluetoothOppTransfer.java
BluetoothSocket btSocket = bluetoothDevice.createInsecureRfcommSocketToServiceRecord(uuid);
btSocket.connect();
2.分析
1.bluetoothDevice.createInsecureRfcommSocketToServiceRecord(uuid);
BluetoothDevice.java
public BluetoothSocket createInsecureRfcommSocketToServiceRecord(UUID uuid) throws IOException {
if (isBluetoothEnabled() == false) {
Log.e(TAG, "Bluetooth is not enabled");
throw new IOException();
}
return new BluetoothSocket(BluetoothSocket.TYPE_RFCOMM, -1, false, false, this, -1,
new ParcelUuid(uuid));//创建BluetoothSocket对象
}
2.btSocket.connect();
BluetoothSocket.java
public void connect() throws IOException {
if (mDevice == null) throw new IOException("Connect is called on null device");
try {
if (mSocketState == SocketState.CLOSED) throw new IOException("socket closed");
IBluetooth bluetoothProxy =
BluetoothAdapter.getDefaultAdapter().getBluetoothService(null);
if (bluetoothProxy == null) throw new IOException("Bluetooth is off");
mPfd = bluetoothProxy.connectSocket(mDevice, mType,
mUuid, mPort, getSecurityFlags());//获取ParcelFileDescriptor,即FileDescriptor的Android包装类
synchronized(this)
{
if (DBG) Log.d(TAG, "connect(), SocketState: " + mSocketState + ", mPfd: " + mPfd);
if (mSocketState == SocketState.CLOSED) throw new IOException("socket closed");
if (mPfd == null) throw new IOException("bt socket connect failed");
FileDescriptor fd = mPfd.getFileDescriptor();//把ParcelFileDescriptor转化为fd
mSocket = new LocalSocket(fd);//建立Socket连接准备
mSocketIS = mSocket.getInputStream();
mSocketOS = mSocket.getOutputStream();
}
int channel = readInt(mSocketIS);
if (channel <= 0)
throw new IOException("bt socket connect failed");
mPort = channel;
waitSocketSignal(mSocketIS);//等待连接。这里代表connect是堵塞的方法
synchronized(this)
{
if (mSocketState == SocketState.CLOSED)
throw new IOException("bt socket closed");
mSocketState = SocketState.CONNECTED;
}
} catch (RemoteException e) {
Log.e(TAG, Log.getStackTraceString(new Throwable()));
throw new IOException("unable to send RPC: " + e.getMessage());
}
}
3.接下来我们先分析怎么等待连接，其后再重点讲解mPfd的来源
waitSocketSignal(mSocketIS)
private String waitSocketSignal(InputStream is) throws IOException {
byte [] sig = new byte[SOCK_SIGNAL_SIZE];
int ret = readAll(is, sig);//等待连接的关键方法
······
return RemoteAddr;
}
private int readAll(InputStream is, byte[] b) throws IOException {
int left = b.length;
while(left > 0) {
int ret = is.read(b, b.length - left, left);//inputstream.read就会阻塞，此方法为常见方法
if(ret <= 0)
throw new IOException("read failed, socket might closed or timeout, read ret: "
+ ret);
left -= ret;
if(left != 0)
Log.w(TAG, "readAll() looping, read partial size: " + (b.length - left) +
", expect size: " + b.length);
}
return b.length;
}
4.现在重点讲解mPfd的来源
IBluetooth bluetoothProxy =
BluetoothAdapter.getDefaultAdapter().getBluetoothService(null);
mPfd = bluetoothProxy.connectSocket(mDevice, mType,
mUuid, mPort, getSecurityFlags());
bluetoothProxy代理的Binder对象，其实就是AdapterService
AdapterService.java
ParcelFileDescriptor connectSocket(BluetoothDevice device, int type,
ParcelUuid uuid, int port, int flag) {
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
int fd = connectSocketNative(Utils.getBytesFromAddress(device.getAddress()),
type, Utils.uuidToByteArray(uuid), port, flag, Binder.getCallingUid());//通过jni获取fd
if (fd < 0) {
errorLog("Failed to connect socket");
return null;
}
return ParcelFileDescriptor.adoptFd(fd);//通过fd创建ParcelFileDescriptor
}
来到connectSocketNative代表来到了JNI层，下面我们重点简介JNI层
JNI -- libbluetooth_jni.so (/system/lib/libbluetooth_jni.so)
packages\apps\Bluetooth\jni
jni分析
com_android_bluetooth_btservice_AdapterService.cpp
static int connectSocketNative(JNIEnv *env, jobject object, jbyteArray address, jint type,
jbyteArray uuidObj, jint channel, jint flag, jint callingUid) {
···
if ( (status = sBluetoothSocketInterface->connect((bt_bdaddr_t *) addr, (btsock_type_t) type,
(const uint8_t*) uuid, channel, &socket_fd, flag, callingUid))
!= BT_STATUS_SUCCESS) {
ALOGE("Socket connection failed: %d", status);
goto Fail;
}
···
return socket_fd;//sBluetoothSocketInterface->connect函数将socket_fd传进去并被赋值
Fail:
if (addr) env->ReleaseByteArrayElements(address, addr, 0);
if (uuid) env->ReleaseByteArrayElements(uuidObj, uuid, 0);
return -1;
}
这里sBluetoothSocketInterface->connect其实就是进入了HAL层
HAL层 --- bluetooth.default.so
system\bt
1.在分析HAL层代码之前，我们先搞清楚jni怎么关联上HAL成的
讲解sBluetoothSocketInterface->connect之前，我们先了解一下sBluetoothSocketInterface的由来
1.在jni的initNative初始化
static bool initNative(JNIEnv* env, jobject obj) {
ALOGV("%s:",__FUNCTION__);
···
if ( (sBluetoothSocketInterface = (btsock_interface_t *)
sBluetoothInterface->get_profile_interface(BT_PROFILE_SOCKETS_ID)) == NULL) {
ALOGE("Error getting socket interface");
}
···
return JNI_FALSE;
}
要弄清楚sBluetoothSocketInterface，则一定要弄清楚sBluetoothInterface
2.在jni的classInitNative初始化
static void classInitNative(JNIEnv* env, jclass clazz) {
int err;
hw_module_t* module;
····
if (!strncmp(type, "RTL", 3)) {
ALOGD("%s, load %s.default.so", __func__, BT_STACK_RTK_MODULE_ID);
err = hw_get_module(BT_STACK_RTK_MODULE_ID, (hw_module_t const**)&module);
} else {
ALOGD("%s, load %s.default.so", __func__, id);
err = hw_get_module(id, (hw_module_t const**)&module);
}
if (err == 0) {
hw_device_t* abstraction;
err = module->methods->open(module, id, &abstraction);//关键点1
if (err == 0) {
bluetooth_module_t* btStack = (bluetooth_module_t *)abstraction;
sBluetoothInterface = btStack->get_bluetooth_interface();//通过btStack获取
} else {
ALOGE("Error while opening Bluetooth library");
}
} else {
ALOGE("No Bluetooth Library found");
}
}
想要弄清楚sBluetoothInterface的来路，则一定要弄清楚btStack的来源
2.真正HAL层代码来了。btStack的来源就是Android标准的JNI到HAL层架构方式
注意：
blutooth.default.so的源码来自system/bt
1)查看bluetooth.c
static int open_bluetooth_stack(const struct hw_module_t *module, UNUSED_ATTR char const *name, struct hw_device_t **abstraction) {
static bluetooth_device_t device = {
.common = {
.tag = HARDWARE_DEVICE_TAG,
.version = 0,
.close = close_bluetooth_stack,
},
.get_bluetooth_interface = bluetooth__get_bluetooth_interface
};
device.common.module = (struct hw_module_t *)module;
*abstraction = (struct hw_device_t *)&device;//abstraction就是btStack
return 0;
}
static struct hw_module_methods_t bt_stack_module_methods = {
.open = open_bluetooth_stack,//关键点1的真实调用方法open_bluetooth_stack
};
a)btStack调用get_bluetooth_interface，其实调用的是bluetooth__get_bluetooth_interface
b)bluetoothInterface的来源
const bt_interface_t* bluetooth__get_bluetooth_interface ()
{
/* fixme -- add property to disable bt interface ? */
return &bluetoothInterface;
}
bluetoothInterface的结构体bt_interface_t
c)查看bt_interface_t
static const bt_interface_t bluetoothInterface = {
···
get_profile_interface,
···
};
3.至此已经解锁sBluetoothInterface的来源，反推sBluetoothSocketInterface的来源
sBluetoothSocketInterface = (btsock_interface_t *)
sBluetoothInterface->get_profile_interface(BT_PROFILE_SOCKETS_ID)
static const void* get_profile_interface (const char *profile_id)
{
···
if (is_profile(profile_id, BT_PROFILE_SOCKETS_ID))
return btif_sock_get_interface();
···
return NULL;
}
btif_sock.c
btsock_interface_t *btif_sock_get_interface(void) {
static btsock_interface_t interface = {
sizeof(interface),
btsock_listen,
btsock_connect
};
return &interface;
}
bt_sock.h
typedef struct {
/** set to size of this struct*/
size_t size;
bt_status_t (*listen)(btsock_type_t type, const char* service_name,
const uint8_t* service_uuid, int channel, int* sock_fd, int flags, int callingUid);
bt_status_t (*connect)(const bt_bdaddr_t *bd_addr, btsock_type_t type, const uint8_t* uuid,
int channel, int* sock_fd, int flags, int callingUid);
} btsock_interface_t
connect 对应到 btsock_connect
4.至此已经来到HAL层的connect处
btif_sock.c
static bt_status_t btsock_connect(const bt_bdaddr_t *bd_addr, btsock_type_t type, const uint8_t *uuid, int channel, int *sock_fd, int flags, int app_uid) {
···
bt_status_t status = BT_STATUS_FAIL;
switch (type) {
case BTSOCK_RFCOMM://选择此通道
status = btsock_rfc_connect(bd_addr, uuid, channel, sock_fd, flags, app_uid);
break;
···
}
return status;
}
bt_status_t btsock_rfc_connect(const bt_bdaddr_t *bd_addr, const uint8_t *service_uuid, int channel, int *sock_fd, int flags, int app_uid) {
···
*sock_fd = slot->app_fd; // Transfer ownership of fd to caller.
slot->app_fd = INVALID_FD; // Drop our reference to the fd.
slot->app_uid = app_uid;
btsock_thread_add_fd(pth, slot->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_RD, slot->id);//发数据发送出去
status = BT_STATUS_SUCCESS;
out:;
pthread_mutex_unlock(&slot_lock);
return status;
}
btif_sock_thread.c 发送数据
int btsock_thread_add_fd(int h, int fd, int type, int flags, uint32_t user_id)
{
···
OSI_NO_INTR(ret = send(ts[h].cmd_fdw, &cmd, sizeof(cmd), 0));//socket发送数据
return ret == sizeof(cmd);
}
总结
1.apk -- jni -- hal 整个过程有很多Android定制的代码实现的框架格式
2.弄清楚基础的框架格式，再分析源码的流程就方便很多
3.跨设备，其实通信用的就是socket
demo案例
1.development\samples\BluetoothChat
2.https://github.com/googlearchive/android-BluetoothChat#readme
3.https://blog.csdn.net/mo_android/article/details/76472824
