579 lines
19 KiB
C++
579 lines
19 KiB
C++
/*
|
|
* Copyright (C) 2021 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.
|
|
*/
|
|
|
|
#include "chre/common.h"
|
|
#include "inc/test_util.h"
|
|
#include "test_base.h"
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <cstdint>
|
|
|
|
#include "chre/core/event_loop_manager.h"
|
|
#include "chre/core/settings.h"
|
|
#include "chre/platform/fatal_error.h"
|
|
#include "chre/platform/linux/pal_ble.h"
|
|
#include "chre/util/dynamic_vector.h"
|
|
#include "chre_api/chre/ble.h"
|
|
#include "chre_api/chre/user_settings.h"
|
|
#include "test_util.h"
|
|
|
|
namespace chre {
|
|
|
|
namespace {
|
|
|
|
/**
|
|
* This test verifies that a nanoapp can query for BLE capabilities and filter
|
|
* capabilities. Note that a nanoapp does not require BLE permissions to use
|
|
* these APIs.
|
|
*/
|
|
TEST_F(TestBase, BleCapabilitiesTest) {
|
|
CREATE_CHRE_TEST_EVENT(GET_CAPABILITIES, 0);
|
|
CREATE_CHRE_TEST_EVENT(GET_FILTER_CAPABILITIES, 1);
|
|
|
|
struct App : public TestNanoapp {
|
|
uint32_t perms = NanoappPermissions::CHRE_PERMS_WIFI;
|
|
|
|
void (*handleEvent)(uint32_t, uint16_t, const void *) =
|
|
[](uint32_t, uint16_t eventType, const void *eventData) {
|
|
switch (eventType) {
|
|
case CHRE_EVENT_TEST_EVENT: {
|
|
auto event = static_cast<const TestEvent *>(eventData);
|
|
switch (event->type) {
|
|
case GET_CAPABILITIES: {
|
|
TestEventQueueSingleton::get()->pushEvent(
|
|
GET_CAPABILITIES, chreBleGetCapabilities());
|
|
break;
|
|
}
|
|
|
|
case GET_FILTER_CAPABILITIES: {
|
|
TestEventQueueSingleton::get()->pushEvent(
|
|
GET_FILTER_CAPABILITIES, chreBleGetFilterCapabilities());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
auto app = loadNanoapp<App>();
|
|
|
|
uint32_t capabilities;
|
|
sendEventToNanoapp(app, GET_CAPABILITIES);
|
|
waitForEvent(GET_CAPABILITIES, &capabilities);
|
|
ASSERT_EQ(capabilities, CHRE_BLE_CAPABILITIES_SCAN |
|
|
CHRE_BLE_CAPABILITIES_SCAN_RESULT_BATCHING |
|
|
CHRE_BLE_CAPABILITIES_SCAN_FILTER_BEST_EFFORT);
|
|
|
|
sendEventToNanoapp(app, GET_FILTER_CAPABILITIES);
|
|
waitForEvent(GET_FILTER_CAPABILITIES, &capabilities);
|
|
ASSERT_EQ(capabilities, CHRE_BLE_FILTER_CAPABILITIES_RSSI |
|
|
CHRE_BLE_FILTER_CAPABILITIES_SERVICE_DATA);
|
|
}
|
|
|
|
struct BleTestNanoapp : public TestNanoapp {
|
|
uint32_t perms = NanoappPermissions::CHRE_PERMS_BLE;
|
|
|
|
bool (*start)() = []() {
|
|
chreUserSettingConfigureEvents(CHRE_USER_SETTING_BLE_AVAILABLE,
|
|
true /* enable */);
|
|
return true;
|
|
};
|
|
|
|
void (*end)() = []() {
|
|
chreUserSettingConfigureEvents(CHRE_USER_SETTING_BLE_AVAILABLE,
|
|
false /* enable */);
|
|
};
|
|
};
|
|
|
|
/**
|
|
* This test validates the case in which a nanoapp starts a scan, receives
|
|
* at least one advertisement event, and stops a scan.
|
|
*/
|
|
TEST_F(TestBase, BleSimpleScanTest) {
|
|
CREATE_CHRE_TEST_EVENT(START_SCAN, 0);
|
|
CREATE_CHRE_TEST_EVENT(SCAN_STARTED, 1);
|
|
CREATE_CHRE_TEST_EVENT(STOP_SCAN, 2);
|
|
CREATE_CHRE_TEST_EVENT(SCAN_STOPPED, 3);
|
|
|
|
struct App : public BleTestNanoapp {
|
|
void (*handleEvent)(uint32_t, uint16_t,
|
|
const void *) = [](uint32_t, uint16_t eventType,
|
|
const void *eventData) {
|
|
switch (eventType) {
|
|
case CHRE_EVENT_BLE_ASYNC_RESULT: {
|
|
auto *event = static_cast<const struct chreAsyncResult *>(eventData);
|
|
if (event->errorCode == CHRE_ERROR_NONE) {
|
|
uint16_t type =
|
|
(event->requestType == CHRE_BLE_REQUEST_TYPE_START_SCAN)
|
|
? SCAN_STARTED
|
|
: SCAN_STOPPED;
|
|
TestEventQueueSingleton::get()->pushEvent(type);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case CHRE_EVENT_BLE_ADVERTISEMENT: {
|
|
TestEventQueueSingleton::get()->pushEvent(
|
|
CHRE_EVENT_BLE_ADVERTISEMENT);
|
|
break;
|
|
}
|
|
|
|
case CHRE_EVENT_TEST_EVENT: {
|
|
auto event = static_cast<const TestEvent *>(eventData);
|
|
switch (event->type) {
|
|
case START_SCAN: {
|
|
const bool success = chreBleStartScanAsync(
|
|
CHRE_BLE_SCAN_MODE_BACKGROUND, 0, nullptr);
|
|
TestEventQueueSingleton::get()->pushEvent(START_SCAN, success);
|
|
break;
|
|
}
|
|
|
|
case STOP_SCAN: {
|
|
const bool success = chreBleStopScanAsync();
|
|
TestEventQueueSingleton::get()->pushEvent(STOP_SCAN, success);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
auto app = loadNanoapp<App>();
|
|
|
|
bool success;
|
|
sendEventToNanoapp(app, START_SCAN);
|
|
waitForEvent(START_SCAN, &success);
|
|
EXPECT_TRUE(success);
|
|
waitForEvent(SCAN_STARTED);
|
|
ASSERT_TRUE(chrePalIsBleEnabled());
|
|
waitForEvent(CHRE_EVENT_BLE_ADVERTISEMENT);
|
|
|
|
sendEventToNanoapp(app, STOP_SCAN);
|
|
waitForEvent(STOP_SCAN, &success);
|
|
EXPECT_TRUE(success);
|
|
waitForEvent(SCAN_STOPPED);
|
|
ASSERT_FALSE(chrePalIsBleEnabled());
|
|
}
|
|
|
|
TEST_F(TestBase, BleStopScanOnUnload) {
|
|
CREATE_CHRE_TEST_EVENT(START_SCAN, 0);
|
|
CREATE_CHRE_TEST_EVENT(SCAN_STARTED, 1);
|
|
|
|
struct App : public BleTestNanoapp {
|
|
void (*handleEvent)(uint32_t, uint16_t,
|
|
const void *) = [](uint32_t, uint16_t eventType,
|
|
const void *eventData) {
|
|
switch (eventType) {
|
|
case CHRE_EVENT_BLE_ASYNC_RESULT: {
|
|
auto *event = static_cast<const struct chreAsyncResult *>(eventData);
|
|
if (event->requestType == CHRE_BLE_REQUEST_TYPE_START_SCAN &&
|
|
event->errorCode == CHRE_ERROR_NONE) {
|
|
TestEventQueueSingleton::get()->pushEvent(SCAN_STARTED);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case CHRE_EVENT_TEST_EVENT: {
|
|
auto event = static_cast<const TestEvent *>(eventData);
|
|
switch (event->type) {
|
|
case START_SCAN: {
|
|
const bool success = chreBleStartScanAsync(
|
|
CHRE_BLE_SCAN_MODE_BACKGROUND, 0, nullptr);
|
|
TestEventQueueSingleton::get()->pushEvent(START_SCAN, success);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
auto app = loadNanoapp<App>();
|
|
bool success;
|
|
|
|
sendEventToNanoapp(app, START_SCAN);
|
|
waitForEvent(START_SCAN, &success);
|
|
EXPECT_TRUE(success);
|
|
waitForEvent(SCAN_STARTED);
|
|
ASSERT_TRUE(chrePalIsBleEnabled());
|
|
|
|
unloadNanoapp(app);
|
|
ASSERT_FALSE(chrePalIsBleEnabled());
|
|
}
|
|
|
|
/**
|
|
* This test validates that a nanoapp can start a scan twice and the platform
|
|
* will be enabled.
|
|
*/
|
|
TEST_F(TestBase, BleStartTwiceScanTest) {
|
|
CREATE_CHRE_TEST_EVENT(START_SCAN, 0);
|
|
CREATE_CHRE_TEST_EVENT(SCAN_STARTED, 1);
|
|
CREATE_CHRE_TEST_EVENT(STOP_SCAN, 2);
|
|
CREATE_CHRE_TEST_EVENT(SCAN_STOPPED, 3);
|
|
|
|
struct App : public BleTestNanoapp {
|
|
void (*handleEvent)(uint32_t, uint16_t,
|
|
const void *) = [](uint32_t, uint16_t eventType,
|
|
const void *eventData) {
|
|
switch (eventType) {
|
|
case CHRE_EVENT_BLE_ASYNC_RESULT: {
|
|
auto *event = static_cast<const struct chreAsyncResult *>(eventData);
|
|
if (event->errorCode == CHRE_ERROR_NONE) {
|
|
uint16_t type =
|
|
(event->requestType == CHRE_BLE_REQUEST_TYPE_START_SCAN)
|
|
? SCAN_STARTED
|
|
: SCAN_STOPPED;
|
|
TestEventQueueSingleton::get()->pushEvent(type);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case CHRE_EVENT_BLE_ADVERTISEMENT: {
|
|
TestEventQueueSingleton::get()->pushEvent(
|
|
CHRE_EVENT_BLE_ADVERTISEMENT);
|
|
break;
|
|
}
|
|
|
|
case CHRE_EVENT_TEST_EVENT: {
|
|
auto event = static_cast<const TestEvent *>(eventData);
|
|
switch (event->type) {
|
|
case START_SCAN: {
|
|
const bool success = chreBleStartScanAsync(
|
|
CHRE_BLE_SCAN_MODE_BACKGROUND, 0, nullptr);
|
|
TestEventQueueSingleton::get()->pushEvent(START_SCAN, success);
|
|
break;
|
|
}
|
|
|
|
case STOP_SCAN: {
|
|
const bool success = chreBleStopScanAsync();
|
|
TestEventQueueSingleton::get()->pushEvent(STOP_SCAN, success);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
auto app = loadNanoapp<App>();
|
|
bool success;
|
|
|
|
sendEventToNanoapp(app, START_SCAN);
|
|
waitForEvent(START_SCAN, &success);
|
|
EXPECT_TRUE(success);
|
|
waitForEvent(SCAN_STARTED);
|
|
|
|
sendEventToNanoapp(app, START_SCAN);
|
|
waitForEvent(START_SCAN, &success);
|
|
EXPECT_TRUE(success);
|
|
waitForEvent(SCAN_STARTED);
|
|
waitForEvent(CHRE_EVENT_BLE_ADVERTISEMENT);
|
|
|
|
sendEventToNanoapp(app, STOP_SCAN);
|
|
waitForEvent(STOP_SCAN, &success);
|
|
EXPECT_TRUE(success);
|
|
waitForEvent(SCAN_STOPPED);
|
|
}
|
|
|
|
/**
|
|
* This test validates that a nanoapp can request to stop a scan twice without
|
|
* any ongoing scan existing. It asserts that the nanoapp did not receive any
|
|
* advertisment events because a scan was never started.
|
|
*/
|
|
TEST_F(TestBase, BleStopTwiceScanTest) {
|
|
CREATE_CHRE_TEST_EVENT(SCAN_STARTED, 1);
|
|
CREATE_CHRE_TEST_EVENT(STOP_SCAN, 2);
|
|
CREATE_CHRE_TEST_EVENT(SCAN_STOPPED, 3);
|
|
|
|
struct App : public BleTestNanoapp {
|
|
void (*handleEvent)(uint32_t, uint16_t, const void *) =
|
|
[](uint32_t, uint16_t eventType, const void *eventData) {
|
|
switch (eventType) {
|
|
case CHRE_EVENT_BLE_ASYNC_RESULT: {
|
|
auto *event =
|
|
static_cast<const struct chreAsyncResult *>(eventData);
|
|
if (event->errorCode == CHRE_ERROR_NONE) {
|
|
uint16_t type =
|
|
(event->requestType == CHRE_BLE_REQUEST_TYPE_START_SCAN)
|
|
? SCAN_STARTED
|
|
: SCAN_STOPPED;
|
|
TestEventQueueSingleton::get()->pushEvent(type);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case CHRE_EVENT_BLE_ADVERTISEMENT: {
|
|
FATAL_ERROR("No advertisement expected");
|
|
break;
|
|
}
|
|
|
|
case CHRE_EVENT_TEST_EVENT: {
|
|
auto event = static_cast<const TestEvent *>(eventData);
|
|
switch (event->type) {
|
|
case STOP_SCAN: {
|
|
const bool success = chreBleStopScanAsync();
|
|
TestEventQueueSingleton::get()->pushEvent(STOP_SCAN, success);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
auto app = loadNanoapp<App>();
|
|
bool success;
|
|
|
|
sendEventToNanoapp(app, STOP_SCAN);
|
|
waitForEvent(STOP_SCAN, &success);
|
|
EXPECT_TRUE(success);
|
|
waitForEvent(SCAN_STOPPED);
|
|
|
|
sendEventToNanoapp(app, STOP_SCAN);
|
|
waitForEvent(STOP_SCAN, &success);
|
|
EXPECT_TRUE(success);
|
|
|
|
waitForEvent(SCAN_STOPPED);
|
|
unloadNanoapp(app);
|
|
}
|
|
|
|
/**
|
|
* This test verifies the following BLE settings behavior:
|
|
* 1) Nanoapp makes BLE scan request
|
|
* 2) Toggle BLE setting -> disabled
|
|
* 3) Toggle BLE setting -> enabled.
|
|
* 4) Verify things resume.
|
|
*/
|
|
TEST_F(TestBase, BleSettingChangeTest) {
|
|
CREATE_CHRE_TEST_EVENT(START_SCAN, 0);
|
|
CREATE_CHRE_TEST_EVENT(SCAN_STARTED, 1);
|
|
CREATE_CHRE_TEST_EVENT(SCAN_STOPPED, 3);
|
|
|
|
struct App : public BleTestNanoapp {
|
|
void (*handleEvent)(uint32_t, uint16_t,
|
|
const void *) = [](uint32_t, uint16_t eventType,
|
|
const void *eventData) {
|
|
switch (eventType) {
|
|
case CHRE_EVENT_BLE_ASYNC_RESULT: {
|
|
auto *event = static_cast<const struct chreAsyncResult *>(eventData);
|
|
if (event->errorCode == CHRE_ERROR_NONE) {
|
|
uint16_t type =
|
|
(event->requestType == CHRE_BLE_REQUEST_TYPE_START_SCAN)
|
|
? SCAN_STARTED
|
|
: SCAN_STOPPED;
|
|
TestEventQueueSingleton::get()->pushEvent(type);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case CHRE_EVENT_BLE_ADVERTISEMENT: {
|
|
TestEventQueueSingleton::get()->pushEvent(
|
|
CHRE_EVENT_BLE_ADVERTISEMENT);
|
|
break;
|
|
}
|
|
|
|
case CHRE_EVENT_SETTING_CHANGED_BLE_AVAILABLE: {
|
|
auto *event =
|
|
static_cast<const chreUserSettingChangedEvent *>(eventData);
|
|
bool enabled =
|
|
(event->settingState == CHRE_USER_SETTING_STATE_ENABLED);
|
|
TestEventQueueSingleton::get()->pushEvent(
|
|
CHRE_EVENT_SETTING_CHANGED_BLE_AVAILABLE, enabled);
|
|
break;
|
|
}
|
|
|
|
case CHRE_EVENT_TEST_EVENT: {
|
|
auto event = static_cast<const TestEvent *>(eventData);
|
|
switch (event->type) {
|
|
case START_SCAN: {
|
|
const bool success = chreBleStartScanAsync(
|
|
CHRE_BLE_SCAN_MODE_BACKGROUND, 0, nullptr);
|
|
TestEventQueueSingleton::get()->pushEvent(START_SCAN, success);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
auto app = loadNanoapp<App>();
|
|
bool success;
|
|
|
|
sendEventToNanoapp(app, START_SCAN);
|
|
waitForEvent(START_SCAN, &success);
|
|
EXPECT_TRUE(success);
|
|
|
|
waitForEvent(SCAN_STARTED);
|
|
waitForEvent(CHRE_EVENT_BLE_ADVERTISEMENT);
|
|
|
|
EventLoopManagerSingleton::get()->getSettingManager().postSettingChange(
|
|
Setting::BLE_AVAILABLE, false /* enabled */);
|
|
bool enabled;
|
|
waitForEvent(CHRE_EVENT_SETTING_CHANGED_BLE_AVAILABLE, &enabled);
|
|
EXPECT_FALSE(enabled);
|
|
EXPECT_FALSE(
|
|
EventLoopManagerSingleton::get()->getSettingManager().getSettingEnabled(
|
|
Setting::BLE_AVAILABLE));
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
EXPECT_FALSE(chrePalIsBleEnabled());
|
|
|
|
EventLoopManagerSingleton::get()->getSettingManager().postSettingChange(
|
|
Setting::BLE_AVAILABLE, true /* enabled */);
|
|
waitForEvent(CHRE_EVENT_SETTING_CHANGED_BLE_AVAILABLE, &enabled);
|
|
EXPECT_TRUE(enabled);
|
|
EXPECT_TRUE(
|
|
EventLoopManagerSingleton::get()->getSettingManager().getSettingEnabled(
|
|
Setting::BLE_AVAILABLE));
|
|
waitForEvent(CHRE_EVENT_BLE_ADVERTISEMENT);
|
|
EXPECT_TRUE(chrePalIsBleEnabled());
|
|
}
|
|
|
|
/**
|
|
* Test that a nanoapp receives a function disabled error if it attempts to
|
|
* start a scan when the BLE setting is disabled.
|
|
*/
|
|
TEST_F(TestBase, BleSettingDisabledStartScanTest) {
|
|
CREATE_CHRE_TEST_EVENT(START_SCAN, 0);
|
|
|
|
struct App : public BleTestNanoapp {
|
|
void (*handleEvent)(uint32_t, uint16_t,
|
|
const void *) = [](uint32_t, uint16_t eventType,
|
|
const void *eventData) {
|
|
switch (eventType) {
|
|
case CHRE_EVENT_BLE_ASYNC_RESULT: {
|
|
auto *event = static_cast<const struct chreAsyncResult *>(eventData);
|
|
if (event->errorCode == CHRE_ERROR_FUNCTION_DISABLED) {
|
|
TestEventQueueSingleton::get()->pushEvent(
|
|
CHRE_EVENT_BLE_ASYNC_RESULT);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case CHRE_EVENT_SETTING_CHANGED_BLE_AVAILABLE: {
|
|
auto *event =
|
|
static_cast<const chreUserSettingChangedEvent *>(eventData);
|
|
bool enabled =
|
|
(event->settingState == CHRE_USER_SETTING_STATE_ENABLED);
|
|
TestEventQueueSingleton::get()->pushEvent(
|
|
CHRE_EVENT_SETTING_CHANGED_BLE_AVAILABLE, enabled);
|
|
break;
|
|
}
|
|
|
|
case CHRE_EVENT_TEST_EVENT: {
|
|
auto event = static_cast<const TestEvent *>(eventData);
|
|
switch (event->type) {
|
|
case START_SCAN: {
|
|
const bool success = chreBleStartScanAsync(
|
|
CHRE_BLE_SCAN_MODE_BACKGROUND, 0, nullptr);
|
|
TestEventQueueSingleton::get()->pushEvent(START_SCAN, success);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
auto app = loadNanoapp<App>();
|
|
|
|
EventLoopManagerSingleton::get()->getSettingManager().postSettingChange(
|
|
Setting::BLE_AVAILABLE, false /* enable */);
|
|
|
|
bool enabled;
|
|
waitForEvent(CHRE_EVENT_SETTING_CHANGED_BLE_AVAILABLE, &enabled);
|
|
EXPECT_FALSE(enabled);
|
|
|
|
bool success;
|
|
sendEventToNanoapp(app, START_SCAN);
|
|
waitForEvent(START_SCAN, &success);
|
|
EXPECT_TRUE(success);
|
|
waitForEvent(CHRE_EVENT_BLE_ASYNC_RESULT);
|
|
}
|
|
|
|
/**
|
|
* Test that a nanoapp receives a success response when it attempts to stop a
|
|
* BLE scan while the BLE setting is disabled.
|
|
*/
|
|
TEST_F(TestBase, BleSettingDisabledStopScanTest) {
|
|
CREATE_CHRE_TEST_EVENT(SCAN_STARTED, 1);
|
|
CREATE_CHRE_TEST_EVENT(STOP_SCAN, 2);
|
|
CREATE_CHRE_TEST_EVENT(SCAN_STOPPED, 3);
|
|
|
|
struct App : public BleTestNanoapp {
|
|
void (*handleEvent)(uint32_t, uint16_t, const void *) =
|
|
[](uint32_t, uint16_t eventType, const void *eventData) {
|
|
switch (eventType) {
|
|
case CHRE_EVENT_BLE_ASYNC_RESULT: {
|
|
auto *event =
|
|
static_cast<const struct chreAsyncResult *>(eventData);
|
|
if (event->errorCode == CHRE_ERROR_NONE) {
|
|
uint16_t type =
|
|
(event->requestType == CHRE_BLE_REQUEST_TYPE_START_SCAN)
|
|
? SCAN_STARTED
|
|
: SCAN_STOPPED;
|
|
TestEventQueueSingleton::get()->pushEvent(type);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case CHRE_EVENT_SETTING_CHANGED_BLE_AVAILABLE: {
|
|
auto *event =
|
|
static_cast<const chreUserSettingChangedEvent *>(eventData);
|
|
bool enabled =
|
|
(event->settingState == CHRE_USER_SETTING_STATE_ENABLED);
|
|
TestEventQueueSingleton::get()->pushEvent(
|
|
CHRE_EVENT_SETTING_CHANGED_BLE_AVAILABLE, enabled);
|
|
break;
|
|
}
|
|
|
|
case CHRE_EVENT_TEST_EVENT: {
|
|
auto event = static_cast<const TestEvent *>(eventData);
|
|
switch (event->type) {
|
|
case STOP_SCAN: {
|
|
const bool success = chreBleStopScanAsync();
|
|
TestEventQueueSingleton::get()->pushEvent(STOP_SCAN, success);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
auto app = loadNanoapp<App>();
|
|
|
|
EventLoopManagerSingleton::get()->getSettingManager().postSettingChange(
|
|
Setting::BLE_AVAILABLE, false /* enable */);
|
|
|
|
bool enabled;
|
|
waitForEvent(CHRE_EVENT_SETTING_CHANGED_BLE_AVAILABLE, &enabled);
|
|
EXPECT_FALSE(enabled);
|
|
|
|
bool success;
|
|
sendEventToNanoapp(app, STOP_SCAN);
|
|
waitForEvent(STOP_SCAN, &success);
|
|
EXPECT_TRUE(success);
|
|
waitForEvent(SCAN_STOPPED);
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace chre
|