tequilaOS/platform_hardware_tequila_interfaces
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Compare commits

base: tequilaOS:720054de96c7006e463b4f57a4749fc3786e9c0c
Branches Tags
tequilaOS:staging/volcan
...
compare: tequilaOS:239c3734f1842d0876217449323bebab74e2e515
Branches Tags
tequilaOS:staging/volcan

10 commits
720054de96 ... 239c3734f1

Author SHA1 Message Date
Han Sol Jin
239c3734f1 vibrator: port default HIDL service to AIDL 
Change-Id: I714c28f4cc046cf1671baa748119a69a021ee9cc
 2024-08-24 09:20:39 +00:00
Bruno Martins
9ed3b03032 fingerprint: Include VINTF fragment 
Change-Id: I48ce57982e818ce06b4c57b5df700d8a4acf4284
 2024-08-24 02:02:20 +00:00
Cosmin Tanislav
bd66d5bf2e powershare: add default implementation 
Change-Id: If14d0e2038c604d6da5e383df638fd138e7aea26
 2024-08-22 14:08:46 +03:00
Aaron Kling
7cbd562024 health: Introduce batteryless aidl HAL 
Change-Id: I9877cb3cd4a6b55a59249aeae58060e616d2cd28
 2024-07-27 14:20:24 +01:00
Derek
0b534a8050 radio: 1.4: legacy: Initial wrapper (original) 
Change-Id: I214d413590378f88187766313bafcff7237637e6
 2024-06-05 18:26:29 +00:00
Yumi Yukimura
65cabbc3b0 radio: config: 1.1-wrapper: Enable mobile data at last 
* This fixes mobile data for a user who have Redmi 3S (running latest
  global firmware) with single SIM on SIM1 slot
  (it doesn't happen for me and the others, though)

* Logically, Enabling stuff after disabling finishes should be safer

Change-Id: I1bc84f8d4a4a449cb478143b01adf9cc2a4db6de
 2024-06-02 19:53:51 +08:00
Yumi Yukimura
0f94319ee8 radio: config: 1.1-wrapper: Remove superfluous null check for radios[i] 
https://review.lineageos.org/c/LineageOS/android_hardware_lineage_interfaces/+/393102/comment/4a0bd32b_cbfc3c64/

Change-Id: I30436fbae3bebd6ab51df821b6f317488be1bd5d
 2024-06-02 19:53:16 +08:00
LuK1337
329cea518d power: Allow device specific hooks for setMode, isModeSupported 
* Some devices may want to implement custom hooks

Change-Id: Icb2d66471ec649a69b1e69849fd86282775052cb
 2024-05-19 15:42:41 +01:00
guibing
48f6929e4c
power-libperfmgr: ADPF: use errno to check the failure type 
Bug: 296159697
Test: Manual
Change-Id: Idb74d12fd0d1028514382a4e09116b506b5ec176
 2024-05-18 09:01:32 +03:00
guibing
14b5c18399
power-libperfmgr: ADPF: report verbose log for dead thread uclamp min update 
If thread is detected as dead while setting the uclamp min, it currently
sends warning log. This caused log spamming issue. Change it to verbose
log first, then consider long term solution in master branch.

Bug: 296159697
Test: Manual
Change-Id: Ia8ea632be75a431ce0f9faa4c3792635f540be16
 2024-05-18 09:00:59 +03:00
37 changed files with 4016 additions and 10 deletions
Show stats Expand all files Collapse all files

1
biometrics/fingerprint/2.0/Android.bp
View file

@ -18,6 +18,7 @@ cc_binary {
defaults: ["hidl_defaults"],
relative_install_path: "hw",
init_rc: ["android.hardware.biometrics.fingerprint@2.0-service.rc"],
vintf_fragments: ["android.hardware.biometrics.fingerprint@2.0-service.xml"],
srcs: ["service.cpp", "BiometricsFingerprint.cpp"],
shared_libs: [
"libutils",

11
biometrics/fingerprint/2.0/android.hardware.biometrics.fingerprint@2.0-service.xml Normal file
View file

@ -0,0 +1,11 @@
<manifest version="1.0" type="device">
<hal format="hidl">
<name>android.hardware.biometrics.fingerprint</name>
<transport>hwbinder</transport>
<version>2.1</version>
<interface>
<name>IBiometricsFingerprint</name>
<instance>default</instance>
</interface>
</hal>
</manifest>

51
health/aidl/default/Android.bp
View file

@ -1,9 +1,58 @@
/*
* Copyright (C) 2022-2023 The LineageOS Project
* Copyright (C) 2022-2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
cc_defaults {
name: "android.hardware.health-service.batteryless-defaults",
relative_install_path: "hw",
vintf_fragments: ["android.hardware.health-service.batteryless.xml"],
vendor: true,
recovery_available: true,
defaults: [
"libhealth_aidl_impl_user",
],
include_dirs: [
"system/core/healthd",
"system/core/healthd/include",
"system/core/healthd/include_charger"
],
static_libs: [
"libhealth_aidl_impl",
],
srcs: [
"service-batteryless.cpp",
],
cflags: [
"-Wall",
"-Werror",
],
}
cc_binary {
name: "android.hardware.health-service.batteryless",
recovery: false,
vendor: true,
defaults: ["android.hardware.health-service.batteryless-defaults"],
init_rc: ["android.hardware.health-service.batteryless.rc"],
overrides: ["charger"],
}
cc_binary {
name: "android.hardware.health-service.batteryless_recovery",
vendor: false,
recovery: true,
defaults: ["android.hardware.health-service.batteryless-defaults"],
init_rc: ["android.hardware.health-service.batteryless_recovery.rc"],
overrides: ["charger.recovery"],
}
cc_binary {
name: "vendor.lineage.health-service.default",
defaults: ["health_charging_control_defaults"],

6
health/aidl/default/android.hardware.health-service.batteryless.rc Normal file
View file

@ -0,0 +1,6 @@
service vendor.health-default /vendor/bin/hw/android.hardware.health-service.batteryless
class hal
user system
group system
capabilities WAKE_ALARM BLOCK_SUSPEND
file /dev/kmsg w

13
health/aidl/default/android.hardware.health-service.batteryless.xml Normal file
View file

@ -0,0 +1,13 @@
<!--
Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
Copyright (C) 2024 The LineageOS Project
SPDX-License-Identifier: BSD-3-Clause-Clear
-->
<manifest version="1.0" type="device">
<hal format="aidl">
<name>android.hardware.health</name>
<version>1</version>
<fqname>IHealth/default</fqname>
</hal>
</manifest>

7
health/aidl/default/android.hardware.health-service.batteryless_recovery.rc Normal file
View file

@ -0,0 +1,7 @@
service vendor.health-recovery /system/bin/hw/android.hardware.health-service.batteryless_recovery
class hal
seclabel u:r:hal_health_default:s0
user system
group system
capabilities WAKE_ALARM BLOCK_SUSPEND
file /dev/kmsg w

53
health/aidl/default/service-batteryless.cpp Normal file
View file

@ -0,0 +1,53 @@
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
* Copyright (C) 2024 The LineageOS Project
* SPDX-License-Identifier: BSD-3-Clause-Clear
*/
#define LOG_TAG "android.hardware.health-service.batteryless"
#include <android-base/logging.h>
#include <android/binder_interface_utils.h>
#include <cutils/klog.h>
#include <health-impl/ChargerUtils.h>
#include <health-impl/Health.h>
#include <health/utils.h>
using aidl::android::hardware::health::BatteryHealth;
using aidl::android::hardware::health::BatteryStatus;
using aidl::android::hardware::health::HalHealthLoop;
using aidl::android::hardware::health::Health;
namespace aidl::android::hardware::health {
class HealthImpl : public Health {
public:
HealthImpl(std::string_view instance_name, std::unique_ptr<struct healthd_config>&& config)
: Health(instance_name, std::move(config)) {}
protected:
void UpdateHealthInfo(HealthInfo* health_info) override {
health_info->chargerAcOnline = true;
health_info->chargerUsbOnline = false;
health_info->chargerWirelessOnline = false;
health_info->chargerDockOnline = false;
health_info->batteryStatus = BatteryStatus::UNKNOWN;
health_info->batteryHealth = BatteryHealth::UNKNOWN;
health_info->batteryPresent = false;
health_info->batteryLevel = 100;
}
};
} // namespace aidl::android::hardware::health
int main() {
#ifdef __ANDROID_RECOVERY__
android::base::InitLogging(NULL, android::base::KernelLogger);
#endif
auto config = std::make_unique<healthd_config>();
::android::hardware::health::InitHealthdConfig(config.get());
auto binder = ndk::SharedRefBase::make<aidl::android::hardware::health::HealthImpl>(
"default", std::move(config));
KLOG_INFO(LOG_TAG, "Starting health HAL.");
auto hal_health_loop = std::make_shared<HalHealthLoop>(binder, binder);
return hal_health_loop->StartLoop();
}

14
power-libperfmgr/Android.bp
View file

@ -13,6 +13,9 @@ soong_namespace {
cc_binary {
name: "android.hardware.power-service.lineage-libperfmgr",
defaults: [
"power_libperfmgr_defaults",
],
relative_install_path: "hw",
init_rc: ["aidl/android.hardware.power-service.lineage-libperfmgr.rc"],
vintf_fragments: ["aidl/android.hardware.power-service.lineage.xml"],
@ -42,3 +45,14 @@ cc_binary {
"aidl/PowerSessionManager.cpp",
],
}
cc_library_static {
name: "libperfmgr-ext",
vendor: true,
srcs: [
"aidl/PowerModeExtension.cpp",
],
shared_libs: [
"android.hardware.power-V4-ndk",
],
}

11
power-libperfmgr/aidl/Power.cpp
View file

@ -45,6 +45,9 @@ constexpr char kPowerHalStateProp[] = "vendor.powerhal.state";
constexpr char kPowerHalAudioProp[] = "vendor.powerhal.audio";
constexpr char kPowerHalRenderingProp[] = "vendor.powerhal.rendering";
extern bool isDeviceSpecificModeSupported(Mode type, bool* _aidl_return);
extern bool setDeviceSpecificMode(Mode type, bool enabled);
Power::Power()
: mInteractionHandler(nullptr),
mSustainedPerfModeOn(false) {
@ -79,6 +82,10 @@ ndk::ScopedAStatus Power::setMode(Mode type, bool enabled) {
HintManager::GetInstance()->GetAdpfProfile()->mReportingRateLimitNs > 0) {
PowerSessionManager::getInstance()->updateHintMode(toString(type), enabled);
}
if (setDeviceSpecificMode(type, enabled)) {
return ndk::ScopedAStatus::ok();
}
switch (type) {
case Mode::SUSTAINED_PERFORMANCE:
if (enabled) {
@ -120,6 +127,10 @@ ndk::ScopedAStatus Power::setMode(Mode type, bool enabled) {
}
ndk::ScopedAStatus Power::isModeSupported(Mode type, bool *_aidl_return) {
if (isDeviceSpecificModeSupported(type, _aidl_return)) {
return ndk::ScopedAStatus::ok();
}
bool supported = HintManager::GetInstance()->IsHintSupported(toString(type));
LOG(INFO) << "Power mode " << toString(type) << " isModeSupported: " << supported;
*_aidl_return = supported;

45
power-libperfmgr/aidl/PowerModeExtension.cpp Normal file
View file

@ -0,0 +1,45 @@
/*
* Copyright (C) 2020 The LineageOS 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 <aidl/android/hardware/power/BnPower.h>
namespace aidl {
namespace google {
namespace hardware {
namespace power {
namespace impl {
namespace pixel {
using ::aidl::android::hardware::power::Mode;
bool isDeviceSpecificModeSupported(Mode type, bool* _aidl_return) {
(void) type;
(void) _aidl_return;
return false;
}
bool setDeviceSpecificMode(Mode type, bool enabled) {
(void) type;
(void) enabled;
return false;
}
} // namespace pixel
} // namespace impl
} // namespace power
} // namespace hardware
} // namespace google
} // namespace aidl

6
power-libperfmgr/aidl/PowerSessionManager.cpp
View file

@ -72,7 +72,11 @@ static void set_uclamp_min(int tid, int min) {
int ret = sched_setattr(tid, &attr, 0);
if (ret) {
ALOGW("sched_setattr failed for thread %d, err=%d", tid, errno);
if (errno == ESRCH) {
ALOGV("sched_setattr failed for thread %d, err=%d", tid, errno);
} else {
ALOGW("sched_setattr failed for thread %d, err=%d", tid, errno);
}
}
}
} // namespace

21
powershare/1.0/default/Android.bp Normal file
View file

@ -0,0 +1,21 @@
cc_binary {
name: "vendor.lineage.powershare@1.0-service.default",
defaults: [
"hidl_defaults",
"powershare_defaults",
],
init_rc: ["vendor.lineage.powershare@1.0-service.default.rc"],
vintf_fragments: ["vendor.lineage.powershare@1.0-service.default.xml"],
vendor: true,
relative_install_path: "hw",
srcs: [
"service.cpp",
"PowerShare.cpp",
],
shared_libs: [
"libbase",
"libhidlbase",
"libutils",
"vendor.lineage.powershare@1.0",
],
}

51
powershare/1.0/default/PowerShare.cpp Normal file
View file

@ -0,0 +1,51 @@
/*
* Copyright (C) 2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "PowerShare.h"
#include <android-base/file.h>
#include <android-base/strings.h>
using ::android::base::ReadFileToString;
using ::android::base::WriteStringToFile;
namespace vendor {
namespace lineage {
namespace powershare {
namespace V1_0 {
namespace implementation {
Return<bool> PowerShare::isEnabled() {
std::string value;
if (!ReadFileToString(POWERSHARE_PATH, &value)) {
LOG(ERROR) << "Failed to read current powershare value";
return false;
}
value = android::base::Trim(value);
return value == POWERSHARE_ENABLED;
}
Return<bool> PowerShare::setEnabled(bool enable) {
const auto& value = enable ? POWERSHARE_ENABLED : POWERSHARE_DISABLED;
return WriteStringToFile(value, POWERSHARE_PATH, true);
}
Return<uint32_t> PowerShare::getMinBattery() {
return 0;
}
Return<uint32_t> PowerShare::setMinBattery(uint32_t /*minBattery*/) {
return getMinBattery();
}
} // namespace implementation
} // namespace V1_0
} // namespace powershare
} // namespace lineage
} // namespace vendor

40
powershare/1.0/default/PowerShare.h Normal file
View file

@ -0,0 +1,40 @@
/*
* Copyright (C) 2022 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef VENDOR_LINEAGE_POWERSHARE_V1_0_POWERSHARE_H
#define VENDOR_LINEAGE_POWERSHARE_V1_0_POWERSHARE_H
#define LOG_TAG "vendor.lineage.powershare@1.0-service.default"
#include <android-base/logging.h>
#include <vendor/lineage/powershare/1.0/IPowerShare.h>
namespace vendor {
namespace lineage {
namespace powershare {
namespace V1_0 {
namespace implementation {
using ::android::sp;
using ::android::hardware::Return;
using ::android::hardware::Void;
class PowerShare : public IPowerShare {
public:
Return<bool> isEnabled() override;
Return<bool> setEnabled(bool enable) override;
Return<uint32_t> getMinBattery() override;
Return<uint32_t> setMinBattery(uint32_t minBattery) override;
};
} // namespace implementation
} // namespace V1_0
} // namespace powershare
} // namespace lineage
} // namespace vendor
#endif // VENDOR_LINEAGE_POWERSHARE_V1_0_POWERSHARE_H

31
powershare/1.0/default/service.cpp Normal file
View file

@ -0,0 +1,31 @@
/*
* Copyright (C) 2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "PowerShare.h"
#include <hidl/HidlTransportSupport.h>
using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool;
using android::sp;
using vendor::lineage::powershare::V1_0::IPowerShare;
using vendor::lineage::powershare::V1_0::implementation::PowerShare;
int main() {
sp<IPowerShare> powerShareService = new PowerShare();
configureRpcThreadpool(1, true /*callerWillJoin*/);
if (powerShareService->registerAsService() != android::OK) {
LOG(ERROR) << "Can't register PowerShare HAL service";
return 1;
}
joinRpcThreadpool();
return 0; // should never get here
}

4
powershare/1.0/default/vendor.lineage.powershare@1.0-service.default.rc Normal file
View file

@ -0,0 +1,4 @@
service vendor.powershare-hal-1-0 /vendor/bin/hw/vendor.lineage.powershare@1.0-service.default
class hal
user system
group system

11
powershare/1.0/default/vendor.lineage.powershare@1.0-service.default.xml Normal file
View file

@ -0,0 +1,11 @@
<manifest version="1.0" type="device">
<hal format="hidl">
<name>vendor.lineage.powershare</name>
<transport>hwbinder</transport>
<version>1.0</version>
<interface>
<name>IPowerShare</name>
<instance>default</instance>
</interface>
</hal>
</manifest>

32
radio/1.4/legacy/Android.bp Normal file
View file

@ -0,0 +1,32 @@
//
// Copyright (C) 2024 The LineageOS Project
//
// SPDX-License-Identifier: Apache-2.0
//
cc_binary {
name: "android.hardware.radio@1.4-service.legacy",
owner: "lineage",
relative_install_path: "hw",
vendor: true,
init_rc: ["android.hardware.radio@1.4-service.legacy.rc"],
srcs: [
"Radio.cpp",
"RadioIndication.cpp",
"RadioResponse.cpp",
"service.cpp",
"Helpers.cpp",
"hidl-utils.cpp",
],
shared_libs: [
"libbase",
"libhidlbase",
"libutils",
"android.hardware.radio@1.0",
"android.hardware.radio@1.1",
"android.hardware.radio@1.2",
"android.hardware.radio@1.3",
"android.hardware.radio@1.4",
"android.hidl.safe_union@1.0",
],
}

184
radio/1.4/legacy/Helpers.cpp Normal file
View file

