opp分析（ACTION_DEVICE_SELECTED）

最新推荐文章于 2023-07-04 15:03:43 发布
最新推荐文章于 2023-07-04 15:03:43 发布
阅读量1.7k 收藏
点赞数
分类专栏： opp

选择设备之后就是发送了一个BluetoothDevicePicker.ACTION_DEVICE_SELECTED的broadcast来通知我们选择了某个设备进行文件的传输。对这个broadcast的监听就只有一个，就是BluetoothOppReceiver.cpp


设备点击之后，会发送一个ACTION_DEVICE_SELECTED的broadcast，BluetoothOppReceiver收到这个broadcast后，会启动insertThread来把需要分享的文件内容加入到对应的数据库中并引起后续的发送操作，同时在ui上显示“正在向**发送文件”的toast。


  else if (action->equals(BluetoothDevicePicker::ACTION_DEVICE_SELECTED())) {

        sp<BluetoothOppManager> mOppManager = BluetoothOppManager::getInstance(context);
//得到选中的设备
        sp<BluetoothDevice> remoteDevice = safe_cast<BluetoothDevice *>(intent->getParcelableExtra(BluetoothDevice::EXTRA_DEVICE()));

        GLOGV("Received BT device selected intent, bt device: %s", SP_TOSTRING_STR(remoteDevice));

        // Insert transfer session record to database
         mOppManager->startTransfer(remoteDevice);

   

//显示正在向。。。传输文件的信息

        sp<String> deviceName = mOppManager->getDeviceName(remoteDevice);
        int32_t batchSize = mOppManager->getBatchSize();
        
        if (mOppManager->mMultipleFlag) {
            mToastText = context->getString(R::string::bt_toast_5, Integer::toString(batchSize)->string(),deviceName->string());
        } else {
            mToastText = context->getString(R::string::bt_toast_4, deviceName->string());
        }

        Toast::makeText(context,mToastText, Toast::LENGTH_SHORT)->show();

    }




void BluetoothOppManager::startTransfer(const sp<BluetoothDevice>& device) {
    GLOGENTRY();
    GLOGI("Active InsertShareThread number is : %d", mInsertShareThreadNum);
        sp<InsertShareInfoThread> insertThread;
        {
            RecursiveMutex::Autolock _l(mBluetoothOppManagerMutex);
            if (mInsertShareThreadNum > ALLOWED_INSERT_SHARE_THREAD_NUMBER) {
                LOGE("Too many shares user triggered concurrently!");
                return;
            /*
                // Notice user
                // TODO TODO TODO
                // check due to different translation
                // sp<Intent> in = new Intent(mContext, BluetoothOppBtErrorActivity.class);
                sp<Intent> in = new Intent();
                sp<ComponentName> component = new ComponentName(sp<String>(new String("BluetoothOppPbapService")), sp<String>(new String("BluetoothOppBtErrorActivity")));
                in->setComponent(component);

                in->setFlags(Intent::FLAG_ACTIVITY_NEW_TASK);
                // TODO TODO TODO
                // check due to different translation
                // in->putExtra(new String("title"), mContext->getString(R.string.enabling_progress_title));
                // in->putExtra(new String("content"), mContext->getString(R.string.ErrorTooManyRequests));
                in->putExtra(new String("title"), mContext->getString(R::string::enabling_progress_title));
                in->putExtra(new String("content"), mContext->getString(R::string::ErrorTooManyRequests));
                mContext->startActivity(in);

                return;
            */
            }
            insertThread = new InsertShareInfoThread(device, mMultipleFlag, mMimeTypeOfSendingFile,
                    mUriOfSendingFile, mMimeTypeOfSendingFiles, mUrisOfSendingFiles,
                    mIsHandoverInitiated, this);
            if (mMultipleFlag) {
                mfileNumInBatch = mUrisOfSendingFiles->size();
            }
        }

        insertThread->run("Insert ShareInfo Thread");
}


