Question

我需要将文件发送到计算机而不是其他Android应用程序。我看过蓝牙api，但它只允许连接作为客户端 - 服务器。在我的情况下，我不知道UUId将在计算机上。我需要看看obex吗？我之前没用过它。所以任何帮助都是有益的。

Answer 1

试试这个。我可以使用此代码发送文件。

ContentValues values = new ContentValues();
values.put(BluetoothShare.URI, "file:///sdcard/refresh.txt");
values.put(BluetoothShare.DESTINATION, deviceAddress);
values.put(BluetoothShare.DIRECTION, BluetoothShare.DIRECTION_OUTBOUND);
Long ts = System.currentTimeMillis();
values.put(BluetoothShare.TIMESTAMP, ts);
getContentResolver().insert(BluetoothShare.CONTENT_URI, values);

BluetoothShare.java代码

import android.provider.BaseColumns;
import android.net.Uri;

/**
 * Exposes constants used to interact with the Bluetooth Share manager's content
 * provider.
 */

public final class BluetoothShare implements BaseColumns {
private BluetoothShare() {
}
/**
 * The permission to access the Bluetooth Share Manager
 */
public static final String PERMISSION_ACCESS = "android.permission.ACCESS_BLUETOOTH_SHARE";

/**
 * The content:// URI for the data table in the provider
 */
public static final Uri CONTENT_URI = Uri.parse("content://com.android.bluetooth.opp/btopp");

/**
 * Broadcast Action: this is sent by the Bluetooth Share component to
 * transfer complete. The request detail could be retrieved by app * as _ID
 * is specified in the intent's data.
 */
public static final String TRANSFER_COMPLETED_ACTION = "android.btopp.intent.action.TRANSFER_COMPLETE";

/**
 * This is sent by the Bluetooth Share component to indicate there is an
 * incoming file need user to confirm.
 */
public static final String INCOMING_FILE_CONFIRMATION_REQUEST_ACTION = "android.btopp.intent.action.INCOMING_FILE_NOTIFICATION";

/**
 * This is sent by the Bluetooth Share component to indicate there is an
 * incoming file request timeout and need update UI.
 */
public static final String USER_CONFIRMATION_TIMEOUT_ACTION = "android.btopp.intent.action.USER_CONFIRMATION_TIMEOUT";

/**
 * The name of the column containing the URI of the file being
 * sent/received.
 */
public static final String URI = "uri";

/**
 * The name of the column containing the filename that the incoming file
 * request recommends. When possible, the Bluetooth Share manager will
 * attempt to use this filename, or a variation, as the actual name for the
 * file.
 */
public static final String FILENAME_HINT = "hint";

/**
 * The name of the column containing the filename where the shared file was
 * actually stored.
 */
public static final String _DATA = "_data";

/**
 * The name of the column containing the MIME type of the shared file.
 */
public static final String MIMETYPE = "mimetype";

/**
 * The name of the column containing the direction (Inbound/Outbound) of the
 * transfer. See the DIRECTION_* constants for a list of legal values.
 */
public static final String DIRECTION = "direction";

/**
 * The name of the column containing Bluetooth Device Address that the
 * transfer is associated with.
 */
public static final String DESTINATION = "destination";

/**
 * The name of the column containing the flags that controls whether the
 * transfer is displayed by the UI. See the VISIBILITY_* constants for a
 * list of legal values.
 */
public static final String VISIBILITY = "visibility";

/**
 * The name of the column containing the current user confirmation state of
 * the transfer. Applications can write to this to confirm the transfer. the
 * USER_CONFIRMATION_* constants for a list of legal values.
 */
public static final String USER_CONFIRMATION = "confirm";

/**
 * The name of the column containing the current status of the transfer.
 * Applications can read this to follow the progress of each download. See
 * the STATUS_* constants for a list of legal values.
 */
public static final String STATUS = "status";

/**
 * The name of the column containing the total size of the file being
 * transferred.
 */
public static final String TOTAL_BYTES = "total_bytes";

/**
 * The name of the column containing the size of the part of the file that
 * has been transferred so far.
 */
public static final String CURRENT_BYTES = "current_bytes";

/**
 * The name of the column containing the timestamp when the transfer is
 * initialized.
 */
public static final String TIMESTAMP = "timestamp";

/**
 * This transfer is outbound, e.g. share file to other device.
 */
public static final int DIRECTION_OUTBOUND = 0;

/**
 * This transfer is inbound, e.g. receive file from other device.
 */
public static final int DIRECTION_INBOUND = 1;

/**
 * This transfer is waiting for user confirmation.
 */
public static final int USER_CONFIRMATION_PENDING = 0;

/**
 * This transfer is confirmed by user.
 */
public static final int USER_CONFIRMATION_CONFIRMED = 1;

/**
 * This transfer is auto-confirmed per previous user confirmation.
 */
public static final int USER_CONFIRMATION_AUTO_CONFIRMED = 2;

/**
 * This transfer is denied by user.
 */
public static final int USER_CONFIRMATION_DENIED = 3;

/**
 * This transfer is timeout before user action.
 */
public static final int USER_CONFIRMATION_TIMEOUT = 4;

/**
 * This transfer is visible and shows in the notifications while in progress
 * and after completion.
 */
public static final int VISIBILITY_VISIBLE = 0;

/**
 * This transfer doesn't show in the notifications.
 */
public static final int VISIBILITY_HIDDEN = 1;

/**
 * Returns whether the status is informational (i.e. 1xx).
 */
public static boolean isStatusInformational(int status) {
    return (status >= 100 && status < 200);
}

/**
 * Returns whether the transfer is suspended. (i.e. whether the transfer
 * won't complete without some action from outside the transfer manager).
 */
public static boolean isStatusSuspended(int status) {
    return (status == STATUS_PENDING);
}

/**
 * Returns whether the status is a success (i.e. 2xx).
 */
public static boolean isStatusSuccess(int status) {
    return (status >= 200 && status < 300);
}

/**
 * Returns whether the status is an error (i.e. 4xx or 5xx).
 */
public static boolean isStatusError(int status) {
    return (status >= 400 && status < 600);
}

/**
 * Returns whether the status is a client error (i.e. 4xx).
 */
public static boolean isStatusClientError(int status) {
    return (status >= 400 && status < 500);
}

/**
 * Returns whether the status is a server error (i.e. 5xx).
 */
public static boolean isStatusServerError(int status) {
    return (status >= 500 && status < 600);
}

/**
 * Returns whether the transfer has completed (either with success or
 * error).
 */
public static boolean isStatusCompleted(int status) {
    return (status >= 200 && status < 300) || (status >= 400 && status < 600);
}

/**
 * This transfer hasn't stated yet
 */
public static final int STATUS_PENDING = 190;

/**
 * This transfer has started
 */
public static final int STATUS_RUNNING = 192;

/**
 * This transfer has successfully completed. Warning: there might be other
 * status values that indicate success in the future. Use isSucccess() to
 * capture the entire category.
 */
public static final int STATUS_SUCCESS = 200;

/**
 * This request couldn't be parsed. This is also used when processing
 * requests with unknown/unsupported URI schemes.
 */
public static final int STATUS_BAD_REQUEST = 400;

/**
 * This transfer is forbidden by target device.
 */
public static final int STATUS_FORBIDDEN = 403;

/**
 * This transfer can't be performed because the content cannot be handled.
 */
public static final int STATUS_NOT_ACCEPTABLE = 406;

/**
 * This transfer cannot be performed because the length cannot be determined
 * accurately. This is the code for the HTTP error "Length Required", which
 * is typically used when making requests that require a content length but
 * don't have one, and it is also used in the client when a response is
 * received whose length cannot be determined accurately (therefore making
 * it impossible to know when a transfer completes).
 */
public static final int STATUS_LENGTH_REQUIRED = 411;

/**
 * This transfer was interrupted and cannot be resumed. This is the code for
 * the OBEX error "Precondition Failed", and it is also used in situations
 * where the client doesn't have an ETag at all.
 */
public static final int STATUS_PRECONDITION_FAILED = 412;

/**
 * This transfer was canceled
 */
public static final int STATUS_CANCELED = 490;

/**
 * This transfer has completed with an error. Warning: there will be other
 * status values that indicate errors in the future. Use isStatusError() to
 * capture the entire category.
 */
public static final int STATUS_UNKNOWN_ERROR = 491;

/**
 * This transfer couldn't be completed because of a storage issue.
 * Typically, that's because the file system is missing or full.
 */
public static final int STATUS_FILE_ERROR = 492;

/**
 * This transfer couldn't be completed because of no sdcard.
 */
public static final int STATUS_ERROR_NO_SDCARD = 493;

/**
 * This transfer couldn't be completed because of sdcard full.
 */
public static final int STATUS_ERROR_SDCARD_FULL = 494;

/**
 * This transfer couldn't be completed because of an unspecified un-handled
 * OBEX code.
 */
public static final int STATUS_UNHANDLED_OBEX_CODE = 495;

/**
 * This transfer couldn't be completed because of an error receiving or
 * processing data at the OBEX level.
 */
public static final int STATUS_OBEX_DATA_ERROR = 496;

/**
 * This transfer couldn't be completed because of an error when establishing
 * connection.
 */
public static final int STATUS_CONNECTION_ERROR = 497;

}