@ -0,0 +1,184 @@
/*
* Copyright (C) 2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "Helpers.h"
#include <regex>
#include <vector>
using namespace android::hardware::radio;
V1_4::SignalStrength Create1_4SignalStrength(const V1_0::SignalStrength& sigStrength){
V1_4::SignalStrength newSigStrength = {};
newSigStrength.gsm = sigStrength.gw;
newSigStrength.cdma = sigStrength.cdma;
newSigStrength.evdo = sigStrength.evdo;
newSigStrength.lte = sigStrength.lte;
newSigStrength.tdscdma.signalStrength = INT_MAX;
newSigStrength.tdscdma.bitErrorRate = INT_MAX;
newSigStrength.tdscdma.rscp = sigStrength.tdScdma.rscp != INT_MAX ?
-sigStrength.tdScdma.rscp + 120 : INT_MAX;
newSigStrength.wcdma.base.signalStrength = INT_MAX;
newSigStrength.wcdma.base.bitErrorRate = INT_MAX;
newSigStrength.wcdma.rscp = INT_MAX;
newSigStrength.wcdma.ecno = INT_MAX;
newSigStrength.nr.ssRsrp = INT_MAX;
newSigStrength.nr.ssRsrq = INT_MAX;
newSigStrength.nr.ssSinr = INT_MAX;
newSigStrength.nr.csiRsrp = INT_MAX;
newSigStrength.nr.csiRsrq = INT_MAX;
newSigStrength.nr.csiSinr = INT_MAX;
return newSigStrength;
}
V1_4::SignalStrength Create1_4SignalStrength(const V1_2::SignalStrength& sigStrength){
V1_4::SignalStrength newSigStrength = {};
newSigStrength.gsm = sigStrength.gsm;
newSigStrength.cdma = sigStrength.cdma;
newSigStrength.evdo = sigStrength.evdo;
newSigStrength.lte = sigStrength.lte;
newSigStrength.wcdma = sigStrength.wcdma;
newSigStrength.tdscdma.signalStrength = INT_MAX;
newSigStrength.tdscdma.bitErrorRate = INT_MAX;
newSigStrength.tdscdma.rscp = sigStrength.tdScdma.rscp != INT_MAX ?
-sigStrength.tdScdma.rscp + 120 : INT_MAX;
newSigStrength.nr.ssRsrp = INT_MAX;
newSigStrength.nr.ssRsrq = INT_MAX;
newSigStrength.nr.ssSinr = INT_MAX;
newSigStrength.nr.csiRsrp = INT_MAX;
newSigStrength.nr.csiRsrq = INT_MAX;
newSigStrength.nr.csiSinr = INT_MAX;
return newSigStrength;
}
hidl_vec<V1_4::CellInfo> Create1_4CellInfoList(const hidl_vec<V1_0::CellInfo>& cellInfo) {
hidl_vec<V1_4::CellInfo> newCI;
newCI.resize(cellInfo.size());
for(int x = 0; x < cellInfo.size(); ++x){
newCI[x].isRegistered = cellInfo[x].registered;
newCI[x].connectionStatus = (V1_2::CellConnectionStatus) INT_MAX;
if(cellInfo[x].gsm.size() == 1){
V1_2::CellInfoGsm GsmInfo = {};
GsmInfo.cellIdentityGsm.base = cellInfo[x].gsm[0].cellIdentityGsm;
GsmInfo.signalStrengthGsm = cellInfo[x].gsm[0].signalStrengthGsm;
newCI[x].info.gsm(GsmInfo);
}
else if(cellInfo[x].cdma.size() == 1){
V1_2::CellInfoCdma CdmaInfo = {};
CdmaInfo.cellIdentityCdma.base = cellInfo[x].cdma[0].cellIdentityCdma;
CdmaInfo.signalStrengthCdma = cellInfo[x].cdma[0].signalStrengthCdma;
CdmaInfo.signalStrengthEvdo = cellInfo[x].cdma[0].signalStrengthEvdo;
newCI[x].info.cdma(CdmaInfo);
}
else if(cellInfo[x].lte.size() == 1){
V1_4::CellInfoLte LteInfo = {};
LteInfo.base.cellIdentityLte.base = cellInfo[x].lte[0].cellIdentityLte;
LteInfo.base.cellIdentityLte.bandwidth = INT_MAX;
LteInfo.cellConfig.isEndcAvailable = false;
LteInfo.base.signalStrengthLte = cellInfo[x].lte[0].signalStrengthLte;
newCI[x].info.lte(LteInfo);
}
else if(cellInfo[x].wcdma.size() == 1){
V1_2::CellInfoWcdma WcdmaInfo = {};
WcdmaInfo.cellIdentityWcdma.base = cellInfo[x].wcdma[0].cellIdentityWcdma;
WcdmaInfo.signalStrengthWcdma.base = cellInfo[x].wcdma[0].signalStrengthWcdma;
WcdmaInfo.signalStrengthWcdma.rscp = INT_MAX;
WcdmaInfo.signalStrengthWcdma.ecno = INT_MAX;
newCI[x].info.wcdma(WcdmaInfo);
}
else if(cellInfo[x].tdscdma.size() == 1){
V1_2::CellInfoTdscdma TdscdmaInfo = {};
TdscdmaInfo.cellIdentityTdscdma.base = cellInfo[x].tdscdma[0].cellIdentityTdscdma;
TdscdmaInfo.cellIdentityTdscdma.uarfcn = INT_MAX;
TdscdmaInfo.signalStrengthTdscdma.signalStrength = INT_MAX;
TdscdmaInfo.signalStrengthTdscdma.bitErrorRate = INT_MAX;
TdscdmaInfo.signalStrengthTdscdma.rscp = cellInfo[x].tdscdma[0].signalStrengthTdscdma.rscp != INT_MAX ?
-cellInfo[x].tdscdma[0].signalStrengthTdscdma.rscp + 120 : INT_MAX;
newCI[x].info.tdscdma(TdscdmaInfo);
}
}
return newCI;
}
hidl_vec<V1_4::CellInfo> Create1_4CellInfoList(const hidl_vec<V1_2::CellInfo>& cellInfo) {
hidl_vec<V1_4::CellInfo> newCI;
newCI.resize(cellInfo.size());
for(int x = 0; x < cellInfo.size(); ++x){
newCI[x].isRegistered = cellInfo[x].registered;
newCI[x].connectionStatus = cellInfo[x].connectionStatus;
if(cellInfo[x].gsm.size() == 1)
newCI[x].info.gsm(cellInfo[x].gsm[0]);
else if(cellInfo[x].cdma.size() == 1)
newCI[x].info.cdma(cellInfo[x].cdma[0]);
else if(cellInfo[x].lte.size() == 1){
V1_4::CellInfoLte LteInfo = {};
LteInfo.base = cellInfo[x].lte[0];
LteInfo.cellConfig.isEndcAvailable = false;
newCI[x].info.lte(LteInfo);
}
else if(cellInfo[x].wcdma.size() == 1)
newCI[x].info.wcdma(cellInfo[x].wcdma[0]);
else if(cellInfo[x].tdscdma.size() == 1)
newCI[x].info.tdscdma(cellInfo[x].tdscdma[0]);
}
return newCI;
}
hidl_vec<hidl_string> DelimitedStrToVec(std::string delimitedStr){
std::regex rgx("\\s+");
std::sregex_token_iterator iter(delimitedStr.begin(), delimitedStr.end(), rgx, -1);
std::sregex_token_iterator end;
std::vector<hidl_string> tokens;
for ( ; iter != end; ++iter)
tokens.push_back(hidl_string(*iter));
return hidl_vec(tokens);
}
V1_4::SetupDataCallResult Create1_4SetupDataCallResult(const V1_0::SetupDataCallResult& dcResponse){
V1_4::SetupDataCallResult newDCR = {};
newDCR.cause = (V1_4::DataCallFailCause) dcResponse.status;
newDCR.suggestedRetryTime = dcResponse.suggestedRetryTime;
newDCR.cid = dcResponse.cid;
newDCR.active = (V1_4::DataConnActiveStatus) dcResponse.active;
newDCR.ifname = dcResponse.ifname;
newDCR.mtu = dcResponse.mtu;
newDCR.addresses = DelimitedStrToVec(dcResponse.addresses);
newDCR.dnses = DelimitedStrToVec(dcResponse.dnses);
newDCR.gateways = DelimitedStrToVec(dcResponse.gateways);
newDCR.pcscf = DelimitedStrToVec(dcResponse.pcscf);
if(dcResponse.type == std::string("IP"))
newDCR.type= V1_4::PdpProtocolType::IP;
else if(dcResponse.type == std::string("IPV6"))
newDCR.type= V1_4::PdpProtocolType::IPV6;
else if(dcResponse.type == std::string("IPV4V6"))
newDCR.type= V1_4::PdpProtocolType::IPV4V6;
else if(dcResponse.type == std::string("PPP"))
newDCR.type= V1_4::PdpProtocolType::PPP;
else if(dcResponse.type == std::string("NON-IP"))
newDCR.type= V1_4::PdpProtocolType::NON_IP;
else if(dcResponse.type == std::string("UNSTRUCTURED"))
newDCR.type= V1_4::PdpProtocolType::UNSTRUCTURED;
else
newDCR.type= V1_4::PdpProtocolType::UNKNOWN;
return newDCR;
}

29
radio/1.4/legacy/Helpers.h Normal file
View file

@ -0,0 +1,29 @@
/*
* Copyright (C) 2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <android/hardware/radio/1.4/IRadioResponse.h>
#include <android/hardware/radio/1.4/IRadio.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
#define GSMBITS (V1_0::RadioAccessFamily::GSM | V1_0::RadioAccessFamily::GPRS | V1_0::RadioAccessFamily::EDGE)
#define CDMABITS (V1_0::RadioAccessFamily::IS95A | V1_0::RadioAccessFamily::IS95B | V1_0::RadioAccessFamily::ONE_X_RTT)
#define EVDOBITS (V1_0::RadioAccessFamily::EVDO_0 | V1_0::RadioAccessFamily::EVDO_A | V1_0::RadioAccessFamily::EVDO_B | V1_0::RadioAccessFamily::EHRPD)
#define WCDMABITS (V1_0::RadioAccessFamily::HSUPA | V1_0::RadioAccessFamily::HSDPA | V1_0::RadioAccessFamily::HSPA | V1_0::RadioAccessFamily::HSPAP | V1_0::RadioAccessFamily::UMTS)
#define LTEBITS (V1_0::RadioAccessFamily::LTE | V1_0::RadioAccessFamily::LTE_CA)
#define TDSCDMABIT ((int) V1_0::RadioAccessFamily::TD_SCDMA)
android::hardware::radio::V1_4::SignalStrength Create1_4SignalStrength(const android::hardware::radio::V1_0::SignalStrength& sigStrength);
android::hardware::radio::V1_4::SignalStrength Create1_4SignalStrength(const android::hardware::radio::V1_2::SignalStrength& sigStrength);
hidl_vec<android::hardware::radio::V1_4::CellInfo> Create1_4CellInfoList(const hidl_vec<android::hardware::radio::V1_0::CellInfo>& cellInfo);
hidl_vec<android::hardware::radio::V1_4::CellInfo> Create1_4CellInfoList(const hidl_vec<android::hardware::radio::V1_2::CellInfo>& cellInfo);
android::hardware::radio::V1_4::SetupDataCallResult Create1_4SetupDataCallResult(const android::hardware::radio::V1_0::SetupDataCallResult& dcResponse);

984
radio/1.4/legacy/Radio.cpp Normal file
View file

@ -0,0 +1,984 @@
/*
* Copyright (C) 2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#define LOG_TAG "android.hardware.radio@1.4-service.legacy"
#include "Radio.h"
#include "Helpers.h"
#include <vector>
#include <string>
#include <android-base/logging.h>
#define WRAP_V1_0_CALL(method, ...) \
do { \
auto realRadio = mRealRadio; \
if (realRadio != nullptr) { \
return realRadio->method(__VA_ARGS__); \
} \
return Status::fromExceptionCode(Status::Exception::EX_ILLEGAL_STATE); \
} while (0)
#define MAYBE_WRAP_V1_1_CALL(method, ...) \
do { \
auto realRadio_V1_1 = getRealRadio_V1_1(); \
if (realRadio_V1_1 != nullptr) { \
return realRadio_V1_1->method(__VA_ARGS__); \
} \
} while (0)
#define MAYBE_WRAP_V1_2_CALL(method, ...) \
do { \
auto realRadio_V1_2 = getRealRadio_V1_2(); \
if (realRadio_V1_2 != nullptr) { \
return realRadio_V1_2->method(__VA_ARGS__); \
} \
} while (0)
#define MAYBE_WRAP_V1_3_CALL(method, ...) \
do { \
auto realRadio_V1_3 = getRealRadio_V1_3(); \
if (realRadio_V1_3 != nullptr) { \
return realRadio_V1_3->method(__VA_ARGS__); \
} \
} while (0)
#define MAYBE_WRAP_V1_4_CALL(method, ...) \
do { \
auto realRadio_V1_4 = getRealRadio_V1_4(); \
if (realRadio_V1_4 != nullptr) { \
LOG(WARNING) << "Using wrapper when not needed"; \
return realRadio_V1_4->method(__VA_ARGS__); \
} \
} while (0)
namespace android::hardware::radio::implementation {
Radio::Radio(sp<V1_0::IRadio> realRadio) : mRealRadio(realRadio) {}
// Methods from ::android::hardware::radio::V1_0::IRadio follow.
Return<void> Radio::setResponseFunctions(const sp<V1_0::IRadioResponse>& radioResponse,
const sp<V1_0::IRadioIndication>& radioIndication) {
mRadioResponse->mRealRadioResponse = V1_4::IRadioResponse::castFrom(radioResponse);
mRadioIndication->mRealRadioIndication = V1_4::IRadioIndication::castFrom(radioIndication);
WRAP_V1_0_CALL(setResponseFunctions, mRadioResponse, mRadioIndication);
}
Return<void> Radio::getIccCardStatus(int32_t serial) {
WRAP_V1_0_CALL(getIccCardStatus, serial);
}
Return<void> Radio::supplyIccPinForApp(int32_t serial, const hidl_string& pin,
const hidl_string& aid) {
WRAP_V1_0_CALL(supplyIccPinForApp, serial, pin, aid);
}
Return<void> Radio::supplyIccPukForApp(int32_t serial, const hidl_string& puk,
const hidl_string& pin, const hidl_string& aid) {
WRAP_V1_0_CALL(supplyIccPukForApp, serial, puk, pin, aid);
}
Return<void> Radio::supplyIccPin2ForApp(int32_t serial, const hidl_string& pin2,
const hidl_string& aid) {
WRAP_V1_0_CALL(supplyIccPin2ForApp, serial, pin2, aid);
}
Return<void> Radio::supplyIccPuk2ForApp(int32_t serial, const hidl_string& puk2,
const hidl_string& pin2, const hidl_string& aid) {
WRAP_V1_0_CALL(supplyIccPuk2ForApp, serial, puk2, pin2, aid);
}
Return<void> Radio::changeIccPinForApp(int32_t serial, const hidl_string& oldPin,
const hidl_string& newPin, const hidl_string& aid) {
WRAP_V1_0_CALL(changeIccPinForApp, serial, oldPin, newPin, aid);
}
Return<void> Radio::changeIccPin2ForApp(int32_t serial, const hidl_string& oldPin2,
const hidl_string& newPin2, const hidl_string& aid) {
WRAP_V1_0_CALL(changeIccPin2ForApp, serial, oldPin2, newPin2, aid);
}
Return<void> Radio::supplyNetworkDepersonalization(int32_t serial, const hidl_string& netPin) {
WRAP_V1_0_CALL(supplyNetworkDepersonalization, serial, netPin);
}
Return<void> Radio::getCurrentCalls(int32_t serial) {
WRAP_V1_0_CALL(getCurrentCalls, serial);
}
Return<void> Radio::dial(int32_t serial, const V1_0::Dial& dialInfo) {
WRAP_V1_0_CALL(dial, serial, dialInfo);
}
Return<void> Radio::getImsiForApp(int32_t serial, const hidl_string& aid) {
WRAP_V1_0_CALL(getImsiForApp, serial, aid);
}
Return<void> Radio::hangup(int32_t serial, int32_t gsmIndex) {
WRAP_V1_0_CALL(hangup, serial, gsmIndex);
}
Return<void> Radio::hangupWaitingOrBackground(int32_t serial) {
WRAP_V1_0_CALL(hangupWaitingOrBackground, serial);
}
Return<void> Radio::hangupForegroundResumeBackground(int32_t serial) {
WRAP_V1_0_CALL(hangupForegroundResumeBackground, serial);
}
Return<void> Radio::switchWaitingOrHoldingAndActive(int32_t serial) {
WRAP_V1_0_CALL(switchWaitingOrHoldingAndActive, serial);
}
Return<void> Radio::conference(int32_t serial) {
WRAP_V1_0_CALL(conference, serial);
}
Return<void> Radio::rejectCall(int32_t serial) {
WRAP_V1_0_CALL(rejectCall, serial);
}
Return<void> Radio::getLastCallFailCause(int32_t serial) {
WRAP_V1_0_CALL(getLastCallFailCause, serial);
}
Return<void> Radio::getSignalStrength(int32_t serial) {
WRAP_V1_0_CALL(getSignalStrength, serial);
}
Return<void> Radio::getVoiceRegistrationState(int32_t serial) {
WRAP_V1_0_CALL(getVoiceRegistrationState, serial);
}
Return<void> Radio::getDataRegistrationState(int32_t serial) {
WRAP_V1_0_CALL(getDataRegistrationState, serial);
}
Return<void> Radio::getOperator(int32_t serial) {
WRAP_V1_0_CALL(getOperator, serial);
}
Return<void> Radio::setRadioPower(int32_t serial, bool on) {
WRAP_V1_0_CALL(setRadioPower, serial, on);
}
Return<void> Radio::sendDtmf(int32_t serial, const hidl_string& s) {
WRAP_V1_0_CALL(sendDtmf, serial, s);
}
Return<void> Radio::sendSms(int32_t serial, const V1_0::GsmSmsMessage& message) {
WRAP_V1_0_CALL(sendSms, serial, message);
}
Return<void> Radio::sendSMSExpectMore(int32_t serial, const V1_0::GsmSmsMessage& message) {
WRAP_V1_0_CALL(sendSMSExpectMore, serial, message);
}
Return<void> Radio::setupDataCall(int32_t serial, V1_0::RadioTechnology radioTechnology,
const V1_0::DataProfileInfo& dataProfileInfo, bool modemCognitive,
bool roamingAllowed, bool isRoaming) {
WRAP_V1_0_CALL(setupDataCall, serial, radioTechnology, dataProfileInfo, modemCognitive,
roamingAllowed, isRoaming);
}
Return<void> Radio::iccIOForApp(int32_t serial, const V1_0::IccIo& iccIo) {
WRAP_V1_0_CALL(iccIOForApp, serial, iccIo);
}
Return<void> Radio::sendUssd(int32_t serial, const hidl_string& ussd) {
WRAP_V1_0_CALL(sendUssd, serial, ussd);
}
Return<void> Radio::cancelPendingUssd(int32_t serial) {
WRAP_V1_0_CALL(cancelPendingUssd, serial);
}
Return<void> Radio::getClir(int32_t serial) {
WRAP_V1_0_CALL(getClir, serial);
}
Return<void> Radio::setClir(int32_t serial, int32_t status) {
WRAP_V1_0_CALL(setClir, serial, status);
}
Return<void> Radio::getCallForwardStatus(int32_t serial, const V1_0::CallForwardInfo& callInfo) {
WRAP_V1_0_CALL(getCallForwardStatus, serial, callInfo);
}
Return<void> Radio::setCallForward(int32_t serial, const V1_0::CallForwardInfo& callInfo) {
WRAP_V1_0_CALL(setCallForward, serial, callInfo);
}
Return<void> Radio::getCallWaiting(int32_t serial, int32_t serviceClass) {
WRAP_V1_0_CALL(getCallWaiting, serial, serviceClass);
}
Return<void> Radio::setCallWaiting(int32_t serial, bool enable, int32_t serviceClass) {
WRAP_V1_0_CALL(setCallWaiting, serial, enable, serviceClass);
}
Return<void> Radio::acknowledgeLastIncomingGsmSms(int32_t serial, bool success,
V1_0::SmsAcknowledgeFailCause cause) {
WRAP_V1_0_CALL(acknowledgeLastIncomingGsmSms, serial, success, cause);
}
Return<void> Radio::acceptCall(int32_t serial) {
WRAP_V1_0_CALL(acceptCall, serial);
}
Return<void> Radio::deactivateDataCall(int32_t serial, int32_t cid, bool reasonRadioShutDown) {
WRAP_V1_0_CALL(deactivateDataCall, serial, cid, reasonRadioShutDown);
}
Return<void> Radio::getFacilityLockForApp(int32_t serial, const hidl_string& facility,
const hidl_string& password, int32_t serviceClass,
const hidl_string& appId) {
WRAP_V1_0_CALL(getFacilityLockForApp, serial, facility, password, serviceClass, appId);
}
Return<void> Radio::setFacilityLockForApp(int32_t serial, const hidl_string& facility,
bool lockState, const hidl_string& password,
int32_t serviceClass, const hidl_string& appId) {
WRAP_V1_0_CALL(setFacilityLockForApp, serial, facility, lockState, password, serviceClass,
appId);
}
Return<void> Radio::setBarringPassword(int32_t serial, const hidl_string& facility,
const hidl_string& oldPassword,
const hidl_string& newPassword) {
WRAP_V1_0_CALL(setBarringPassword, serial, facility, oldPassword, newPassword);
}
Return<void> Radio::getNetworkSelectionMode(int32_t serial) {
WRAP_V1_0_CALL(getNetworkSelectionMode, serial);
}
Return<void> Radio::setNetworkSelectionModeAutomatic(int32_t serial) {
WRAP_V1_0_CALL(setNetworkSelectionModeAutomatic, serial);
}
Return<void> Radio::setNetworkSelectionModeManual(int32_t serial,
const hidl_string& operatorNumeric) {
WRAP_V1_0_CALL(setNetworkSelectionModeManual, serial, operatorNumeric);
}
Return<void> Radio::getAvailableNetworks(int32_t serial) {
WRAP_V1_0_CALL(getAvailableNetworks, serial);
}
Return<void> Radio::startDtmf(int32_t serial, const hidl_string& s) {
WRAP_V1_0_CALL(startDtmf, serial, s);
}
Return<void> Radio::stopDtmf(int32_t serial) {
WRAP_V1_0_CALL(stopDtmf, serial);
}
Return<void> Radio::getBasebandVersion(int32_t serial) {
WRAP_V1_0_CALL(getBasebandVersion, serial);
}
Return<void> Radio::separateConnection(int32_t serial, int32_t gsmIndex) {
WRAP_V1_0_CALL(separateConnection, serial, gsmIndex);
}
Return<void> Radio::setMute(int32_t serial, bool enable) {
WRAP_V1_0_CALL(setMute, serial, enable);
}
Return<void> Radio::getMute(int32_t serial) {
WRAP_V1_0_CALL(getMute, serial);
}
Return<void> Radio::getClip(int32_t serial) {
WRAP_V1_0_CALL(getClip, serial);
}
Return<void> Radio::getDataCallList(int32_t serial) {
WRAP_V1_0_CALL(getDataCallList, serial);
}
Return<void> Radio::setSuppServiceNotifications(int32_t serial, bool enable) {
WRAP_V1_0_CALL(setSuppServiceNotifications, serial, enable);
}
Return<void> Radio::writeSmsToSim(int32_t serial, const V1_0::SmsWriteArgs& smsWriteArgs) {
WRAP_V1_0_CALL(writeSmsToSim, serial, smsWriteArgs);
}
Return<void> Radio::deleteSmsOnSim(int32_t serial, int32_t index) {
WRAP_V1_0_CALL(deleteSmsOnSim, serial, index);
}
Return<void> Radio::setBandMode(int32_t serial, V1_0::RadioBandMode mode) {
WRAP_V1_0_CALL(setBandMode, serial, mode);
}
Return<void> Radio::getAvailableBandModes(int32_t serial) {
WRAP_V1_0_CALL(getAvailableBandModes, serial);
}
Return<void> Radio::sendEnvelope(int32_t serial, const hidl_string& command) {
WRAP_V1_0_CALL(sendEnvelope, serial, command);
}
Return<void> Radio::sendTerminalResponseToSim(int32_t serial, const hidl_string& commandResponse) {
WRAP_V1_0_CALL(sendTerminalResponseToSim, serial, commandResponse);
}
Return<void> Radio::handleStkCallSetupRequestFromSim(int32_t serial, bool accept) {
WRAP_V1_0_CALL(handleStkCallSetupRequestFromSim, serial, accept);
}
Return<void> Radio::explicitCallTransfer(int32_t serial) {
WRAP_V1_0_CALL(explicitCallTransfer, serial);
}
Return<void> Radio::setPreferredNetworkType(int32_t serial, V1_0::PreferredNetworkType nwType) {
WRAP_V1_0_CALL(setPreferredNetworkType, serial, nwType);
}
Return<void> Radio::getPreferredNetworkType(int32_t serial) {
WRAP_V1_0_CALL(getPreferredNetworkType, serial);
}
Return<void> Radio::getNeighboringCids(int32_t serial) {
WRAP_V1_0_CALL(getNeighboringCids, serial);
}
Return<void> Radio::setLocationUpdates(int32_t serial, bool enable) {
WRAP_V1_0_CALL(setLocationUpdates, serial, enable);
}
Return<void> Radio::setCdmaSubscriptionSource(int32_t serial,
V1_0::CdmaSubscriptionSource cdmaSub) {
WRAP_V1_0_CALL(setCdmaSubscriptionSource, serial, cdmaSub);
}
Return<void> Radio::setCdmaRoamingPreference(int32_t serial, V1_0::CdmaRoamingType type) {
WRAP_V1_0_CALL(setCdmaRoamingPreference, serial, type);
}
Return<void> Radio::getCdmaRoamingPreference(int32_t serial) {
WRAP_V1_0_CALL(getCdmaRoamingPreference, serial);
}
Return<void> Radio::setTTYMode(int32_t serial, V1_0::TtyMode mode) {
WRAP_V1_0_CALL(setTTYMode, serial, mode);
}
Return<void> Radio::getTTYMode(int32_t serial) {
WRAP_V1_0_CALL(getTTYMode, serial);
}
Return<void> Radio::setPreferredVoicePrivacy(int32_t serial, bool enable) {
WRAP_V1_0_CALL(setPreferredVoicePrivacy, serial, enable);
}
Return<void> Radio::getPreferredVoicePrivacy(int32_t serial) {
WRAP_V1_0_CALL(getPreferredVoicePrivacy, serial);
}
Return<void> Radio::sendCDMAFeatureCode(int32_t serial, const hidl_string& featureCode) {
WRAP_V1_0_CALL(sendCDMAFeatureCode, serial, featureCode);
}
Return<void> Radio::sendBurstDtmf(int32_t serial, const hidl_string& dtmf, int32_t on,
int32_t off) {
WRAP_V1_0_CALL(sendBurstDtmf, serial, dtmf, on, off);
}
Return<void> Radio::sendCdmaSms(int32_t serial, const V1_0::CdmaSmsMessage& sms) {
WRAP_V1_0_CALL(sendCdmaSms, serial, sms);
}
Return<void> Radio::acknowledgeLastIncomingCdmaSms(int32_t serial, const V1_0::CdmaSmsAck& smsAck) {
WRAP_V1_0_CALL(acknowledgeLastIncomingCdmaSms, serial, smsAck);
}
Return<void> Radio::getGsmBroadcastConfig(int32_t serial) {
WRAP_V1_0_CALL(getGsmBroadcastConfig, serial);
}
Return<void> Radio::setGsmBroadcastConfig(
int32_t serial, const hidl_vec<V1_0::GsmBroadcastSmsConfigInfo>& configInfo) {
WRAP_V1_0_CALL(setGsmBroadcastConfig, serial, configInfo);
}
Return<void> Radio::setGsmBroadcastActivation(int32_t serial, bool activate) {
WRAP_V1_0_CALL(setGsmBroadcastActivation, serial, activate);
}
Return<void> Radio::getCdmaBroadcastConfig(int32_t serial) {
WRAP_V1_0_CALL(getCdmaBroadcastConfig, serial);
}
Return<void> Radio::setCdmaBroadcastConfig(
int32_t serial, const hidl_vec<V1_0::CdmaBroadcastSmsConfigInfo>& configInfo) {
WRAP_V1_0_CALL(setCdmaBroadcastConfig, serial, configInfo);
}
Return<void> Radio::setCdmaBroadcastActivation(int32_t serial, bool activate) {
WRAP_V1_0_CALL(setCdmaBroadcastActivation, serial, activate);
}
Return<void> Radio::getCDMASubscription(int32_t serial) {
WRAP_V1_0_CALL(getCDMASubscription, serial);
}
Return<void> Radio::writeSmsToRuim(int32_t serial, const V1_0::CdmaSmsWriteArgs& cdmaSms) {
WRAP_V1_0_CALL(writeSmsToRuim, serial, cdmaSms);
}
Return<void> Radio::deleteSmsOnRuim(int32_t serial, int32_t index) {
WRAP_V1_0_CALL(deleteSmsOnRuim, serial, index);
}
Return<void> Radio::getDeviceIdentity(int32_t serial) {
WRAP_V1_0_CALL(getDeviceIdentity, serial);
}
Return<void> Radio::exitEmergencyCallbackMode(int32_t serial) {
WRAP_V1_0_CALL(exitEmergencyCallbackMode, serial);
}
Return<void> Radio::getSmscAddress(int32_t serial) {
WRAP_V1_0_CALL(getSmscAddress, serial);
}
Return<void> Radio::setSmscAddress(int32_t serial, const hidl_string& smsc) {
WRAP_V1_0_CALL(setSmscAddress, serial, smsc);
}
Return<void> Radio::reportSmsMemoryStatus(int32_t serial, bool available) {
WRAP_V1_0_CALL(reportSmsMemoryStatus, serial, available);
}
Return<void> Radio::reportStkServiceIsRunning(int32_t serial) {
WRAP_V1_0_CALL(reportStkServiceIsRunning, serial);
}
Return<void> Radio::getCdmaSubscriptionSource(int32_t serial) {
WRAP_V1_0_CALL(getCdmaSubscriptionSource, serial);
}
Return<void> Radio::requestIsimAuthentication(int32_t serial, const hidl_string& challenge) {
WRAP_V1_0_CALL(requestIsimAuthentication, serial, challenge);
}
Return<void> Radio::acknowledgeIncomingGsmSmsWithPdu(int32_t serial, bool success,
const hidl_string& ackPdu) {
WRAP_V1_0_CALL(acknowledgeIncomingGsmSmsWithPdu, serial, success, ackPdu);
}
Return<void> Radio::sendEnvelopeWithStatus(int32_t serial, const hidl_string& contents) {
WRAP_V1_0_CALL(sendEnvelopeWithStatus, serial, contents);
}
Return<void> Radio::getVoiceRadioTechnology(int32_t serial) {
WRAP_V1_0_CALL(getVoiceRadioTechnology, serial);
}
Return<void> Radio::getCellInfoList(int32_t serial) {
WRAP_V1_0_CALL(getCellInfoList, serial);
}
Return<void> Radio::setCellInfoListRate(int32_t serial, int32_t rate) {
WRAP_V1_0_CALL(setCellInfoListRate, serial, rate);
}
Return<void> Radio::setInitialAttachApn(int32_t serial,
const V1_0::DataProfileInfo& dataProfileInfo,
bool modemCognitive, bool isRoaming) {
WRAP_V1_0_CALL(setInitialAttachApn, serial, dataProfileInfo, modemCognitive, isRoaming);
}
Return<void> Radio::getImsRegistrationState(int32_t serial) {
WRAP_V1_0_CALL(getImsRegistrationState, serial);
}
Return<void> Radio::sendImsSms(int32_t serial, const V1_0::ImsSmsMessage& message) {
WRAP_V1_0_CALL(sendImsSms, serial, message);
}
Return<void> Radio::iccTransmitApduBasicChannel(int32_t serial, const V1_0::SimApdu& message) {
WRAP_V1_0_CALL(iccTransmitApduBasicChannel, serial, message);
}
Return<void> Radio::iccOpenLogicalChannel(int32_t serial, const hidl_string& aid, int32_t p2) {
WRAP_V1_0_CALL(iccOpenLogicalChannel, serial, aid, p2);
}
Return<void> Radio::iccCloseLogicalChannel(int32_t serial, int32_t channelId) {
WRAP_V1_0_CALL(iccCloseLogicalChannel, serial, channelId);
}
Return<void> Radio::iccTransmitApduLogicalChannel(int32_t serial, const V1_0::SimApdu& message) {
WRAP_V1_0_CALL(iccTransmitApduLogicalChannel, serial, message);
}
Return<void> Radio::nvReadItem(int32_t serial, V1_0::NvItem itemId) {
WRAP_V1_0_CALL(nvReadItem, serial, itemId);
}
Return<void> Radio::nvWriteItem(int32_t serial, const V1_0::NvWriteItem& item) {
WRAP_V1_0_CALL(nvWriteItem, serial, item);
}
Return<void> Radio::nvWriteCdmaPrl(int32_t serial, const hidl_vec<uint8_t>& prl) {
WRAP_V1_0_CALL(nvWriteCdmaPrl, serial, prl);
}
Return<void> Radio::nvResetConfig(int32_t serial, V1_0::ResetNvType resetType) {
WRAP_V1_0_CALL(nvResetConfig, serial, resetType);
}
Return<void> Radio::setUiccSubscription(int32_t serial, const V1_0::SelectUiccSub& uiccSub) {
WRAP_V1_0_CALL(setUiccSubscription, serial, uiccSub);
}
Return<void> Radio::setDataAllowed(int32_t serial, bool allow) {
WRAP_V1_0_CALL(setDataAllowed, serial, allow);
}
Return<void> Radio::getHardwareConfig(int32_t serial) {
WRAP_V1_0_CALL(getHardwareConfig, serial);
}
Return<void> Radio::requestIccSimAuthentication(int32_t serial, int32_t authContext,
const hidl_string& authData,
const hidl_string& aid) {
WRAP_V1_0_CALL(requestIccSimAuthentication, serial, authContext, authData, aid);
}
Return<void> Radio::setDataProfile(int32_t serial, const hidl_vec<V1_0::DataProfileInfo>& profiles,
bool isRoaming) {
WRAP_V1_0_CALL(setDataProfile, serial, profiles, isRoaming);
}
Return<void> Radio::requestShutdown(int32_t serial) {
WRAP_V1_0_CALL(requestShutdown, serial);
}
Return<void> Radio::getRadioCapability(int32_t serial) {
WRAP_V1_0_CALL(getRadioCapability, serial);
}
Return<void> Radio::setRadioCapability(int32_t serial, const V1_0::RadioCapability& rc) {
WRAP_V1_0_CALL(setRadioCapability, serial, rc);
}
Return<void> Radio::startLceService(int32_t serial, int32_t reportInterval, bool pullMode) {
WRAP_V1_0_CALL(startLceService, serial, reportInterval, pullMode);
}
Return<void> Radio::stopLceService(int32_t serial) {
WRAP_V1_0_CALL(stopLceService, serial);
}
Return<void> Radio::pullLceData(int32_t serial) {
WRAP_V1_0_CALL(pullLceData, serial);
}
Return<void> Radio::getModemActivityInfo(int32_t serial) {
WRAP_V1_0_CALL(getModemActivityInfo, serial);
}
Return<void> Radio::setAllowedCarriers(int32_t serial, bool allAllowed,
const V1_0::CarrierRestrictions& carriers) {
WRAP_V1_0_CALL(setAllowedCarriers, serial, allAllowed, carriers);
}
Return<void> Radio::getAllowedCarriers(int32_t serial) {
WRAP_V1_0_CALL(getAllowedCarriers, serial);
}
Return<void> Radio::sendDeviceState(int32_t serial, V1_0::DeviceStateType deviceStateType,
bool state) {
WRAP_V1_0_CALL(sendDeviceState, serial, deviceStateType, state);
}
Return<void> Radio::setIndicationFilter(int32_t serial,
hidl_bitfield<V1_0::IndicationFilter> indicationFilter) {
WRAP_V1_0_CALL(setIndicationFilter, serial, indicationFilter);
}
Return<void> Radio::setSimCardPower(int32_t serial, bool powerUp) {
WRAP_V1_0_CALL(setSimCardPower, serial, powerUp);
}
Return<void> Radio::responseAcknowledgement() {
WRAP_V1_0_CALL(responseAcknowledgement);
}
// Methods from ::android::hardware::radio::V1_1::IRadio follow.
Return<void> Radio::setCarrierInfoForImsiEncryption(
int32_t serial, const V1_1::ImsiEncryptionInfo& imsiEncryptionInfo) {
MAYBE_WRAP_V1_1_CALL(setCarrierInfoForImsiEncryption, serial, imsiEncryptionInfo);
// TODO implement
return Void();
}
Return<void> Radio::setSimCardPower_1_1(int32_t serial, V1_1::CardPowerState powerUp) {
MAYBE_WRAP_V1_1_CALL(setSimCardPower_1_1, serial, powerUp);
if(powerUp != V1_1::CardPowerState::POWER_UP_PASS_THROUGH)
WRAP_V1_0_CALL(setSimCardPower, serial, (bool) powerUp);
return Void();
}
Return<void> Radio::startNetworkScan(int32_t serial, const V1_1::NetworkScanRequest& request) {
MAYBE_WRAP_V1_1_CALL(startNetworkScan, serial, request);
// TODO implement
return Void();
}
Return<void> Radio::stopNetworkScan(int32_t serial) {
MAYBE_WRAP_V1_1_CALL(stopNetworkScan, serial);
// TODO implement
return Void();
}
Return<void> Radio::startKeepalive(int32_t serial, const V1_1::KeepaliveRequest& keepalive) {
MAYBE_WRAP_V1_1_CALL(startKeepalive, serial, keepalive);
// TODO implement
return Void();
}
Return<void> Radio::stopKeepalive(int32_t serial, int32_t sessionHandle) {
MAYBE_WRAP_V1_1_CALL(stopKeepalive, serial, sessionHandle);
// TODO implement
return Void();
}
// Methods from ::android::hardware::radio::V1_2::IRadio follow.
Return<void> Radio::startNetworkScan_1_2(int32_t serial, const V1_2::NetworkScanRequest& request) {
MAYBE_WRAP_V1_2_CALL(startNetworkScan_1_2, serial, request);
// TODO implement
return Void();
}
Return<void> Radio::setIndicationFilter_1_2(
int32_t serial, hidl_bitfield<V1_2::IndicationFilter> indicationFilter) {
MAYBE_WRAP_V1_2_CALL(setIndicationFilter_1_2, serial, indicationFilter);
WRAP_V1_0_CALL(setIndicationFilter, serial, indicationFilter & V1_0::IndicationFilter::ALL);
}
Return<void> Radio::setSignalStrengthReportingCriteria(int32_t serial, int32_t hysteresisMs,
int32_t hysteresisDb,
const hidl_vec<int32_t>& thresholdsDbm,
V1_2::AccessNetwork accessNetwork) {
MAYBE_WRAP_V1_2_CALL(setSignalStrengthReportingCriteria, serial, hysteresisMs, hysteresisDb,
thresholdsDbm, accessNetwork);
// TODO implement
return Void();
}
Return<void> Radio::setLinkCapacityReportingCriteria(
int32_t serial, int32_t hysteresisMs, int32_t hysteresisDlKbps, int32_t hysteresisUlKbps,
const hidl_vec<int32_t>& thresholdsDownlinkKbps,
const hidl_vec<int32_t>& thresholdsUplinkKbps, V1_2::AccessNetwork accessNetwork) {
MAYBE_WRAP_V1_2_CALL(setLinkCapacityReportingCriteria, serial, hysteresisMs, hysteresisDlKbps,
hysteresisUlKbps, thresholdsDownlinkKbps, thresholdsUplinkKbps,
accessNetwork);
// TODO implement
return Void();
}
Return<void> Radio::setupDataCall_1_2(int32_t serial, V1_2::AccessNetwork accessNetwork,
const V1_0::DataProfileInfo& dataProfileInfo,
bool modemCognitive, bool roamingAllowed, bool isRoaming,
V1_2::DataRequestReason reason,
const hidl_vec<hidl_string>& addresses,
const hidl_vec<hidl_string>& dnses) {
MAYBE_WRAP_V1_2_CALL(setupDataCall_1_2, serial, accessNetwork, dataProfileInfo, modemCognitive,
roamingAllowed, isRoaming, reason, addresses, dnses);
// TODO implement
return Void();
}
Return<void> Radio::deactivateDataCall_1_2(int32_t serial, int32_t cid,
V1_2::DataRequestReason reason) {
MAYBE_WRAP_V1_2_CALL(deactivateDataCall_1_2, serial, cid, reason);
WRAP_V1_0_CALL(deactivateDataCall, serial, cid, reason == V1_2::DataRequestReason::SHUTDOWN);
}
// Methods from ::android::hardware::radio::V1_3::IRadio follow.
Return<void> Radio::setSystemSelectionChannels(
int32_t serial, bool specifyChannels,
const hidl_vec<V1_1::RadioAccessSpecifier>& specifiers) {
MAYBE_WRAP_V1_3_CALL(setSystemSelectionChannels, serial, specifyChannels, specifiers);
// TODO implement
return Void();
}
Return<void> Radio::enableModem(int32_t serial, bool on) {
MAYBE_WRAP_V1_3_CALL(enableModem, serial, on);
// TODO implement
return Void();
}
Return<void> Radio::getModemStackStatus(int32_t serial) {
MAYBE_WRAP_V1_3_CALL(getModemStackStatus, serial);
// TODO implement
return Void();
}
hidl_string getProtocolStringFromInt(const V1_4::PdpProtocolType protocol){
const hidl_string protocolStrings[] = {hidl_string("IP"), hidl_string("IPV6"), hidl_string("IPV4V6"), hidl_string("PPP"),
hidl_string("NON-IP"), hidl_string("UNSTRUCTURED")};
if(protocol >= V1_4::PdpProtocolType::IP && protocol <= V1_4::PdpProtocolType::UNSTRUCTURED)
return protocolStrings[(int)protocol];
return hidl_string("");
}
V1_0::DataProfileInfo Get1_0DataProfileInfo(const V1_4::DataProfileInfo& dataProfileInfo){
V1_0::DataProfileInfo legacyProfile = {};
legacyProfile.profileId = dataProfileInfo.profileId;
legacyProfile.apn = dataProfileInfo.apn;
legacyProfile.protocol = getProtocolStringFromInt(dataProfileInfo.protocol);
legacyProfile.roamingProtocol = getProtocolStringFromInt(dataProfileInfo.roamingProtocol);
legacyProfile.authType = dataProfileInfo.authType;
legacyProfile.user = dataProfileInfo.user;
legacyProfile.password = dataProfileInfo.password;
legacyProfile.type = dataProfileInfo.type;
legacyProfile.maxConnsTime = dataProfileInfo.maxConnsTime;
legacyProfile.maxConns = dataProfileInfo.maxConns;
legacyProfile.waitTime = dataProfileInfo.waitTime;
legacyProfile.enabled = dataProfileInfo.enabled;
legacyProfile.supportedApnTypesBitmap = dataProfileInfo.supportedApnTypesBitmap;
legacyProfile.bearerBitmap = dataProfileInfo.bearerBitmap;
legacyProfile.mtu = dataProfileInfo.mtu;
legacyProfile.mvnoType = V1_0::MvnoType::NONE;
return legacyProfile;
}
// Methods from ::android::hardware::radio::V1_4::IRadio follow.
Return<void> Radio::setupDataCall_1_4(int32_t serial, V1_4::AccessNetwork accessNetwork,
const V1_4::DataProfileInfo& dataProfileInfo,
bool roamingAllowed, V1_2::DataRequestReason reason,
const hidl_vec<hidl_string>& addresses,
const hidl_vec<hidl_string>& dnses) {
MAYBE_WRAP_V1_4_CALL(setupDataCall_1_4, serial, accessNetwork, dataProfileInfo, roamingAllowed,
reason, addresses, dnses);
MAYBE_WRAP_V1_2_CALL(setupDataCall_1_2, serial, (V1_2::AccessNetwork) accessNetwork, Get1_0DataProfileInfo(dataProfileInfo),
dataProfileInfo.persistent, roamingAllowed, mRadioResponse->mDataRoaming, reason, addresses, dnses);
WRAP_V1_0_CALL(setupDataCall, serial, mRadioResponse->mRat, Get1_0DataProfileInfo(dataProfileInfo),
dataProfileInfo.persistent, roamingAllowed, mRadioResponse->mDataRoaming);
}
Return<void> Radio::setInitialAttachApn_1_4(int32_t serial,
const V1_4::DataProfileInfo& dataProfileInfo) {
MAYBE_WRAP_V1_4_CALL(setInitialAttachApn_1_4, serial, dataProfileInfo);
WRAP_V1_0_CALL(setInitialAttachApn, serial, Get1_0DataProfileInfo(dataProfileInfo),
dataProfileInfo.persistent, mRadioResponse->mDataRoaming);
}
Return<void> Radio::setDataProfile_1_4(int32_t serial,
const hidl_vec<V1_4::DataProfileInfo>& profiles) {
MAYBE_WRAP_V1_4_CALL(setDataProfile_1_4, serial, profiles);
std::vector<V1_0::DataProfileInfo> legacyProfiles;
for(const V1_4::DataProfileInfo &profile : profiles){
if(profile.persistent)
legacyProfiles.push_back(Get1_0DataProfileInfo(profile));
}
if(legacyProfiles.size())
WRAP_V1_0_CALL(setDataProfile, serial, hidl_vec(legacyProfiles), mRadioResponse->mDataRoaming);
return Void();
}
Return<void> Radio::emergencyDial(int32_t serial, const V1_0::Dial& dialInfo,
hidl_bitfield<V1_4::EmergencyServiceCategory> categories,
const hidl_vec<hidl_string>& urns,
V1_4::EmergencyCallRouting routing,
bool hasKnownUserIntentEmergency, bool isTesting) {
MAYBE_WRAP_V1_4_CALL(emergencyDial, serial, dialInfo, categories, urns, routing,
hasKnownUserIntentEmergency, isTesting);
// TODO implement
return Void();
}
Return<void> Radio::startNetworkScan_1_4(int32_t serial, const V1_2::NetworkScanRequest& request) {
MAYBE_WRAP_V1_4_CALL(startNetworkScan_1_4, serial, request);
MAYBE_WRAP_V1_2_CALL(startNetworkScan_1_2, serial, request);
V1_1::NetworkScanRequest legacyRequest = {};
legacyRequest.type = request.type;
legacyRequest.interval = request.interval;
legacyRequest.specifiers = request.specifiers;
MAYBE_WRAP_V1_1_CALL(startNetworkScan, serial, legacyRequest);
// TODO implement
return Void();
}
Return<void> Radio::getPreferredNetworkTypeBitmap(int32_t serial) {
MAYBE_WRAP_V1_4_CALL(getPreferredNetworkTypeBitmap, serial);
WRAP_V1_0_CALL(getPreferredNetworkType, serial);
}
Return<void> Radio::setPreferredNetworkTypeBitmap(
int32_t serial, hidl_bitfield<V1_4::RadioAccessFamily> networkTypeBitmap) {
MAYBE_WRAP_V1_4_CALL(setPreferredNetworkTypeBitmap, serial, networkTypeBitmap);
if(networkTypeBitmap & GSMBITS)
networkTypeBitmap |= GSMBITS;
if(networkTypeBitmap & CDMABITS)
networkTypeBitmap |= CDMABITS;
if(networkTypeBitmap & EVDOBITS)
networkTypeBitmap |= EVDOBITS;
if(networkTypeBitmap & WCDMABITS)
networkTypeBitmap |= WCDMABITS;
if(networkTypeBitmap & LTEBITS)
networkTypeBitmap |= LTEBITS;
V1_0::PreferredNetworkType nwType;
switch(networkTypeBitmap){
case (GSMBITS | WCDMABITS):
nwType = V1_0::PreferredNetworkType::GSM_WCDMA_AUTO;
break;
case GSMBITS:
nwType = V1_0::PreferredNetworkType::GSM_ONLY;
break;
case WCDMABITS:
nwType = V1_0::PreferredNetworkType::WCDMA;
break;
case (CDMABITS | EVDOBITS):
nwType = V1_0::PreferredNetworkType::CDMA_EVDO_AUTO;
break;
case CDMABITS:
nwType = V1_0::PreferredNetworkType::CDMA_ONLY;
break;
case EVDOBITS:
nwType = V1_0::PreferredNetworkType::EVDO_ONLY;
break;
case (GSMBITS | WCDMABITS | CDMABITS | EVDOBITS):
nwType = V1_0::PreferredNetworkType::GSM_WCDMA_CDMA_EVDO_AUTO;
break;
case (LTEBITS | CDMABITS | EVDOBITS):
nwType = V1_0::PreferredNetworkType::LTE_CDMA_EVDO;
break;
case (LTEBITS | GSMBITS | WCDMABITS):
nwType = V1_0::PreferredNetworkType::LTE_GSM_WCDMA;
break;
case (LTEBITS | CDMABITS | EVDOBITS | GSMBITS | WCDMABITS):
nwType = V1_0::PreferredNetworkType::LTE_CMDA_EVDO_GSM_WCDMA;
break;
case LTEBITS:
nwType = V1_0::PreferredNetworkType::LTE_ONLY;
break;
case (LTEBITS | WCDMABITS):
nwType = V1_0::PreferredNetworkType::LTE_WCDMA;
break;
case TDSCDMABIT:
nwType = V1_0::PreferredNetworkType::TD_SCDMA_ONLY;
break;
case (TDSCDMABIT | WCDMABITS):
nwType = V1_0::PreferredNetworkType::TD_SCDMA_WCDMA;
break;
case (TDSCDMABIT | LTEBITS):
nwType = V1_0::PreferredNetworkType::TD_SCDMA_LTE;
break;
case (TDSCDMABIT | GSMBITS):
nwType = V1_0::PreferredNetworkType::TD_SCDMA_GSM;
break;
case (TDSCDMABIT | GSMBITS | LTEBITS):
nwType = V1_0::PreferredNetworkType::TD_SCDMA_GSM_LTE;
break;
case (TDSCDMABIT | GSMBITS | WCDMABITS):
nwType = V1_0::PreferredNetworkType::TD_SCDMA_GSM_WCDMA;
break;
case (TDSCDMABIT | WCDMABITS | LTEBITS):
nwType = V1_0::PreferredNetworkType::TD_SCDMA_WCDMA_LTE;
break;
case (TDSCDMABIT | GSMBITS | WCDMABITS | LTEBITS):
nwType = V1_0::PreferredNetworkType::TD_SCDMA_GSM_WCDMA_LTE;
break;
case (TDSCDMABIT | GSMBITS | WCDMABITS | CDMABITS | EVDOBITS):
nwType = V1_0::PreferredNetworkType::TD_SCDMA_GSM_WCDMA_CDMA_EVDO_AUTO;
break;
case (TDSCDMABIT | LTEBITS | CDMABITS | EVDOBITS | GSMBITS | WCDMABITS):
nwType = V1_0::PreferredNetworkType::TD_SCDMA_LTE_CDMA_EVDO_GSM_WCDMA;
break;
default:
nwType = V1_0::PreferredNetworkType::LTE_CMDA_EVDO_GSM_WCDMA;
}
WRAP_V1_0_CALL(setPreferredNetworkType, serial, nwType);
}
Return<void> Radio::setAllowedCarriers_1_4(int32_t serial,
const V1_4::CarrierRestrictionsWithPriority& carriers,
V1_4::SimLockMultiSimPolicy multiSimPolicy) {
MAYBE_WRAP_V1_4_CALL(setAllowedCarriers_1_4, serial, carriers, multiSimPolicy);
bool isAllCarriersAllowed = carriers.allowedCarriers.size() == 0 &&
carriers.excludedCarriers.size() == 0 && !carriers.allowedCarriersPrioritized;
bool supported = (isAllCarriersAllowed
|| (carriers.excludedCarriers.size() == 0
&& carriers.allowedCarriersPrioritized))
&& multiSimPolicy == V1_4::SimLockMultiSimPolicy::NO_MULTISIM_POLICY;
if(supported){
V1_0::CarrierRestrictions legacyCarriers = {};
legacyCarriers.allowedCarriers = carriers.allowedCarriers;
WRAP_V1_0_CALL(setAllowedCarriers, serial, isAllCarriersAllowed, legacyCarriers);
}
return Void();
}
Return<void> Radio::getAllowedCarriers_1_4(int32_t serial) {
MAYBE_WRAP_V1_4_CALL(getAllowedCarriers_1_4, serial);
WRAP_V1_0_CALL(getAllowedCarriers, serial);
}
Return<void> Radio::getSignalStrength_1_4(int32_t serial) {
MAYBE_WRAP_V1_4_CALL(getSignalStrength_1_4, serial);
WRAP_V1_0_CALL(getSignalStrength, serial);
}
sp<V1_1::IRadio> Radio::getRealRadio_V1_1() {
return V1_1::IRadio::castFrom(mRealRadio).withDefault(nullptr);
}
sp<V1_2::IRadio> Radio::getRealRadio_V1_2() {
return V1_2::IRadio::castFrom(mRealRadio).withDefault(nullptr);
}
sp<V1_3::IRadio> Radio::getRealRadio_V1_3() {
return V1_3::IRadio::castFrom(mRealRadio).withDefault(nullptr);
}
sp<V1_4::IRadio> Radio::getRealRadio_V1_4() {
return V1_4::IRadio::castFrom(mRealRadio).withDefault(nullptr);
}
} // namespace android::hardware::radio::implementation

273
radio/1.4/legacy/Radio.h Normal file
View file

@ -0,0 +1,273 @@
/*
* Copyright (C) 2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <android/hardware/radio/1.4/IRadio.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
#include "RadioIndication.h"
#include "RadioResponse.h"
namespace android::hardware::radio::implementation {
using ::android::sp;
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
struct Radio : public V1_4::IRadio {
public:
Radio(sp<V1_0::IRadio> realRadio);
// Methods from ::android::hardware::radio::V1_0::IRadio follow.
Return<void> setResponseFunctions(const sp<V1_0::IRadioResponse>& radioResponse,
const sp<V1_0::IRadioIndication>& radioIndication) override;
Return<void> getIccCardStatus(int32_t serial) override;
Return<void> supplyIccPinForApp(int32_t serial, const hidl_string& pin,
const hidl_string& aid) override;
Return<void> supplyIccPukForApp(int32_t serial, const hidl_string& puk, const hidl_string& pin,
const hidl_string& aid) override;
Return<void> supplyIccPin2ForApp(int32_t serial, const hidl_string& pin2,
const hidl_string& aid) override;
Return<void> supplyIccPuk2ForApp(int32_t serial, const hidl_string& puk2,
const hidl_string& pin2, const hidl_string& aid) override;
Return<void> changeIccPinForApp(int32_t serial, const hidl_string& oldPin,
const hidl_string& newPin, const hidl_string& aid) override;
Return<void> changeIccPin2ForApp(int32_t serial, const hidl_string& oldPin2,
const hidl_string& newPin2, const hidl_string& aid) override;
Return<void> supplyNetworkDepersonalization(int32_t serial, const hidl_string& netPin) override;
Return<void> getCurrentCalls(int32_t serial) override;
Return<void> dial(int32_t serial, const V1_0::Dial& dialInfo) override;
Return<void> getImsiForApp(int32_t serial, const hidl_string& aid) override;
Return<void> hangup(int32_t serial, int32_t gsmIndex) override;
Return<void> hangupWaitingOrBackground(int32_t serial) override;
Return<void> hangupForegroundResumeBackground(int32_t serial) override;
Return<void> switchWaitingOrHoldingAndActive(int32_t serial) override;
Return<void> conference(int32_t serial) override;
Return<void> rejectCall(int32_t serial) override;
Return<void> getLastCallFailCause(int32_t serial) override;
Return<void> getSignalStrength(int32_t serial) override;
Return<void> getVoiceRegistrationState(int32_t serial) override;
Return<void> getDataRegistrationState(int32_t serial) override;
Return<void> getOperator(int32_t serial) override;
Return<void> setRadioPower(int32_t serial, bool on) override;
Return<void> sendDtmf(int32_t serial, const hidl_string& s) override;
Return<void> sendSms(int32_t serial, const V1_0::GsmSmsMessage& message) override;
Return<void> sendSMSExpectMore(int32_t serial, const V1_0::GsmSmsMessage& message) override;
Return<void> setupDataCall(int32_t serial, V1_0::RadioTechnology radioTechnology,
const V1_0::DataProfileInfo& dataProfileInfo, bool modemCognitive,
bool roamingAllowed, bool isRoaming) override;
Return<void> iccIOForApp(int32_t serial, const V1_0::IccIo& iccIo) override;
Return<void> sendUssd(int32_t serial, const hidl_string& ussd) override;
Return<void> cancelPendingUssd(int32_t serial) override;
Return<void> getClir(int32_t serial) override;
Return<void> setClir(int32_t serial, int32_t status) override;
Return<void> getCallForwardStatus(int32_t serial,
const V1_0::CallForwardInfo& callInfo) override;
Return<void> setCallForward(int32_t serial, const V1_0::CallForwardInfo& callInfo) override;
Return<void> getCallWaiting(int32_t serial, int32_t serviceClass) override;
Return<void> setCallWaiting(int32_t serial, bool enable, int32_t serviceClass) override;
Return<void> acknowledgeLastIncomingGsmSms(int32_t serial, bool success,
V1_0::SmsAcknowledgeFailCause cause) override;
Return<void> acceptCall(int32_t serial) override;
Return<void> deactivateDataCall(int32_t serial, int32_t cid, bool reasonRadioShutDown) override;
Return<void> getFacilityLockForApp(int32_t serial, const hidl_string& facility,
const hidl_string& password, int32_t serviceClass,
const hidl_string& appId) override;
Return<void> setFacilityLockForApp(int32_t serial, const hidl_string& facility, bool lockState,
const hidl_string& password, int32_t serviceClass,
const hidl_string& appId) override;
Return<void> setBarringPassword(int32_t serial, const hidl_string& facility,
const hidl_string& oldPassword,
const hidl_string& newPassword) override;
Return<void> getNetworkSelectionMode(int32_t serial) override;
Return<void> setNetworkSelectionModeAutomatic(int32_t serial) override;
Return<void> setNetworkSelectionModeManual(int32_t serial,
const hidl_string& operatorNumeric) override;
Return<void> getAvailableNetworks(int32_t serial) override;
Return<void> startDtmf(int32_t serial, const hidl_string& s) override;
Return<void> stopDtmf(int32_t serial) override;
Return<void> getBasebandVersion(int32_t serial) override;
Return<void> separateConnection(int32_t serial, int32_t gsmIndex) override;
Return<void> setMute(int32_t serial, bool enable) override;
Return<void> getMute(int32_t serial) override;
Return<void> getClip(int32_t serial) override;
Return<void> getDataCallList(int32_t serial) override;
Return<void> setSuppServiceNotifications(int32_t serial, bool enable) override;
Return<void> writeSmsToSim(int32_t serial, const V1_0::SmsWriteArgs& smsWriteArgs) override;
Return<void> deleteSmsOnSim(int32_t serial, int32_t index) override;
Return<void> setBandMode(int32_t serial, V1_0::RadioBandMode mode) override;
Return<void> getAvailableBandModes(int32_t serial) override;
Return<void> sendEnvelope(int32_t serial, const hidl_string& command) override;
Return<void> sendTerminalResponseToSim(int32_t serial,
const hidl_string& commandResponse) override;
Return<void> handleStkCallSetupRequestFromSim(int32_t serial, bool accept) override;
Return<void> explicitCallTransfer(int32_t serial) override;
Return<void> setPreferredNetworkType(int32_t serial,
V1_0::PreferredNetworkType nwType) override;
Return<void> getPreferredNetworkType(int32_t serial) override;
Return<void> getNeighboringCids(int32_t serial) override;
Return<void> setLocationUpdates(int32_t serial, bool enable) override;
Return<void> setCdmaSubscriptionSource(int32_t serial,
V1_0::CdmaSubscriptionSource cdmaSub) override;
Return<void> setCdmaRoamingPreference(int32_t serial, V1_0::CdmaRoamingType type) override;
Return<void> getCdmaRoamingPreference(int32_t serial) override;
Return<void> setTTYMode(int32_t serial, V1_0::TtyMode mode) override;
Return<void> getTTYMode(int32_t serial) override;
Return<void> setPreferredVoicePrivacy(int32_t serial, bool enable) override;
Return<void> getPreferredVoicePrivacy(int32_t serial) override;
Return<void> sendCDMAFeatureCode(int32_t serial, const hidl_string& featureCode) override;
Return<void> sendBurstDtmf(int32_t serial, const hidl_string& dtmf, int32_t on,
int32_t off) override;
Return<void> sendCdmaSms(int32_t serial, const V1_0::CdmaSmsMessage& sms) override;
Return<void> acknowledgeLastIncomingCdmaSms(int32_t serial,
const V1_0::CdmaSmsAck& smsAck) override;
Return<void> getGsmBroadcastConfig(int32_t serial) override;
Return<void> setGsmBroadcastConfig(
int32_t serial, const hidl_vec<V1_0::GsmBroadcastSmsConfigInfo>& configInfo) override;
Return<void> setGsmBroadcastActivation(int32_t serial, bool activate) override;
Return<void> getCdmaBroadcastConfig(int32_t serial) override;
Return<void> setCdmaBroadcastConfig(
int32_t serial, const hidl_vec<V1_0::CdmaBroadcastSmsConfigInfo>& configInfo) override;
Return<void> setCdmaBroadcastActivation(int32_t serial, bool activate) override;
Return<void> getCDMASubscription(int32_t serial) override;
Return<void> writeSmsToRuim(int32_t serial, const V1_0::CdmaSmsWriteArgs& cdmaSms) override;
Return<void> deleteSmsOnRuim(int32_t serial, int32_t index) override;
Return<void> getDeviceIdentity(int32_t serial) override;
Return<void> exitEmergencyCallbackMode(int32_t serial) override;
Return<void> getSmscAddress(int32_t serial) override;
Return<void> setSmscAddress(int32_t serial, const hidl_string& smsc) override;
Return<void> reportSmsMemoryStatus(int32_t serial, bool available) override;
Return<void> reportStkServiceIsRunning(int32_t serial) override;
Return<void> getCdmaSubscriptionSource(int32_t serial) override;
Return<void> requestIsimAuthentication(int32_t serial, const hidl_string& challenge) override;
Return<void> acknowledgeIncomingGsmSmsWithPdu(int32_t serial, bool success,
const hidl_string& ackPdu) override;
Return<void> sendEnvelopeWithStatus(int32_t serial, const hidl_string& contents) override;
Return<void> getVoiceRadioTechnology(int32_t serial) override;
Return<void> getCellInfoList(int32_t serial) override;
Return<void> setCellInfoListRate(int32_t serial, int32_t rate) override;
Return<void> setInitialAttachApn(int32_t serial, const V1_0::DataProfileInfo& dataProfileInfo,
bool modemCognitive, bool isRoaming) override;
Return<void> getImsRegistrationState(int32_t serial) override;
Return<void> sendImsSms(int32_t serial, const V1_0::ImsSmsMessage& message) override;
Return<void> iccTransmitApduBasicChannel(int32_t serial, const V1_0::SimApdu& message) override;
Return<void> iccOpenLogicalChannel(int32_t serial, const hidl_string& aid, int32_t p2) override;
Return<void> iccCloseLogicalChannel(int32_t serial, int32_t channelId) override;
Return<void> iccTransmitApduLogicalChannel(int32_t serial,
const V1_0::SimApdu& message) override;
Return<void> nvReadItem(int32_t serial, V1_0::NvItem itemId) override;
Return<void> nvWriteItem(int32_t serial, const V1_0::NvWriteItem& item) override;
Return<void> nvWriteCdmaPrl(int32_t serial, const hidl_vec<uint8_t>& prl) override;
Return<void> nvResetConfig(int32_t serial, V1_0::ResetNvType resetType) override;
Return<void> setUiccSubscription(int32_t serial, const V1_0::SelectUiccSub& uiccSub) override;
Return<void> setDataAllowed(int32_t serial, bool allow) override;
Return<void> getHardwareConfig(int32_t serial) override;
Return<void> requestIccSimAuthentication(int32_t serial, int32_t authContext,
const hidl_string& authData,
const hidl_string& aid) override;
Return<void> setDataProfile(int32_t serial, const hidl_vec<V1_0::DataProfileInfo>& profiles,
bool isRoaming) override;
Return<void> requestShutdown(int32_t serial) override;
Return<void> getRadioCapability(int32_t serial) override;
Return<void> setRadioCapability(int32_t serial, const V1_0::RadioCapability& rc) override;
Return<void> startLceService(int32_t serial, int32_t reportInterval, bool pullMode) override;
Return<void> stopLceService(int32_t serial) override;
Return<void> pullLceData(int32_t serial) override;
Return<void> getModemActivityInfo(int32_t serial) override;
Return<void> setAllowedCarriers(int32_t serial, bool allAllowed,
const V1_0::CarrierRestrictions& carriers) override;
Return<void> getAllowedCarriers(int32_t serial) override;
Return<void> sendDeviceState(int32_t serial, V1_0::DeviceStateType deviceStateType,
bool state) override;
Return<void> setIndicationFilter(
int32_t serial, hidl_bitfield<V1_0::IndicationFilter> indicationFilter) override;
Return<void> setSimCardPower(int32_t serial, bool powerUp) override;
Return<void> responseAcknowledgement() override;
// Methods from ::android::hardware::radio::V1_1::IRadio follow.
Return<void> setCarrierInfoForImsiEncryption(
int32_t serial, const V1_1::ImsiEncryptionInfo& imsiEncryptionInfo) override;
Return<void> setSimCardPower_1_1(int32_t serial, V1_1::CardPowerState powerUp) override;
Return<void> startNetworkScan(int32_t serial, const V1_1::NetworkScanRequest& request) override;
Return<void> stopNetworkScan(int32_t serial) override;
Return<void> startKeepalive(int32_t serial, const V1_1::KeepaliveRequest& keepalive) override;
Return<void> stopKeepalive(int32_t serial, int32_t sessionHandle) override;
// Methods from ::android::hardware::radio::V1_2::IRadio follow.
Return<void> startNetworkScan_1_2(int32_t serial,
const V1_2::NetworkScanRequest& request) override;
Return<void> setIndicationFilter_1_2(
int32_t serial, hidl_bitfield<V1_2::IndicationFilter> indicationFilter) override;
Return<void> setSignalStrengthReportingCriteria(int32_t serial, int32_t hysteresisMs,
int32_t hysteresisDb,
const hidl_vec<int32_t>& thresholdsDbm,
V1_2::AccessNetwork accessNetwork) override;
Return<void> setLinkCapacityReportingCriteria(int32_t serial, int32_t hysteresisMs,
int32_t hysteresisDlKbps,
int32_t hysteresisUlKbps,
const hidl_vec<int32_t>& thresholdsDownlinkKbps,
const hidl_vec<int32_t>& thresholdsUplinkKbps,
V1_2::AccessNetwork accessNetwork) override;
Return<void> setupDataCall_1_2(int32_t serial, V1_2::AccessNetwork accessNetwork,
const V1_0::DataProfileInfo& dataProfileInfo,
bool modemCognitive, bool roamingAllowed, bool isRoaming,
V1_2::DataRequestReason reason,
const hidl_vec<hidl_string>& addresses,
const hidl_vec<hidl_string>& dnses) override;
Return<void> deactivateDataCall_1_2(int32_t serial, int32_t cid,
V1_2::DataRequestReason reason) override;
// Methods from ::android::hardware::radio::V1_3::IRadio follow.
Return<void> setSystemSelectionChannels(
int32_t serial, bool specifyChannels,
const hidl_vec<V1_1::RadioAccessSpecifier>& specifiers) override;
Return<void> enableModem(int32_t serial, bool on) override;
Return<void> getModemStackStatus(int32_t serial) override;
// Methods from ::android::hardware::radio::V1_4::IRadio follow.
Return<void> setupDataCall_1_4(int32_t serial, V1_4::AccessNetwork accessNetwork,
const V1_4::DataProfileInfo& dataProfileInfo,
bool roamingAllowed, V1_2::DataRequestReason reason,
const hidl_vec<hidl_string>& addresses,
const hidl_vec<hidl_string>& dnses) override;
Return<void> setInitialAttachApn_1_4(int32_t serial,
const V1_4::DataProfileInfo& dataProfileInfo) override;
Return<void> setDataProfile_1_4(int32_t serial,
const hidl_vec<V1_4::DataProfileInfo>& profiles) override;
Return<void> emergencyDial(int32_t serial, const V1_0::Dial& dialInfo,
hidl_bitfield<V1_4::EmergencyServiceCategory> categories,
const hidl_vec<hidl_string>& urns,
V1_4::EmergencyCallRouting routing, bool hasKnownUserIntentEmergency,
bool isTesting) override;
Return<void> startNetworkScan_1_4(int32_t serial,
const V1_2::NetworkScanRequest& request) override;
Return<void> getPreferredNetworkTypeBitmap(int32_t serial) override;
Return<void> setPreferredNetworkTypeBitmap(
int32_t serial, hidl_bitfield<V1_4::RadioAccessFamily> networkTypeBitmap) override;
Return<void> setAllowedCarriers_1_4(int32_t serial,
const V1_4::CarrierRestrictionsWithPriority& carriers,
V1_4::SimLockMultiSimPolicy multiSimPolicy) override;
Return<void> getAllowedCarriers_1_4(int32_t serial) override;
Return<void> getSignalStrength_1_4(int32_t serial) override;
private:
sp<V1_0::IRadio> mRealRadio;
sp<RadioResponse> mRadioResponse = new RadioResponse();
sp<RadioIndication> mRadioIndication = new RadioIndication();
sp<V1_1::IRadio> getRealRadio_V1_1();
sp<V1_2::IRadio> getRealRadio_V1_2();
sp<V1_3::IRadio> getRealRadio_V1_3();
sp<V1_4::IRadio> getRealRadio_V1_4();
};
} // namespace android::hardware::radio::implementation

314
radio/1.4/legacy/RadioIndication.cpp Normal file
View file

@ -0,0 +1,314 @@
/*
* Copyright (C) 2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "RadioIndication.h"
#include "Helpers.h"
namespace android::hardware::radio::implementation {
// Methods from ::android::hardware::radio::V1_0::IRadioIndication follow.
Return<void> RadioIndication::radioStateChanged(V1_0::RadioIndicationType type,
V1_0::RadioState radioState) {
return mRealRadioIndication->radioStateChanged(type, radioState);
}
Return<void> RadioIndication::callStateChanged(V1_0::RadioIndicationType type) {
return mRealRadioIndication->callStateChanged(type);
}
Return<void> RadioIndication::networkStateChanged(V1_0::RadioIndicationType type) {
return mRealRadioIndication->networkStateChanged(type);
}
Return<void> RadioIndication::newSms(V1_0::RadioIndicationType type, const hidl_vec<uint8_t>& pdu) {
return mRealRadioIndication->newSms(type, pdu);
}
Return<void> RadioIndication::newSmsStatusReport(V1_0::RadioIndicationType type,
const hidl_vec<uint8_t>& pdu) {
return mRealRadioIndication->newSmsStatusReport(type, pdu);
}
Return<void> RadioIndication::newSmsOnSim(V1_0::RadioIndicationType type, int32_t recordNumber) {
return mRealRadioIndication->newSmsOnSim(type, recordNumber);
}
Return<void> RadioIndication::onUssd(V1_0::RadioIndicationType type, V1_0::UssdModeType modeType,
const hidl_string& msg) {
return mRealRadioIndication->onUssd(type, modeType, msg);
}
Return<void> RadioIndication::nitzTimeReceived(V1_0::RadioIndicationType type,
const hidl_string& nitzTime, uint64_t receivedTime) {
return mRealRadioIndication->nitzTimeReceived(type, nitzTime, receivedTime);
}
Return<void> RadioIndication::currentSignalStrength(V1_0::RadioIndicationType type,
const V1_0::SignalStrength& signalStrength) {
return mRealRadioIndication->currentSignalStrength_1_4(type, Create1_4SignalStrength(signalStrength));
}
Return<void> RadioIndication::dataCallListChanged(
V1_0::RadioIndicationType type, const hidl_vec<V1_0::SetupDataCallResult>& dcList) {
hidl_vec<V1_4::SetupDataCallResult> newDcList;
newDcList.resize(dcList.size());
for(int x = 0; x < dcList.size(); ++x)
newDcList[x] = Create1_4SetupDataCallResult(dcList[x]);
return mRealRadioIndication->dataCallListChanged_1_4(type, newDcList);
}
Return<void> RadioIndication::suppSvcNotify(V1_0::RadioIndicationType type,
const V1_0::SuppSvcNotification& suppSvc) {
return mRealRadioIndication->suppSvcNotify(type, suppSvc);
}
Return<void> RadioIndication::stkSessionEnd(V1_0::RadioIndicationType type) {
return mRealRadioIndication->stkSessionEnd(type);
}
Return<void> RadioIndication::stkProactiveCommand(V1_0::RadioIndicationType type,
const hidl_string& cmd) {
return mRealRadioIndication->stkProactiveCommand(type, cmd);
}
Return<void> RadioIndication::stkEventNotify(V1_0::RadioIndicationType type,
const hidl_string& cmd) {
return mRealRadioIndication->stkEventNotify(type, cmd);
}
Return<void> RadioIndication::stkCallSetup(V1_0::RadioIndicationType type, int64_t timeout) {
return mRealRadioIndication->stkCallSetup(type, timeout);
}
Return<void> RadioIndication::simSmsStorageFull(V1_0::RadioIndicationType type) {
return mRealRadioIndication->simSmsStorageFull(type);
}
Return<void> RadioIndication::simRefresh(V1_0::RadioIndicationType type,
const V1_0::SimRefreshResult& refreshResult) {
return mRealRadioIndication->simRefresh(type, refreshResult);
}
Return<void> RadioIndication::callRing(V1_0::RadioIndicationType type, bool isGsm,
const V1_0::CdmaSignalInfoRecord& record) {
return mRealRadioIndication->callRing(type, isGsm, record);
}
Return<void> RadioIndication::simStatusChanged(V1_0::RadioIndicationType type) {
return mRealRadioIndication->simStatusChanged(type);
}
Return<void> RadioIndication::cdmaNewSms(V1_0::RadioIndicationType type,
const V1_0::CdmaSmsMessage& msg) {
return mRealRadioIndication->cdmaNewSms(type, msg);
}
Return<void> RadioIndication::newBroadcastSms(V1_0::RadioIndicationType type,
const hidl_vec<uint8_t>& data) {
return mRealRadioIndication->newBroadcastSms(type, data);
}
Return<void> RadioIndication::cdmaRuimSmsStorageFull(V1_0::RadioIndicationType type) {
return mRealRadioIndication->cdmaRuimSmsStorageFull(type);
}
Return<void> RadioIndication::restrictedStateChanged(V1_0::RadioIndicationType type,
V1_0::PhoneRestrictedState state) {
return mRealRadioIndication->restrictedStateChanged(type, state);
}
Return<void> RadioIndication::enterEmergencyCallbackMode(V1_0::RadioIndicationType type) {
return mRealRadioIndication->enterEmergencyCallbackMode(type);
}
Return<void> RadioIndication::cdmaCallWaiting(V1_0::RadioIndicationType type,
const V1_0::CdmaCallWaiting& callWaitingRecord) {
return mRealRadioIndication->cdmaCallWaiting(type, callWaitingRecord);
}
Return<void> RadioIndication::cdmaOtaProvisionStatus(V1_0::RadioIndicationType type,
V1_0::CdmaOtaProvisionStatus status) {
return mRealRadioIndication->cdmaOtaProvisionStatus(type, status);
}
Return<void> RadioIndication::cdmaInfoRec(V1_0::RadioIndicationType type,
const V1_0::CdmaInformationRecords& records) {
return mRealRadioIndication->cdmaInfoRec(type, records);
}
Return<void> RadioIndication::indicateRingbackTone(V1_0::RadioIndicationType type, bool start) {
return mRealRadioIndication->indicateRingbackTone(type, start);
}
Return<void> RadioIndication::resendIncallMute(V1_0::RadioIndicationType type) {
return mRealRadioIndication->resendIncallMute(type);
}
Return<void> RadioIndication::cdmaSubscriptionSourceChanged(
V1_0::RadioIndicationType type, V1_0::CdmaSubscriptionSource cdmaSource) {
return mRealRadioIndication->cdmaSubscriptionSourceChanged(type, cdmaSource);
}
Return<void> RadioIndication::cdmaPrlChanged(V1_0::RadioIndicationType type, int32_t version) {
return mRealRadioIndication->cdmaPrlChanged(type, version);
}
Return<void> RadioIndication::exitEmergencyCallbackMode(V1_0::RadioIndicationType type) {
return mRealRadioIndication->exitEmergencyCallbackMode(type);
}
Return<void> RadioIndication::rilConnected(V1_0::RadioIndicationType type) {
return mRealRadioIndication->rilConnected(type);
}
Return<void> RadioIndication::voiceRadioTechChanged(V1_0::RadioIndicationType type,
V1_0::RadioTechnology rat) {
return mRealRadioIndication->voiceRadioTechChanged(type, rat);
}
Return<void> RadioIndication::cellInfoList(V1_0::RadioIndicationType type,
const hidl_vec<V1_0::CellInfo>& records) {
return mRealRadioIndication->cellInfoList_1_4(type, Create1_4CellInfoList(records));
}
Return<void> RadioIndication::imsNetworkStateChanged(V1_0::RadioIndicationType type) {
return mRealRadioIndication->imsNetworkStateChanged(type);
}
Return<void> RadioIndication::subscriptionStatusChanged(V1_0::RadioIndicationType type,
bool activate) {
return mRealRadioIndication->subscriptionStatusChanged(type, activate);
}
Return<void> RadioIndication::srvccStateNotify(V1_0::RadioIndicationType type,
V1_0::SrvccState state) {
return mRealRadioIndication->srvccStateNotify(type, state);
}
Return<void> RadioIndication::hardwareConfigChanged(V1_0::RadioIndicationType type,
const hidl_vec<V1_0::HardwareConfig>& configs) {
return mRealRadioIndication->hardwareConfigChanged(type, configs);
}
Return<void> RadioIndication::radioCapabilityIndication(V1_0::RadioIndicationType type,
const V1_0::RadioCapability& rc) {
return mRealRadioIndication->radioCapabilityIndication(type, rc);
}
Return<void> RadioIndication::onSupplementaryServiceIndication(V1_0::RadioIndicationType type,
const V1_0::StkCcUnsolSsResult& ss) {
return mRealRadioIndication->onSupplementaryServiceIndication(type, ss);
}
Return<void> RadioIndication::stkCallControlAlphaNotify(V1_0::RadioIndicationType type,
const hidl_string& alpha) {
return mRealRadioIndication->stkCallControlAlphaNotify(type, alpha);
}
Return<void> RadioIndication::lceData(V1_0::RadioIndicationType type,
const V1_0::LceDataInfo& lce) {
return mRealRadioIndication->lceData(type, lce);
}
Return<void> RadioIndication::pcoData(V1_0::RadioIndicationType type,
const V1_0::PcoDataInfo& pco) {
return mRealRadioIndication->pcoData(type, pco);
}
Return<void> RadioIndication::modemReset(V1_0::RadioIndicationType type,
const hidl_string& reason) {
return mRealRadioIndication->modemReset(type, reason);
}
// Methods from ::android::hardware::radio::V1_1::IRadioIndication follow.
Return<void> RadioIndication::carrierInfoForImsiEncryption(V1_0::RadioIndicationType info) {
return mRealRadioIndication->carrierInfoForImsiEncryption(info);
}
Return<void> RadioIndication::networkScanResult(V1_0::RadioIndicationType type,
const V1_1::NetworkScanResult& result) {
V1_4::NetworkScanResult newNSR = {};
newNSR.status = result.status;
newNSR.error = result.error;
newNSR.networkInfos = Create1_4CellInfoList(result.networkInfos);
return mRealRadioIndication->networkScanResult_1_4(type, newNSR);
}
Return<void> RadioIndication::keepaliveStatus(V1_0::RadioIndicationType type,
const V1_1::KeepaliveStatus& status) {
return mRealRadioIndication->keepaliveStatus(type, status);
}
// Methods from ::android::hardware::radio::V1_2::IRadioIndication follow.
Return<void> RadioIndication::networkScanResult_1_2(V1_0::RadioIndicationType type,
const V1_2::NetworkScanResult& result) {
V1_4::NetworkScanResult newNSR = {};
newNSR.status = result.status;
newNSR.error = result.error;
newNSR.networkInfos = Create1_4CellInfoList(result.networkInfos);
return mRealRadioIndication->networkScanResult_1_4(type, newNSR);
}
Return<void> RadioIndication::cellInfoList_1_2(V1_0::RadioIndicationType type,
const hidl_vec<V1_2::CellInfo>& records) {
return mRealRadioIndication->cellInfoList_1_4(type, Create1_4CellInfoList(records));
}
Return<void> RadioIndication::currentLinkCapacityEstimate(V1_0::RadioIndicationType type,
const V1_2::LinkCapacityEstimate& lce) {
return mRealRadioIndication->currentLinkCapacityEstimate(type, lce);
}
Return<void> RadioIndication::currentPhysicalChannelConfigs(
V1_0::RadioIndicationType type, const hidl_vec<V1_2::PhysicalChannelConfig>& configs) {
hidl_vec<V1_4::PhysicalChannelConfig> newConfigs;
newConfigs.resize(configs.size());
for(int x = 0; x < configs.size(); ++x){
newConfigs[x].base = configs[x];
newConfigs[x].rat = V1_4::RadioTechnology::UNKNOWN;
newConfigs[x].physicalCellId = -1;
}
return mRealRadioIndication->currentPhysicalChannelConfigs_1_4(type, newConfigs);
}
Return<void> RadioIndication::currentSignalStrength_1_2(
V1_0::RadioIndicationType type, const V1_2::SignalStrength& signalStrength) {
return mRealRadioIndication->currentSignalStrength_1_4(type, Create1_4SignalStrength(signalStrength));
}
// Methods from ::android::hardware::radio::V1_4::IRadioIndication follow.
Return<void> RadioIndication::currentEmergencyNumberList(
V1_0::RadioIndicationType type,
const hidl_vec<V1_4::EmergencyNumber>& emergencyNumberList) {
return mRealRadioIndication->currentEmergencyNumberList(type, emergencyNumberList);
}
Return<void> RadioIndication::cellInfoList_1_4(V1_0::RadioIndicationType type,
const hidl_vec<V1_4::CellInfo>& records) {
return mRealRadioIndication->cellInfoList_1_4(type, records);
}
Return<void> RadioIndication::networkScanResult_1_4(V1_0::RadioIndicationType type,
const V1_4::NetworkScanResult& result) {
return mRealRadioIndication->networkScanResult_1_4(type, result);
}
Return<void> RadioIndication::currentPhysicalChannelConfigs_1_4(
V1_0::RadioIndicationType type, const hidl_vec<V1_4::PhysicalChannelConfig>& configs) {
return mRealRadioIndication->currentPhysicalChannelConfigs_1_4(type, configs);
}
Return<void> RadioIndication::dataCallListChanged_1_4(
V1_0::RadioIndicationType type, const hidl_vec<V1_4::SetupDataCallResult>& dcList) {
return mRealRadioIndication->dataCallListChanged_1_4(type, dcList);
}
Return<void> RadioIndication::currentSignalStrength_1_4(
V1_0::RadioIndicationType type, const V1_4::SignalStrength& signalStrength) {
return mRealRadioIndication->currentSignalStrength_1_4(type, signalStrength);
}
} // namespace android::hardware::radio::implementation

133
radio/1.4/legacy/RadioIndication.h Normal file
View file

@ -0,0 +1,133 @@
/*
* Copyright (C) 2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <android/hardware/radio/1.4/IRadioIndication.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
namespace android::hardware::radio::implementation {
using ::android::sp;
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
struct RadioIndication : public V1_4::IRadioIndication {
sp<V1_4::IRadioIndication> mRealRadioIndication;
// Methods from ::android::hardware::radio::V1_0::IRadioIndication follow.
Return<void> radioStateChanged(V1_0::RadioIndicationType type,
V1_0::RadioState radioState) override;
Return<void> callStateChanged(V1_0::RadioIndicationType type) override;
Return<void> networkStateChanged(V1_0::RadioIndicationType type) override;
Return<void> newSms(V1_0::RadioIndicationType type, const hidl_vec<uint8_t>& pdu) override;
Return<void> newSmsStatusReport(V1_0::RadioIndicationType type,
const hidl_vec<uint8_t>& pdu) override;
Return<void> newSmsOnSim(V1_0::RadioIndicationType type, int32_t recordNumber) override;
Return<void> onUssd(V1_0::RadioIndicationType type, V1_0::UssdModeType modeType,
const hidl_string& msg) override;
Return<void> nitzTimeReceived(V1_0::RadioIndicationType type, const hidl_string& nitzTime,
uint64_t receivedTime) override;
Return<void> currentSignalStrength(V1_0::RadioIndicationType type,
const V1_0::SignalStrength& signalStrength) override;
Return<void> dataCallListChanged(V1_0::RadioIndicationType type,
const hidl_vec<V1_0::SetupDataCallResult>& dcList) override;
Return<void> suppSvcNotify(V1_0::RadioIndicationType type,
const V1_0::SuppSvcNotification& suppSvc) override;
Return<void> stkSessionEnd(V1_0::RadioIndicationType type) override;
Return<void> stkProactiveCommand(V1_0::RadioIndicationType type,
const hidl_string& cmd) override;
Return<void> stkEventNotify(V1_0::RadioIndicationType type, const hidl_string& cmd) override;
Return<void> stkCallSetup(V1_0::RadioIndicationType type, int64_t timeout) override;
Return<void> simSmsStorageFull(V1_0::RadioIndicationType type) override;
Return<void> simRefresh(V1_0::RadioIndicationType type,
const V1_0::SimRefreshResult& refreshResult) override;
Return<void> callRing(V1_0::RadioIndicationType type, bool isGsm,
const V1_0::CdmaSignalInfoRecord& record) override;
Return<void> simStatusChanged(V1_0::RadioIndicationType type) override;
Return<void> cdmaNewSms(V1_0::RadioIndicationType type,
const V1_0::CdmaSmsMessage& msg) override;
Return<void> newBroadcastSms(V1_0::RadioIndicationType type,
const hidl_vec<uint8_t>& data) override;
Return<void> cdmaRuimSmsStorageFull(V1_0::RadioIndicationType type) override;
Return<void> restrictedStateChanged(V1_0::RadioIndicationType type,
V1_0::PhoneRestrictedState state) override;
Return<void> enterEmergencyCallbackMode(V1_0::RadioIndicationType type) override;
Return<void> cdmaCallWaiting(V1_0::RadioIndicationType type,
const V1_0::CdmaCallWaiting& callWaitingRecord) override;
Return<void> cdmaOtaProvisionStatus(V1_0::RadioIndicationType type,
V1_0::CdmaOtaProvisionStatus status) override;
Return<void> cdmaInfoRec(V1_0::RadioIndicationType type,
const V1_0::CdmaInformationRecords& records) override;
Return<void> indicateRingbackTone(V1_0::RadioIndicationType type, bool start) override;
Return<void> resendIncallMute(V1_0::RadioIndicationType type) override;
Return<void> cdmaSubscriptionSourceChanged(V1_0::RadioIndicationType type,
V1_0::CdmaSubscriptionSource cdmaSource) override;
Return<void> cdmaPrlChanged(V1_0::RadioIndicationType type, int32_t version) override;
Return<void> exitEmergencyCallbackMode(V1_0::RadioIndicationType type) override;
Return<void> rilConnected(V1_0::RadioIndicationType type) override;
Return<void> voiceRadioTechChanged(V1_0::RadioIndicationType type,
V1_0::RadioTechnology rat) override;
Return<void> cellInfoList(V1_0::RadioIndicationType type,
const hidl_vec<V1_0::CellInfo>& records) override;
Return<void> imsNetworkStateChanged(V1_0::RadioIndicationType type) override;
Return<void> subscriptionStatusChanged(V1_0::RadioIndicationType type, bool activate) override;
Return<void> srvccStateNotify(V1_0::RadioIndicationType type, V1_0::SrvccState state) override;
Return<void> hardwareConfigChanged(V1_0::RadioIndicationType type,
const hidl_vec<V1_0::HardwareConfig>& configs) override;
Return<void> radioCapabilityIndication(V1_0::RadioIndicationType type,
const V1_0::RadioCapability& rc) override;
Return<void> onSupplementaryServiceIndication(V1_0::RadioIndicationType type,
const V1_0::StkCcUnsolSsResult& ss) override;
Return<void> stkCallControlAlphaNotify(V1_0::RadioIndicationType type,
const hidl_string& alpha) override;
Return<void> lceData(V1_0::RadioIndicationType type, const V1_0::LceDataInfo& lce) override;
Return<void> pcoData(V1_0::RadioIndicationType type, const V1_0::PcoDataInfo& pco) override;
Return<void> modemReset(V1_0::RadioIndicationType type, const hidl_string& reason) override;
// Methods from ::android::hardware::radio::V1_1::IRadioIndication follow.
Return<void> carrierInfoForImsiEncryption(V1_0::RadioIndicationType info) override;
Return<void> networkScanResult(V1_0::RadioIndicationType type,
const V1_1::NetworkScanResult& result) override;
Return<void> keepaliveStatus(V1_0::RadioIndicationType type,
const V1_1::KeepaliveStatus& status) override;
// Methods from ::android::hardware::radio::V1_2::IRadioIndication follow.
Return<void> networkScanResult_1_2(V1_0::RadioIndicationType type,
const V1_2::NetworkScanResult& result) override;
Return<void> cellInfoList_1_2(V1_0::RadioIndicationType type,
const hidl_vec<V1_2::CellInfo>& records) override;
Return<void> currentLinkCapacityEstimate(V1_0::RadioIndicationType type,
const V1_2::LinkCapacityEstimate& lce) override;
Return<void> currentPhysicalChannelConfigs(
V1_0::RadioIndicationType type,
const hidl_vec<V1_2::PhysicalChannelConfig>& configs) override;
Return<void> currentSignalStrength_1_2(V1_0::RadioIndicationType type,
const V1_2::SignalStrength& signalStrength) override;
// Methods from ::android::hardware::radio::V1_4::IRadioIndication follow.
Return<void> currentEmergencyNumberList(
V1_0::RadioIndicationType type,
const hidl_vec<V1_4::EmergencyNumber>& emergencyNumberList) override;
Return<void> cellInfoList_1_4(V1_0::RadioIndicationType type,
const hidl_vec<V1_4::CellInfo>& records) override;
Return<void> networkScanResult_1_4(V1_0::RadioIndicationType type,
const V1_4::NetworkScanResult& result) override;
Return<void> currentPhysicalChannelConfigs_1_4(
V1_0::RadioIndicationType type,
const hidl_vec<V1_4::PhysicalChannelConfig>& configs) override;
Return<void> dataCallListChanged_1_4(
V1_0::RadioIndicationType type,
const hidl_vec<V1_4::SetupDataCallResult>& dcList) override;
Return<void> currentSignalStrength_1_4(V1_0::RadioIndicationType type,
const V1_4::SignalStrength& signalStrength) override;
};
} // namespace android::hardware::radio::implementation

906
radio/1.4/legacy/RadioResponse.cpp Normal file
View file

@ -0,0 +1,906 @@
/*
* Copyright (C) 2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "RadioResponse.h"
#include "Helpers.h"
#include<string>
namespace android::hardware::radio::implementation {
// Methods from ::android::hardware::radio::V1_0::IRadioResponse follow.
Return<void> RadioResponse::getIccCardStatusResponse(const V1_0::RadioResponseInfo& info,
const V1_0::CardStatus& cardStatus) {
V1_4::CardStatus newCS = {};
newCS.base.base = cardStatus;
newCS.base.physicalSlotId = -1;
newCS.base.iccid = hidl_string(" ");
return mRealRadioResponse->getIccCardStatusResponse_1_4(info, newCS);
}
Return<void> RadioResponse::supplyIccPinForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t remainingRetries) {
return mRealRadioResponse->supplyIccPinForAppResponse(info, remainingRetries);
}
Return<void> RadioResponse::supplyIccPukForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t remainingRetries) {
return mRealRadioResponse->supplyIccPukForAppResponse(info, remainingRetries);
}
Return<void> RadioResponse::supplyIccPin2ForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t remainingRetries) {
return mRealRadioResponse->supplyIccPin2ForAppResponse(info, remainingRetries);
}
Return<void> RadioResponse::supplyIccPuk2ForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t remainingRetries) {
return mRealRadioResponse->supplyIccPuk2ForAppResponse(info, remainingRetries);
}
Return<void> RadioResponse::changeIccPinForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t remainingRetries) {
return mRealRadioResponse->changeIccPinForAppResponse(info, remainingRetries);
}
Return<void> RadioResponse::changeIccPin2ForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t remainingRetries) {
return mRealRadioResponse->changeIccPin2ForAppResponse(info, remainingRetries);
}
Return<void> RadioResponse::supplyNetworkDepersonalizationResponse(
const V1_0::RadioResponseInfo& info, int32_t remainingRetries) {
return mRealRadioResponse->supplyNetworkDepersonalizationResponse(info, remainingRetries);
}
Return<void> RadioResponse::getCurrentCallsResponse(const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::Call>& calls) {
hidl_vec<V1_2::Call> newCalls;
newCalls.resize(calls.size());
for(int x = 0; x < calls.size(); ++x){
newCalls[x].base = calls[x];
newCalls[x].audioQuality = V1_2::AudioQuality::UNSPECIFIED;
}
return mRealRadioResponse->getCurrentCallsResponse_1_2(info, newCalls);
}
Return<void> RadioResponse::dialResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->dialResponse(info);
}
Return<void> RadioResponse::getIMSIForAppResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& imsi) {
return mRealRadioResponse->getIMSIForAppResponse(info, imsi);
}
Return<void> RadioResponse::hangupConnectionResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->hangupConnectionResponse(info);
}
Return<void> RadioResponse::hangupWaitingOrBackgroundResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->hangupWaitingOrBackgroundResponse(info);
}
Return<void> RadioResponse::hangupForegroundResumeBackgroundResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->hangupForegroundResumeBackgroundResponse(info);
}
Return<void> RadioResponse::switchWaitingOrHoldingAndActiveResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->switchWaitingOrHoldingAndActiveResponse(info);
}
Return<void> RadioResponse::conferenceResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->conferenceResponse(info);
}
Return<void> RadioResponse::rejectCallResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->rejectCallResponse(info);
}
Return<void> RadioResponse::getLastCallFailCauseResponse(
const V1_0::RadioResponseInfo& info, const V1_0::LastCallFailCauseInfo& failCauseinfo) {
return mRealRadioResponse->getLastCallFailCauseResponse(info, failCauseinfo);
}
Return<void> RadioResponse::getSignalStrengthResponse(const V1_0::RadioResponseInfo& info,
const V1_0::SignalStrength& sigStrength) {
return mRealRadioResponse->getSignalStrengthResponse_1_4(info, Create1_4SignalStrength(sigStrength));
}
void Init1_2CellIdentity(const V1_0::CellIdentity& legacyCI, V1_2::CellIdentity& newCI) {
if(legacyCI.cellIdentityGsm.size() == 1){
newCI.cellIdentityGsm.resize(1);
newCI.cellIdentityGsm[0].base = legacyCI.cellIdentityGsm[0];
}
else if(legacyCI.cellIdentityCdma.size() == 1){
newCI.cellIdentityCdma.resize(1);
newCI.cellIdentityCdma[0].base = legacyCI.cellIdentityCdma[0];
}
else if(legacyCI.cellIdentityLte.size() == 1){
newCI.cellIdentityLte.resize(1);
newCI.cellIdentityLte[0].base = legacyCI.cellIdentityLte[0];
newCI.cellIdentityLte[0].bandwidth = INT_MAX;
}
else if(legacyCI.cellIdentityWcdma.size() == 1){
newCI.cellIdentityWcdma.resize(1);
newCI.cellIdentityWcdma[0].base = legacyCI.cellIdentityWcdma[0];
}
else if(legacyCI.cellIdentityTdscdma.size() == 1){
newCI.cellIdentityTdscdma.resize(1);
newCI.cellIdentityTdscdma[0].base = legacyCI.cellIdentityTdscdma[0];
newCI.cellIdentityTdscdma[0].uarfcn = INT_MAX;
}
}
Return<void> RadioResponse::getVoiceRegistrationStateResponse(
const V1_0::RadioResponseInfo& info, const V1_0::VoiceRegStateResult& voiceRegResponse) {
V1_2::VoiceRegStateResult newVRR = {};
newVRR.regState = voiceRegResponse.regState;
newVRR.rat = voiceRegResponse.rat;
newVRR.cssSupported = voiceRegResponse.cssSupported;
newVRR.roamingIndicator = voiceRegResponse.roamingIndicator;
newVRR.systemIsInPrl = voiceRegResponse.systemIsInPrl;
newVRR.defaultRoamingIndicator = voiceRegResponse.defaultRoamingIndicator;
newVRR.reasonForDenial = voiceRegResponse.reasonForDenial;
Init1_2CellIdentity(voiceRegResponse.cellIdentity, newVRR.cellIdentity);
return mRealRadioResponse->getVoiceRegistrationStateResponse_1_2(info, newVRR);
}
Return<void> RadioResponse::getDataRegistrationStateResponse(
const V1_0::RadioResponseInfo& info, const V1_0::DataRegStateResult& dataRegResponse) {
mDataRoaming = (dataRegResponse.regState == V1_0::RegState::REG_ROAMING);
mRat = (V1_0::RadioTechnology) dataRegResponse.rat;
V1_4::DataRegStateResult newDRR = {};
newDRR.base.regState = dataRegResponse.regState;
newDRR.base.rat = dataRegResponse.rat;
newDRR.base.reasonDataDenied = dataRegResponse.reasonDataDenied;
newDRR.base.maxDataCalls = dataRegResponse.maxDataCalls;
Init1_2CellIdentity(dataRegResponse.cellIdentity, newDRR.base.cellIdentity);
return mRealRadioResponse->getDataRegistrationStateResponse_1_4(info, newDRR);
}
Return<void> RadioResponse::getOperatorResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& longName,
const hidl_string& shortName,
const hidl_string& numeric) {
return mRealRadioResponse->getOperatorResponse(info, longName, shortName, numeric);
}
Return<void> RadioResponse::setRadioPowerResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setRadioPowerResponse(info);
}
Return<void> RadioResponse::sendDtmfResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->sendDtmfResponse(info);
}
Return<void> RadioResponse::sendSmsResponse(const V1_0::RadioResponseInfo& info,
const V1_0::SendSmsResult& sms) {
return mRealRadioResponse->sendSmsResponse(info, sms);
}
Return<void> RadioResponse::sendSMSExpectMoreResponse(const V1_0::RadioResponseInfo& info,
const V1_0::SendSmsResult& sms) {
return mRealRadioResponse->sendSMSExpectMoreResponse(info, sms);
}
Return<void> RadioResponse::setupDataCallResponse(const V1_0::RadioResponseInfo& info,
const V1_0::SetupDataCallResult& dcResponse) {
return mRealRadioResponse->setupDataCallResponse_1_4(info, Create1_4SetupDataCallResult(dcResponse));
}
Return<void> RadioResponse::iccIOForAppResponse(const V1_0::RadioResponseInfo& info,
const V1_0::IccIoResult& iccIo) {
return mRealRadioResponse->iccIOForAppResponse(info, iccIo);
}
Return<void> RadioResponse::sendUssdResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->sendUssdResponse(info);
}
Return<void> RadioResponse::cancelPendingUssdResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->cancelPendingUssdResponse(info);
}
Return<void> RadioResponse::getClirResponse(const V1_0::RadioResponseInfo& info, int32_t n,
int32_t m) {
return mRealRadioResponse->getClirResponse(info, n, m);
}
Return<void> RadioResponse::setClirResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setClirResponse(info);
}
Return<void> RadioResponse::getCallForwardStatusResponse(
const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::CallForwardInfo>& callForwardInfos) {
return mRealRadioResponse->getCallForwardStatusResponse(info, callForwardInfos);
}
Return<void> RadioResponse::setCallForwardResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setCallForwardResponse(info);
}
Return<void> RadioResponse::getCallWaitingResponse(const V1_0::RadioResponseInfo& info, bool enable,
int32_t serviceClass) {
return mRealRadioResponse->getCallWaitingResponse(info, enable, serviceClass);
}
Return<void> RadioResponse::setCallWaitingResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setCallWaitingResponse(info);
}
Return<void> RadioResponse::acknowledgeLastIncomingGsmSmsResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->acknowledgeLastIncomingGsmSmsResponse(info);
}
Return<void> RadioResponse::acceptCallResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->acceptCallResponse(info);
}
Return<void> RadioResponse::deactivateDataCallResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->deactivateDataCallResponse(info);
}
Return<void> RadioResponse::getFacilityLockForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t response) {
return mRealRadioResponse->getFacilityLockForAppResponse(info, response);
}
Return<void> RadioResponse::setFacilityLockForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t retry) {
return mRealRadioResponse->setFacilityLockForAppResponse(info, retry);
}
Return<void> RadioResponse::setBarringPasswordResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setBarringPasswordResponse(info);
}
Return<void> RadioResponse::getNetworkSelectionModeResponse(const V1_0::RadioResponseInfo& info,
bool manual) {
return mRealRadioResponse->getNetworkSelectionModeResponse(info, manual);
}
Return<void> RadioResponse::setNetworkSelectionModeAutomaticResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setNetworkSelectionModeAutomaticResponse(info);
}
Return<void> RadioResponse::setNetworkSelectionModeManualResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setNetworkSelectionModeManualResponse(info);
}
Return<void> RadioResponse::getAvailableNetworksResponse(
const V1_0::RadioResponseInfo& info, const hidl_vec<V1_0::OperatorInfo>& networkInfos) {
return mRealRadioResponse->getAvailableNetworksResponse(info, networkInfos);
}
Return<void> RadioResponse::startDtmfResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->startDtmfResponse(info);
}
Return<void> RadioResponse::stopDtmfResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->stopDtmfResponse(info);
}
Return<void> RadioResponse::getBasebandVersionResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& version) {
return mRealRadioResponse->getBasebandVersionResponse(info, version);
}
Return<void> RadioResponse::separateConnectionResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->separateConnectionResponse(info);
}
Return<void> RadioResponse::setMuteResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setMuteResponse(info);
}
Return<void> RadioResponse::getMuteResponse(const V1_0::RadioResponseInfo& info, bool enable) {
return mRealRadioResponse->getMuteResponse(info, enable);
}
Return<void> RadioResponse::getClipResponse(const V1_0::RadioResponseInfo& info,
V1_0::ClipStatus status) {
return mRealRadioResponse->getClipResponse(info, status);
}
Return<void> RadioResponse::getDataCallListResponse(
const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::SetupDataCallResult>& dcResponse) {
hidl_vec<V1_4::SetupDataCallResult> newResponse;
newResponse.resize(dcResponse.size());
for(int x = 0; x < dcResponse.size(); ++x)
newResponse[x] = Create1_4SetupDataCallResult(dcResponse[x]);
return mRealRadioResponse->getDataCallListResponse_1_4(info, newResponse);
}
Return<void> RadioResponse::setSuppServiceNotificationsResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setSuppServiceNotificationsResponse(info);
}
Return<void> RadioResponse::writeSmsToSimResponse(const V1_0::RadioResponseInfo& info,
int32_t index) {
return mRealRadioResponse->writeSmsToSimResponse(info, index);
}
Return<void> RadioResponse::deleteSmsOnSimResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->deleteSmsOnSimResponse(info);
}
Return<void> RadioResponse::setBandModeResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setBandModeResponse(info);
}
Return<void> RadioResponse::getAvailableBandModesResponse(
const V1_0::RadioResponseInfo& info, const hidl_vec<V1_0::RadioBandMode>& bandModes) {
return mRealRadioResponse->getAvailableBandModesResponse(info, bandModes);
}
Return<void> RadioResponse::sendEnvelopeResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& commandResponse) {
return mRealRadioResponse->sendEnvelopeResponse(info, commandResponse);
}
Return<void> RadioResponse::sendTerminalResponseToSimResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->sendTerminalResponseToSimResponse(info);
}
Return<void> RadioResponse::handleStkCallSetupRequestFromSimResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->handleStkCallSetupRequestFromSimResponse(info);
}
Return<void> RadioResponse::explicitCallTransferResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->explicitCallTransferResponse(info);
}
Return<void> RadioResponse::setPreferredNetworkTypeResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setPreferredNetworkTypeBitmapResponse(info);
}
Return<void> RadioResponse::getPreferredNetworkTypeResponse(const V1_0::RadioResponseInfo& info,
V1_0::PreferredNetworkType nwType) {
hidl_bitfield<V1_4::RadioAccessFamily> nwTypeBitmap = 0;
switch(nwType){
case V1_0::PreferredNetworkType::GSM_WCDMA:
case V1_0::PreferredNetworkType::GSM_WCDMA_AUTO:
nwTypeBitmap = GSMBITS | WCDMABITS;
break;
case V1_0::PreferredNetworkType::GSM_ONLY:
nwTypeBitmap = GSMBITS;
break;
case V1_0::PreferredNetworkType::WCDMA:
nwTypeBitmap = WCDMABITS;
break;
case V1_0::PreferredNetworkType::CDMA_EVDO_AUTO:
nwTypeBitmap = CDMABITS | EVDOBITS;
break;
case V1_0::PreferredNetworkType::CDMA_ONLY:
nwTypeBitmap = CDMABITS;
break;
case V1_0::PreferredNetworkType::EVDO_ONLY:
nwTypeBitmap = EVDOBITS;
break;
case V1_0::PreferredNetworkType::GSM_WCDMA_CDMA_EVDO_AUTO:
nwTypeBitmap = GSMBITS | WCDMABITS | CDMABITS | EVDOBITS;
break;
case V1_0::PreferredNetworkType::LTE_CDMA_EVDO:
nwTypeBitmap = LTEBITS | CDMABITS | EVDOBITS;
break;
case V1_0::PreferredNetworkType::LTE_GSM_WCDMA:
nwTypeBitmap = LTEBITS | GSMBITS | WCDMABITS;
break;
case V1_0::PreferredNetworkType::LTE_CMDA_EVDO_GSM_WCDMA:
nwTypeBitmap = LTEBITS | CDMABITS | EVDOBITS | GSMBITS | WCDMABITS;
break;
case V1_0::PreferredNetworkType::LTE_ONLY:
nwTypeBitmap = LTEBITS;
break;
case V1_0::PreferredNetworkType::LTE_WCDMA:
nwTypeBitmap = LTEBITS | WCDMABITS;
break;
case V1_0::PreferredNetworkType::TD_SCDMA_ONLY:
nwTypeBitmap = TDSCDMABIT;
break;
case V1_0::PreferredNetworkType::TD_SCDMA_WCDMA:
nwTypeBitmap = TDSCDMABIT | WCDMABITS;
break;
case V1_0::PreferredNetworkType::TD_SCDMA_LTE:
nwTypeBitmap = TDSCDMABIT | LTEBITS;
break;
case V1_0::PreferredNetworkType::TD_SCDMA_GSM:
nwTypeBitmap = TDSCDMABIT | GSMBITS;
break;
case V1_0::PreferredNetworkType::TD_SCDMA_GSM_LTE:
nwTypeBitmap = TDSCDMABIT | GSMBITS | LTEBITS;
break;
case V1_0::PreferredNetworkType::TD_SCDMA_GSM_WCDMA:
nwTypeBitmap = TDSCDMABIT | GSMBITS | WCDMABITS;
break;
case V1_0::PreferredNetworkType::TD_SCDMA_WCDMA_LTE:
nwTypeBitmap = TDSCDMABIT | WCDMABITS | LTEBITS;
break;
case V1_0::PreferredNetworkType::TD_SCDMA_GSM_WCDMA_LTE:
nwTypeBitmap = TDSCDMABIT | GSMBITS | WCDMABITS | LTEBITS;
break;
case V1_0::PreferredNetworkType::TD_SCDMA_GSM_WCDMA_CDMA_EVDO_AUTO:
nwTypeBitmap = TDSCDMABIT | GSMBITS | WCDMABITS | CDMABITS | EVDOBITS;
break;
case V1_0::PreferredNetworkType::TD_SCDMA_LTE_CDMA_EVDO_GSM_WCDMA:
nwTypeBitmap = TDSCDMABIT | LTEBITS | CDMABITS | EVDOBITS | GSMBITS | WCDMABITS;
break;
}
return mRealRadioResponse->getPreferredNetworkTypeBitmapResponse(info, nwTypeBitmap);
}
Return<void> RadioResponse::getNeighboringCidsResponse(
const V1_0::RadioResponseInfo& info, const hidl_vec<V1_0::NeighboringCell>& cells) {
return mRealRadioResponse->getNeighboringCidsResponse(info, cells);
}
Return<void> RadioResponse::setLocationUpdatesResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setLocationUpdatesResponse(info);
}
Return<void> RadioResponse::setCdmaSubscriptionSourceResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setCdmaSubscriptionSourceResponse(info);
}
Return<void> RadioResponse::setCdmaRoamingPreferenceResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setCdmaRoamingPreferenceResponse(info);
}
Return<void> RadioResponse::getCdmaRoamingPreferenceResponse(const V1_0::RadioResponseInfo& info,
V1_0::CdmaRoamingType type) {
return mRealRadioResponse->getCdmaRoamingPreferenceResponse(info, type);
}
Return<void> RadioResponse::setTTYModeResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setTTYModeResponse(info);
}
Return<void> RadioResponse::getTTYModeResponse(const V1_0::RadioResponseInfo& info,
V1_0::TtyMode mode) {
return mRealRadioResponse->getTTYModeResponse(info, mode);
}
Return<void> RadioResponse::setPreferredVoicePrivacyResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setPreferredVoicePrivacyResponse(info);
}
Return<void> RadioResponse::getPreferredVoicePrivacyResponse(const V1_0::RadioResponseInfo& info,
bool enable) {
return mRealRadioResponse->getPreferredVoicePrivacyResponse(info, enable);
}
Return<void> RadioResponse::sendCDMAFeatureCodeResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->sendCDMAFeatureCodeResponse(info);
}
Return<void> RadioResponse::sendBurstDtmfResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->sendBurstDtmfResponse(info);
}
Return<void> RadioResponse::sendCdmaSmsResponse(const V1_0::RadioResponseInfo& info,
const V1_0::SendSmsResult& sms) {
return mRealRadioResponse->sendCdmaSmsResponse(info, sms);
}
Return<void> RadioResponse::acknowledgeLastIncomingCdmaSmsResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->acknowledgeLastIncomingCdmaSmsResponse(info);
}
Return<void> RadioResponse::getGsmBroadcastConfigResponse(
const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::GsmBroadcastSmsConfigInfo>& configs) {
return mRealRadioResponse->getGsmBroadcastConfigResponse(info, configs);
}
Return<void> RadioResponse::setGsmBroadcastConfigResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setGsmBroadcastConfigResponse(info);
}
Return<void> RadioResponse::setGsmBroadcastActivationResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setGsmBroadcastActivationResponse(info);
}
Return<void> RadioResponse::getCdmaBroadcastConfigResponse(
const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::CdmaBroadcastSmsConfigInfo>& configs) {
return mRealRadioResponse->getCdmaBroadcastConfigResponse(info, configs);
}
Return<void> RadioResponse::setCdmaBroadcastConfigResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setCdmaBroadcastConfigResponse(info);
}
Return<void> RadioResponse::setCdmaBroadcastActivationResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setCdmaBroadcastActivationResponse(info);
}
Return<void> RadioResponse::getCDMASubscriptionResponse(
const V1_0::RadioResponseInfo& info, const hidl_string& mdn, const hidl_string& hSid,
const hidl_string& hNid, const hidl_string& min, const hidl_string& prl) {
return mRealRadioResponse->getCDMASubscriptionResponse(info, mdn, hSid, hNid, min, prl);
}
Return<void> RadioResponse::writeSmsToRuimResponse(const V1_0::RadioResponseInfo& info,
uint32_t index) {
return mRealRadioResponse->writeSmsToRuimResponse(info, index);
}
Return<void> RadioResponse::deleteSmsOnRuimResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->deleteSmsOnRuimResponse(info);
}
Return<void> RadioResponse::getDeviceIdentityResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& imei,
const hidl_string& imeisv,
const hidl_string& esn,
const hidl_string& meid) {
return mRealRadioResponse->getDeviceIdentityResponse(info, imei, imeisv, esn, meid);
}
Return<void> RadioResponse::exitEmergencyCallbackModeResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->exitEmergencyCallbackModeResponse(info);
}
Return<void> RadioResponse::getSmscAddressResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& smsc) {
return mRealRadioResponse->getSmscAddressResponse(info, smsc);
}
Return<void> RadioResponse::setSmscAddressResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setSmscAddressResponse(info);
}
Return<void> RadioResponse::reportSmsMemoryStatusResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->reportSmsMemoryStatusResponse(info);
}
Return<void> RadioResponse::reportStkServiceIsRunningResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->reportStkServiceIsRunningResponse(info);
}
Return<void> RadioResponse::getCdmaSubscriptionSourceResponse(const V1_0::RadioResponseInfo& info,
V1_0::CdmaSubscriptionSource source) {
return mRealRadioResponse->getCdmaSubscriptionSourceResponse(info, source);
}
Return<void> RadioResponse::requestIsimAuthenticationResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& response) {
return mRealRadioResponse->requestIsimAuthenticationResponse(info, response);
}
Return<void> RadioResponse::acknowledgeIncomingGsmSmsWithPduResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->acknowledgeIncomingGsmSmsWithPduResponse(info);
}
Return<void> RadioResponse::sendEnvelopeWithStatusResponse(const V1_0::RadioResponseInfo& info,
const V1_0::IccIoResult& iccIo) {
return mRealRadioResponse->sendEnvelopeWithStatusResponse(info, iccIo);
}
Return<void> RadioResponse::getVoiceRadioTechnologyResponse(const V1_0::RadioResponseInfo& info,
V1_0::RadioTechnology rat) {
return mRealRadioResponse->getVoiceRadioTechnologyResponse(info, rat);
}
Return<void> RadioResponse::getCellInfoListResponse(const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::CellInfo>& cellInfo) {
return mRealRadioResponse->getCellInfoListResponse_1_4(info, Create1_4CellInfoList(cellInfo));
}
Return<void> RadioResponse::setCellInfoListRateResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setCellInfoListRateResponse(info);
}
Return<void> RadioResponse::setInitialAttachApnResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setInitialAttachApnResponse(info);
}
Return<void> RadioResponse::getImsRegistrationStateResponse(const V1_0::RadioResponseInfo& info,
bool isRegistered,
V1_0::RadioTechnologyFamily ratFamily) {
return mRealRadioResponse->getImsRegistrationStateResponse(info, isRegistered, ratFamily);
}
Return<void> RadioResponse::sendImsSmsResponse(const V1_0::RadioResponseInfo& info,
const V1_0::SendSmsResult& sms) {
return mRealRadioResponse->sendImsSmsResponse(info, sms);
}
Return<void> RadioResponse::iccTransmitApduBasicChannelResponse(const V1_0::RadioResponseInfo& info,
const V1_0::IccIoResult& result) {
return mRealRadioResponse->iccTransmitApduBasicChannelResponse(info, result);
}
Return<void> RadioResponse::iccOpenLogicalChannelResponse(const V1_0::RadioResponseInfo& info,
int32_t channelId,
const hidl_vec<int8_t>& selectResponse) {
return mRealRadioResponse->iccOpenLogicalChannelResponse(info, channelId, selectResponse);
}
Return<void> RadioResponse::iccCloseLogicalChannelResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->iccCloseLogicalChannelResponse(info);
}
Return<void> RadioResponse::iccTransmitApduLogicalChannelResponse(
const V1_0::RadioResponseInfo& info, const V1_0::IccIoResult& result) {
return mRealRadioResponse->iccTransmitApduLogicalChannelResponse(info, result);
}
Return<void> RadioResponse::nvReadItemResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& result) {
return mRealRadioResponse->nvReadItemResponse(info, result);
}
Return<void> RadioResponse::nvWriteItemResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->nvWriteItemResponse(info);
}
Return<void> RadioResponse::nvWriteCdmaPrlResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->nvWriteCdmaPrlResponse(info);
}
Return<void> RadioResponse::nvResetConfigResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->nvResetConfigResponse(info);
}
Return<void> RadioResponse::setUiccSubscriptionResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setUiccSubscriptionResponse(info);
}
Return<void> RadioResponse::setDataAllowedResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setDataAllowedResponse(info);
}
Return<void> RadioResponse::getHardwareConfigResponse(
const V1_0::RadioResponseInfo& info, const hidl_vec<V1_0::HardwareConfig>& config) {
return mRealRadioResponse->getHardwareConfigResponse(info, config);
}
Return<void> RadioResponse::requestIccSimAuthenticationResponse(const V1_0::RadioResponseInfo& info,
const V1_0::IccIoResult& result) {
return mRealRadioResponse->requestIccSimAuthenticationResponse(info, result);
}
Return<void> RadioResponse::setDataProfileResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setDataProfileResponse(info);
}
Return<void> RadioResponse::requestShutdownResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->requestShutdownResponse(info);
}
Return<void> RadioResponse::getRadioCapabilityResponse(const V1_0::RadioResponseInfo& info,
const V1_0::RadioCapability& rc) {
return mRealRadioResponse->getRadioCapabilityResponse(info, rc);
}
Return<void> RadioResponse::setRadioCapabilityResponse(const V1_0::RadioResponseInfo& info,
const V1_0::RadioCapability& rc) {
return mRealRadioResponse->setRadioCapabilityResponse(info, rc);
}
Return<void> RadioResponse::startLceServiceResponse(const V1_0::RadioResponseInfo& info,
const V1_0::LceStatusInfo& statusInfo) {
return mRealRadioResponse->startLceServiceResponse(info, statusInfo);
}
Return<void> RadioResponse::stopLceServiceResponse(const V1_0::RadioResponseInfo& info,
const V1_0::LceStatusInfo& statusInfo) {
return mRealRadioResponse->stopLceServiceResponse(info, statusInfo);
}
Return<void> RadioResponse::pullLceDataResponse(const V1_0::RadioResponseInfo& info,
const V1_0::LceDataInfo& lceInfo) {
return mRealRadioResponse->pullLceDataResponse(info, lceInfo);
}
Return<void> RadioResponse::getModemActivityInfoResponse(
const V1_0::RadioResponseInfo& info, const V1_0::ActivityStatsInfo& activityInfo) {
return mRealRadioResponse->getModemActivityInfoResponse(info, activityInfo);
}
Return<void> RadioResponse::setAllowedCarriersResponse(const V1_0::RadioResponseInfo& info,
int32_t /* numAllowed */) {
return mRealRadioResponse->setAllowedCarriersResponse_1_4(info);
}
Return<void> RadioResponse::getAllowedCarriersResponse(const V1_0::RadioResponseInfo& info,
bool allAllowed,
const V1_0::CarrierRestrictions& carriers) {
V1_4::CarrierRestrictionsWithPriority newCarriers = {};
if(allAllowed){
newCarriers.allowedCarriersPrioritized = false;
return mRealRadioResponse->getAllowedCarriersResponse_1_4(info, newCarriers, V1_4::SimLockMultiSimPolicy::NO_MULTISIM_POLICY);
}
newCarriers.allowedCarriers = carriers.allowedCarriers;
newCarriers.excludedCarriers = carriers.excludedCarriers;
newCarriers.allowedCarriersPrioritized = true;
return mRealRadioResponse->getAllowedCarriersResponse_1_4(info, newCarriers, V1_4::SimLockMultiSimPolicy::NO_MULTISIM_POLICY);
}
Return<void> RadioResponse::sendDeviceStateResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->sendDeviceStateResponse(info);
}
Return<void> RadioResponse::setIndicationFilterResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setIndicationFilterResponse(info);
}
Return<void> RadioResponse::setSimCardPowerResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setSimCardPowerResponse_1_1(info);
}
Return<void> RadioResponse::acknowledgeRequest(int32_t serial) {
return mRealRadioResponse->acknowledgeRequest(serial);
}
// Methods from ::android::hardware::radio::V1_1::IRadioResponse follow.
Return<void> RadioResponse::setCarrierInfoForImsiEncryptionResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setCarrierInfoForImsiEncryptionResponse(info);
}
Return<void> RadioResponse::setSimCardPowerResponse_1_1(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setSimCardPowerResponse_1_1(info);
}
Return<void> RadioResponse::startNetworkScanResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->startNetworkScanResponse_1_4(info);
}
Return<void> RadioResponse::stopNetworkScanResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->stopNetworkScanResponse(info);
}
Return<void> RadioResponse::startKeepaliveResponse(const V1_0::RadioResponseInfo& info,
const V1_1::KeepaliveStatus& status) {
return mRealRadioResponse->startKeepaliveResponse(info, status);
}
Return<void> RadioResponse::stopKeepaliveResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->stopKeepaliveResponse(info);
}
// Methods from ::android::hardware::radio::V1_2::IRadioResponse follow.
Return<void> RadioResponse::getCellInfoListResponse_1_2(const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_2::CellInfo>& cellInfo) {
return mRealRadioResponse->getCellInfoListResponse_1_4(info, Create1_4CellInfoList(cellInfo));
}
Return<void> RadioResponse::getIccCardStatusResponse_1_2(const V1_0::RadioResponseInfo& info,
const V1_2::CardStatus& cardStatus) {
return mRealRadioResponse->getIccCardStatusResponse_1_4(info, {cardStatus, hidl_string("")});
}
Return<void> RadioResponse::setSignalStrengthReportingCriteriaResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setSignalStrengthReportingCriteriaResponse(info);
}
Return<void> RadioResponse::setLinkCapacityReportingCriteriaResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setLinkCapacityReportingCriteriaResponse(info);
}
Return<void> RadioResponse::getCurrentCallsResponse_1_2(const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_2::Call>& calls) {
return mRealRadioResponse->getCurrentCallsResponse_1_2(info, calls);
}
Return<void> RadioResponse::getSignalStrengthResponse_1_2(
const V1_0::RadioResponseInfo& info, const V1_2::SignalStrength& signalStrength) {
return mRealRadioResponse->getSignalStrengthResponse_1_4(info, Create1_4SignalStrength(signalStrength));
}
Return<void> RadioResponse::getVoiceRegistrationStateResponse_1_2(
const V1_0::RadioResponseInfo& info, const V1_2::VoiceRegStateResult& voiceRegResponse) {
return mRealRadioResponse->getVoiceRegistrationStateResponse_1_2(info, voiceRegResponse);
}
Return<void> RadioResponse::getDataRegistrationStateResponse_1_2(
const V1_0::RadioResponseInfo& info, const V1_2::DataRegStateResult& dataRegResponse) {
mDataRoaming = (dataRegResponse.regState == V1_0::RegState::REG_ROAMING);
V1_4::DataRegStateResult newDRR = {};
newDRR.base = dataRegResponse;
return mRealRadioResponse->getDataRegistrationStateResponse_1_4(info, newDRR);
}
// Methods from ::android::hardware::radio::V1_3::IRadioResponse follow.
Return<void> RadioResponse::setSystemSelectionChannelsResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setSystemSelectionChannelsResponse(info);
}
Return<void> RadioResponse::enableModemResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->enableModemResponse(info);
}
Return<void> RadioResponse::getModemStackStatusResponse(const V1_0::RadioResponseInfo& info,
bool isEnabled) {
return mRealRadioResponse->getModemStackStatusResponse(info, isEnabled);
}
// Methods from ::android::hardware::radio::V1_4::IRadioResponse follow.
Return<void> RadioResponse::emergencyDialResponse(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->emergencyDialResponse(info);
}
Return<void> RadioResponse::startNetworkScanResponse_1_4(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->startNetworkScanResponse_1_4(info);
}
Return<void> RadioResponse::getCellInfoListResponse_1_4(const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_4::CellInfo>& cellInfo) {
return mRealRadioResponse->getCellInfoListResponse_1_4(info, cellInfo);
}
Return<void> RadioResponse::getDataRegistrationStateResponse_1_4(
const V1_0::RadioResponseInfo& info, const V1_4::DataRegStateResult& dataRegResponse) {
return mRealRadioResponse->getDataRegistrationStateResponse_1_4(info, dataRegResponse);
}
Return<void> RadioResponse::getIccCardStatusResponse_1_4(const V1_0::RadioResponseInfo& info,
const V1_4::CardStatus& cardStatus) {
return mRealRadioResponse->getIccCardStatusResponse_1_4(info, cardStatus);
}
Return<void> RadioResponse::getPreferredNetworkTypeBitmapResponse(
const V1_0::RadioResponseInfo& info, hidl_bitfield<V1_4::RadioAccessFamily> networkTypeBitmap) {
return mRealRadioResponse->getPreferredNetworkTypeBitmapResponse(info, networkTypeBitmap);
}
Return<void> RadioResponse::setPreferredNetworkTypeBitmapResponse(
const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setPreferredNetworkTypeBitmapResponse(info);
}
Return<void> RadioResponse::getDataCallListResponse_1_4(
const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_4::SetupDataCallResult>& dcResponse) {
return mRealRadioResponse->getDataCallListResponse_1_4(info, dcResponse);
}
Return<void> RadioResponse::setupDataCallResponse_1_4(const V1_0::RadioResponseInfo& info,
const V1_4::SetupDataCallResult& dcResponse) {
return mRealRadioResponse->setupDataCallResponse_1_4(info, dcResponse);
}
Return<void> RadioResponse::setAllowedCarriersResponse_1_4(const V1_0::RadioResponseInfo& info) {
return mRealRadioResponse->setAllowedCarriersResponse_1_4(info);
}
Return<void> RadioResponse::getAllowedCarriersResponse_1_4(
const V1_0::RadioResponseInfo& info, const V1_4::CarrierRestrictionsWithPriority& carriers,
V1_4::SimLockMultiSimPolicy multiSimPolicy) {
return mRealRadioResponse->getAllowedCarriersResponse_1_4(info, carriers, multiSimPolicy);
}
Return<void> RadioResponse::getSignalStrengthResponse_1_4(
const V1_0::RadioResponseInfo& info, const V1_4::SignalStrength& signalStrength) {
return mRealRadioResponse->getSignalStrengthResponse_1_4(info, signalStrength);
}
} // namespace android::hardware::radio::implementation

