| // |
| // Copyright (C) 2015 Google, Inc. |
| // |
| // 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 <base.h> |
| #include <base/at_exit.h> |
| #include <base/command_line.h> |
| #include <base/logging.h> |
| #include <base/macros.h> |
| #include <base/strings/string_split.h> |
| #include <base/strings/string_util.h> |
| #include <binder/IPCThreadState.h> |
| #include <binder/ProcessState.h> |
| |
| #include "bluetooth_binder_facade.h" |
| #include <service/common/bluetooth/binder/IBluetooth.h> |
| #include <service/common/bluetooth/binder/IBluetoothCallback.h> |
| #include <service/common/bluetooth/binder/IBluetoothLowEnergy.h> |
| #include <service/common/bluetooth/low_energy_constants.h> |
| #include <tuple> |
| |
| using android::sp; |
| using ipc::binder::IBluetooth; |
| using ipc::binder::IBluetoothLowEnergy; |
| |
| std::atomic_bool ble_registering(false); |
| std::atomic_int ble_client_id(0); |
| |
| bool BluetoothBinderFacade::SharedValidator() { |
| if (bt_iface == NULL) { |
| LOG(ERROR) << sl4n::kTagStr << " IBluetooth interface not initialized"; |
| return false; |
| } |
| if (!bt_iface->IsEnabled()) { |
| LOG(ERROR) << sl4n::kTagStr << " IBluetooth interface not enabled"; |
| return false; |
| } |
| return true; |
| } |
| |
| std::tuple<bool, int> BluetoothBinderFacade::BluetoothBinderEnable() { |
| if (bt_iface == NULL) { |
| LOG(ERROR) << sl4n::kTagStr << ": IBluetooth interface not enabled"; |
| return std::make_tuple(false, sl4n_error_codes::kFailInt); |
| } |
| bool result = bt_iface->Enable(); |
| if (!result) { |
| LOG(ERROR) << sl4n::kTagStr << ": Failed to enable the Bluetooth service"; |
| return std::make_tuple(false, sl4n_error_codes::kPassInt); |
| } else { |
| return std::make_tuple(true, sl4n_error_codes::kPassInt); |
| } |
| } |
| |
| std::tuple<std::string, int> BluetoothBinderFacade::BluetoothBinderGetAddress() { |
| if (!SharedValidator()) { |
| return std::make_tuple(sl4n::kFailStr, sl4n_error_codes::kFailInt); |
| } |
| return std::make_tuple(bt_iface->GetAddress(), sl4n_error_codes::kPassInt); |
| } |
| |
| std::tuple<std::string, int> BluetoothBinderFacade::BluetoothBinderGetName() { |
| if (!SharedValidator()) { |
| return std::make_tuple(sl4n::kFailStr,sl4n_error_codes::kFailInt); |
| } |
| std::string name = bt_iface->GetName(); |
| if (name.empty()) { |
| LOG(ERROR) << sl4n::kTagStr << ": Failed to get device name"; |
| return std::make_tuple(sl4n::kFailStr, sl4n_error_codes::kFailInt); |
| } else { |
| return std::make_tuple(name, sl4n_error_codes::kPassInt); |
| } |
| } |
| |
| std::tuple<bool, int> BluetoothBinderFacade::BluetoothBinderSetName( |
| std::string name) { |
| |
| if (!SharedValidator()) { |
| return std::make_tuple(false, sl4n_error_codes::kFailInt); |
| } |
| bool result = bt_iface->SetName(name); |
| if (!result) { |
| LOG(ERROR) << sl4n::kTagStr << ": Failed to set device name"; |
| return std::make_tuple(false, sl4n_error_codes::kFailInt); |
| } |
| return std::make_tuple(true, sl4n_error_codes::kPassInt); |
| } |
| |
| std::tuple<bool, int> BluetoothBinderFacade::BluetoothBinderInitInterface() { |
| bt_iface = IBluetooth::getClientInterface(); |
| if(!bt_iface.get()) { |
| LOG(ERROR) << sl4n::kTagStr << |
| ": Failed to initialize IBluetooth interface"; |
| return std::make_tuple(false, sl4n_error_codes::kFailInt); |
| } |
| return std::make_tuple(true, sl4n_error_codes::kPassInt); |
| } |
| |
| std::tuple<bool, int> BluetoothBinderFacade::BluetoothBinderRegisterBLE() { |
| // TODO (tturney): verify bt_iface initialized everywhere |
| if (!SharedValidator()) { |
| return std::make_tuple(false, sl4n_error_codes::kFailInt); |
| } |
| ble_iface = bt_iface->GetLowEnergyInterface(); |
| if(!ble_iface.get()) { |
| LOG(ERROR) << sl4n::kTagStr << ": Failed to register BLE"; |
| return std::make_tuple(false, sl4n_error_codes::kFailInt); |
| } |
| return std::make_tuple(true, sl4n_error_codes::kPassInt); |
| } |
| |
| std::tuple<int, int> BluetoothBinderFacade::BluetoothBinderSetAdvSettings( |
| int mode, int timeout_seconds, int tx_power_level, bool is_connectable) { |
| if (!SharedValidator()) { |
| return std::make_tuple(false,sl4n_error_codes::kFailInt); |
| } |
| bluetooth::AdvertiseSettings::Mode adv_mode; |
| switch (mode) { |
| case sl4n_ble::kAdvSettingsModeLowPowerInt : |
| adv_mode = bluetooth::AdvertiseSettings::Mode::MODE_LOW_POWER; |
| case sl4n_ble::kAdvSettingsModeBalancedInt : |
| adv_mode = bluetooth::AdvertiseSettings::Mode::MODE_BALANCED; |
| case sl4n_ble::kAdvSettingsModeLowLatencyInt : |
| adv_mode = bluetooth::AdvertiseSettings::Mode::MODE_LOW_LATENCY; |
| default : |
| LOG(ERROR) << sl4n::kTagStr << |
| ": Input mode is outside the accepted values"; |
| return std::make_tuple( |
| sl4n::kFailedCounterInt, sl4n_error_codes::kFailInt); |
| } |
| |
| base::TimeDelta adv_timeout = base::TimeDelta::FromSeconds( |
| timeout_seconds); |
| |
| bluetooth::AdvertiseSettings::TxPowerLevel adv_tx_power_level; |
| switch (tx_power_level) { |
| case sl4n_ble::kAdvSettingsTxPowerLevelUltraLowInt: tx_power_level = |
| bluetooth::AdvertiseSettings::TxPowerLevel::TX_POWER_LEVEL_ULTRA_LOW; |
| case sl4n_ble::kAdvSettingsTxPowerLevelLowInt: tx_power_level = |
| bluetooth::AdvertiseSettings::TxPowerLevel::TX_POWER_LEVEL_LOW; |
| case sl4n_ble::kAdvSettingsTxPowerLevelMediumInt: tx_power_level = |
| bluetooth::AdvertiseSettings::TxPowerLevel::TX_POWER_LEVEL_MEDIUM; |
| case sl4n_ble::kAdvSettingsTxPowerLevelHighInt: tx_power_level = |
| bluetooth::AdvertiseSettings::TxPowerLevel::TX_POWER_LEVEL_HIGH; |
| default : |
| LOG(ERROR) << sl4n::kTagStr << |
| ": Input tx power level is outside the accepted values"; |
| return std::make_tuple( |
| sl4n::kFailedCounterInt, sl4n_error_codes::kFailInt); |
| } |
| |
| bluetooth::AdvertiseSettings adv_settings = bluetooth::AdvertiseSettings( |
| adv_mode, adv_timeout, adv_tx_power_level, is_connectable); |
| adv_settings_map[adv_settings_count] = adv_settings; |
| int adv_settings_id = adv_settings_count; |
| adv_settings_count++; |
| return std::make_tuple(adv_settings_id, sl4n_error_codes::kPassInt); |
| } |
| |
| BluetoothBinderFacade::BluetoothBinderFacade() { |
| adv_settings_count = 0; |
| manu_data_count = 0; |
| } |