1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
//
// Copyright 2017 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.
//
#pragma once
#include <chrono> // for milliseconds
#include <functional> // for __base, function
#include <future> // for promise
#include <memory> // for shared_ptr, make_...
#include <string> // for string
#include "model/controller/dual_mode_controller.h" // for DualModeController
#include "model/setup/async_manager.h" // for AsyncTaskId, Asyn...
#include "model/setup/test_channel_transport.h" // for TestChannelTransport
#include "model/setup/test_command_handler.h" // for TestCommandHandler
#include "model/setup/test_model.h" // for TestModel
#include "net/async_data_channel_server.h" // for AsyncDataChannelS...
namespace android {
namespace net {
class AsyncDataChannel;
class AsyncDataChannelConnector;
} // namespace net
namespace bluetooth {
namespace root_canal {
using android::net::AsyncDataChannel;
using android::net::AsyncDataChannelConnector;
using android::net::AsyncDataChannelServer;
using android::net::ConnectCallback;
using rootcanal::Device;
using rootcanal::Phy;
class TestEnvironment {
public:
TestEnvironment(std::shared_ptr<AsyncDataChannelServer> test_port,
std::shared_ptr<AsyncDataChannelServer> hci_server_port,
std::shared_ptr<AsyncDataChannelServer> link_server_port,
std::shared_ptr<AsyncDataChannelServer> link_ble_server_port,
std::shared_ptr<AsyncDataChannelConnector> connector,
const std::string& controller_properties_file = "",
const std::string& default_commands_file = "")
: test_socket_server_(test_port),
hci_socket_server_(hci_server_port),
link_socket_server_(link_server_port),
link_ble_socket_server_(link_ble_server_port),
connector_(connector),
controller_properties_file_(controller_properties_file),
default_commands_file_(default_commands_file),
controller_(std::make_shared<rootcanal::DualModeController>(
controller_properties_file)) {}
void initialize(std::promise<void> barrier);
void close();
private:
rootcanal::AsyncManager async_manager_;
std::shared_ptr<AsyncDataChannelServer> test_socket_server_;
std::shared_ptr<AsyncDataChannelServer> hci_socket_server_;
std::shared_ptr<AsyncDataChannelServer> link_socket_server_;
std::shared_ptr<AsyncDataChannelServer> link_ble_socket_server_;
std::shared_ptr<AsyncDataChannelConnector> connector_;
std::string controller_properties_file_;
std::string default_commands_file_;
bool test_channel_open_{false};
std::promise<void> barrier_;
void SetUpTestChannel();
void SetUpHciServer(ConnectCallback on_connect);
void SetUpLinkLayerServer();
void SetUpLinkBleLayerServer();
std::shared_ptr<Device> ConnectToRemoteServer(const std::string& server,
int port, Phy::Type phy_type);
std::shared_ptr<rootcanal::DualModeController> controller_;
rootcanal::TestChannelTransport test_channel_transport_;
rootcanal::TestChannelTransport remote_hci_transport_;
rootcanal::TestChannelTransport remote_link_layer_transport_;
rootcanal::TestChannelTransport remote_link_ble_layer_transport_;
rootcanal::TestModel test_model_{
[this]() { return async_manager_.GetNextUserId(); },
[this](rootcanal::AsyncUserId user_id, std::chrono::milliseconds delay,
const rootcanal::TaskCallback& task) {
return async_manager_.ExecAsync(user_id, delay, task);
},
[this](rootcanal::AsyncUserId user_id, std::chrono::milliseconds delay,
std::chrono::milliseconds period,
const rootcanal::TaskCallback& task) {
return async_manager_.ExecAsyncPeriodically(user_id, delay, period,
task);
},
[this](rootcanal::AsyncUserId user) {
async_manager_.CancelAsyncTasksFromUser(user);
},
[this](rootcanal::AsyncTaskId task) {
async_manager_.CancelAsyncTask(task);
},
[this](const std::string& server, int port, Phy::Type phy_type) {
return ConnectToRemoteServer(server, port, phy_type);
}};
rootcanal::TestCommandHandler test_channel_{test_model_};
};
} // namespace root_canal
} // namespace bluetooth
} // namespace android
|