BluetoothOppManager::InsertShareInfoThread::InsertShareInfoThread(const sp<BluetoothDevice>& device, bool multiple,
        const sp<String>& typeOfSingleFile, const sp<String>& uri, const sp<String>& typeOfMultipleFiles,
        const sp<GArrayList<Uri> >& uris, bool handoverInitiated,  const wp<BluetoothOppManager>& bluetoothoppmanager)
    : PREINIT_DYNAMIC()
    , mRemoteDevice(device)
    , mTypeOfSingleFile(typeOfSingleFile)
    , mUri(uri)
    , mTypeOfMultipleFiles(typeOfMultipleFiles)
    , mUris(uris)
    , mIsMultiple(multiple)
    , mIsHandoverInitiated(handoverInitiated)
    , condition(false)
    , mwpbtom(bluetoothoppmanager) {
    GLOGENTRY();
    sp<BluetoothOppManager> mspbtom = mwpbtom.promote();
    CHECK_NULL_POINTER_RETURN(mspbtom);

    {
        RecursiveMutex::Autolock _l(mspbtom->mBluetoothOppManagerMutex);
        mspbtom->mInsertShareThreadNum++;
    }
    GLOGV("Thread id is: %d", this->getTid());
}


bool BluetoothOppManager::InsertShareInfoThread::threadLoop() {
    GLOGENTRY();
    sp<BluetoothOppManager> mspbtom = mwpbtom.promote();
    CHECK_NULL_POINTER_RETURN_FALSE(mspbtom);

    Process::setThreadPriority(Process::THREAD_PRIORITY_BACKGROUND);

    Looper::prepare();

    if (mRemoteDevice == NULL) {
        LOGE("Target bt device is null!");
        return false;
    }
    if (mIsMultiple) {
        insertMultipleShare();
    } else {
        insertSingleShare();
    }
    {
        RecursiveMutex::Autolock _l(mspbtom->mBluetoothOppManagerMutex);
        mspbtom->mInsertShareThreadNum--;
    }

    mConLock.lock();
    condition = true;
    mThreadStartCondition.broadcast();
    mConLock.unlock();

    Looper::loop();
    return false;
}



void BluetoothOppManager::InsertShareInfoThread::insertSingleShare() {
    GLOGENTRY();
    sp<BluetoothOppManager> mspbtom = mwpbtom.promote();
    CHECK_NULL_POINTER_RETURN(mspbtom);

    sp<ContentValues> values = new ContentValues();
    values->put(BluetoothShare::URI(), mUri);
    values->put(BluetoothShare::MIMETYPE(), mTypeOfSingleFile);
    values->put(BluetoothShare::DESTINATION(), mRemoteDevice->getAddress());
    if (mIsHandoverInitiated) {
        values->put(BluetoothShare::USER_CONFIRMATION(), BluetoothShare::USER_CONFIRMATION_HANDOVER_CONFIRMED);
    }
    sp<Uri> contentUri = mspbtom->mContext->getContentResolver()->insert(BluetoothShare::CONTENT_URI(), values);
    GLOGI("Insert contentUri: %s  to device: %s", SP_TOSTRING_STR(contentUri), SP_STRING_STR(mspbtom->getDeviceName(mRemoteDevice)));
}

对insert的处理有以下几个比较重要的操作：

1）创建一个可读/可写的database

2）启动了BluetoothOppService

3）通知database的改变，调用对应的onChange函数