Answer 2

对于Ice Cream Sandwich，此代码无效，因此您必须使用此代码

            int currentapiVersion = android.os.Build.VERSION.SDK_INT;
            if (currentapiVersion >= android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
                Intent sharingIntent = new Intent(
                        android.content.Intent.ACTION_SEND);
                sharingIntent.setType("image/jpeg");
                sharingIntent
                        .setComponent(new ComponentName(
                                "com.android.bluetooth",
                                "com.android.bluetooth.opp.BluetoothOppLauncherActivity"));
                sharingIntent.putExtra(Intent.EXTRA_STREAM, uri);
                startActivity(sharingIntent);
            } else {
                ContentValues values = new ContentValues();
                values.put(BluetoothShare.URI, uri.toString());
                Toast.makeText(getBaseContext(), "URi : " + uri,
                        Toast.LENGTH_LONG).show();
                values.put(BluetoothShare.DESTINATION, deviceAddress);
                values.put(BluetoothShare.DIRECTION,
                        BluetoothShare.DIRECTION_OUTBOUND);
                Long ts = System.currentTimeMillis();
                values.put(BluetoothShare.TIMESTAMP, ts);
                getContentResolver().insert(BluetoothShare.CONTENT_URI,
                        values);
            }

Answer 3

您可以使用obex库。似乎android没有提供obex库，但我解决了问题并且解决方案已发布here。

