Amy Zhang | bb94eeb | 2020-07-09 22:48:04 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2020 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #define LOG_TAG "android.hardware.tv.tuner@1.1-Frontend" |
| 18 | |
| 19 | #include "Frontend.h" |
| 20 | #include <android/hardware/tv/tuner/1.0/IFrontendCallback.h> |
| 21 | #include <utils/Log.h> |
| 22 | |
| 23 | namespace android { |
| 24 | namespace hardware { |
| 25 | namespace tv { |
| 26 | namespace tuner { |
| 27 | namespace V1_0 { |
| 28 | namespace implementation { |
| 29 | |
| 30 | Frontend::Frontend(FrontendType type, FrontendId id, sp<Tuner> tuner) { |
| 31 | mType = type; |
| 32 | mId = id; |
| 33 | mTunerService = tuner; |
| 34 | // Init callback to nullptr |
| 35 | mCallback = nullptr; |
| 36 | } |
| 37 | |
| 38 | Frontend::~Frontend() {} |
| 39 | |
| 40 | Return<Result> Frontend::close() { |
| 41 | ALOGV("%s", __FUNCTION__); |
| 42 | // Reset callback |
| 43 | mCallback = nullptr; |
| 44 | mIsLocked = false; |
Amy Zhang | 80cb960 | 2020-07-15 13:06:39 -0700 | [diff] [blame] | 45 | mTunerService->removeFrontend(mId); |
Amy Zhang | bb94eeb | 2020-07-09 22:48:04 -0700 | [diff] [blame] | 46 | |
| 47 | return Result::SUCCESS; |
| 48 | } |
| 49 | |
| 50 | Return<Result> Frontend::setCallback(const sp<IFrontendCallback>& callback) { |
| 51 | ALOGV("%s", __FUNCTION__); |
| 52 | if (callback == nullptr) { |
| 53 | ALOGW("[ WARN ] Set Frontend callback with nullptr"); |
| 54 | return Result::INVALID_ARGUMENT; |
| 55 | } |
| 56 | |
| 57 | mCallback = callback; |
| 58 | return Result::SUCCESS; |
| 59 | } |
| 60 | |
| 61 | Return<Result> Frontend::tune(const FrontendSettings& /* settings */) { |
| 62 | ALOGV("%s", __FUNCTION__); |
| 63 | if (mCallback == nullptr) { |
| 64 | ALOGW("[ WARN ] Frontend callback is not set when tune"); |
| 65 | return Result::INVALID_STATE; |
| 66 | } |
| 67 | |
| 68 | mTunerService->frontendStartTune(mId); |
| 69 | mCallback->onEvent(FrontendEventType::LOCKED); |
| 70 | mIsLocked = true; |
| 71 | return Result::SUCCESS; |
| 72 | } |
| 73 | |
Amy Zhang | 3ea25a6 | 2020-08-04 10:23:52 -0700 | [diff] [blame] | 74 | Return<Result> Frontend::tune_1_1(const FrontendSettings& settings, |
Amy Zhang | bc15b59 | 2020-09-25 15:35:55 -0700 | [diff] [blame] | 75 | const V1_1::FrontendSettingsExt1_1& /*settingsExt1_1*/) { |
Amy Zhang | 3ea25a6 | 2020-08-04 10:23:52 -0700 | [diff] [blame] | 76 | ALOGV("%s", __FUNCTION__); |
| 77 | return tune(settings); |
| 78 | } |
| 79 | |
Amy Zhang | bb94eeb | 2020-07-09 22:48:04 -0700 | [diff] [blame] | 80 | Return<Result> Frontend::stopTune() { |
| 81 | ALOGV("%s", __FUNCTION__); |
| 82 | |
| 83 | mTunerService->frontendStopTune(mId); |
| 84 | mIsLocked = false; |
| 85 | |
| 86 | return Result::SUCCESS; |
| 87 | } |
| 88 | |
| 89 | Return<Result> Frontend::scan(const FrontendSettings& settings, FrontendScanType type) { |
| 90 | ALOGV("%s", __FUNCTION__); |
| 91 | |
| 92 | if (mType == FrontendType::ATSC) { |
| 93 | FrontendScanMessage msg; |
| 94 | msg.isLocked(true); |
| 95 | mCallback->onScanMessage(FrontendScanMessageType::LOCKED, msg); |
| 96 | mIsLocked = true; |
| 97 | return Result::SUCCESS; |
| 98 | } |
| 99 | if (mType != FrontendType::DVBT) { |
| 100 | return Result::UNAVAILABLE; |
| 101 | } |
| 102 | |
| 103 | FrontendScanMessage msg; |
| 104 | |
| 105 | if (mIsLocked) { |
| 106 | msg.isEnd(true); |
| 107 | mCallback->onScanMessage(FrontendScanMessageType::END, msg); |
| 108 | return Result::SUCCESS; |
| 109 | } |
| 110 | |
| 111 | uint32_t frequency = settings.dvbt().frequency; |
| 112 | if (type == FrontendScanType::SCAN_BLIND) { |
| 113 | frequency += 100; |
| 114 | } |
| 115 | msg.frequencies({frequency}); |
| 116 | mCallback->onScanMessage(FrontendScanMessageType::FREQUENCY, msg); |
| 117 | msg.isLocked(true); |
| 118 | mCallback->onScanMessage(FrontendScanMessageType::LOCKED, msg); |
| 119 | mIsLocked = true; |
| 120 | |
| 121 | return Result::SUCCESS; |
| 122 | } |
| 123 | |
Amy Zhang | 3ea25a6 | 2020-08-04 10:23:52 -0700 | [diff] [blame] | 124 | Return<Result> Frontend::scan_1_1(const FrontendSettings& settings, FrontendScanType type, |
Amy Zhang | bc15b59 | 2020-09-25 15:35:55 -0700 | [diff] [blame] | 125 | const V1_1::FrontendSettingsExt1_1& /*settingsExt1_1*/) { |
Amy Zhang | 3ea25a6 | 2020-08-04 10:23:52 -0700 | [diff] [blame] | 126 | ALOGV("%s", __FUNCTION__); |
| 127 | return scan(settings, type); |
| 128 | } |
| 129 | |
Amy Zhang | bb94eeb | 2020-07-09 22:48:04 -0700 | [diff] [blame] | 130 | Return<Result> Frontend::stopScan() { |
| 131 | ALOGV("%s", __FUNCTION__); |
| 132 | |
| 133 | mIsLocked = false; |
| 134 | return Result::SUCCESS; |
| 135 | } |
| 136 | |
| 137 | Return<void> Frontend::getStatus(const hidl_vec<FrontendStatusType>& statusTypes, |
| 138 | getStatus_cb _hidl_cb) { |
| 139 | ALOGV("%s", __FUNCTION__); |
| 140 | |
| 141 | vector<FrontendStatus> statuses; |
| 142 | for (int i = 0; i < statusTypes.size(); i++) { |
| 143 | FrontendStatusType type = statusTypes[i]; |
| 144 | FrontendStatus status; |
| 145 | // assign randomly selected values for testing. |
| 146 | switch (type) { |
| 147 | case FrontendStatusType::DEMOD_LOCK: { |
| 148 | status.isDemodLocked(true); |
| 149 | break; |
| 150 | } |
| 151 | case FrontendStatusType::SNR: { |
| 152 | status.snr(221); |
| 153 | break; |
| 154 | } |
| 155 | case FrontendStatusType::BER: { |
| 156 | status.ber(1); |
| 157 | break; |
| 158 | } |
| 159 | case FrontendStatusType::PER: { |
| 160 | status.per(2); |
| 161 | break; |
| 162 | } |
| 163 | case FrontendStatusType::PRE_BER: { |
| 164 | status.preBer(3); |
| 165 | break; |
| 166 | } |
| 167 | case FrontendStatusType::SIGNAL_QUALITY: { |
| 168 | status.signalQuality(4); |
| 169 | break; |
| 170 | } |
| 171 | case FrontendStatusType::SIGNAL_STRENGTH: { |
| 172 | status.signalStrength(5); |
| 173 | break; |
| 174 | } |
| 175 | case FrontendStatusType::SYMBOL_RATE: { |
| 176 | status.symbolRate(6); |
| 177 | break; |
| 178 | } |
| 179 | case FrontendStatusType::FEC: { |
| 180 | status.innerFec(FrontendInnerFec::FEC_2_9); // value = 1 << 7 |
| 181 | break; |
| 182 | } |
| 183 | case FrontendStatusType::MODULATION: { |
| 184 | FrontendModulationStatus modulationStatus; |
| 185 | modulationStatus.isdbt(FrontendIsdbtModulation::MOD_16QAM); // value = 1 << 3 |
| 186 | status.modulation(modulationStatus); |
| 187 | break; |
| 188 | } |
| 189 | case FrontendStatusType::SPECTRAL: { |
| 190 | status.inversion(FrontendDvbcSpectralInversion::NORMAL); |
| 191 | break; |
| 192 | } |
| 193 | case FrontendStatusType::LNB_VOLTAGE: { |
| 194 | status.lnbVoltage(LnbVoltage::VOLTAGE_5V); |
| 195 | break; |
| 196 | } |
| 197 | case FrontendStatusType::PLP_ID: { |
| 198 | status.plpId(101); // type uint8_t |
| 199 | break; |
| 200 | } |
| 201 | case FrontendStatusType::EWBS: { |
| 202 | status.isEWBS(false); |
| 203 | break; |
| 204 | } |
| 205 | case FrontendStatusType::AGC: { |
| 206 | status.agc(7); |
| 207 | break; |
| 208 | } |
| 209 | case FrontendStatusType::LNA: { |
| 210 | status.isLnaOn(false); |
| 211 | break; |
| 212 | } |
| 213 | case FrontendStatusType::LAYER_ERROR: { |
| 214 | vector<bool> v = {false, true, true}; |
| 215 | status.isLayerError(v); |
| 216 | break; |
| 217 | } |
| 218 | case FrontendStatusType::MER: { |
| 219 | status.mer(8); |
| 220 | break; |
| 221 | } |
| 222 | case FrontendStatusType::FREQ_OFFSET: { |
| 223 | status.freqOffset(9); |
| 224 | break; |
| 225 | } |
| 226 | case FrontendStatusType::HIERARCHY: { |
| 227 | status.hierarchy(FrontendDvbtHierarchy::HIERARCHY_1_NATIVE); |
| 228 | break; |
| 229 | } |
| 230 | case FrontendStatusType::RF_LOCK: { |
| 231 | status.isRfLocked(false); |
| 232 | break; |
| 233 | } |
| 234 | case FrontendStatusType::ATSC3_PLP_INFO: { |
| 235 | vector<FrontendStatusAtsc3PlpInfo> v; |
| 236 | FrontendStatusAtsc3PlpInfo info1{ |
| 237 | .plpId = 3, |
| 238 | .isLocked = false, |
| 239 | .uec = 313, |
| 240 | }; |
| 241 | FrontendStatusAtsc3PlpInfo info2{ |
| 242 | .plpId = 5, |
| 243 | .isLocked = true, |
| 244 | .uec = 515, |
| 245 | }; |
| 246 | v.push_back(info1); |
| 247 | v.push_back(info2); |
| 248 | status.plpInfo(v); |
| 249 | break; |
| 250 | } |
| 251 | default: { |
| 252 | continue; |
| 253 | } |
| 254 | } |
| 255 | statuses.push_back(status); |
| 256 | } |
| 257 | _hidl_cb(Result::SUCCESS, statuses); |
| 258 | |
| 259 | return Void(); |
| 260 | } |
| 261 | |
| 262 | Return<Result> Frontend::setLna(bool /* bEnable */) { |
| 263 | ALOGV("%s", __FUNCTION__); |
| 264 | |
| 265 | return Result::SUCCESS; |
| 266 | } |
| 267 | |
| 268 | Return<Result> Frontend::setLnb(uint32_t /* lnb */) { |
| 269 | ALOGV("%s", __FUNCTION__); |
| 270 | if (!supportsSatellite()) { |
| 271 | return Result::INVALID_STATE; |
| 272 | } |
| 273 | return Result::SUCCESS; |
| 274 | } |
| 275 | |
Amy Zhang | 17f8eac | 2020-08-17 16:52:13 -0700 | [diff] [blame] | 276 | Return<Result> Frontend::linkCiCam(uint32_t ciCamId) { |
| 277 | ALOGV("%s", __FUNCTION__); |
| 278 | |
| 279 | mCiCamId = ciCamId; |
| 280 | |
| 281 | return Result::SUCCESS; |
| 282 | } |
| 283 | |
Amy Zhang | bb94eeb | 2020-07-09 22:48:04 -0700 | [diff] [blame] | 284 | FrontendType Frontend::getFrontendType() { |
| 285 | return mType; |
| 286 | } |
| 287 | |
| 288 | FrontendId Frontend::getFrontendId() { |
| 289 | return mId; |
| 290 | } |
| 291 | |
| 292 | bool Frontend::supportsSatellite() { |
| 293 | return mType == FrontendType::DVBS || mType == FrontendType::ISDBS || |
| 294 | mType == FrontendType::ISDBS3; |
| 295 | } |
| 296 | |
| 297 | bool Frontend::isLocked() { |
| 298 | return mIsLocked; |
| 299 | } |
| 300 | } // namespace implementation |
| 301 | } // namespace V1_0 |
| 302 | } // namespace tuner |
| 303 | } // namespace tv |
| 304 | } // namespace hardware |
| 305 | } // namespace android |