sp<Uri> BluetoothOppProvider::insert(const sp<Uri>& uri, const sp<ContentValues>& values) {
    GLOGENTRY();
    GLOGI("BluetoothOppProvider insert");

//创建一个可读可写的数据
    sp<SQLiteDatabase> db = mOpenHelper->getWritableDatabase();

    sp<UriMatcher> urimatcher = sURIMatcher();
    CHECK_NULL_POINTER_RETURN_NULL(urimatcher);

    GLOGI("BluetoothOppProvider::insert 1");
    int32_t match = urimatcher->match(uri);
    GLOGI("BluetoothOppProvider::insert 2");

    if (match != SHARES) {
        GLOGD("calling insert on an unknown/invalid URI: %s" , SP_TOSTRING_STR(uri));
    }

    sp<ContentValues> filteredValues = new ContentValues();
//得到对应values中的信息
    copyString(BluetoothShare::URI(), values, filteredValues);
    copyString(BluetoothShare::FILENAME_HINT(), values, filteredValues);
    copyString(BluetoothShare::MIMETYPE(), values, filteredValues);
    copyString(BluetoothShare::DESTINATION(), values, filteredValues);

    copyInteger(BluetoothShare::VISIBILITY(), values, filteredValues);
    copyInteger(BluetoothShare::TOTAL_BYTES(), values, filteredValues);

    // if (values->getAsInteger(BluetoothShare::VISIBILITY()) == NULL) {
    filteredValues->put(BluetoothShare::VISIBILITY(), BluetoothShare::VISIBILITY_VISIBLE);
    // }
    int32_t dir = values->getAsInteger(BluetoothShare::DIRECTION());
    int32_t con = values->getAsInteger(BluetoothShare::USER_CONFIRMATION());
    sp<String> address = values->getAsString(BluetoothShare::DESTINATION());

    if (values->getAsInteger(BluetoothShare::DIRECTION()) == 0) {
        dir = BluetoothShare::DIRECTION_OUTBOUND;
    }
    if (dir == BluetoothShare::DIRECTION_OUTBOUND && con == 0) {
        con = BluetoothShare::USER_CONFIRMATION_AUTO_CONFIRMED;
    }
    if (dir == BluetoothShare::DIRECTION_INBOUND && con == 0) {
        con = BluetoothShare::USER_CONFIRMATION_PENDING;
    }
    filteredValues->put(BluetoothShare::USER_CONFIRMATION(), con);
    filteredValues->put(BluetoothShare::DIRECTION(), dir);

    filteredValues->put(BluetoothShare::STATUS(), BluetoothShare::STATUS_PENDING);
    filteredValues->put(Constants::MEDIA_SCANNED(), 0);

    int64_t ts = values->getAsLong(BluetoothShare::TIMESTAMP());
    if (ts == 0) {
        ts = System::currentTimeMillis();
    }
    filteredValues->put(BluetoothShare::TIMESTAMP(), ts);

    GLOGI("start BluetoothOppService");

    sp<Context> context = getContext();

    sp<Intent> intent = new Intent();
    sp<ComponentName> component = new ComponentName(sp<String>(new String("BluetoothOppPbapService")), sp<String>(new String("BluetoothOppService")));
    intent->setComponent(component);
//启动BluetoothOppService这个服务
    context->startService(intent);
    // context->startService(new Intent(context, Class::forName(new String("BluetoothOppService"))));

    int64_t rowID = db->insert(DB_TABLE(), NULL, filteredValues);

    sp<Uri> ret = NULL;

    if (rowID != -1) {
        GLOGI("rowID is not -1");

//再次启动这个服务
        context->startService(intent);
        // context->startService(new Intent(context, Class::forName(new String("BluetoothOppService"))));
        ret = Uri::parse(BluetoothShare::CONTENT_URI()->toString() + String("/") + String(rowID));

//通知数据库的变化
        context->getContentResolver()->notifyChange(uri, NULL);
    } else {
        GLOGD("couldn't insert into btopp database");
    }

    return ret;
}


监听数据库变化的：
mObserver = new BluetoothShareContentObserver();
        getContentResolver().registerContentObserver(BluetoothShare.CONTENT_URI, true, mObserver);
注：将文件加入数据库后，在BluetoothOppService的内部类BluetoothShareContentObserver会收到数据改变的事件，调用onChange（）-----updateFromProvider（）---updatethread;
updatethread里调用insertShare，这函数里面用到BluetoothOppTransfer，然后启动了BluetoothOppTransfer（mTransfer.start();）。


void BluetoothOppService::BluetoothShareContentObserver::onChange(bool selfChange) {
    GLOGENTRY();
    sp<BluetoothOppService> mspbtoppser = mBtOppService.promote();
    GLOGD("BluetoothOppService:: ContentObserver received notification");
    mspbtoppser->updateFromProvider();
}