311
radio/1.4/legacy/RadioResponse.h Normal file
View file

@ -0,0 +1,311 @@
/*
* Copyright (C) 2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <android/hardware/radio/1.4/IRadioResponse.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
namespace android::hardware::radio::implementation {
using ::android::sp;
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
struct RadioResponse : public V1_4::IRadioResponse {
sp<V1_4::IRadioResponse> mRealRadioResponse;
V1_0::RadioTechnology mRat = V1_0::RadioTechnology::UNKNOWN;
bool mDataRoaming = false;
// Methods from ::android::hardware::radio::V1_0::IRadioResponse follow.
Return<void> getIccCardStatusResponse(const V1_0::RadioResponseInfo& info,
const V1_0::CardStatus& cardStatus) override;
Return<void> supplyIccPinForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t remainingRetries) override;
Return<void> supplyIccPukForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t remainingRetries) override;
Return<void> supplyIccPin2ForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t remainingRetries) override;
Return<void> supplyIccPuk2ForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t remainingRetries) override;
Return<void> changeIccPinForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t remainingRetries) override;
Return<void> changeIccPin2ForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t remainingRetries) override;
Return<void> supplyNetworkDepersonalizationResponse(const V1_0::RadioResponseInfo& info,
int32_t remainingRetries) override;
Return<void> getCurrentCallsResponse(const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::Call>& calls) override;
Return<void> dialResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getIMSIForAppResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& imsi) override;
Return<void> hangupConnectionResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> hangupWaitingOrBackgroundResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> hangupForegroundResumeBackgroundResponse(
const V1_0::RadioResponseInfo& info) override;
Return<void> switchWaitingOrHoldingAndActiveResponse(
const V1_0::RadioResponseInfo& info) override;
Return<void> conferenceResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> rejectCallResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getLastCallFailCauseResponse(
const V1_0::RadioResponseInfo& info,
const V1_0::LastCallFailCauseInfo& failCauseinfo) override;
Return<void> getSignalStrengthResponse(const V1_0::RadioResponseInfo& info,
const V1_0::SignalStrength& sigStrength) override;
Return<void> getVoiceRegistrationStateResponse(
const V1_0::RadioResponseInfo& info,
const V1_0::VoiceRegStateResult& voiceRegResponse) override;
Return<void> getDataRegistrationStateResponse(
const V1_0::RadioResponseInfo& info,
const V1_0::DataRegStateResult& dataRegResponse) override;
Return<void> getOperatorResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& longName, const hidl_string& shortName,
const hidl_string& numeric) override;
Return<void> setRadioPowerResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> sendDtmfResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> sendSmsResponse(const V1_0::RadioResponseInfo& info,
const V1_0::SendSmsResult& sms) override;
Return<void> sendSMSExpectMoreResponse(const V1_0::RadioResponseInfo& info,
const V1_0::SendSmsResult& sms) override;
Return<void> setupDataCallResponse(const V1_0::RadioResponseInfo& info,
const V1_0::SetupDataCallResult& dcResponse) override;
Return<void> iccIOForAppResponse(const V1_0::RadioResponseInfo& info,
const V1_0::IccIoResult& iccIo) override;
Return<void> sendUssdResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> cancelPendingUssdResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getClirResponse(const V1_0::RadioResponseInfo& info, int32_t n,
int32_t m) override;
Return<void> setClirResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getCallForwardStatusResponse(
const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::CallForwardInfo>& callForwardInfos) override;
Return<void> setCallForwardResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getCallWaitingResponse(const V1_0::RadioResponseInfo& info, bool enable,
int32_t serviceClass) override;
Return<void> setCallWaitingResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> acknowledgeLastIncomingGsmSmsResponse(
const V1_0::RadioResponseInfo& info) override;
Return<void> acceptCallResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> deactivateDataCallResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getFacilityLockForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t response) override;
Return<void> setFacilityLockForAppResponse(const V1_0::RadioResponseInfo& info,
int32_t retry) override;
Return<void> setBarringPasswordResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getNetworkSelectionModeResponse(const V1_0::RadioResponseInfo& info,
bool manual) override;
Return<void> setNetworkSelectionModeAutomaticResponse(
const V1_0::RadioResponseInfo& info) override;
Return<void> setNetworkSelectionModeManualResponse(
const V1_0::RadioResponseInfo& info) override;
Return<void> getAvailableNetworksResponse(
const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::OperatorInfo>& networkInfos) override;
Return<void> startDtmfResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> stopDtmfResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getBasebandVersionResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& version) override;
Return<void> separateConnectionResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> setMuteResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getMuteResponse(const V1_0::RadioResponseInfo& info, bool enable) override;
Return<void> getClipResponse(const V1_0::RadioResponseInfo& info,
V1_0::ClipStatus status) override;
Return<void> getDataCallListResponse(
const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::SetupDataCallResult>& dcResponse) override;
Return<void> setSuppServiceNotificationsResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> writeSmsToSimResponse(const V1_0::RadioResponseInfo& info, int32_t index) override;
Return<void> deleteSmsOnSimResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> setBandModeResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getAvailableBandModesResponse(
const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::RadioBandMode>& bandModes) override;
Return<void> sendEnvelopeResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& commandResponse) override;
Return<void> sendTerminalResponseToSimResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> handleStkCallSetupRequestFromSimResponse(
const V1_0::RadioResponseInfo& info) override;
Return<void> explicitCallTransferResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> setPreferredNetworkTypeResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getPreferredNetworkTypeResponse(const V1_0::RadioResponseInfo& info,
V1_0::PreferredNetworkType nwType) override;
Return<void> getNeighboringCidsResponse(const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::NeighboringCell>& cells) override;
Return<void> setLocationUpdatesResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> setCdmaSubscriptionSourceResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> setCdmaRoamingPreferenceResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getCdmaRoamingPreferenceResponse(const V1_0::RadioResponseInfo& info,
V1_0::CdmaRoamingType type) override;
Return<void> setTTYModeResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getTTYModeResponse(const V1_0::RadioResponseInfo& info,
V1_0::TtyMode mode) override;
Return<void> setPreferredVoicePrivacyResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getPreferredVoicePrivacyResponse(const V1_0::RadioResponseInfo& info,
bool enable) override;
Return<void> sendCDMAFeatureCodeResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> sendBurstDtmfResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> sendCdmaSmsResponse(const V1_0::RadioResponseInfo& info,
const V1_0::SendSmsResult& sms) override;
Return<void> acknowledgeLastIncomingCdmaSmsResponse(
const V1_0::RadioResponseInfo& info) override;
Return<void> getGsmBroadcastConfigResponse(
const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::GsmBroadcastSmsConfigInfo>& configs) override;
Return<void> setGsmBroadcastConfigResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> setGsmBroadcastActivationResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getCdmaBroadcastConfigResponse(
const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::CdmaBroadcastSmsConfigInfo>& configs) override;
Return<void> setCdmaBroadcastConfigResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> setCdmaBroadcastActivationResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getCDMASubscriptionResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& mdn, const hidl_string& hSid,
const hidl_string& hNid, const hidl_string& min,
const hidl_string& prl) override;
Return<void> writeSmsToRuimResponse(const V1_0::RadioResponseInfo& info,
uint32_t index) override;
Return<void> deleteSmsOnRuimResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getDeviceIdentityResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& imei, const hidl_string& imeisv,
const hidl_string& esn,
const hidl_string& meid) override;
Return<void> exitEmergencyCallbackModeResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getSmscAddressResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& smsc) override;
Return<void> setSmscAddressResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> reportSmsMemoryStatusResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> reportStkServiceIsRunningResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getCdmaSubscriptionSourceResponse(const V1_0::RadioResponseInfo& info,
V1_0::CdmaSubscriptionSource source) override;
Return<void> requestIsimAuthenticationResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& response) override;
Return<void> acknowledgeIncomingGsmSmsWithPduResponse(
const V1_0::RadioResponseInfo& info) override;
Return<void> sendEnvelopeWithStatusResponse(const V1_0::RadioResponseInfo& info,
const V1_0::IccIoResult& iccIo) override;
Return<void> getVoiceRadioTechnologyResponse(const V1_0::RadioResponseInfo& info,
V1_0::RadioTechnology rat) override;
Return<void> getCellInfoListResponse(const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::CellInfo>& cellInfo) override;
Return<void> setCellInfoListRateResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> setInitialAttachApnResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getImsRegistrationStateResponse(const V1_0::RadioResponseInfo& info,
bool isRegistered,
V1_0::RadioTechnologyFamily ratFamily) override;
Return<void> sendImsSmsResponse(const V1_0::RadioResponseInfo& info,
const V1_0::SendSmsResult& sms) override;
Return<void> iccTransmitApduBasicChannelResponse(const V1_0::RadioResponseInfo& info,
const V1_0::IccIoResult& result) override;
Return<void> iccOpenLogicalChannelResponse(const V1_0::RadioResponseInfo& info,
int32_t channelId,
const hidl_vec<int8_t>& selectResponse) override;
Return<void> iccCloseLogicalChannelResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> iccTransmitApduLogicalChannelResponse(const V1_0::RadioResponseInfo& info,
const V1_0::IccIoResult& result) override;
Return<void> nvReadItemResponse(const V1_0::RadioResponseInfo& info,
const hidl_string& result) override;
Return<void> nvWriteItemResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> nvWriteCdmaPrlResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> nvResetConfigResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> setUiccSubscriptionResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> setDataAllowedResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getHardwareConfigResponse(const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_0::HardwareConfig>& config) override;
Return<void> requestIccSimAuthenticationResponse(const V1_0::RadioResponseInfo& info,
const V1_0::IccIoResult& result) override;
Return<void> setDataProfileResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> requestShutdownResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getRadioCapabilityResponse(const V1_0::RadioResponseInfo& info,
const V1_0::RadioCapability& rc) override;
Return<void> setRadioCapabilityResponse(const V1_0::RadioResponseInfo& info,
const V1_0::RadioCapability& rc) override;
Return<void> startLceServiceResponse(const V1_0::RadioResponseInfo& info,
const V1_0::LceStatusInfo& statusInfo) override;
Return<void> stopLceServiceResponse(const V1_0::RadioResponseInfo& info,
const V1_0::LceStatusInfo& statusInfo) override;
Return<void> pullLceDataResponse(const V1_0::RadioResponseInfo& info,
const V1_0::LceDataInfo& lceInfo) override;
Return<void> getModemActivityInfoResponse(const V1_0::RadioResponseInfo& info,
const V1_0::ActivityStatsInfo& activityInfo) override;
Return<void> setAllowedCarriersResponse(const V1_0::RadioResponseInfo& info,
int32_t numAllowed) override;
Return<void> getAllowedCarriersResponse(const V1_0::RadioResponseInfo& info, bool allAllowed,
const V1_0::CarrierRestrictions& carriers) override;
Return<void> sendDeviceStateResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> setIndicationFilterResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> setSimCardPowerResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> acknowledgeRequest(int32_t serial) override;
// Methods from ::android::hardware::radio::V1_1::IRadioResponse follow.
Return<void> setCarrierInfoForImsiEncryptionResponse(
const V1_0::RadioResponseInfo& info) override;
Return<void> setSimCardPowerResponse_1_1(const V1_0::RadioResponseInfo& info) override;
Return<void> startNetworkScanResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> stopNetworkScanResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> startKeepaliveResponse(const V1_0::RadioResponseInfo& info,
const V1_1::KeepaliveStatus& status) override;
Return<void> stopKeepaliveResponse(const V1_0::RadioResponseInfo& info) override;
// Methods from ::android::hardware::radio::V1_2::IRadioResponse follow.
Return<void> getCellInfoListResponse_1_2(const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_2::CellInfo>& cellInfo) override;
Return<void> getIccCardStatusResponse_1_2(const V1_0::RadioResponseInfo& info,
const V1_2::CardStatus& cardStatus) override;
Return<void> setSignalStrengthReportingCriteriaResponse(
const V1_0::RadioResponseInfo& info) override;
Return<void> setLinkCapacityReportingCriteriaResponse(
const V1_0::RadioResponseInfo& info) override;
Return<void> getCurrentCallsResponse_1_2(const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_2::Call>& calls) override;
Return<void> getSignalStrengthResponse_1_2(const V1_0::RadioResponseInfo& info,
const V1_2::SignalStrength& signalStrength) override;
Return<void> getVoiceRegistrationStateResponse_1_2(
const V1_0::RadioResponseInfo& info,
const V1_2::VoiceRegStateResult& voiceRegResponse) override;
Return<void> getDataRegistrationStateResponse_1_2(
const V1_0::RadioResponseInfo& info,
const V1_2::DataRegStateResult& dataRegResponse) override;
// Methods from ::android::hardware::radio::V1_3::IRadioResponse follow.
Return<void> setSystemSelectionChannelsResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> enableModemResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> getModemStackStatusResponse(const V1_0::RadioResponseInfo& info,
bool isEnabled) override;
// Methods from ::android::hardware::radio::V1_4::IRadioResponse follow.
Return<void> emergencyDialResponse(const V1_0::RadioResponseInfo& info) override;
Return<void> startNetworkScanResponse_1_4(const V1_0::RadioResponseInfo& info) override;
Return<void> getCellInfoListResponse_1_4(const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_4::CellInfo>& cellInfo) override;
Return<void> getDataRegistrationStateResponse_1_4(
const V1_0::RadioResponseInfo& info,
const V1_4::DataRegStateResult& dataRegResponse) override;
Return<void> getIccCardStatusResponse_1_4(const V1_0::RadioResponseInfo& info,
const V1_4::CardStatus& cardStatus) override;
Return<void> getPreferredNetworkTypeBitmapResponse(
const V1_0::RadioResponseInfo& info,
hidl_bitfield<V1_0::RadioAccessFamily> networkTypeBitmap) override;
Return<void> setPreferredNetworkTypeBitmapResponse(
const V1_0::RadioResponseInfo& info) override;
Return<void> getDataCallListResponse_1_4(
const V1_0::RadioResponseInfo& info,
const hidl_vec<V1_4::SetupDataCallResult>& dcResponse) override;
Return<void> setupDataCallResponse_1_4(const V1_0::RadioResponseInfo& info,
const V1_4::SetupDataCallResult& dcResponse) override;
Return<void> setAllowedCarriersResponse_1_4(const V1_0::RadioResponseInfo& info) override;
Return<void> getAllowedCarriersResponse_1_4(
const V1_0::RadioResponseInfo& info,
const V1_4::CarrierRestrictionsWithPriority& carriers,
V1_4::SimLockMultiSimPolicy multiSimPolicy) override;
Return<void> getSignalStrengthResponse_1_4(const V1_0::RadioResponseInfo& info,
const V1_4::SignalStrength& signalStrength) override;
};
} // namespace android::hardware::radio::implementation

9
radio/1.4/legacy/android.hardware.radio@1.4-service.legacy.rc Normal file
View file

@ -0,0 +1,9 @@
service vendor.radio-1-4-legacy /vendor/bin/hw/android.hardware.radio@1.4-service.legacy
interface android.hardware.radio@1.0::IRadio default
interface android.hardware.radio@1.1::IRadio default
interface android.hardware.radio@1.2::IRadio default
interface android.hardware.radio@1.3::IRadio default
interface android.hardware.radio@1.4::IRadio default
class hal
user system
group system

46
radio/1.4/legacy/hidl-utils.cpp Normal file
View file

@ -0,0 +1,46 @@
/*
* 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 "hidl-utils.h"
#include <android-base/logging.h>
#include <android/hidl/manager/1.2/IServiceManager.h>
namespace android::hardware::hidl_utils {
class HalDeathRecipient : public hidl_death_recipient {
void serviceDied(uint64_t /* cookie */, const wp<hidl::base::V1_0::IBase>& /* who */) override {
LOG(FATAL) << "One of the linked HALs died. Restarting...";
}
};
static const auto gHalDeathRecipient = sp<HalDeathRecipient>::make();
void linkDeathToDeath(sp<::android::hidl::base::V1_0::IBase> hal) {
const auto linkStatus = hal->linkToDeath(gHalDeathRecipient, 0);
CHECK(linkStatus.withDefault(false)) << "Failed to link to HAL death";
}
hidl_vec<hidl_string> listManifestByInterface(const char* descriptor) {
auto manager = hidl::manager::V1_2::IServiceManager::getService();
hidl_vec<hidl_string> services;
manager->listManifestByInterface(descriptor, hidl_utils::fill(&services));
CHECK_GT(services.size(), 0u) << "No " << descriptor
<< " services in manifest (missing privileges?)" << std::endl;
return services;
}
} // namespace android::hardware::hidl_utils

78
radio/1.4/legacy/hidl-utils.h Normal file
View file

@ -0,0 +1,78 @@
/*
* 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.
*/
#pragma once
#include <android/hidl/base/1.0/IBase.h>
#include <functional>
namespace android::hardware::hidl_utils {
/**
* Helper functor to fetch results from multi-return HIDL calls.
* It's meant to be used in place of _hidl_cb callbacks.
*
* Please note extracting these return variables outside of the callback scope requires making
* a copy of each return variable. This may be costly for frequently called HIDL methods with
* non-negligible return object size. Please be cautious about performance when using this.
*
* Example usage:
* Result result;
* sp<ISomeInterface> iface;
* hidlObject->someMethod(arg1, arg2, hidl_utils::fill(&result, &iface)).assertOk();
* // use result and iface
*/
template <typename... T>
struct fill : public std::function<void(const T&...)> {
/**
* Create _hidl_cb functor that copies the call arguments to specified pointers.
*
* \param args... Targets to copy the call arguments to
*/
fill(T*... args) : mTargets(args...) {}
void operator()(const T&... args) { copy<0, T...>(args...); }
private:
std::tuple<T*...> mTargets;
template <int Pos, typename First>
inline void copy(const First& first) {
*std::get<Pos>(mTargets) = first;
}
template <int Pos, typename First, typename... Rest>
inline void copy(const First& first, const Rest&... rest) {
*std::get<Pos>(mTargets) = first;
copy<Pos + 1, Rest...>(rest...);
}
};
/**
* Link to a given HALs death and restart the current process in such a case.
* \param hal HAL to which death to link
*/
void linkDeathToDeath(sp<hidl::base::V1_0::IBase> hal);
/**
* List HAL instances of a given interface.
*
* \descriptor HIDL HAL descriptor
*/
hidl_vec<hidl_string> listManifestByInterface(const char* descriptor);
} // namespace android::hardware::hidl_utils

68
radio/1.4/legacy/service.cpp Normal file
View file

@ -0,0 +1,68 @@
/*
* Copyright (C) 2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#define LOG_TAG "android.hardware.radio@1.4-service.legacy"
#include <android-base/logging.h>
#include <hidl/HidlTransportSupport.h>
#include "Radio.h"
#include "hidl-utils.h"
#include <map>
using namespace android::hardware::radio;
using namespace android::hardware::hidl_utils;
using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool;
using android::hardware::radio::implementation::Radio;
using android::OK;
using android::sp;
using android::status_t;
#define MAX_SLOT_ID 4
int main() {
// Note: Starts from slot 1
std::map<int, sp<V1_4::IRadio>> slotIdToRadio;
for (int slotId = 1; slotId <= MAX_SLOT_ID; slotId++) {
sp<V1_0::IRadio> realRadio = V1_0::IRadio::getService("slot" + std::to_string(slotId));
if (realRadio == nullptr) {
LOG(INFO) << "Cannot get radio service for slot " << slotId;
if (slotId == 1) {
LOG(ERROR) << "Cannot get radio service for slot 1.";
return 1;
}
break;
}
slotIdToRadio[slotId] = new Radio(realRadio);
linkDeathToDeath(realRadio);
}
configureRpcThreadpool(1, true);
for (auto const& [slotId, radio] : slotIdToRadio) {
status_t status = radio->registerAsService("slot" + std::to_string(slotId));
if (status != OK) {
LOG(ERROR) << "Cannot register Radio HAL service for slot " << slotId;
return 1;
}
}
LOG(INFO) << "Radio HAL service ready.";
joinRpcThreadpool();
LOG(INFO) << "Radio HAL service failed to join thread pool.";
return 1;
}

11
radio/config/1.1-wrapper/RadioConfig.cpp
View file

@ -144,15 +144,10 @@ Return<void> RadioConfig::setPreferredDataModem(int32_t serial, uint8_t modemId)
radioError = RadioError::INVALID_ARGUMENTS;
} else {
for (uint8_t i = 0; i < radios.size(); i++) {
auto radio = radios[i];
if (radio == nullptr) {
LOG(ERROR) << __func__ << ": radios[" << std::to_string(i) << "] is null";
radioError = RadioError::INTERNAL_ERR;
continue;
}
radio->setDataAllowed(-1, i == modemId);
if (i != modemId) radios[i]->setDataAllowed(-1, false);
}
radios[modemId]->setDataAllowed(-1, true);
}
auto radioConfigResponseV1_1 = mRadioConfigResponseV1_1;

24
vibrator/aidl-legacy/Android.bp Normal file
View file

@ -0,0 +1,24 @@
//
// Copyright (C) 2024 The LineageOS Project
//
// SPDX-License-Identifier: Apache-2.0
//
cc_binary {
name: "android.hardware.vibrator-service.legacy",
relative_install_path: "hw",
init_rc: ["android.hardware.vibrator-service.legacy.rc"],
vintf_fragments: ["android.hardware.vibrator-service.legacy.xml"],
srcs: [
"Vibrator.cpp",
"service.cpp",
],
shared_libs: [
"libbase",
"libbinder_ndk",
"libhardware",
"liblog",
"android.hardware.vibrator-V2-ndk",
],
vendor: true,
}

150
vibrator/aidl-legacy/Vibrator.cpp Normal file
View file

@ -0,0 +1,150 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* Copyright (C) 2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <log/log.h>
#include <hardware/hardware.h>
#include <hardware/vibrator.h>
#include "Vibrator.h"
namespace aidl {
namespace android {
namespace hardware {
namespace vibrator {
Vibrator::Vibrator() {
vibrator_device_t *vib_device;
const hw_module_t *hw_module = nullptr;
int ret = hw_get_module(VIBRATOR_HARDWARE_MODULE_ID, &hw_module);
if (ret == 0) {
ret = vibrator_open(hw_module, &vib_device);
if (ret != 0) {
ALOGE("vibrator_open failed: %d", ret);
return;
}
} else {
ALOGE("hw_get_module %s failed: %d", VIBRATOR_HARDWARE_MODULE_ID, ret);
return;
}
mDevice = vib_device;
}
ndk::ScopedAStatus Vibrator::getCapabilities(int32_t* _aidl_return) {
ALOGV("Vibrator reporting capabilities");
*_aidl_return = IVibrator::CAP_ON_CALLBACK;
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus Vibrator::off() {
int32_t ret = mDevice->vibrator_off(mDevice);
if (ret != 0) {
ALOGE("off command failed : %s", strerror(-ret));
return ndk::ScopedAStatus::fromExceptionCode(EX_TRANSACTION_FAILED);
}
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs, const std::shared_ptr<IVibratorCallback>& /*callback*/) {
int32_t ret = mDevice->vibrator_on(mDevice, timeoutMs);
if (ret != 0) {
ALOGE("on command failed : %s", strerror(-ret));
return ndk::ScopedAStatus::fromExceptionCode(EX_TRANSACTION_FAILED);
}
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus Vibrator::perform(Effect /*effect*/, EffectStrength /*strength*/, const std::shared_ptr<IVibratorCallback>& /*callback*/, int32_t* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getSupportedEffects(std::vector<Effect>* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::setAmplitude(float /*amplitude*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::setExternalControl(bool /*enabled*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getCompositionDelayMax(int32_t* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getCompositionSizeMax(int32_t* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getSupportedPrimitives(std::vector<CompositePrimitive>* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getPrimitiveDuration(CompositePrimitive /*primitive*/, int32_t* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::compose(const std::vector<CompositeEffect>& /*composite*/, const std::shared_ptr<IVibratorCallback>& /*callback*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getSupportedAlwaysOnEffects(std::vector<Effect>* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::alwaysOnEnable(int32_t /*id*/, Effect /*effect*/, EffectStrength /*strength*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::alwaysOnDisable(int32_t /*id*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getResonantFrequency(float* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getQFactor(float* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getFrequencyResolution(float* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getFrequencyMinimum(float* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getBandwidthAmplitudeMap(std::vector<float>* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getPwlePrimitiveDurationMax(int32_t* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getPwleCompositionSizeMax(int32_t* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getSupportedBraking(std::vector<Braking>* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle>& /*composite*/, const std::shared_ptr<IVibratorCallback>& /*callback*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
} // namespace vibrator
} // namespace hardware
} // namespace android
} // namespace aidl

63
vibrator/aidl-legacy/Vibrator.h Normal file
View file

@ -0,0 +1,63 @@
/*
* Copyright (C) 2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <aidl/android/hardware/vibrator/BnVibrator.h>
#include <hardware/hardware.h>
#include <hardware/vibrator.h>
using ::aidl::android::hardware::vibrator::IVibratorCallback;
using ::aidl::android::hardware::vibrator::Braking;
using ::aidl::android::hardware::vibrator::Effect;
using ::aidl::android::hardware::vibrator::EffectStrength;
using ::aidl::android::hardware::vibrator::CompositeEffect;
using ::aidl::android::hardware::vibrator::CompositePrimitive;
using ::aidl::android::hardware::vibrator::PrimitivePwle;
namespace aidl {
namespace android {
namespace hardware {
namespace vibrator {
class Vibrator : public BnVibrator {
public:
Vibrator();
ndk::ScopedAStatus getCapabilities(int32_t* _aidl_return) override;
ndk::ScopedAStatus off() override;
ndk::ScopedAStatus on(int32_t timeoutMs, const std::shared_ptr<IVibratorCallback>& callback) override;
ndk::ScopedAStatus perform(Effect effect, EffectStrength strength, const std::shared_ptr<IVibratorCallback>& callback, int32_t* _aidl_return) override;
ndk::ScopedAStatus getSupportedEffects(std::vector<Effect>* _aidl_return) override;
ndk::ScopedAStatus setAmplitude(float amplitude) override;
ndk::ScopedAStatus setExternalControl(bool enabled) override;
ndk::ScopedAStatus getCompositionDelayMax(int32_t* _aidl_return) override;
ndk::ScopedAStatus getCompositionSizeMax(int32_t* _aidl_return) override;
ndk::ScopedAStatus getSupportedPrimitives(std::vector<CompositePrimitive>* _aidl_return) override;
ndk::ScopedAStatus getPrimitiveDuration(CompositePrimitive primitive, int32_t* _aidl_return) override;
ndk::ScopedAStatus compose(const std::vector<CompositeEffect>& composite, const std::shared_ptr<IVibratorCallback>& callback) override;
ndk::ScopedAStatus getSupportedAlwaysOnEffects(std::vector<Effect>* _aidl_return) override;
ndk::ScopedAStatus alwaysOnEnable(int32_t id, Effect effect, EffectStrength strength) override;
ndk::ScopedAStatus alwaysOnDisable(int32_t id) override;
ndk::ScopedAStatus getResonantFrequency(float* _aidl_return) override;
ndk::ScopedAStatus getQFactor(float* _aidl_return) override;
ndk::ScopedAStatus getFrequencyResolution(float* _aidl_return) override;
ndk::ScopedAStatus getFrequencyMinimum(float* _aidl_return) override;
ndk::ScopedAStatus getBandwidthAmplitudeMap(std::vector<float>* _aidl_return) override;
ndk::ScopedAStatus getPwlePrimitiveDurationMax(int32_t* _aidl_return) override;
ndk::ScopedAStatus getPwleCompositionSizeMax(int32_t* _aidl_return) override;
ndk::ScopedAStatus getSupportedBraking(std::vector<Braking>* _aidl_return) override;
ndk::ScopedAStatus composePwle(const std::vector<PrimitivePwle> &composite, const std::shared_ptr<IVibratorCallback> &callback) override;
private:
vibrator_device_t *mDevice;
};
} // namespace vibrator
} // namespace hardware
} // namespace android
} // namespace aidl

4
vibrator/aidl-legacy/android.hardware.vibrator-service.legacy.rc Normal file
View file

@ -0,0 +1,4 @@
service vendor.vibrator-legacy /vendor/bin/hw/android.hardware.vibrator-service.legacy
class hal
user system
group system

6
vibrator/aidl-legacy/android.hardware.vibrator-service.legacy.xml Normal file
View file

@ -0,0 +1,6 @@
<manifest version="1.0" type="device">
<hal format="aidl">
<name>android.hardware.vibrator</name>
<fqname>IVibrator/default</fqname>
</hal>
</manifest>

25
vibrator/aidl-legacy/service.cpp Normal file
View file

@ -0,0 +1,25 @@
/*
* Copyright (C) 2024 The LineageOS Project
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "Vibrator.h"
#include <android/binder_manager.h>
#include <android/binder_process.h>
#include <android-base/logging.h>
using ::aidl::android::hardware::vibrator::Vibrator;
int main() {
ABinderProcess_setThreadPoolMaxThreadCount(0);
std::shared_ptr<Vibrator> vibrator = ndk::SharedRefBase::make<Vibrator>();
const std::string instance = std::string() + Vibrator::descriptor + "/default";
binder_status_t status = AServiceManager_addService(vibrator->asBinder().get(), instance.c_str());
CHECK(status == STATUS_OK);
ABinderProcess_joinThreadPool();
return EXIT_FAILURE; // should not reach
}