blob: 290aa5eb9596f49919d07231f68af5a4dbf9ccdc [file] [log] [blame]
// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use failure::Error;
use serde_derive::{Deserialize, Serialize};
use serde_json::Value;
use std::sync::mpsc;
/// Information about each client that has connected
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ClientData {
// client_id: String ID of client (ACTS test suite)
pub command_id: String,
// command_result: The response of running the command (to be stored in the table)
pub command_result: AsyncResponse,
impl ClientData {
pub fn new(id: String, result: AsyncResponse) -> ClientData {
ClientData { command_id: id, command_result: result }
/// Required fields for making a request
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CommandRequest {
// method: name of method to be called
pub method: String,
// id: String id of command
pub id: String,
// params: Arguments required for method
pub params: Value,
/// Return packet after SL4F runs command
#[derive(Serialize, Clone, Debug)]
pub struct CommandResponse {
// id: String id of command
pub id: String,
// result: Result value of method call, can be None
pub result: Option<Value>,
// error: Error message of method call, can be None
pub error: Option<String>,
impl CommandResponse {
pub fn new(id: String, result: Option<Value>, error: Option<String>) -> CommandResponse {
CommandResponse { id, result, error }
// Represents a RPC request to be fulfilled by the FIDL event loop
pub struct AsyncRequest {
// tx: Transmit channel from FIDL event loop to RPC request side
pub tx: mpsc::Sender<AsyncResponse>,
// id: String id of the method
pub id: String,
// type: Method type of the request (e.g bluetooth, wlan, etc...)
pub method_type: String,
// name: Name of the method
pub name: String,
// params: serde_json::Value representing args for method
pub params: Value,
impl AsyncRequest {
pub fn new(
tx: mpsc::Sender<AsyncResponse>,
id: String,
method_type: String,
name: String,
params: Value,
) -> AsyncRequest {
AsyncRequest { tx, id, method_type, name, params }
// Represents a RPC response from the FIDL event loop to the RPC request side
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AsyncResponse {
// res: serde_json::Value of FIDL method result
pub result: Option<Value>,
pub error: Option<String>,
impl AsyncResponse {
pub fn new(res: Result<Value, Error>) -> AsyncResponse {
match res {
Ok(v) => AsyncResponse { result: Some(v), error: None },
Err(e) => AsyncResponse { result: None, error: Some(e.to_string()) },
/// Enum for supported connectivity stacks
/// Make sure to update match statement
pub enum FacadeType {
impl FacadeType {
pub fn from_str(facade: &String) -> FacadeType {
match facade.as_ref() {
"audio_facade" => FacadeType::AudioFacade,
"auth_facade" => FacadeType::AuthFacade,
"ble_advertise_facade" => FacadeType::BleAdvertiseFacade,
"bluetooth" => FacadeType::Bluetooth,
"bt_control_facade" => FacadeType::BluetoothControlFacade,
"gatt_client_facade" => FacadeType::GattClientFacade,
"gatt_server_facade" => FacadeType::GattServerFacade,
"logging" => FacadeType::LoggingFacade,
"netstack_facade" => FacadeType::NetstackFacade,
"scenic_facade" => FacadeType::ScenicFacade,
"setui_facade" => FacadeType::SetUiFacade,
"traceutil_facade" => FacadeType::TraceutilFacade,
"wlan" => FacadeType::Wlan,
_ => FacadeType::Undefined,