void BluetoothOppService::updateFromProvider() {
    GLOGENTRY();
    GLOGI("updateFromProvider");
    RecursiveMutex::Autolock _l(mBluetoothOppServiceMutex);

    mPendingUpdate = true;
    if (mUpdateThread == NULL) {
        GLOGD("BluetoothOppService:: UpdateThread count %d", getStrongCount());
        mUpdateThread = new UpdateThread(this);
        GLOGD("BluetoothOppService:: UpdateThread count %d", getStrongCount());
        mUpdateThread->run("Bluetooth Share Service");
    }
}

void BluetoothOppService::insertShare(const sp<Cursor>& cursor, int32_t arrayPos) {
    GLOGENTRY();
    GLOGI("insertShare");
    sp<BluetoothOppShareInfo> info = new BluetoothOppShareInfo(
            cursor->getInt(cursor->getColumnIndexOrThrow(BluetoothShare::_ID)),
            cursor->getString(cursor->getColumnIndexOrThrow(BluetoothShare::URI())),
            cursor->getString(cursor->getColumnIndexOrThrow(BluetoothShare::FILENAME_HINT())),
            cursor->getString(cursor->getColumnIndexOrThrow(BluetoothShare::_DATA())),
            cursor->getString(cursor->getColumnIndexOrThrow(BluetoothShare::MIMETYPE())),
            cursor->getInt(cursor->getColumnIndexOrThrow(BluetoothShare::DIRECTION())),
            cursor->getString(cursor->getColumnIndexOrThrow(BluetoothShare::DESTINATION())),
            cursor->getInt(cursor->getColumnIndexOrThrow(BluetoothShare::VISIBILITY())),
            cursor->getInt(cursor->getColumnIndexOrThrow(BluetoothShare::USER_CONFIRMATION())),
            cursor->getInt(cursor->getColumnIndexOrThrow(BluetoothShare::STATUS())),
            cursor->getInt(cursor->getColumnIndexOrThrow(BluetoothShare::TOTAL_BYTES())),
            cursor->getInt(cursor->getColumnIndexOrThrow(BluetoothShare::CURRENT_BYTES())),
            cursor->getInt(cursor->getColumnIndexOrThrow(BluetoothShare::TIMESTAMP())),
            cursor->getInt(cursor->getColumnIndexOrThrow(Constants::MEDIA_SCANNED())) != Constants::MEDIA_SCANNED_NOT_SCANNED);

    GLOGI("Service adding new entry");
    GLOGV("ID      : %d", info->mId);
    // Log.v(TAG, "URI     : " + ((info.mUri != null) ? "yes" : "no"));
    GLOGV("URI     : %s", SP_STRING_STR(info->mUri));
    GLOGI("HINT    : %s", SP_STRING_STR(info->mHint));
    GLOGI("FILENAME: %s", SP_STRING_STR(info->mFilename));
    GLOGV("MIMETYPE: %s", SP_STRING_STR(info->mMimetype));
    GLOGV("DIRECTION: %d", info->mDirection);
    GLOGV("DESTINAT: %s", SP_STRING_STR(info->mDestination));
    GLOGV("VISIBILI: %d", info->mVisibility);
    GLOGI("CONFIRM : %d", info->mConfirm);
    GLOGI("STATUS  : %d", info->mStatus);
    GLOGV("TOTAL   : %d", info->mTotalBytes);
    GLOGV("CURRENT : %d", info->mCurrentBytes);
    GLOGV("TIMESTAMP : %lld", info->mTimestamp);
    GLOGV("SCANNED : %d", info->mMediaScanned);

    mShares->add(arrayPos, info);

    /* Mark the info as failed if it's in invalid status */
    if (info->isObsolete()) {
        Constants::updateShareStatus(this, info->mId, BluetoothShare::STATUS_UNKNOWN_ERROR);
        GLOGD("BluetoothOppService:: Constants::updateShareStatus count %d", getStrongCount());
    }
    /*
     * Add info into a batch. The logic is
     * 1) Only add valid and readyToStart info
     * 2) If there is no batch, create a batch and insert this transfer into batch,
     * then run the batch
     * 3) If there is existing batch and timestamp match, insert transfer into batch
     * 4) If there is existing batch and timestamp does not match, create a new batch and
     * put in queue
     */

    if (info->isReadyToStart()) {
        if (info->mDirection == BluetoothShare::DIRECTION_OUTBOUND) {
            /* check if the file exists */
            sp<InputStream> i;
#if 0
            try {
                i = getContentResolver()->openInputStream(Uri::parse(info->mUri));
            } catch(FileNotFoundException e) {
                Log.e(TAG, "Can't open file for OUTBOUND info " + info.mId);
                Constants.updateShareStatus(this, info.mId, BluetoothShare.STATUS_BAD_REQUEST);
                return;
            } catch(SecurityException e) {
                Log.e(TAG, "Exception:" + e.toString() + " for OUTBOUND info " + info.mId);
                Constants.updateShareStatus(this, info.mId, BluetoothShare.STATUS_BAD_REQUEST);
                return;
            }
#endif  // mark
            // TODO TODO TODO
            // check due to different translation
            i = getContentResolver()->openInputStream(Uri::parse(info->mUri));
            if (i == NULL) {
                LOGE("Can't open file for OUTBOUND info %d", info->mId);
                Constants::updateShareStatus(this, info->mId, BluetoothShare::STATUS_BAD_REQUEST);
                GLOGD("BluetoothOppService:: Constants::updateShareStatus count %d", getStrongCount());
                return;
            }
            // try {
                i->close();
            // } catch(IOException ex) {
            //    LOGE("IO error when close file for OUTBOUND info %d", info->mId);
            //    return;
            // }
        }
        if (mBatchs->size() == 0) {
            sp<BluetoothOppBatch> newBatch = new BluetoothOppBatch(this, info);
            newBatch->mId = mBatchId;
            mBatchId++;
            mBatchs->add(newBatch);
            if (info->mDirection == BluetoothShare::DIRECTION_OUTBOUND) {
                GLOGI("Service create new Batch %d for OUTBOUND info %d", newBatch->mId, info->mId);
                mTransfer = new BluetoothOppTransfer(this, mPowerManager, newBatch);
                GLOGD("BluetoothOppService:: BluetoothOppTransfer count %d", getStrongCount());
            } else if (info->mDirection == BluetoothShare::DIRECTION_INBOUND) {
                GLOGI("Service create new Batch %d for INBOUND info %d", newBatch->mId, info->mId);
                mServerTransfer = new BluetoothOppTransfer(this, mPowerManager, newBatch, mServerSession);
                GLOGD("BluetoothOppService:: BluetoothOppTransfer count %d", getStrongCount());
            }

            if (info->mDirection == BluetoothShare::DIRECTION_OUTBOUND && mTransfer != NULL) {
                GLOGI("Service start transfer new Batch %d for info %d", newBatch->mId, info->mId);
                mTransfer->start();
            } else if (info->mDirection == BluetoothShare::DIRECTION_INBOUND && mServerTransfer != NULL) {
                GLOGI("Service start server transfer new Batch %d for info %d", newBatch->mId, info->mId);
                mServerTransfer->start();
            }

        } else {
            int32_t i = findBatchWithTimeStamp(info->mTimestamp);
            if (i != -1) {
                GLOGI("Service add info %d to existing batch %d", info->mId, mBatchs->get(i)->mId);
                mBatchs->get(i)->addShare(info);
            } else {
                // There is ongoing batch
                sp<BluetoothOppBatch> newBatch = new BluetoothOppBatch(this, info);
                GLOGD("BluetoothOppService:: BluetoothOppBatch count %d", getStrongCount());
                newBatch->mId = mBatchId;
                mBatchId++;
                mBatchs->add(newBatch);
                GLOGI("Service add new Batch %d for info %d", newBatch->mId, info->mId);
                if (Constants::USE_TCP_DEBUG && !Constants::USE_TCP_SIMPLE_SERVER) {
                    // only allow  concurrent serverTransfer in debug mode
                    if (info->mDirection == BluetoothShare::DIRECTION_INBOUND) {
                        GLOGV("TCP_DEBUG start server transfer new Batch %d for info %d", newBatch->mId, info->mId);
                        mServerTransfer = new BluetoothOppTransfer(this, mPowerManager, newBatch, mServerSession);
                        GLOGD("BluetoothOppService:: BluetoothOppTransfer count %d", getStrongCount());
                        mServerTransfer->start();
                    }
                }
            }
        }
    }
}