进一步说明（如果您正忙，请从此处开始阅读）

我正在尝试创建一个Android手机远程控制器（以及类似于telnet服务器的东西），这有助于使用我的旧功能手机远程控制手机。

主要内容：蓝牙FTP客户端

我的第一个计划是让应用程序检查功能手机目录中的文件列表。
但我不知道如何连接到我的功能手机的ftp服务器。
我搜索了很多关于如何通过蓝牙连接到ftp服务器但我只能发现Bluetoorh FTP服务器使用了OBEX Protocol。
我在SO线程中找到了一个有用的资料（PDF文件），并研究了OBEX连接请求，放置和获取操作。
所以我最后写了一些试图连接到Bluetooth FTP服务器的代码。我想向你展示它们，但我失去了它:(代码就像是直接将字节序列写入输出流。

我也很难找到UUID使应用程序连接为FTP客户端的内容。但我尝试使用下面的代码检索每个UUID。

String parcels="";
ParcelUuid[] uuids=mBtDevice.getUuids();
int i=0;
for (ParcelUuid p:uuids)
{
     parcels += "UUID UUID" + new Integer(i).toString() + "=UUID.fromString((\"" + p.getUuid().toString() + "\"));\n\n";
     ++i;
}

似乎没有什么能让我得到我想要的答案。所以我用Google搜索了更多，发现我不仅应该使用UUID 00001106-0000-1000-8000-00805f9b34fb 连接到OBEX FTP服务器，还要发送目标头**发送OBEX connect请求时，使用UUID ** F9EC7BC4-953C-11D2-984E-525400DC9E09 。下面的代码显示了如何作为客户端连接到蓝牙FTP服务器。

try
{
    mBtSocket = mBtDevice.createInsecureRfcommSocketToServiceRecord(UUID.fromString(" 00001106-0000-1000-8000-00805f9b34fb"));
}
catch (Exception e)
{
    //e.printStackTrace();
}

Thread thread=new Thread(new Runnable() {
        public void run()
        {
            UUID uuid=UUID.fromString("F9EC7BC4-953C-11D2-984E-525400DC9E09");
            ByteBuffer bb = ByteBuffer.wrap(new byte[16]);
            bb.putLong(uuid.getMostSignificantBits());
            bb.putLong(uuid.getLeastSignificantBits());
            byte [] bytes=bb.array();
            Operation putOperation=null;
            Operation getOperation=null;
            try
            {
                // connect the socket
                mBtSocket.connect();
    //I will explain below
                mSession = new ClientSession((ObexTransport)(mTransport = new BluetoothObexTransport(mBtSocket)));

                HeaderSet headerset = new HeaderSet();
                headerset.setHeader(HeaderSet.TARGET, bytes);

                headerset = mSession.connect(headerset);

                if (headerset.getResponseCode() == ResponseCodes.OBEX_HTTP_OK)
                {
                    mConnected = true;
                }
                else
                {
                    mSession.disconnect(headerset);
                }
    ...

然后，您现在已连接为FTP客户端，并准备使用OBEX操作发送文件，请求文件，列出目录等。

但我不想等一个小时将命令发送到我的Android手机。（如果我增加轮询频率，那么效率会很低，因为每种轮询方法都是如此。）

如果您正忙，请从此处开始阅读 主要内容：OBEX OPP

由于我上面提到的原因，我贪婪地搜索了从OBEX文档中发现的操作OPP的方法。

您可能希望通过蓝牙正常传输文件（无需定义协议并为其构建新的桌面应用程序），对吧？然后发送到桌面Windows计算机上本机运行的OBEX OPP收件箱服务是最佳解决方案。那么我们如何连接到OPP（Obex Object Push）收件箱服务？

设置OBEX库将import javax.obex;添加到您的源代码中。如果您的编译器不支持OBEX库，请下载源代码并从here添加到您的项目中。
实施ObexTransport 您应该在使用时为库提供一个实现ObexTransport的类。它定义了库应该如何发送数据（如RFCOMM，TCP，......）。示例实现是here。这可能会导致某些运行时或编译错误，例如there's no method。但是，您可以通过将方法调用替换为return 4096而不是return mSocket.getMaxTransmitPacketSize();等常量来部分修复这些问题，从而取消if的{{1}}语句。或者您可以尝试使用 reflection 来获取这些方法的运行时间。
获取public int getMaxTransmitPacketSize() 使用BluetoothSocket获取蓝牙套接字并拨打mBtDevice.createInsecureRfcommSocketToServiceRecord(UUID.fromString(" 00001105-0000-1000-8000-00805f9b34fb" ));。
创建connect() 创建ClientSession实施的实例，并创建一个新的ObexTransport ClientSession。

将OBEX连接请求发送到您的计算机OPP收件箱服务。

mSession = new ClientSession((ObexTransport)(mTransport = new BluetoothObexTransport(mBtSocket)));

使用HeaderSet headerset = new HeaderSet(); // headerset.setHeader(HeaderSet.COUNT,n); headerset = mSession.connect(null); if (headerset.getResponseCode() == ResponseCodes.OBEX_HTTP_OK) { mConnected = true; }发送OBEX放置请求。
```
ClientSession
```

最后，断开连接。

protected boolean Put(ClientSession session, byte[] bytes, String as, String type)
{
    // TODO: Implement this method
    //byte [] bytes;
    String filename=as;
    boolean retry=true;
    int times=0;
    while (retry && times < 4)
    {        
        Operation putOperation=null;
        OutputStream mOutput = null;
        //ClientSession mSession = null;
        //ArrayUtils.reverse(bytes);
        try
        {    
            // Send a file with meta data to the server
            final HeaderSet hs = new HeaderSet();
            hs.setHeader(HeaderSet.NAME, filename);
            hs.setHeader(HeaderSet.TYPE, type);
            hs.setHeader(HeaderSet.LENGTH, new Long((long)bytes.length));
            Log.v(TAG,filename);
            //Log.v(TAG,type);
            Log.v(TAG,bytes.toString());
            putOperation = session.put(hs);

            mOutput = putOperation.openOutputStream();
            mOutput.write(bytes);
            mOutput.close();
            putOperation.close();
        }
        catch (Exception e)
        {
            Log.e(TAG, "put failed", e);
            retry = true;
            times++;
            continue;
            //e.printStackTrace();
        }
        finally
        {
            try
            {

                if(mOutput!=null)
                    mOutput.close();
                if(putOperation!=null)
                    putOperation.close();
            }
            catch (Exception e)
            {
                Log.e(TAG, "put finally" , e);
                retry = true;
                times++;
                continue;
            }
            //updateStatus("[CLIENT] Connection Closed");
        }
        retry = false;
        return true;
    }
    return false;
}

然后这是一个包装类。

private void FinishBatch(ClientSession mSession) throws IOException
{
    mSession.disconnect(null);
   try
   {
         Thread.sleep((long)500);
   }
   catch (InterruptedException e)
   {}
    mBtSocket.close();
}

Answer 4

您需要在OBEX上实施FTP。实施标准协议和配置文件后，您的Android FTP实施将与几乎任何蓝牙FTP服务器互操作。您还需要实现OPP以实现最大的互操作性。 OBEX协议并不难实现，规格可以免费获得。

Answer 5

我知道这个问题很老了，但对于任何不得不处理这个问题的人来说：

使用这个库，您可以通过 OBEX 发送文件，通过 RFCOMM 发送命令： https://github.com/ddibiasi/Funker

一旦连接到目标设备，您就可以操作其文件系统。

以下示例发送文件：

val rxOBEX = RxObex(device)
rxOBEX
    .putFile("rubberduck.txt", "text/plain", "oh hi mark".toByteArray(), "example/directory")  // Name of file, mimetype, bytes of file, directory
    .subscribeBy(
        onComplete = {
            Log.d(TAG, "Succesfully sent a testfile to device")
        },
        onError = { e ->
            Log.e(TAG, "Received error!")
        }
    )

该库基于 Rx 构建，因此所有调用都是非阻塞的。

如何在android上以编程方式使用蓝牙发送文件？

5 个答案: