Complete Frontend Status aidl interface and getStatus API in
TunerFrontend
Test: make
Bug: 159067322
Change-Id: Ifc3aea59ae10d22c7f31965f07705f473d4847e7
diff --git a/services/tuner/TunerFilter.cpp b/services/tuner/TunerFilter.cpp
index b712348..2d7aeb9 100644
--- a/services/tuner/TunerFilter.cpp
+++ b/services/tuner/TunerFilter.cpp
@@ -311,12 +311,9 @@
switch (s.condition.getTag()) {
case TunerFilterSectionCondition::sectionBits: {
auto sectionBits = s.condition.get<TunerFilterSectionCondition::sectionBits>();
- vector<uint8_t> filter(sectionBits.filter.size());
- vector<uint8_t> mask(sectionBits.mask.size());
- vector<uint8_t> mode(sectionBits.mode.size());
- copy(sectionBits.filter.begin(), sectionBits.filter.end(), filter.begin());
- copy(sectionBits.mask.begin(), sectionBits.mask.end(), mask.begin());
- copy(sectionBits.mode.begin(), sectionBits.mode.end(), mode.begin());
+ vector<uint8_t> filter(sectionBits.filter.begin(), sectionBits.filter.end());
+ vector<uint8_t> mask(sectionBits.mask.begin(), sectionBits.mask.end());
+ vector<uint8_t> mode(sectionBits.mode.begin(), sectionBits.mode.end());
section.condition.sectionBits({
.filter = filter,
.mask = mask,
diff --git a/services/tuner/TunerFrontend.cpp b/services/tuner/TunerFrontend.cpp
index 9b847ab..a919f98 100644
--- a/services/tuner/TunerFrontend.cpp
+++ b/services/tuner/TunerFrontend.cpp
@@ -20,6 +20,7 @@
using ::aidl::android::media::tv::tuner::TunerFrontendAtsc3PlpSettings;
using ::aidl::android::media::tv::tuner::TunerFrontendScanAtsc3PlpInfo;
+using ::aidl::android::media::tv::tuner::TunerFrontendStatusAtsc3PlpInfo;
using ::aidl::android::media::tv::tuner::TunerFrontendUnionSettings;
using ::android::hardware::tv::tuner::V1_0::FrontendAnalogSifStandard;
using ::android::hardware::tv::tuner::V1_0::FrontendAnalogType;
@@ -65,13 +66,15 @@
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtMode;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtModulation;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtSettings;
+using ::android::hardware::tv::tuner::V1_0::FrontendModulationStatus;
using ::android::hardware::tv::tuner::V1_0::FrontendScanAtsc3PlpInfo;
using ::android::hardware::tv::tuner::V1_0::FrontendScanType;
+using ::android::hardware::tv::tuner::V1_0::FrontendStatusType;
using ::android::hardware::tv::tuner::V1_0::Result;
using ::android::hardware::tv::tuner::V1_1::FrontendAnalogAftFlag;
+using ::android::hardware::tv::tuner::V1_1::FrontendBandwidth;
using ::android::hardware::tv::tuner::V1_1::FrontendCableTimeInterleaveMode;
using ::android::hardware::tv::tuner::V1_1::FrontendDvbcBandwidth;
-using ::android::hardware::tv::tuner::V1_1::FrontendModulation;
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbBandwidth;
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbCodeRate;
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbGuardInterval;
@@ -79,7 +82,13 @@
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbTimeInterleaveMode;
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbTransmissionMode;
using ::android::hardware::tv::tuner::V1_1::FrontendDvbsScanType;
+using ::android::hardware::tv::tuner::V1_1::FrontendGuardInterval;
+using ::android::hardware::tv::tuner::V1_1::FrontendInterleaveMode;
+using ::android::hardware::tv::tuner::V1_1::FrontendModulation;
+using ::android::hardware::tv::tuner::V1_1::FrontendRollOff;
+using ::android::hardware::tv::tuner::V1_1::FrontendTransmissionMode;
using ::android::hardware::tv::tuner::V1_1::FrontendSpectralInversion;
+using ::android::hardware::tv::tuner::V1_1::FrontendStatusTypeExt1_1;
namespace android {
@@ -219,8 +228,55 @@
return Status::fromServiceSpecificError(static_cast<int32_t>(status));
}
-Status TunerFrontend::getStatus(const vector<int32_t>& /*statusTypes*/,
- vector<TunerFrontendStatus>* /*_aidl_return*/) {
+Status TunerFrontend::getStatus(const vector<int32_t>& statusTypes,
+ vector<TunerFrontendStatus>* _aidl_return) {
+ if (mFrontend == NULL) {
+ ALOGD("IFrontend is not initialized");
+ return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
+ }
+
+ Result res;
+ vector<FrontendStatus> status;
+ vector<FrontendStatusType> types;
+ for (auto s : statusTypes) {
+ types.push_back(static_cast<FrontendStatusType>(s));
+ }
+
+ mFrontend->getStatus(types, [&](Result r, const hidl_vec<FrontendStatus>& s) {
+ res = r;
+ status = s;
+ });
+ if (res != Result::SUCCESS) {
+ return Status::fromServiceSpecificError(static_cast<int32_t>(res));
+ }
+
+ getAidlFrontendStatus(status, *_aidl_return);
+ return Status::ok();
+}
+
+Status TunerFrontend::getStatusExtended_1_1(const vector<int32_t>& statusTypes,
+ vector<TunerFrontendStatus>* _aidl_return) {
+ if (mFrontend_1_1 == NULL) {
+ ALOGD("IFrontend_1_1 is not initialized");
+ return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
+ }
+
+ Result res;
+ vector<FrontendStatusExt1_1> status;
+ vector<FrontendStatusTypeExt1_1> types;
+ for (auto s : statusTypes) {
+ types.push_back(static_cast<FrontendStatusTypeExt1_1>(s));
+ }
+
+ mFrontend_1_1->getStatusExt1_1(types, [&](Result r, const hidl_vec<FrontendStatusExt1_1>& s) {
+ res = r;
+ status = s;
+ });
+ if (res != Result::SUCCESS) {
+ return Status::fromServiceSpecificError(static_cast<int32_t>(res));
+ }
+
+ getAidlFrontendStatusExt(status, *_aidl_return);
return Status::ok();
}
@@ -312,7 +368,7 @@
vector<TunerFrontendScanAtsc3PlpInfo> tunerPlpInfos;
for (int i = 0; i < plpInfos.size(); i++) {
auto info = plpInfos[i];
- int plpId = (int) info.plpId;
+ int8_t plpId = (int8_t) info.plpId;
bool lls = (bool) info.bLlsFlag;
TunerFrontendScanAtsc3PlpInfo plpInfo{
.plpId = plpId,
@@ -387,6 +443,341 @@
/////////////// TunerFrontend Helper Methods ///////////////////////
+void TunerFrontend::getAidlFrontendStatus(
+ vector<FrontendStatus>& hidlStatus, vector<TunerFrontendStatus>& aidlStatus) {
+ for (FrontendStatus s : hidlStatus) {
+ TunerFrontendStatus status;
+ switch (s.getDiscriminator()) {
+ case FrontendStatus::hidl_discriminator::isDemodLocked: {
+ status.set<TunerFrontendStatus::isDemodLocked>(s.isDemodLocked());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::snr: {
+ status.set<TunerFrontendStatus::snr>((int)s.snr());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::ber: {
+ status.set<TunerFrontendStatus::ber>((int)s.ber());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::per: {
+ status.set<TunerFrontendStatus::per>((int)s.per());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::preBer: {
+ status.set<TunerFrontendStatus::preBer>((int)s.preBer());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::signalQuality: {
+ status.set<TunerFrontendStatus::signalQuality>((int)s.signalQuality());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::signalStrength: {
+ status.set<TunerFrontendStatus::signalStrength>((int)s.signalStrength());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::symbolRate: {
+ status.set<TunerFrontendStatus::symbolRate>((int)s.symbolRate());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::innerFec: {
+ status.set<TunerFrontendStatus::innerFec>((long)s.innerFec());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::modulation: {
+ switch (s.modulation().getDiscriminator()) {
+ case FrontendModulationStatus::hidl_discriminator::dvbc:
+ status.set<TunerFrontendStatus::modulation>((int)s.modulation().dvbc());
+ aidlStatus.push_back(status);
+ break;
+ case FrontendModulationStatus::hidl_discriminator::dvbs:
+ status.set<TunerFrontendStatus::modulation>((int)s.modulation().dvbs());
+ aidlStatus.push_back(status);
+ break;
+ case FrontendModulationStatus::hidl_discriminator::isdbs:
+ status.set<TunerFrontendStatus::modulation>((int)s.modulation().isdbs());
+ aidlStatus.push_back(status);
+ break;
+ case FrontendModulationStatus::hidl_discriminator::isdbs3:
+ status.set<TunerFrontendStatus::modulation>((int)s.modulation().isdbs3());
+ aidlStatus.push_back(status);
+ break;
+ case FrontendModulationStatus::hidl_discriminator::isdbt:
+ status.set<TunerFrontendStatus::modulation>((int)s.modulation().isdbt());
+ aidlStatus.push_back(status);
+ break;
+ }
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::inversion: {
+ status.set<TunerFrontendStatus::inversion>((int)s.inversion());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::lnbVoltage: {
+ status.set<TunerFrontendStatus::lnbVoltage>((int)s.lnbVoltage());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::plpId: {
+ status.set<TunerFrontendStatus::plpId>((int8_t)s.plpId());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::isEWBS: {
+ status.set<TunerFrontendStatus::isEWBS>(s.isEWBS());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::agc: {
+ status.set<TunerFrontendStatus::agc>((int8_t)s.agc());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::isLnaOn: {
+ status.set<TunerFrontendStatus::isLnaOn>(s.isLnaOn());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::isLayerError: {
+ vector<bool> e(s.isLayerError().begin(), s.isLayerError().end());
+ status.set<TunerFrontendStatus::isLayerError>(e);
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::mer: {
+ status.set<TunerFrontendStatus::mer>((int)s.mer());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::freqOffset: {
+ status.set<TunerFrontendStatus::freqOffset>((int)s.freqOffset());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::hierarchy: {
+ status.set<TunerFrontendStatus::hierarchy>((int)s.hierarchy());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::isRfLocked: {
+ status.set<TunerFrontendStatus::isRfLocked>(s.isRfLocked());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatus::hidl_discriminator::plpInfo: {
+ vector<TunerFrontendStatusAtsc3PlpInfo> info;
+ for (auto i : s.plpInfo()) {
+ info.push_back({
+ .plpId = (int8_t)i.plpId,
+ .isLocked = i.isLocked,
+ .uec = (int)i.uec,
+ });
+ }
+ status.set<TunerFrontendStatus::plpInfo>(info);
+ aidlStatus.push_back(status);
+ break;
+ }
+ }
+ }
+}
+
+void TunerFrontend::getAidlFrontendStatusExt(
+ vector<FrontendStatusExt1_1>& hidlStatus, vector<TunerFrontendStatus>& aidlStatus) {
+ for (FrontendStatusExt1_1 s : hidlStatus) {
+ TunerFrontendStatus status;
+ switch (s.getDiscriminator()) {
+ case FrontendStatusExt1_1::hidl_discriminator::modulations: {
+ vector<int> aidlMod;
+ for (auto m : s.modulations()) {
+ switch (m.getDiscriminator()) {
+ case FrontendModulation::hidl_discriminator::dvbc:
+ aidlMod.push_back((int)m.dvbc());
+ break;
+ case FrontendModulation::hidl_discriminator::dvbs:
+ aidlMod.push_back((int)m.dvbs());
+ break;
+ case FrontendModulation::hidl_discriminator::dvbt:
+ aidlMod.push_back((int)m.dvbt());
+ break;
+ case FrontendModulation::hidl_discriminator::isdbs:
+ aidlMod.push_back((int)m.isdbs());
+ break;
+ case FrontendModulation::hidl_discriminator::isdbs3:
+ aidlMod.push_back((int)m.isdbs3());
+ break;
+ case FrontendModulation::hidl_discriminator::isdbt:
+ aidlMod.push_back((int)m.isdbt());
+ break;
+ case FrontendModulation::hidl_discriminator::atsc:
+ aidlMod.push_back((int)m.atsc());
+ break;
+ case FrontendModulation::hidl_discriminator::atsc3:
+ aidlMod.push_back((int)m.atsc3());
+ break;
+ case FrontendModulation::hidl_discriminator::dtmb:
+ aidlMod.push_back((int)m.dtmb());
+ break;
+ }
+ }
+ status.set<TunerFrontendStatus::modulations>(aidlMod);
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatusExt1_1::hidl_discriminator::bers: {
+ vector<int> b(s.bers().begin(), s.bers().end());
+ status.set<TunerFrontendStatus::bers>(b);
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatusExt1_1::hidl_discriminator::codeRates: {
+ vector<int64_t> codeRates;
+ for (auto c : s.codeRates()) {
+ codeRates.push_back((long)c);
+ }
+ status.set<TunerFrontendStatus::codeRates>(codeRates);
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatusExt1_1::hidl_discriminator::bandwidth: {
+ switch (s.bandwidth().getDiscriminator()) {
+ case FrontendBandwidth::hidl_discriminator::atsc3:
+ status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().atsc3());
+ break;
+ case FrontendBandwidth::hidl_discriminator::dvbc:
+ status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().dvbc());
+ break;
+ case FrontendBandwidth::hidl_discriminator::dvbt:
+ status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().dvbt());
+ break;
+ case FrontendBandwidth::hidl_discriminator::isdbt:
+ status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().isdbt());
+ break;
+ case FrontendBandwidth::hidl_discriminator::dtmb:
+ status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().dtmb());
+ break;
+ }
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatusExt1_1::hidl_discriminator::interval: {
+ switch (s.interval().getDiscriminator()) {
+ case FrontendGuardInterval::hidl_discriminator::dvbt:
+ status.set<TunerFrontendStatus::interval>((int)s.interval().dvbt());
+ break;
+ case FrontendGuardInterval::hidl_discriminator::isdbt:
+ status.set<TunerFrontendStatus::interval>((int)s.interval().isdbt());
+ break;
+ case FrontendGuardInterval::hidl_discriminator::dtmb:
+ status.set<TunerFrontendStatus::interval>((int)s.interval().dtmb());
+ break;
+ }
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatusExt1_1::hidl_discriminator::transmissionMode: {
+ switch (s.transmissionMode().getDiscriminator()) {
+ case FrontendTransmissionMode::hidl_discriminator::dvbt:
+ status.set<TunerFrontendStatus::transmissionMode>(
+ (int)s.transmissionMode().dvbt());
+ break;
+ case FrontendTransmissionMode::hidl_discriminator::isdbt:
+ status.set<TunerFrontendStatus::transmissionMode>(
+ (int)s.transmissionMode().isdbt());
+ break;
+ case FrontendTransmissionMode::hidl_discriminator::dtmb:
+ status.set<TunerFrontendStatus::transmissionMode>(
+ (int)s.transmissionMode().dtmb());
+ break;
+ }
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatusExt1_1::hidl_discriminator::uec: {
+ status.set<TunerFrontendStatus::uec>((int)s.uec());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatusExt1_1::hidl_discriminator::systemId: {
+ status.set<TunerFrontendStatus::systemId>((char16_t)s.systemId());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatusExt1_1::hidl_discriminator::interleaving: {
+ vector<int> aidlInter;
+ for (auto i : s.interleaving()) {
+ switch (i.getDiscriminator()) {
+ case FrontendInterleaveMode::hidl_discriminator::atsc3:
+ aidlInter.push_back((int)i.atsc3());
+ break;
+ case FrontendInterleaveMode::hidl_discriminator::dvbc:
+ aidlInter.push_back((int)i.dvbc());
+ break;
+ case FrontendInterleaveMode::hidl_discriminator::dtmb:
+ aidlInter.push_back((int)i.dtmb());
+ break;
+ }
+ }
+ status.set<TunerFrontendStatus::interleaving>(aidlInter);
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatusExt1_1::hidl_discriminator::isdbtSegment: {
+ auto seg = s.isdbtSegment();
+ vector<uint8_t> i(seg.begin(), seg.end());
+ status.set<TunerFrontendStatus::isdbtSegment>(i);
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatusExt1_1::hidl_discriminator::tsDataRate: {
+ vector<int> ts(s.tsDataRate().begin(), s.tsDataRate().end());
+ status.set<TunerFrontendStatus::tsDataRate>(ts);
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatusExt1_1::hidl_discriminator::rollOff: {
+ switch (s.rollOff().getDiscriminator()) {
+ case FrontendRollOff::hidl_discriminator::dvbs:
+ status.set<TunerFrontendStatus::interleaving>((int)s.rollOff().dvbs());
+ break;
+ case FrontendRollOff::hidl_discriminator::isdbs:
+ status.set<TunerFrontendStatus::interleaving>((int)s.rollOff().isdbs());
+ break;
+ case FrontendRollOff::hidl_discriminator::isdbs3:
+ status.set<TunerFrontendStatus::interleaving>((int)s.rollOff().isdbs3());
+ break;
+ }
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatusExt1_1::hidl_discriminator::isMiso: {
+ status.set<TunerFrontendStatus::isMiso>(s.isMiso());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatusExt1_1::hidl_discriminator::isLinear: {
+ status.set<TunerFrontendStatus::isLinear>(s.isLinear());
+ aidlStatus.push_back(status);
+ break;
+ }
+ case FrontendStatusExt1_1::hidl_discriminator::isShortFrames: {
+ status.set<TunerFrontendStatus::isShortFrames>(s.isShortFrames());
+ aidlStatus.push_back(status);
+ break;
+ }
+ }
+ }
+}
+
hidl_vec<FrontendAtsc3PlpSettings> TunerFrontend::getAtsc3PlpSettings(
const TunerFrontendAtsc3Settings& settings) {
int len = settings.plpSettings.size();
diff --git a/services/tuner/TunerFrontend.h b/services/tuner/TunerFrontend.h
index c58a862..729640c 100644
--- a/services/tuner/TunerFrontend.h
+++ b/services/tuner/TunerFrontend.h
@@ -42,11 +42,13 @@
using ::android::hardware::tv::tuner::V1_0::FrontendScanMessage;
using ::android::hardware::tv::tuner::V1_0::FrontendScanMessageType;
using ::android::hardware::tv::tuner::V1_0::FrontendSettings;
+using ::android::hardware::tv::tuner::V1_0::FrontendStatus;
using ::android::hardware::tv::tuner::V1_0::IFrontend;
using ::android::hardware::tv::tuner::V1_1::IFrontendCallback;
using ::android::hardware::tv::tuner::V1_1::FrontendScanMessageExt1_1;
using ::android::hardware::tv::tuner::V1_1::FrontendScanMessageTypeExt1_1;
using ::android::hardware::tv::tuner::V1_1::FrontendSettingsExt1_1;
+using ::android::hardware::tv::tuner::V1_1::FrontendStatusExt1_1;
using namespace std;
@@ -68,6 +70,8 @@
Status close() override;
Status getStatus(const vector<int32_t>& statusTypes,
vector<TunerFrontendStatus>* _aidl_return) override;
+ Status getStatusExtended_1_1(const vector<int32_t>& statusTypes,
+ vector<TunerFrontendStatus>* _aidl_return) override;
Status getFrontendId(int* _aidl_return) override;
struct FrontendCallback : public IFrontendCallback {
@@ -89,6 +93,10 @@
FrontendDvbsCodeRate getDvbsCodeRate(const TunerFrontendDvbsCodeRate& codeRate);
FrontendSettings getHidlFrontendSettings(const TunerFrontendSettings& aidlSettings);
FrontendSettingsExt1_1 getHidlFrontendSettingsExt(const TunerFrontendSettings& aidlSettings);
+ void getAidlFrontendStatus(
+ vector<FrontendStatus>& hidlStatus, vector<TunerFrontendStatus>& aidlStatus);
+ void getAidlFrontendStatusExt(
+ vector<FrontendStatusExt1_1>& hidlStatus, vector<TunerFrontendStatus>& aidlStatus);
int mId;
sp<IFrontend> mFrontend;
diff --git a/services/tuner/aidl/android/media/tv/tuner/ITunerFrontend.aidl b/services/tuner/aidl/android/media/tv/tuner/ITunerFrontend.aidl
index bfc3e30..254e16a 100644
--- a/services/tuner/aidl/android/media/tv/tuner/ITunerFrontend.aidl
+++ b/services/tuner/aidl/android/media/tv/tuner/ITunerFrontend.aidl
@@ -83,6 +83,11 @@
TunerFrontendStatus[] getStatus(in int[] statusTypes);
/**
+ * Gets the 1.1 extended statuses of the frontend.
+ */
+ TunerFrontendStatus[] getStatusExtended_1_1(in int[] statusTypes);
+
+ /**
* Gets the id of the frontend.
*/
int getFrontendId();
diff --git a/services/tuner/aidl/android/media/tv/tuner/TunerFrontendScanAtsc3PlpInfo.aidl b/services/tuner/aidl/android/media/tv/tuner/TunerFrontendScanAtsc3PlpInfo.aidl
index ca4a9af..1b8fcbb 100644
--- a/services/tuner/aidl/android/media/tv/tuner/TunerFrontendScanAtsc3PlpInfo.aidl
+++ b/services/tuner/aidl/android/media/tv/tuner/TunerFrontendScanAtsc3PlpInfo.aidl
@@ -22,7 +22,7 @@
* {@hide}
*/
parcelable TunerFrontendScanAtsc3PlpInfo {
- int plpId;
+ byte plpId;
boolean llsFlag;
}
diff --git a/services/tuner/aidl/android/media/tv/tuner/TunerFrontendStatus.aidl b/services/tuner/aidl/android/media/tv/tuner/TunerFrontendStatus.aidl
index 41f9f0e..2b3c01b 100644
--- a/services/tuner/aidl/android/media/tv/tuner/TunerFrontendStatus.aidl
+++ b/services/tuner/aidl/android/media/tv/tuner/TunerFrontendStatus.aidl
@@ -16,9 +16,172 @@
package android.media.tv.tuner;
+import android.media.tv.tuner.TunerFrontendStatusAtsc3PlpInfo;
+
/**
* Tuner Frontend Status interface.
*
* {@hide}
*/
-parcelable TunerFrontendStatus {}
+union TunerFrontendStatus {
+ /**
+ * Lock status for Demod in True/False.
+ */
+ boolean isDemodLocked;
+
+ /**
+ * SNR value measured by 0.001 dB.
+ */
+ int snr;
+
+ /**
+ * The number of error bits per 1 billion bits.
+ */
+ int ber;
+
+ /**
+ * The number of error packages per 1 billion packages.
+ */
+ int per;
+
+ /**
+ * The number of error bits per 1 billion bits before FEC.
+ */
+ int preBer;
+
+ /**
+ * Signal Quality in percent.
+ */
+ int signalQuality;
+
+ /**
+ * Signal Strength measured by 0.001 dBm.
+ */
+ int signalStrength;
+
+ /**
+ * Symbols per second
+ */
+ int symbolRate;
+
+ long innerFec;
+
+ /**
+ * Check frontend type to decide the hidl type value
+ */
+ int modulation;
+
+ int inversion;
+
+ int lnbVoltage;
+
+ byte plpId;
+
+ boolean isEWBS;
+
+ /**
+ * AGC value is normalized from 0 to 255.
+ */
+ byte agc;
+
+ boolean isLnaOn;
+
+ boolean[] isLayerError;
+
+ /**
+ * MER value measured by 0.001 dB
+ */
+ int mer;
+
+ /**
+ * Frequency difference in Hertz.
+ */
+ int freqOffset;
+
+ int hierarchy;
+
+ boolean isRfLocked;
+
+ /**
+ * A list of PLP status for tuned PLPs for ATSC3 frontend.
+ */
+ TunerFrontendStatusAtsc3PlpInfo[] plpInfo;
+
+ // 1.1 Extension Starting
+
+ /**
+ * Extended modulation status. Check frontend type to decide the hidl type value.
+ */
+ int[] modulations;
+
+ /**
+ * Extended bit error ratio status.
+ */
+ int[] bers;
+
+ /**
+ * Extended code rate status.
+ */
+ long[] codeRates;
+
+ /**
+ * Extended bandwidth status. Check frontend type to decide the hidl type value.
+ */
+ int bandwidth;
+
+ /**
+ * Extended guard interval status. Check frontend type to decide the hidl type value.
+ */
+ int interval;
+
+ /**
+ * Extended transmission mode status. Check frontend type to decide the hidl type value.
+ */
+ int transmissionMode;
+
+ /**
+ * Uncorrectable Error Counts of the frontend's Physical Layer Pipe (PLP)
+ * since the last tune operation.
+ */
+ int uec;
+
+ /**
+ * The current DVB-T2 system id status.
+ */
+ char systemId;
+
+ /**
+ * Frontend Interleaving Modes. Check frontend type to decide the hidl type value.
+ */
+ int[] interleaving;
+
+ /**
+ * Segments in ISDB-T Specification of all the channels.
+ */
+ byte[] isdbtSegment;
+
+ /**
+ * Transport Stream Data Rate in BPS of the current channel.
+ */
+ int[] tsDataRate;
+
+ /**
+ * Roll Off Type status of the frontend. Check frontend type to decide the hidl type value.
+ */
+ int rollOff;
+
+ /**
+ * If the frontend currently supports MISO or not.
+ */
+ boolean isMiso;
+
+ /**
+ * If the frontend code rate is linear or not.
+ */
+ boolean isLinear;
+
+ /**
+ * If short frames are enabled or not.
+ */
+ boolean isShortFrames;
+}
diff --git a/services/tuner/aidl/android/media/tv/tuner/TunerFrontendStatusAtsc3PlpInfo.aidl b/services/tuner/aidl/android/media/tv/tuner/TunerFrontendStatusAtsc3PlpInfo.aidl
new file mode 100644
index 0000000..4116c34
--- /dev/null
+++ b/services/tuner/aidl/android/media/tv/tuner/TunerFrontendStatusAtsc3PlpInfo.aidl
@@ -0,0 +1,39 @@
+/**
+ * Copyright 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.
+ */
+
+package android.media.tv.tuner;
+
+/**
+ * Atsc3 Frontend Physical Layer Pipe Info in Frontend status.
+ *
+ * {@hide}
+ */
+parcelable TunerFrontendStatusAtsc3PlpInfo {
+ /**
+ * PLP Id value.
+ */
+ byte plpId;
+
+ /**
+ * Demod Lock/Unlock status of this particular PLP.
+ */
+ boolean isLocked;
+
+ /**
+ * Uncorrectable Error Counts (UEC) of this particular PLP since last tune operation.
+ */
+ int uec;
+}