void BluetoothOppTransfer::start() {
    GLOGENTRY();
    /* check Bluetooth enable status */
    /*
     * normally it's impossible to reach here if BT is disabled. Just check
     * for safety
     */
    if (!mAdapter->isEnabled()) {
        LOGE("Can't start transfer when Bluetooth is disabled for %d", mBatch->mId);
        markBatchFailed();
        mBatch->mStatus = Constants::BATCH_STATUS_FAILED;
        return;
    }

    if (mHandlerThread == NULL) {
        GLOGI("Create handler thread for batch %d", mBatch->mId);
        mHandlerThread = new HandlerThread(new String("BtOpp Transfer Handler"), Process::THREAD_PRIORITY_BACKGROUND);
        mHandlerThread->run();
        mSessionHandler = new EventHandler(mHandlerThread->getLooper(), this);

        GLOGI("mBatch->mDirection = %lld", mBatch->mDirection);

        if (mBatch->mDirection == BluetoothShare::DIRECTION_OUTBOUND) {
            /* for outbound transfer, we do connect first */
            startConnectSession();
        } else if (mBatch->mDirection == BluetoothShare::DIRECTION_INBOUND) {
            /*
             * for inbound transfer, it's already connected, so we start
             * OBEX session directly
             */
            startObexSession();
        }
    }
}

void BluetoothOppTransfer::startConnectSession() {
    GLOGENTRY();
    sp<Context> mspContext = mContext.promote();
    CHECK_NULL_POINTER_RETURN(mspContext);

    if (Constants::USE_TCP_DEBUG) {
        mConnectThread = new SocketConnectThread(new String("localhost"), Constants::TCP_DEBUG_PORT, 0, this);
        mConnectThread->run();
    } else {
        int32_t channel = BluetoothOppPreference::getInstance(mspContext)->getChannel(mBatch->mDestination, OPUSH_UUID16);
        if (channel != -1) {
            GLOGI("Get OPUSH channel %d from cache for %s", channel, SP_TOSTRING_STR(mBatch->mDestination));
            mTimestamp = System::currentTimeMillis();
            mSessionHandler->obtainMessage(SDP_RESULT, channel, -1, mBatch->mDestination)->sendToTarget();
        } else {
            doOpushSdp();
        }
    }
}



void BluetoothOppTransfer::doOpushSdp() {
    GLOGENTRY();
    GLOGI("Do Opush SDP request for address %s", SP_TOSTRING_STR(mBatch->mDestination));

    sp<Context> mspContext = mContext.promote();
    CHECK_NULL_POINTER_RETURN(mspContext);

    mTimestamp = System::currentTimeMillis();

    int32_t channel;
    channel = mBatch->mDestination->getServiceChannel(BluetoothUuid::ObexObjectPush());
    if (channel != -1) {
        GLOGD("Get OPUSH channel %d from SDP for %s", channel, SP_TOSTRING_STR(mBatch->mDestination));
        mSessionHandler->obtainMessage(SDP_RESULT, channel, -1, mBatch->mDestination)->sendToTarget();
        return;
    } else {
        GLOGI("Remote Service channel not in cache");

        if (!mBatch->mDestination->fetchUuidsWithSdp()) {
            LOGE("Start SDP query failed");
        } else {
            // we expect framework send us Intent ACTION_UUID. otherwise we will fail
            GLOGV("Start new SDP, wait for result");
            sp<IntentFilter> intentFilter = new IntentFilter(BluetoothDevice::ACTION_UUID());
            mspContext->registerReceiver(mReceiver, intentFilter);
            return;
        }
    }
    sp<Message> msg = mSessionHandler->obtainMessage(SDP_RESULT, channel, -1, mBatch->mDestination);
    mSessionHandler->sendMessageDelayed(msg, 2000);
}



ok_day
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
闲叙蓝牙OPP（二）---文件传输BluetoothOppService专讲
fanfan
07-22 2213
原文来自 原文链接 从上文可以看出，文件插入db后直接就是BluetoothOppService（下文会缩写成BtOppService）的处理了，在BtOppService中建立传输通道，但在讲述传输通道之前，先来好好分析一下BtOppService。 那么在分析该BtOppService之前先提一个问题，如果让你去设计这么一个service你会怎么设计？service都需要实现哪些功能？ ...
android蓝牙传输文件到mysql_蓝牙opp文件发送过程剖析
weixin_39651735的博客
01-26 1万+
蓝牙文件传输之obex层之上的分析【Android源码解析】在上节中我们仔细分析了蓝牙文件传输过程中涉及到的UI界面，最终定格在蓝牙设备扫描的界面，我们只要选择自己想要传输的蓝牙设备就可以进行蓝牙文件的传输了。那就是这样一个简单的设备选择的点击会引发哪些连锁的操作呢？本节就来详细进行分析。1.1.设备点击的action和响应我们先来回顾一下，最后蓝牙设备的扫描界面是在DevicePickerFra...
Android T 蓝牙传输文件流程（一）
好记性不如烂笔头
07-04 2239
Android T 蓝牙 Opp 流程
Android Bluetooth OPP
我有一壶酒
09-27 1万+
分析Android Bluetooth的Object Push Profile
Android Bluetooth OPP的理解与使用之七
YingbinLi的博客
07-22 1942
Android Bluetooth OPP
android -- 蓝牙 bluetooth （四）OPP文件传输
balmy的专栏
06-22 4万+
在前面android -- 蓝牙 bluetooth （一） 入门文章结尾中提到了会按四个方面来写这系列的文章，前面已写了蓝牙打开和蓝牙搜索，这次一起来看下蓝牙文件分享的流程，也就是蓝牙应用opp目录下的代码，作为蓝牙最基本的一个功能，这部分的代码在之前的版本中就已经有了，新旧版本代码对比很多类名都是一样的，这一部分新东西不多，写在这里帮助大家梳理下流程吧。         有没有这种感觉，
opp3xxx_data.rar_V2
09-21
【标题】"opp3xxx_data.rar_V2" 指示了一个针对OPP3xxx设备的数据包，且标记为版本2。此数据包可能包含了针对Linux操作系统特定版本的固件或者驱动程序更新。 【描述】"MPU OPP1 - OPP50 for Linux v2.13.6." 提供...
opp.rar_disk-on-chip
09-21
标题中的“opp.rar_disk-on-chip”暗示了我们讨论的主题是关于Linux驱动程序，特别是针对Disk-On-Chip(DOC)设备的。Disk-On-Chip是一种特殊的存储技术，它将多个闪存芯片集成在一个封装内，提供高容量和高速度的数据...
OPP.rar_opp开发_opp语言_opp语音怎么用
09-24
使用这些功能，开发者可以构建各种语音交互的应用，例如智能助手、语音控制界面或语音分析工具。为了更好地掌握OPP语音功能，建议深入研究提供的文档、示例代码或教程。 在《OPP语言比较.doc》这个文档中，可能会...
opp.rar_interface
09-20
这通常包括对外设进行读写操作的低级函数，如`opp_read()`和`opp_write()`，以及对OPP接口进行管理和控制的高级函数。这些函数的实现会依赖于具体的硬件平台和架构，因此，opp.c中的代码可能会包含针对特定硬件的...
opp.rar_SOC
09-20
7. **性能监视**：为了确保OPP策略的有效性，系统可能会包含性能监视单元（PMU，Performance Monitoring Unit），用于收集运行时数据，如周期计数器、功耗数据等，以便分析和调整OPP策略。 通过理解并利用OPP机制，...
带你解锁蓝牙skill（三）
fanfan
06-21 6351
本文授权微信公众号fanfan程序媛独家发布 转载请注明出处，本文出自fanfan的带你解锁蓝牙skill系列 蓝牙这块儿算是系统中的一个大块儿，刚开始分析确实很容易没有头绪，所以在进入庞大的源码之前先确定一个分析顺序，也好避免越学越乱。 对于源码的分析不外乎whw（what—how—why）对于蓝牙各协议的功能以及如何演示都已经分析完了，具体可以参考 带你解锁蓝牙skill(一)以及带你解锁
BluetoothOpp共享文件（一）之蓝牙设备选择
Tony-jiang的博客
07-26 1013
当我们共享文件时都会弹出共享方式选择，我们选择蓝牙共享时就会根据蓝牙是否开启来进行不同的结果。接下来就默认蓝牙为开启的状态进行分析。 当我们点击蓝牙的时候就会显现蓝牙设备选择界面，即DevicePickerFragment.java 具体蓝牙列表是怎么显示出来的请自行分析。 1.共享文件就会选择一个要共享的设备，当我们点击共享的设备时，执行的代码如下： @Override     void...
android启动蓝牙选择设备,java – Android蓝牙设备选择器用法
weixin_34593388的博客
05-31 365
我的应用程序需要蓝牙连接.在第一阶段,我正在尝试打开标准活动“蓝牙设备选择器”,以帮助用户扫描新设备或从列表中选择一个设备.问题是我无法获得蓝牙设备选择器的任何工作示例.任务很简单.用Intent“android.bluetooth.devicepicker.action.LAUNCH”启动一个Activity并且设备选择器正在打开而没有任何问题.但是设备选择器需要四个附加功能,我无法确定下面列出...
android 蓝牙 bluetooth OPP文件传输
热门推荐
成长的味道
12-21 4万+
蓝牙文件分享的流程，也就是蓝牙应用opp目录下的代码，作为蓝牙最基本的一个功能，这部分的代码在之前的版本中就已经有了，新旧版本代码对比很多类名都是一样的，这一部分新东西不多，写在这里帮助大家梳理下流程吧。         有没有这种感觉，智能手机的普及让我们提高了一点对蓝牙的关注，手机间使用蓝牙互传文件应该是最常用的应用之一，手机与电脑也可以通过蓝牙做同样的事情，大部分笔记本都支持蓝牙功能，
Android 蓝牙开发（四）OPP传输文件
奋斗的菜鸟ing
04-21 2万+
Android蓝牙功能（传统蓝牙、ble、hid）这三方面功能之前的博客都已经写了。现在接着了解蓝牙OPP传输文件相关功能。 Android手机使用中，经常会用到通过蓝牙分享文件给附近的朋友。那么具体是如何实现的，大部分朋友都不是很清楚。看一下源码是如何实现该功能的。 BluetoothOppLauncherActivity Android手机点击某文件进行蓝牙分享的时候，会跳转到系统自
蓝牙文件分享源码全解析
红旺永福
12-09 3904
Android bluetooth文件分享的完整过程的源码分析
蓝牙配对笔记
这都是什么
01-12 575
显示列表 packages/apps/Settings/src/com/android/settings/bluetooth/DeviceListPreferenceFragment.java DeviceListPreferenceFragment 初始化操作 @Override public void onCreate(Bundle savedInstanceState) {...
Android Bluetooth OPP的理解与使用之五
YingbinLi的博客
07-22 613
Android Bluetooth OPP
dmc_opp_table
最新发布
07-27
DMC_OPP_TABLE 是一个用于管理 DMC (Data Management Committee) 的操作表。DMC 是一个负责管理数据的委员会，它负责规划、协调和监督数据管理活动。DMC_OPP_TABLE 是一个记录 DMC 成员操作的表格，其中包含了每个成员的姓名、操作日期、操作类型等信息。通过这个表格，可以方便地追踪和管理 DMC 成员的操作记录。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值