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 package android.media.tv.tuner.cts; 18 19 import static com.google.common.truth.Truth.assertThat; 20 21 import static org.junit.Assert.assertEquals; 22 import static org.junit.Assert.assertFalse; 23 import static org.junit.Assert.assertNotNull; 24 import static org.junit.Assert.assertTrue; 25 26 import android.content.Context; 27 import android.content.pm.PackageManager; 28 import android.media.tv.tuner.Tuner; 29 import android.media.tv.tuner.TunerVersionChecker; 30 import android.media.tv.tuner.frontend.AnalogFrontendCapabilities; 31 import android.media.tv.tuner.frontend.AnalogFrontendSettings; 32 import android.media.tv.tuner.frontend.Atsc3FrontendCapabilities; 33 import android.media.tv.tuner.frontend.Atsc3FrontendSettings; 34 import android.media.tv.tuner.frontend.Atsc3PlpSettings; 35 import android.media.tv.tuner.frontend.AtscFrontendCapabilities; 36 import android.media.tv.tuner.frontend.AtscFrontendSettings; 37 import android.media.tv.tuner.frontend.DtmbFrontendCapabilities; 38 import android.media.tv.tuner.frontend.DtmbFrontendSettings; 39 import android.media.tv.tuner.frontend.DvbcFrontendCapabilities; 40 import android.media.tv.tuner.frontend.DvbcFrontendSettings; 41 import android.media.tv.tuner.frontend.DvbsCodeRate; 42 import android.media.tv.tuner.frontend.DvbsFrontendCapabilities; 43 import android.media.tv.tuner.frontend.DvbsFrontendSettings; 44 import android.media.tv.tuner.frontend.DvbtFrontendCapabilities; 45 import android.media.tv.tuner.frontend.DvbtFrontendSettings; 46 import android.media.tv.tuner.frontend.FrontendCapabilities; 47 import android.media.tv.tuner.frontend.FrontendInfo; 48 import android.media.tv.tuner.frontend.FrontendSettings; 49 import android.media.tv.tuner.frontend.Isdbs3FrontendCapabilities; 50 import android.media.tv.tuner.frontend.Isdbs3FrontendSettings; 51 import android.media.tv.tuner.frontend.IsdbsFrontendCapabilities; 52 import android.media.tv.tuner.frontend.IsdbsFrontendSettings; 53 import android.media.tv.tuner.frontend.IsdbtFrontendCapabilities; 54 import android.media.tv.tuner.frontend.IsdbtFrontendSettings; 55 56 import androidx.test.InstrumentationRegistry; 57 import androidx.test.filters.SmallTest; 58 import androidx.test.runner.AndroidJUnit4; 59 60 import com.android.compatibility.common.util.RequiredFeatureRule; 61 62 import org.junit.After; 63 import org.junit.Before; 64 import org.junit.Ignore; 65 import org.junit.Rule; 66 import org.junit.Test; 67 import org.junit.runner.RunWith; 68 69 import java.util.HashMap; 70 import java.util.List; 71 import java.util.Map; 72 73 @RunWith(AndroidJUnit4.class) 74 @SmallTest 75 public class TunerFrontendTest { 76 private static final String TAG = "MediaTunerFrontendTest"; 77 78 @Rule 79 public RequiredFeatureRule featureRule = new RequiredFeatureRule( 80 PackageManager.FEATURE_TUNER); 81 82 private Context mContext; 83 private Tuner mTuner; 84 85 @Before setUp()86 public void setUp() throws Exception { 87 mContext = InstrumentationRegistry.getTargetContext(); 88 InstrumentationRegistry 89 .getInstrumentation().getUiAutomation().adoptShellPermissionIdentity(); 90 mTuner = new Tuner(mContext, null, 100); 91 } 92 93 @After tearDown()94 public void tearDown() { 95 if (mTuner != null) { 96 mTuner.close(); 97 mTuner = null; 98 } 99 } 100 101 @Test testAnalogFrontendSettingsWithIntFrequency()102 public void testAnalogFrontendSettingsWithIntFrequency() throws Exception { 103 AnalogFrontendSettings settings = 104 AnalogFrontendSettings 105 .builder() 106 .setFrequency(1) 107 .setSignalType(AnalogFrontendSettings.SIGNAL_TYPE_NTSC) 108 .setSifStandard(AnalogFrontendSettings.SIF_BG_NICAM) 109 .setAftFlag(AnalogFrontendSettings.AFT_FLAG_TRUE) 110 .build(); 111 112 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 113 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 114 settings.setEndFrequency(100); 115 } else { 116 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 117 settings.setEndFrequency(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY); 118 } 119 120 assertEquals(FrontendSettings.TYPE_ANALOG, settings.getType()); 121 assertEquals(1, settings.getFrequency()); 122 assertEquals(AnalogFrontendSettings.SIGNAL_TYPE_NTSC, settings.getSignalType()); 123 assertEquals(AnalogFrontendSettings.SIF_BG_NICAM, settings.getSifStandard()); 124 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 125 assertEquals(AnalogFrontendSettings.AFT_FLAG_TRUE, settings.getAftFlag()); 126 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 127 settings.getFrontendSpectralInversion()); 128 assertEquals(100, settings.getEndFrequency()); 129 } else { 130 assertEquals(AnalogFrontendSettings.AFT_FLAG_UNDEFINED, settings.getAftFlag()); 131 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 132 settings.getFrontendSpectralInversion()); 133 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequency()); 134 } 135 } 136 137 @Test testAtsc3FrontendSettingsWithIntFrequency()138 public void testAtsc3FrontendSettingsWithIntFrequency() throws Exception { 139 Atsc3PlpSettings plp1 = 140 Atsc3PlpSettings 141 .builder() 142 .setPlpId(1) 143 .setModulation(Atsc3FrontendSettings.MODULATION_MOD_QPSK) 144 .setInterleaveMode(Atsc3FrontendSettings.TIME_INTERLEAVE_MODE_AUTO) 145 .setCodeRate(Atsc3FrontendSettings.CODERATE_6_15) 146 .setFec(Atsc3FrontendSettings.FEC_BCH_LDPC_64K) 147 .build(); 148 149 Atsc3PlpSettings plp2 = 150 Atsc3PlpSettings 151 .builder() 152 .setPlpId(2) 153 .setModulation(Atsc3FrontendSettings.MODULATION_MOD_QPSK) 154 .setInterleaveMode(Atsc3FrontendSettings.TIME_INTERLEAVE_MODE_HTI) 155 .setCodeRate(Atsc3FrontendSettings.CODERATE_UNDEFINED) 156 .setFec(Atsc3FrontendSettings.FEC_LDPC_16K) 157 .build(); 158 159 Atsc3FrontendSettings settings = 160 Atsc3FrontendSettings 161 .builder() 162 .setFrequency(2) 163 .setBandwidth(Atsc3FrontendSettings.BANDWIDTH_BANDWIDTH_6MHZ) 164 .setDemodOutputFormat(Atsc3FrontendSettings.MODULATION_MOD_QPSK) 165 .setPlpSettings(new Atsc3PlpSettings[] {plp1, plp2}) 166 .build(); 167 168 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 169 settings.setEndFrequency(100); 170 171 assertEquals(FrontendSettings.TYPE_ATSC3, settings.getType()); 172 assertEquals(2, settings.getFrequency()); 173 assertEquals(Atsc3FrontendSettings.BANDWIDTH_BANDWIDTH_6MHZ, settings.getBandwidth()); 174 assertEquals(Atsc3FrontendSettings.MODULATION_MOD_QPSK, settings.getDemodOutputFormat()); 175 176 Atsc3PlpSettings[] plps = settings.getPlpSettings(); 177 assertEquals(2, plps.length); 178 179 assertEquals(1, plps[0].getPlpId()); 180 assertEquals(Atsc3FrontendSettings.MODULATION_MOD_QPSK, plps[0].getModulation()); 181 assertEquals(Atsc3FrontendSettings.TIME_INTERLEAVE_MODE_AUTO, plps[0].getInterleaveMode()); 182 assertEquals(Atsc3FrontendSettings.CODERATE_6_15, plps[0].getCodeRate()); 183 assertEquals(Atsc3FrontendSettings.FEC_BCH_LDPC_64K, plps[0].getFec()); 184 185 assertEquals(2, plps[1].getPlpId()); 186 assertEquals(Atsc3FrontendSettings.MODULATION_MOD_QPSK, plps[1].getModulation()); 187 assertEquals(Atsc3FrontendSettings.TIME_INTERLEAVE_MODE_HTI, plps[1].getInterleaveMode()); 188 assertEquals(Atsc3FrontendSettings.CODERATE_UNDEFINED, plps[1].getCodeRate()); 189 assertEquals(Atsc3FrontendSettings.FEC_LDPC_16K, plps[1].getFec()); 190 191 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 192 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 193 settings.getFrontendSpectralInversion()); 194 assertEquals(100, settings.getEndFrequency()); 195 } else { 196 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 197 settings.getFrontendSpectralInversion()); 198 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequency()); 199 } 200 } 201 202 @Test testAtscFrontendSettingsWithIntFrequency()203 public void testAtscFrontendSettingsWithIntFrequency() throws Exception { 204 AtscFrontendSettings settings = 205 AtscFrontendSettings 206 .builder() 207 .setFrequency(3) 208 .setModulation(AtscFrontendSettings.MODULATION_MOD_8VSB) 209 .build(); 210 211 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 212 settings.setEndFrequency(100); 213 214 assertEquals(FrontendSettings.TYPE_ATSC, settings.getType()); 215 assertEquals(3, settings.getFrequency()); 216 assertEquals(AtscFrontendSettings.MODULATION_MOD_8VSB, settings.getModulation()); 217 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 218 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 219 settings.getFrontendSpectralInversion()); 220 assertEquals(100, settings.getEndFrequency()); 221 } else { 222 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 223 settings.getFrontendSpectralInversion()); 224 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequency()); 225 } 226 } 227 228 @Test testDvbcFrontendSettingsWithIntFrequency()229 public void testDvbcFrontendSettingsWithIntFrequency() throws Exception { 230 DvbcFrontendSettings settings = 231 DvbcFrontendSettings 232 .builder() 233 .setFrequency(4) 234 .setModulation(DvbcFrontendSettings.MODULATION_MOD_32QAM) 235 .setInnerFec(FrontendSettings.FEC_8_15) 236 .setSymbolRate(3) 237 .setOuterFec(DvbcFrontendSettings.OUTER_FEC_OUTER_FEC_RS) 238 .setAnnex(DvbcFrontendSettings.ANNEX_B) 239 .setTimeInterleaveMode(DvbcFrontendSettings.TIME_INTERLEAVE_MODE_AUTO) 240 .setBandwidth(DvbcFrontendSettings.BANDWIDTH_5MHZ) 241 // DvbcFrontendSettings.SpectralInversion is deprecated in Android 12. Use 242 // FrontendSettings.FrontendSpectralInversion instead. 243 .setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL) 244 .build(); 245 246 settings.setEndFrequency(100); 247 248 assertEquals(FrontendSettings.TYPE_DVBC, settings.getType()); 249 assertEquals(4, settings.getFrequency()); 250 assertEquals(DvbcFrontendSettings.MODULATION_MOD_32QAM, settings.getModulation()); 251 assertEquals(FrontendSettings.FEC_8_15, settings.getInnerFec()); 252 assertEquals(3, settings.getSymbolRate()); 253 assertEquals(DvbcFrontendSettings.OUTER_FEC_OUTER_FEC_RS, settings.getOuterFec()); 254 assertEquals(DvbcFrontendSettings.ANNEX_B, settings.getAnnex()); 255 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 256 settings.getSpectralInversion()); 257 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 258 assertEquals(DvbcFrontendSettings.TIME_INTERLEAVE_MODE_AUTO, 259 settings.getTimeInterleaveMode()); 260 assertEquals(100, settings.getEndFrequency()); 261 assertEquals(DvbcFrontendSettings.BANDWIDTH_5MHZ, settings.getBandwidth()); 262 } else { 263 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequency()); 264 assertEquals(DvbcFrontendSettings.BANDWIDTH_UNDEFINED, settings.getBandwidth()); 265 } 266 } 267 268 @Test testDvbsFrontendSettingsWithIntFrequency()269 public void testDvbsFrontendSettingsWithIntFrequency() throws Exception { 270 DvbsCodeRate codeRate = 271 DvbsCodeRate 272 .builder() 273 .setInnerFec(FrontendSettings.FEC_9_10) 274 .setLinear(true) 275 .setShortFrameEnabled(false) 276 .setBitsPer1000Symbol(55) 277 .build(); 278 279 DvbsFrontendSettings settings = 280 DvbsFrontendSettings 281 .builder() 282 .setFrequency(5) 283 .setModulation(DvbsFrontendSettings.MODULATION_MOD_ACM) 284 .setCodeRate(codeRate) 285 .setSymbolRate(3) 286 .setRolloff(DvbsFrontendSettings.ROLLOFF_0_15) 287 .setPilot(DvbsFrontendSettings.PILOT_OFF) 288 .setInputStreamId(1) 289 .setStandard(DvbsFrontendSettings.STANDARD_S2) 290 .setVcmMode(DvbsFrontendSettings.VCM_MODE_MANUAL) 291 .setScanType(DvbsFrontendSettings.SCAN_TYPE_DIRECT) 292 .setCanHandleDiseqcRxMessage(true) 293 .build(); 294 295 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 296 settings.setEndFrequency(100); 297 298 assertEquals(FrontendSettings.TYPE_DVBS, settings.getType()); 299 assertEquals(5, settings.getFrequency()); 300 assertEquals(DvbsFrontendSettings.MODULATION_MOD_ACM, settings.getModulation()); 301 assertEquals(3, settings.getSymbolRate()); 302 assertEquals(DvbsFrontendSettings.ROLLOFF_0_15, settings.getRolloff()); 303 assertEquals(DvbsFrontendSettings.PILOT_OFF, settings.getPilot()); 304 assertEquals(1, settings.getInputStreamId()); 305 assertEquals(DvbsFrontendSettings.STANDARD_S2, settings.getStandard()); 306 assertEquals(DvbsFrontendSettings.VCM_MODE_MANUAL, settings.getVcmMode()); 307 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 308 assertEquals(DvbsFrontendSettings.SCAN_TYPE_DIRECT, settings.getScanType()); 309 assertTrue(settings.canHandleDiseqcRxMessage()); 310 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 311 settings.getFrontendSpectralInversion()); 312 assertEquals(100, settings.getEndFrequency()); 313 } else { 314 assertEquals(DvbsFrontendSettings.SCAN_TYPE_UNDEFINED, settings.getScanType()); 315 assertFalse(settings.canHandleDiseqcRxMessage()); 316 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 317 settings.getFrontendSpectralInversion()); 318 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequency()); 319 } 320 321 DvbsCodeRate cr = settings.getCodeRate(); 322 assertNotNull(cr); 323 assertEquals(FrontendSettings.FEC_9_10, cr.getInnerFec()); 324 assertEquals(true, cr.isLinear()); 325 assertEquals(false, cr.isShortFrameEnabled()); 326 assertEquals(55, cr.getBitsPer1000Symbol()); 327 } 328 329 @Test testDvbtFrontendSettingsWithIntFrequency()330 public void testDvbtFrontendSettingsWithIntFrequency() throws Exception { 331 DvbtFrontendSettings settings = 332 DvbtFrontendSettings 333 .builder() 334 .setFrequency(6) 335 .setTransmissionMode(DvbtFrontendSettings.TRANSMISSION_MODE_EXTENDED_32K) 336 .setBandwidth(DvbtFrontendSettings.BANDWIDTH_1_7MHZ) 337 .setConstellation(DvbtFrontendSettings.CONSTELLATION_16QAM_R) 338 .setHierarchy(DvbtFrontendSettings.HIERARCHY_4_NATIVE) 339 .setHighPriorityCodeRate(DvbtFrontendSettings.CODERATE_6_7) 340 .setLowPriorityCodeRate(DvbtFrontendSettings.CODERATE_2_3) 341 .setGuardInterval(DvbtFrontendSettings.GUARD_INTERVAL_19_128) 342 .setHighPriority(true) 343 .setStandard(DvbtFrontendSettings.STANDARD_T2) 344 .setMiso(false) 345 .setPlpMode(DvbtFrontendSettings.PLP_MODE_MANUAL) 346 .setPlpId(333) 347 .setPlpGroupId(777) 348 .build(); 349 350 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 351 settings.setEndFrequency(100); 352 353 assertEquals(FrontendSettings.TYPE_DVBT, settings.getType()); 354 assertEquals(6, settings.getFrequency()); 355 assertEquals(DvbtFrontendSettings.BANDWIDTH_1_7MHZ, settings.getBandwidth()); 356 assertEquals(DvbtFrontendSettings.HIERARCHY_4_NATIVE, settings.getHierarchy()); 357 assertEquals(DvbtFrontendSettings.CODERATE_6_7, settings.getHighPriorityCodeRate()); 358 assertEquals(DvbtFrontendSettings.CODERATE_2_3, settings.getLowPriorityCodeRate()); 359 assertEquals(DvbtFrontendSettings.GUARD_INTERVAL_19_128, settings.getGuardInterval()); 360 assertEquals(true, settings.isHighPriority()); 361 assertEquals(DvbtFrontendSettings.STANDARD_T2, settings.getStandard()); 362 assertEquals(false, settings.isMiso()); 363 assertEquals(DvbtFrontendSettings.PLP_MODE_MANUAL, settings.getPlpMode()); 364 assertEquals(333, settings.getPlpId()); 365 assertEquals(777, settings.getPlpGroupId()); 366 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 367 assertEquals(DvbtFrontendSettings.TRANSMISSION_MODE_EXTENDED_32K, 368 settings.getTransmissionMode()); 369 assertEquals(DvbtFrontendSettings.CONSTELLATION_16QAM_R, settings.getConstellation()); 370 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 371 settings.getFrontendSpectralInversion()); 372 assertEquals(100, settings.getEndFrequency()); 373 } else { 374 assertEquals(DvbtFrontendSettings.TRANSMISSION_MODE_UNDEFINED, 375 settings.getTransmissionMode()); 376 assertEquals(DvbtFrontendSettings.CONSTELLATION_UNDEFINED, settings.getConstellation()); 377 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 378 settings.getFrontendSpectralInversion()); 379 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequency()); 380 } 381 } 382 383 @Test testIsdbs3FrontendSettingsWithIntFrequency()384 public void testIsdbs3FrontendSettingsWithIntFrequency() throws Exception { 385 Isdbs3FrontendSettings settings = 386 Isdbs3FrontendSettings 387 .builder() 388 .setFrequency(7) 389 .setStreamId(2) 390 .setStreamIdType(IsdbsFrontendSettings.STREAM_ID_TYPE_ID) 391 .setModulation(Isdbs3FrontendSettings.MODULATION_MOD_BPSK) 392 .setCodeRate(Isdbs3FrontendSettings.CODERATE_1_3) 393 .setSymbolRate(555) 394 .setRolloff(Isdbs3FrontendSettings.ROLLOFF_0_03) 395 .build(); 396 397 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 398 settings.setEndFrequency(100); 399 400 assertEquals(FrontendSettings.TYPE_ISDBS3, settings.getType()); 401 assertEquals(7, settings.getFrequency()); 402 assertEquals(2, settings.getStreamId()); 403 assertEquals(IsdbsFrontendSettings.STREAM_ID_TYPE_ID, settings.getStreamIdType()); 404 assertEquals(Isdbs3FrontendSettings.MODULATION_MOD_BPSK, settings.getModulation()); 405 assertEquals(Isdbs3FrontendSettings.CODERATE_1_3, settings.getCodeRate()); 406 assertEquals(555, settings.getSymbolRate()); 407 assertEquals(Isdbs3FrontendSettings.ROLLOFF_0_03, settings.getRolloff()); 408 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 409 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 410 settings.getFrontendSpectralInversion()); 411 assertEquals(100, settings.getEndFrequency()); 412 } else { 413 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 414 settings.getFrontendSpectralInversion()); 415 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequency()); 416 } 417 } 418 419 @Test testIsdbsFrontendSettingsWithIntFrequency()420 public void testIsdbsFrontendSettingsWithIntFrequency() throws Exception { 421 IsdbsFrontendSettings settings = 422 IsdbsFrontendSettings 423 .builder() 424 .setFrequency(8) 425 .setStreamId(3) 426 .setStreamIdType(IsdbsFrontendSettings.STREAM_ID_TYPE_RELATIVE_NUMBER) 427 .setModulation(IsdbsFrontendSettings.MODULATION_AUTO) 428 .setCodeRate(IsdbsFrontendSettings.CODERATE_3_4) 429 .setSymbolRate(667) 430 .setRolloff(IsdbsFrontendSettings.ROLLOFF_0_35) 431 .build(); 432 433 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 434 settings.setEndFrequency(100); 435 436 assertEquals(FrontendSettings.TYPE_ISDBS, settings.getType()); 437 assertEquals(8, settings.getFrequency()); 438 assertEquals(3, settings.getStreamId()); 439 assertEquals( 440 IsdbsFrontendSettings.STREAM_ID_TYPE_RELATIVE_NUMBER, settings.getStreamIdType()); 441 assertEquals(IsdbsFrontendSettings.MODULATION_AUTO, settings.getModulation()); 442 assertEquals(IsdbsFrontendSettings.CODERATE_3_4, settings.getCodeRate()); 443 assertEquals(667, settings.getSymbolRate()); 444 assertEquals(IsdbsFrontendSettings.ROLLOFF_0_35, settings.getRolloff()); 445 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 446 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 447 settings.getFrontendSpectralInversion()); 448 assertEquals(100, settings.getEndFrequency()); 449 } else { 450 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 451 settings.getFrontendSpectralInversion()); 452 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequency()); 453 } 454 } 455 456 @Test testIsdbtFrontendSettingsWithIntFrequency()457 public void testIsdbtFrontendSettingsWithIntFrequency() throws Exception { 458 IsdbtFrontendSettings.Builder builder = IsdbtFrontendSettings.builder(); 459 builder.setFrequency(9); 460 builder.setModulation(IsdbtFrontendSettings.MODULATION_MOD_64QAM); 461 builder.setBandwidth(IsdbtFrontendSettings.BANDWIDTH_8MHZ); 462 builder.setMode(IsdbtFrontendSettings.MODE_2); 463 builder.setCodeRate(DvbtFrontendSettings.CODERATE_7_8); 464 builder.setGuardInterval(DvbtFrontendSettings.GUARD_INTERVAL_1_4); 465 builder.setServiceAreaId(10); 466 467 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_2_0)) { 468 IsdbtFrontendSettings.IsdbtLayerSettings.Builder layerBuilder = 469 IsdbtFrontendSettings.IsdbtLayerSettings.builder(); 470 layerBuilder.setTimeInterleaveMode(IsdbtFrontendSettings.TIME_INTERLEAVE_MODE_AUTO); 471 layerBuilder.setModulation(IsdbtFrontendSettings.MODULATION_MOD_16QAM); 472 layerBuilder.setCodeRate(DvbtFrontendSettings.CODERATE_5_6); 473 layerBuilder.setNumberOfSegments(0xFF); 474 IsdbtFrontendSettings.IsdbtLayerSettings layer = layerBuilder.build(); 475 builder.setLayerSettings(new IsdbtFrontendSettings.IsdbtLayerSettings[] {layer, layer}); 476 builder.setPartialReceptionFlag(IsdbtFrontendSettings.PARTIAL_RECEPTION_FLAG_TRUE); 477 } 478 479 IsdbtFrontendSettings settings = builder.build(); 480 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 481 settings.setEndFrequency(100); 482 483 assertEquals(FrontendSettings.TYPE_ISDBT, settings.getType()); 484 assertEquals(9, settings.getFrequency()); 485 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_2_0)) { 486 assertEquals(IsdbtFrontendSettings.MODULATION_UNDEFINED, settings.getModulation()); 487 } else { 488 assertEquals(IsdbtFrontendSettings.MODULATION_MOD_64QAM, settings.getModulation()); 489 } 490 assertEquals(IsdbtFrontendSettings.BANDWIDTH_8MHZ, settings.getBandwidth()); 491 assertEquals(IsdbtFrontendSettings.MODE_2, settings.getMode()); 492 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_2_0)) { 493 assertEquals(DvbtFrontendSettings.CODERATE_UNDEFINED, settings.getCodeRate()); 494 } else { 495 assertEquals(DvbtFrontendSettings.CODERATE_7_8, settings.getCodeRate()); 496 } 497 assertEquals(DvbtFrontendSettings.GUARD_INTERVAL_1_4, settings.getGuardInterval()); 498 assertEquals(10, settings.getServiceAreaId()); 499 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 500 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 501 settings.getFrontendSpectralInversion()); 502 assertEquals(100, settings.getEndFrequency()); 503 } else { 504 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 505 settings.getFrontendSpectralInversion()); 506 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequency()); 507 } 508 509 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_2_0)) { 510 IsdbtFrontendSettings.IsdbtLayerSettings[] layers = settings.getLayerSettings(); 511 assertEquals(layers.length, 2); 512 assertEquals(layers[0].getModulation(), IsdbtFrontendSettings.MODULATION_MOD_16QAM); 513 assertEquals(layers[0].getCodeRate(), DvbtFrontendSettings.CODERATE_5_6); 514 assertEquals(layers[0].getTimeInterleaveMode(), 515 IsdbtFrontendSettings.TIME_INTERLEAVE_MODE_AUTO); 516 assertEquals(layers[0].getNumberOfSegments(), 0xFF); 517 assertEquals(layers[1].getModulation(), IsdbtFrontendSettings.MODULATION_MOD_16QAM); 518 assertEquals(layers[1].getCodeRate(), DvbtFrontendSettings.CODERATE_5_6); 519 assertEquals(layers[1].getTimeInterleaveMode(), 520 IsdbtFrontendSettings.TIME_INTERLEAVE_MODE_AUTO); 521 assertEquals(layers[1].getNumberOfSegments(), 0xFF); 522 assertEquals(settings.getPartialReceptionFlag(), 523 IsdbtFrontendSettings.PARTIAL_RECEPTION_FLAG_TRUE); 524 } 525 } 526 527 @Test testDtmbFrontendSettingsWithIntFrequency()528 public void testDtmbFrontendSettingsWithIntFrequency() throws Exception { 529 if (!TunerVersionChecker.checkHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1, 530 TAG + ": testDtmbFrontendSettings")) { 531 return; 532 } 533 DtmbFrontendSettings settings = 534 DtmbFrontendSettings 535 .builder() 536 .setFrequency(6) 537 .setModulation(DtmbFrontendSettings.MODULATION_CONSTELLATION_4QAM) 538 .setCodeRate(DtmbFrontendSettings.CODERATE_2_5) 539 .setTransmissionMode(DtmbFrontendSettings.TRANSMISSION_MODE_C1) 540 .setBandwidth(DtmbFrontendSettings.BANDWIDTH_8MHZ) 541 .setTimeInterleaveMode( 542 DtmbFrontendSettings.TIME_INTERLEAVE_MODE_TIMER_INT_240) 543 .setGuardInterval(DtmbFrontendSettings.GUARD_INTERVAL_PN_945_VARIOUS) 544 .build(); 545 assertEquals(FrontendSettings.TYPE_DTMB, settings.getType()); 546 assertEquals(6, settings.getFrequency()); 547 assertEquals(DtmbFrontendSettings.TRANSMISSION_MODE_C1, settings.getTransmissionMode()); 548 assertEquals(DtmbFrontendSettings.BANDWIDTH_8MHZ, settings.getBandwidth()); 549 assertEquals(DtmbFrontendSettings.MODULATION_CONSTELLATION_4QAM, settings.getModulation()); 550 assertEquals(DtmbFrontendSettings.TIME_INTERLEAVE_MODE_TIMER_INT_240, 551 settings.getTimeInterleaveMode()); 552 assertEquals(DtmbFrontendSettings.CODERATE_2_5, settings.getCodeRate()); 553 assertEquals(DtmbFrontendSettings.GUARD_INTERVAL_PN_945_VARIOUS, 554 settings.getGuardInterval()); 555 } 556 557 @Test testFrontendInfoWithIntFrequency()558 public void testFrontendInfoWithIntFrequency() throws Exception { 559 List<Integer> ids = mTuner.getFrontendIds(); 560 if (ids == null) return; 561 List<FrontendInfo> infos = mTuner.getAvailableFrontendInfos(); 562 Map<Integer, FrontendInfo> infoMap = new HashMap<>(); 563 for (FrontendInfo info : infos) { 564 infoMap.put(info.getId(), info); 565 } 566 for (int id : ids) { 567 FrontendInfo info = mTuner.getFrontendInfoById(id); 568 FrontendInfo infoFromMap = infoMap.get(id); 569 assertNotNull(info); 570 assertThat(info).isEqualTo(infoFromMap); 571 assertEquals(id, info.getId()); 572 assertTrue(info.getFrequencyRange().getLower() > 0); 573 assertTrue(info.getSymbolRateRange().getLower() >= 0); 574 assertTrue(info.getAcquireRange() > 0); 575 info.getExclusiveGroupId(); 576 info.getStatusCapabilities(); 577 578 FrontendCapabilities caps = info.getFrontendCapabilities(); 579 if (info.getType() <= FrontendSettings.TYPE_ISDBT) { 580 assertNotNull(caps); 581 } 582 switch(info.getType()) { 583 case FrontendSettings.TYPE_ANALOG: 584 testAnalogFrontendCapabilities(caps); 585 break; 586 case FrontendSettings.TYPE_ATSC3: 587 testAtsc3FrontendCapabilities(caps); 588 break; 589 case FrontendSettings.TYPE_ATSC: 590 testAtscFrontendCapabilities(caps); 591 break; 592 case FrontendSettings.TYPE_DVBC: 593 testDvbcFrontendCapabilities(caps); 594 break; 595 case FrontendSettings.TYPE_DVBS: 596 testDvbsFrontendCapabilities(caps); 597 break; 598 case FrontendSettings.TYPE_DVBT: 599 testDvbtFrontendCapabilities(caps); 600 break; 601 case FrontendSettings.TYPE_ISDBS3: 602 testIsdbs3FrontendCapabilities(caps); 603 break; 604 case FrontendSettings.TYPE_ISDBS: 605 testIsdbsFrontendCapabilities(caps); 606 break; 607 case FrontendSettings.TYPE_ISDBT: 608 testIsdbtFrontendCapabilities(caps); 609 break; 610 case FrontendSettings.TYPE_DTMB: 611 testDtmbFrontendCapabilities(caps); 612 break; 613 default: 614 break; 615 } 616 infoMap.remove(id); 617 } 618 assertTrue(infoMap.isEmpty()); 619 } 620 621 @Test testAnalogFrontendSettingsWithLongFrequency()622 public void testAnalogFrontendSettingsWithLongFrequency() throws Exception { 623 AnalogFrontendSettings settings = 624 AnalogFrontendSettings 625 .builder() 626 .setFrequencyLong(1) 627 .setSignalType(AnalogFrontendSettings.SIGNAL_TYPE_NTSC) 628 .setSifStandard(AnalogFrontendSettings.SIF_BG_NICAM) 629 .setAftFlag(AnalogFrontendSettings.AFT_FLAG_TRUE) 630 .build(); 631 632 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 633 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 634 settings.setEndFrequencyLong(100); 635 } else { 636 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 637 settings.setEndFrequencyLong(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY); 638 } 639 640 assertEquals(FrontendSettings.TYPE_ANALOG, settings.getType()); 641 assertEquals(1, settings.getFrequencyLong()); 642 assertEquals(AnalogFrontendSettings.SIGNAL_TYPE_NTSC, settings.getSignalType()); 643 assertEquals(AnalogFrontendSettings.SIF_BG_NICAM, settings.getSifStandard()); 644 assertEquals(AnalogFrontendSettings.AFT_FLAG_TRUE, settings.getAftFlag()); 645 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 646 assertEquals(AnalogFrontendSettings.AFT_FLAG_TRUE, settings.getAftFlag()); 647 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 648 settings.getFrontendSpectralInversion()); 649 assertEquals(100, settings.getEndFrequencyLong()); 650 } else { 651 assertEquals(AnalogFrontendSettings.AFT_FLAG_UNDEFINED, settings.getAftFlag()); 652 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 653 settings.getFrontendSpectralInversion()); 654 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequencyLong()); 655 } 656 } 657 658 @Test testAtsc3FrontendSettingsWithLongFrequency()659 public void testAtsc3FrontendSettingsWithLongFrequency() throws Exception { 660 Atsc3PlpSettings plp1 = 661 Atsc3PlpSettings 662 .builder() 663 .setPlpId(1) 664 .setModulation(Atsc3FrontendSettings.MODULATION_MOD_QPSK) 665 .setInterleaveMode(Atsc3FrontendSettings.TIME_INTERLEAVE_MODE_AUTO) 666 .setCodeRate(Atsc3FrontendSettings.CODERATE_6_15) 667 .setFec(Atsc3FrontendSettings.FEC_BCH_LDPC_64K) 668 .build(); 669 670 Atsc3PlpSettings plp2 = 671 Atsc3PlpSettings 672 .builder() 673 .setPlpId(2) 674 .setModulation(Atsc3FrontendSettings.MODULATION_MOD_QPSK) 675 .setInterleaveMode(Atsc3FrontendSettings.TIME_INTERLEAVE_MODE_HTI) 676 .setCodeRate(Atsc3FrontendSettings.CODERATE_UNDEFINED) 677 .setFec(Atsc3FrontendSettings.FEC_LDPC_16K) 678 .build(); 679 680 Atsc3FrontendSettings settings = 681 Atsc3FrontendSettings 682 .builder() 683 .setFrequencyLong(2) 684 .setBandwidth(Atsc3FrontendSettings.BANDWIDTH_BANDWIDTH_6MHZ) 685 .setDemodOutputFormat(Atsc3FrontendSettings.MODULATION_MOD_QPSK) 686 .setPlpSettings(new Atsc3PlpSettings[] {plp1, plp2}) 687 .build(); 688 689 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 690 settings.setEndFrequencyLong(100); 691 692 assertEquals(FrontendSettings.TYPE_ATSC3, settings.getType()); 693 assertEquals(2, settings.getFrequencyLong()); 694 assertEquals(Atsc3FrontendSettings.BANDWIDTH_BANDWIDTH_6MHZ, settings.getBandwidth()); 695 assertEquals(Atsc3FrontendSettings.MODULATION_MOD_QPSK, settings.getDemodOutputFormat()); 696 697 Atsc3PlpSettings[] plps = settings.getPlpSettings(); 698 assertEquals(2, plps.length); 699 700 assertEquals(1, plps[0].getPlpId()); 701 assertEquals(Atsc3FrontendSettings.MODULATION_MOD_QPSK, plps[0].getModulation()); 702 assertEquals(Atsc3FrontendSettings.TIME_INTERLEAVE_MODE_AUTO, plps[0].getInterleaveMode()); 703 assertEquals(Atsc3FrontendSettings.CODERATE_6_15, plps[0].getCodeRate()); 704 assertEquals(Atsc3FrontendSettings.FEC_BCH_LDPC_64K, plps[0].getFec()); 705 706 assertEquals(2, plps[1].getPlpId()); 707 assertEquals(Atsc3FrontendSettings.MODULATION_MOD_QPSK, plps[1].getModulation()); 708 assertEquals(Atsc3FrontendSettings.TIME_INTERLEAVE_MODE_HTI, plps[1].getInterleaveMode()); 709 assertEquals(Atsc3FrontendSettings.CODERATE_UNDEFINED, plps[1].getCodeRate()); 710 assertEquals(Atsc3FrontendSettings.FEC_LDPC_16K, plps[1].getFec()); 711 712 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 713 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 714 settings.getFrontendSpectralInversion()); 715 assertEquals(100, settings.getEndFrequencyLong()); 716 } else { 717 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 718 settings.getFrontendSpectralInversion()); 719 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequencyLong()); 720 } 721 } 722 723 @Test testAtscFrontendSettingsWithLongFrequency()724 public void testAtscFrontendSettingsWithLongFrequency() throws Exception { 725 AtscFrontendSettings settings = 726 AtscFrontendSettings 727 .builder() 728 .setFrequencyLong(3) 729 .setModulation(AtscFrontendSettings.MODULATION_MOD_8VSB) 730 .build(); 731 732 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 733 settings.setEndFrequencyLong(100); 734 735 assertEquals(FrontendSettings.TYPE_ATSC, settings.getType()); 736 assertEquals(3, settings.getFrequencyLong()); 737 assertEquals(AtscFrontendSettings.MODULATION_MOD_8VSB, settings.getModulation()); 738 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 739 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 740 settings.getFrontendSpectralInversion()); 741 assertEquals(100, settings.getEndFrequencyLong()); 742 } else { 743 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 744 settings.getFrontendSpectralInversion()); 745 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequencyLong()); 746 } 747 } 748 749 @Test testDvbcFrontendSettingsWithLongFrequency()750 public void testDvbcFrontendSettingsWithLongFrequency() throws Exception { 751 DvbcFrontendSettings settings = 752 DvbcFrontendSettings 753 .builder() 754 .setFrequencyLong(4) 755 .setModulation(DvbcFrontendSettings.MODULATION_MOD_32QAM) 756 .setInnerFec(FrontendSettings.FEC_8_15) 757 .setSymbolRate(3) 758 .setOuterFec(DvbcFrontendSettings.OUTER_FEC_OUTER_FEC_RS) 759 .setAnnex(DvbcFrontendSettings.ANNEX_B) 760 .setTimeInterleaveMode(DvbcFrontendSettings.TIME_INTERLEAVE_MODE_AUTO) 761 .setBandwidth(DvbcFrontendSettings.BANDWIDTH_5MHZ) 762 // DvbcFrontendSettings.SpectralInversion is deprecated in Android 12. Use 763 // FrontendSettings.FrontendSpectralInversion instead. 764 .setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL) 765 .build(); 766 767 settings.setEndFrequencyLong(100); 768 769 assertEquals(FrontendSettings.TYPE_DVBC, settings.getType()); 770 assertEquals(4, settings.getFrequencyLong()); 771 assertEquals(DvbcFrontendSettings.MODULATION_MOD_32QAM, settings.getModulation()); 772 assertEquals(FrontendSettings.FEC_8_15, settings.getInnerFec()); 773 assertEquals(3, settings.getSymbolRate()); 774 assertEquals(DvbcFrontendSettings.OUTER_FEC_OUTER_FEC_RS, settings.getOuterFec()); 775 assertEquals(DvbcFrontendSettings.ANNEX_B, settings.getAnnex()); 776 assertEquals(DvbcFrontendSettings.TIME_INTERLEAVE_MODE_AUTO, 777 settings.getTimeInterleaveMode()); 778 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 779 settings.getSpectralInversion()); 780 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 781 assertEquals(100, settings.getEndFrequencyLong()); 782 assertEquals(DvbcFrontendSettings.BANDWIDTH_5MHZ, settings.getBandwidth()); 783 } else { 784 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequencyLong()); 785 assertEquals(DvbcFrontendSettings.BANDWIDTH_UNDEFINED, settings.getBandwidth()); 786 } 787 } 788 789 @Test testDvbsFrontendSettingsWithLongFrequency()790 public void testDvbsFrontendSettingsWithLongFrequency() throws Exception { 791 DvbsCodeRate codeRate = 792 DvbsCodeRate 793 .builder() 794 .setInnerFec(FrontendSettings.FEC_9_10) 795 .setLinear(true) 796 .setShortFrameEnabled(false) 797 .setBitsPer1000Symbol(55) 798 .build(); 799 800 DvbsFrontendSettings settings = 801 DvbsFrontendSettings 802 .builder() 803 .setFrequencyLong(5) 804 .setModulation(DvbsFrontendSettings.MODULATION_MOD_ACM) 805 .setCodeRate(codeRate) 806 .setSymbolRate(3) 807 .setRolloff(DvbsFrontendSettings.ROLLOFF_0_15) 808 .setPilot(DvbsFrontendSettings.PILOT_OFF) 809 .setInputStreamId(1) 810 .setStandard(DvbsFrontendSettings.STANDARD_S2) 811 .setVcmMode(DvbsFrontendSettings.VCM_MODE_MANUAL) 812 .setScanType(DvbsFrontendSettings.SCAN_TYPE_DIRECT) 813 .setCanHandleDiseqcRxMessage(true) 814 .build(); 815 816 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 817 settings.setEndFrequencyLong(100); 818 819 assertEquals(FrontendSettings.TYPE_DVBS, settings.getType()); 820 assertEquals(5, settings.getFrequencyLong()); 821 assertEquals(DvbsFrontendSettings.MODULATION_MOD_ACM, settings.getModulation()); 822 assertEquals(3, settings.getSymbolRate()); 823 assertEquals(DvbsFrontendSettings.ROLLOFF_0_15, settings.getRolloff()); 824 assertEquals(DvbsFrontendSettings.PILOT_OFF, settings.getPilot()); 825 assertEquals(1, settings.getInputStreamId()); 826 assertEquals(DvbsFrontendSettings.STANDARD_S2, settings.getStandard()); 827 assertEquals(DvbsFrontendSettings.VCM_MODE_MANUAL, settings.getVcmMode()); 828 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 829 assertEquals(DvbsFrontendSettings.SCAN_TYPE_DIRECT, settings.getScanType()); 830 assertTrue(settings.canHandleDiseqcRxMessage()); 831 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 832 settings.getFrontendSpectralInversion()); 833 assertEquals(100, settings.getEndFrequencyLong()); 834 } else { 835 assertEquals(DvbsFrontendSettings.SCAN_TYPE_UNDEFINED, settings.getScanType()); 836 assertFalse(settings.canHandleDiseqcRxMessage()); 837 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 838 settings.getFrontendSpectralInversion()); 839 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequencyLong()); 840 } 841 842 DvbsCodeRate cr = settings.getCodeRate(); 843 assertNotNull(cr); 844 assertEquals(FrontendSettings.FEC_9_10, cr.getInnerFec()); 845 assertEquals(true, cr.isLinear()); 846 assertEquals(false, cr.isShortFrameEnabled()); 847 assertEquals(55, cr.getBitsPer1000Symbol()); 848 } 849 850 @Test testDvbtFrontendSettingsWithLongFrequency()851 public void testDvbtFrontendSettingsWithLongFrequency() throws Exception { 852 DvbtFrontendSettings settings = 853 DvbtFrontendSettings 854 .builder() 855 .setFrequencyLong(6) 856 .setTransmissionMode(DvbtFrontendSettings.TRANSMISSION_MODE_EXTENDED_32K) 857 .setBandwidth(DvbtFrontendSettings.BANDWIDTH_1_7MHZ) 858 .setConstellation(DvbtFrontendSettings.CONSTELLATION_16QAM_R) 859 .setHierarchy(DvbtFrontendSettings.HIERARCHY_4_NATIVE) 860 .setHighPriorityCodeRate(DvbtFrontendSettings.CODERATE_6_7) 861 .setLowPriorityCodeRate(DvbtFrontendSettings.CODERATE_2_3) 862 .setGuardInterval(DvbtFrontendSettings.GUARD_INTERVAL_19_128) 863 .setHighPriority(true) 864 .setStandard(DvbtFrontendSettings.STANDARD_T2) 865 .setMiso(false) 866 .setPlpMode(DvbtFrontendSettings.PLP_MODE_MANUAL) 867 .setPlpId(333) 868 .setPlpGroupId(777) 869 .build(); 870 871 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 872 settings.setEndFrequencyLong(100); 873 874 assertEquals(FrontendSettings.TYPE_DVBT, settings.getType()); 875 assertEquals(6, settings.getFrequencyLong()); 876 assertEquals(DvbtFrontendSettings.BANDWIDTH_1_7MHZ, settings.getBandwidth()); 877 assertEquals(DvbtFrontendSettings.HIERARCHY_4_NATIVE, settings.getHierarchy()); 878 assertEquals(DvbtFrontendSettings.CODERATE_6_7, settings.getHighPriorityCodeRate()); 879 assertEquals(DvbtFrontendSettings.CODERATE_2_3, settings.getLowPriorityCodeRate()); 880 assertEquals(DvbtFrontendSettings.GUARD_INTERVAL_19_128, settings.getGuardInterval()); 881 assertEquals(true, settings.isHighPriority()); 882 assertEquals(DvbtFrontendSettings.STANDARD_T2, settings.getStandard()); 883 assertEquals(false, settings.isMiso()); 884 assertEquals(DvbtFrontendSettings.PLP_MODE_MANUAL, settings.getPlpMode()); 885 assertEquals(333, settings.getPlpId()); 886 assertEquals(777, settings.getPlpGroupId()); 887 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 888 assertEquals(DvbtFrontendSettings.TRANSMISSION_MODE_EXTENDED_32K, 889 settings.getTransmissionMode()); 890 assertEquals(DvbtFrontendSettings.CONSTELLATION_16QAM_R, settings.getConstellation()); 891 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 892 settings.getFrontendSpectralInversion()); 893 assertEquals(100, settings.getEndFrequencyLong()); 894 } else { 895 assertEquals(DvbtFrontendSettings.TRANSMISSION_MODE_UNDEFINED, 896 settings.getTransmissionMode()); 897 assertEquals(DvbtFrontendSettings.CONSTELLATION_UNDEFINED, settings.getConstellation()); 898 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 899 settings.getFrontendSpectralInversion()); 900 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequencyLong()); 901 } 902 } 903 904 @Test testIsdbs3FrontendSettingsWithLongFrequency()905 public void testIsdbs3FrontendSettingsWithLongFrequency() throws Exception { 906 Isdbs3FrontendSettings settings = 907 Isdbs3FrontendSettings 908 .builder() 909 .setFrequencyLong(7) 910 .setStreamId(2) 911 .setStreamIdType(IsdbsFrontendSettings.STREAM_ID_TYPE_ID) 912 .setModulation(Isdbs3FrontendSettings.MODULATION_MOD_BPSK) 913 .setCodeRate(Isdbs3FrontendSettings.CODERATE_1_3) 914 .setSymbolRate(555) 915 .setRolloff(Isdbs3FrontendSettings.ROLLOFF_0_03) 916 .build(); 917 918 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 919 settings.setEndFrequencyLong(100); 920 921 assertEquals(FrontendSettings.TYPE_ISDBS3, settings.getType()); 922 assertEquals(7, settings.getFrequencyLong()); 923 assertEquals(2, settings.getStreamId()); 924 assertEquals(IsdbsFrontendSettings.STREAM_ID_TYPE_ID, settings.getStreamIdType()); 925 assertEquals(Isdbs3FrontendSettings.MODULATION_MOD_BPSK, settings.getModulation()); 926 assertEquals(Isdbs3FrontendSettings.CODERATE_1_3, settings.getCodeRate()); 927 assertEquals(555, settings.getSymbolRate()); 928 assertEquals(Isdbs3FrontendSettings.ROLLOFF_0_03, settings.getRolloff()); 929 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 930 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 931 settings.getFrontendSpectralInversion()); 932 assertEquals(100, settings.getEndFrequencyLong()); 933 } else { 934 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 935 settings.getFrontendSpectralInversion()); 936 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequencyLong()); 937 } 938 } 939 940 @Test testIsdbsFrontendSettingsWithLongFrequency()941 public void testIsdbsFrontendSettingsWithLongFrequency() throws Exception { 942 IsdbsFrontendSettings settings = 943 IsdbsFrontendSettings 944 .builder() 945 .setFrequencyLong(8) 946 .setStreamId(3) 947 .setStreamIdType(IsdbsFrontendSettings.STREAM_ID_TYPE_RELATIVE_NUMBER) 948 .setModulation(IsdbsFrontendSettings.MODULATION_AUTO) 949 .setCodeRate(IsdbsFrontendSettings.CODERATE_3_4) 950 .setSymbolRate(667) 951 .setRolloff(IsdbsFrontendSettings.ROLLOFF_0_35) 952 .build(); 953 954 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 955 settings.setEndFrequencyLong(100); 956 957 assertEquals(FrontendSettings.TYPE_ISDBS, settings.getType()); 958 assertEquals(8, settings.getFrequencyLong()); 959 assertEquals(3, settings.getStreamId()); 960 assertEquals( 961 IsdbsFrontendSettings.STREAM_ID_TYPE_RELATIVE_NUMBER, settings.getStreamIdType()); 962 assertEquals(IsdbsFrontendSettings.MODULATION_AUTO, settings.getModulation()); 963 assertEquals(IsdbsFrontendSettings.CODERATE_3_4, settings.getCodeRate()); 964 assertEquals(667, settings.getSymbolRate()); 965 assertEquals(IsdbsFrontendSettings.ROLLOFF_0_35, settings.getRolloff()); 966 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 967 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 968 settings.getFrontendSpectralInversion()); 969 assertEquals(100, settings.getEndFrequencyLong()); 970 } else { 971 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 972 settings.getFrontendSpectralInversion()); 973 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequencyLong()); 974 } 975 } 976 977 @Test testIsdbtFrontendSettingsWithLongFrequency()978 public void testIsdbtFrontendSettingsWithLongFrequency() throws Exception { 979 IsdbtFrontendSettings.Builder builder = IsdbtFrontendSettings.builder(); 980 builder.setFrequencyLong(9); 981 builder.setModulation(IsdbtFrontendSettings.MODULATION_MOD_64QAM); 982 builder.setBandwidth(IsdbtFrontendSettings.BANDWIDTH_8MHZ); 983 builder.setMode(IsdbtFrontendSettings.MODE_2); 984 builder.setCodeRate(DvbtFrontendSettings.CODERATE_7_8); 985 builder.setGuardInterval(DvbtFrontendSettings.GUARD_INTERVAL_1_4); 986 builder.setServiceAreaId(10); 987 988 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_2_0)) { 989 IsdbtFrontendSettings.IsdbtLayerSettings.Builder layerBuilder = 990 IsdbtFrontendSettings.IsdbtLayerSettings.builder(); 991 layerBuilder.setTimeInterleaveMode(IsdbtFrontendSettings.TIME_INTERLEAVE_MODE_AUTO); 992 layerBuilder.setModulation(IsdbtFrontendSettings.MODULATION_MOD_16QAM); 993 layerBuilder.setCodeRate(DvbtFrontendSettings.CODERATE_5_6); 994 layerBuilder.setNumberOfSegments(0xFF); 995 IsdbtFrontendSettings.IsdbtLayerSettings layer = layerBuilder.build(); 996 builder.setLayerSettings(new IsdbtFrontendSettings.IsdbtLayerSettings[] {layer, layer}); 997 builder.setPartialReceptionFlag(IsdbtFrontendSettings.PARTIAL_RECEPTION_FLAG_TRUE); 998 } 999 1000 IsdbtFrontendSettings settings = builder.build(); 1001 settings.setSpectralInversion(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL); 1002 settings.setEndFrequencyLong(100); 1003 1004 assertEquals(FrontendSettings.TYPE_ISDBT, settings.getType()); 1005 assertEquals(9, settings.getFrequencyLong()); 1006 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_2_0)) { 1007 assertEquals(IsdbtFrontendSettings.MODULATION_UNDEFINED, settings.getModulation()); 1008 } else { 1009 assertEquals(IsdbtFrontendSettings.MODULATION_MOD_64QAM, settings.getModulation()); 1010 } 1011 assertEquals(IsdbtFrontendSettings.BANDWIDTH_8MHZ, settings.getBandwidth()); 1012 assertEquals(IsdbtFrontendSettings.MODE_2, settings.getMode()); 1013 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_2_0)) { 1014 assertEquals(DvbtFrontendSettings.CODERATE_UNDEFINED, settings.getCodeRate()); 1015 } else { 1016 assertEquals(DvbtFrontendSettings.CODERATE_7_8, settings.getCodeRate()); 1017 } 1018 assertEquals(DvbtFrontendSettings.GUARD_INTERVAL_1_4, settings.getGuardInterval()); 1019 assertEquals(10, settings.getServiceAreaId()); 1020 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1)) { 1021 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_NORMAL, 1022 settings.getFrontendSpectralInversion()); 1023 assertEquals(100, settings.getEndFrequencyLong()); 1024 } else { 1025 assertEquals(FrontendSettings.FRONTEND_SPECTRAL_INVERSION_UNDEFINED, 1026 settings.getFrontendSpectralInversion()); 1027 assertEquals(Tuner.INVALID_FRONTEND_SETTING_FREQUENCY, settings.getEndFrequencyLong()); 1028 } 1029 1030 if (TunerVersionChecker.isHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_2_0)) { 1031 IsdbtFrontendSettings.IsdbtLayerSettings[] layers = settings.getLayerSettings(); 1032 assertEquals(layers.length, 2); 1033 assertEquals(layers[0].getModulation(), IsdbtFrontendSettings.MODULATION_MOD_16QAM); 1034 assertEquals(layers[0].getCodeRate(), DvbtFrontendSettings.CODERATE_5_6); 1035 assertEquals(layers[0].getTimeInterleaveMode(), 1036 IsdbtFrontendSettings.TIME_INTERLEAVE_MODE_AUTO); 1037 assertEquals(layers[0].getNumberOfSegments(), 0xFF); 1038 assertEquals(layers[1].getModulation(), IsdbtFrontendSettings.MODULATION_MOD_16QAM); 1039 assertEquals(layers[1].getCodeRate(), DvbtFrontendSettings.CODERATE_5_6); 1040 assertEquals(layers[1].getTimeInterleaveMode(), 1041 IsdbtFrontendSettings.TIME_INTERLEAVE_MODE_AUTO); 1042 assertEquals(layers[1].getNumberOfSegments(), 0xFF); 1043 assertEquals(settings.getPartialReceptionFlag(), 1044 IsdbtFrontendSettings.PARTIAL_RECEPTION_FLAG_TRUE); 1045 } 1046 } 1047 1048 @Test testDtmbFrontendSettingsWithLongFrequency()1049 public void testDtmbFrontendSettingsWithLongFrequency() throws Exception { 1050 if (!TunerVersionChecker.checkHigherOrEqualVersionTo(TunerVersionChecker.TUNER_VERSION_1_1, 1051 TAG + ": testDtmbFrontendSettings")) { 1052 return; 1053 } 1054 DtmbFrontendSettings settings = 1055 DtmbFrontendSettings 1056 .builder() 1057 .setFrequencyLong(6) 1058 .setModulation(DtmbFrontendSettings.MODULATION_CONSTELLATION_4QAM) 1059 .setCodeRate(DtmbFrontendSettings.CODERATE_2_5) 1060 .setTransmissionMode(DtmbFrontendSettings.TRANSMISSION_MODE_C1) 1061 .setBandwidth(DtmbFrontendSettings.BANDWIDTH_8MHZ) 1062 .setTimeInterleaveMode( 1063 DtmbFrontendSettings.TIME_INTERLEAVE_MODE_TIMER_INT_240) 1064 .setGuardInterval(DtmbFrontendSettings.GUARD_INTERVAL_PN_945_VARIOUS) 1065 .build(); 1066 assertEquals(FrontendSettings.TYPE_DTMB, settings.getType()); 1067 assertEquals(6, settings.getFrequencyLong()); 1068 assertEquals(DtmbFrontendSettings.TRANSMISSION_MODE_C1, settings.getTransmissionMode()); 1069 assertEquals(DtmbFrontendSettings.BANDWIDTH_8MHZ, settings.getBandwidth()); 1070 assertEquals(DtmbFrontendSettings.MODULATION_CONSTELLATION_4QAM, settings.getModulation()); 1071 assertEquals(DtmbFrontendSettings.TIME_INTERLEAVE_MODE_TIMER_INT_240, 1072 settings.getTimeInterleaveMode()); 1073 assertEquals(DtmbFrontendSettings.CODERATE_2_5, settings.getCodeRate()); 1074 assertEquals(DtmbFrontendSettings.GUARD_INTERVAL_PN_945_VARIOUS, 1075 settings.getGuardInterval()); 1076 } 1077 1078 @Test testFrontendInfoWithLongFrequency()1079 public void testFrontendInfoWithLongFrequency() throws Exception { 1080 List<Integer> ids = mTuner.getFrontendIds(); 1081 List<FrontendInfo> infos = mTuner.getAvailableFrontendInfos(); 1082 Map<Integer, FrontendInfo> infoMap = new HashMap<>(); 1083 for (FrontendInfo info : infos) { 1084 infoMap.put(info.getId(), info); 1085 } 1086 for (int id : ids) { 1087 FrontendInfo info = mTuner.getFrontendInfoById(id); 1088 FrontendInfo infoFromMap = infoMap.get(id); 1089 assertNotNull(info); 1090 assertThat(info).isEqualTo(infoFromMap); 1091 assertEquals(id, info.getId()); 1092 assertTrue(info.getFrequencyRangeLong().getLower() > 0); 1093 assertTrue(info.getSymbolRateRange().getLower() >= 0); 1094 assertTrue(info.getAcquireRangeLong() > 0); 1095 info.getExclusiveGroupId(); 1096 info.getStatusCapabilities(); 1097 1098 FrontendCapabilities caps = info.getFrontendCapabilities(); 1099 if (info.getType() <= FrontendSettings.TYPE_ISDBT) { 1100 assertNotNull(caps); 1101 } 1102 switch(info.getType()) { 1103 case FrontendSettings.TYPE_ANALOG: 1104 testAnalogFrontendCapabilities(caps); 1105 break; 1106 case FrontendSettings.TYPE_ATSC3: 1107 testAtsc3FrontendCapabilities(caps); 1108 break; 1109 case FrontendSettings.TYPE_ATSC: 1110 testAtscFrontendCapabilities(caps); 1111 break; 1112 case FrontendSettings.TYPE_DVBC: 1113 testDvbcFrontendCapabilities(caps); 1114 break; 1115 case FrontendSettings.TYPE_DVBS: 1116 testDvbsFrontendCapabilities(caps); 1117 break; 1118 case FrontendSettings.TYPE_DVBT: 1119 testDvbtFrontendCapabilities(caps); 1120 break; 1121 case FrontendSettings.TYPE_ISDBS3: 1122 testIsdbs3FrontendCapabilities(caps); 1123 break; 1124 case FrontendSettings.TYPE_ISDBS: 1125 testIsdbsFrontendCapabilities(caps); 1126 break; 1127 case FrontendSettings.TYPE_ISDBT: 1128 testIsdbtFrontendCapabilities(caps); 1129 break; 1130 case FrontendSettings.TYPE_DTMB: 1131 testDtmbFrontendCapabilities(caps); 1132 break; 1133 default: 1134 break; 1135 } 1136 infoMap.remove(id); 1137 } 1138 assertTrue(infoMap.isEmpty()); 1139 } 1140 testAnalogFrontendCapabilities(FrontendCapabilities caps)1141 private void testAnalogFrontendCapabilities(FrontendCapabilities caps) throws Exception { 1142 assertTrue(caps instanceof AnalogFrontendCapabilities); 1143 AnalogFrontendCapabilities analogCaps = (AnalogFrontendCapabilities) caps; 1144 analogCaps.getSignalTypeCapability(); 1145 analogCaps.getSifStandardCapability(); 1146 } 1147 testAtsc3FrontendCapabilities(FrontendCapabilities caps)1148 private void testAtsc3FrontendCapabilities(FrontendCapabilities caps) throws Exception { 1149 assertTrue(caps instanceof Atsc3FrontendCapabilities); 1150 Atsc3FrontendCapabilities atsc3Caps = (Atsc3FrontendCapabilities) caps; 1151 atsc3Caps.getBandwidthCapability(); 1152 atsc3Caps.getModulationCapability(); 1153 atsc3Caps.getTimeInterleaveModeCapability(); 1154 atsc3Caps.getPlpCodeRateCapability(); 1155 atsc3Caps.getFecCapability(); 1156 atsc3Caps.getDemodOutputFormatCapability(); 1157 } 1158 testAtscFrontendCapabilities(FrontendCapabilities caps)1159 private void testAtscFrontendCapabilities(FrontendCapabilities caps) throws Exception { 1160 assertTrue(caps instanceof AtscFrontendCapabilities); 1161 AtscFrontendCapabilities atscCaps = (AtscFrontendCapabilities) caps; 1162 atscCaps.getModulationCapability(); 1163 } 1164 testDvbcFrontendCapabilities(FrontendCapabilities caps)1165 private void testDvbcFrontendCapabilities(FrontendCapabilities caps) throws Exception { 1166 assertTrue(caps instanceof DvbcFrontendCapabilities); 1167 DvbcFrontendCapabilities dvbcCaps = (DvbcFrontendCapabilities) caps; 1168 dvbcCaps.getModulationCapability(); 1169 // getFecCapability is deprecated starting Android 12. Use getCodeRateCapability instead. 1170 dvbcCaps.getCodeRateCapability(); 1171 dvbcCaps.getFecCapability(); 1172 dvbcCaps.getAnnexCapability(); 1173 } 1174 testDvbsFrontendCapabilities(FrontendCapabilities caps)1175 private void testDvbsFrontendCapabilities(FrontendCapabilities caps) throws Exception { 1176 assertTrue(caps instanceof DvbsFrontendCapabilities); 1177 DvbsFrontendCapabilities dvbsCaps = (DvbsFrontendCapabilities) caps; 1178 dvbsCaps.getModulationCapability(); 1179 dvbsCaps.getInnerFecCapability(); 1180 dvbsCaps.getStandardCapability(); 1181 } 1182 testDvbtFrontendCapabilities(FrontendCapabilities caps)1183 private void testDvbtFrontendCapabilities(FrontendCapabilities caps) throws Exception { 1184 assertTrue(caps instanceof DvbtFrontendCapabilities); 1185 DvbtFrontendCapabilities dvbtCaps = (DvbtFrontendCapabilities) caps; 1186 dvbtCaps.getTransmissionModeCapability(); 1187 dvbtCaps.getBandwidthCapability(); 1188 dvbtCaps.getConstellationCapability(); 1189 dvbtCaps.getCodeRateCapability(); 1190 dvbtCaps.getHierarchyCapability(); 1191 dvbtCaps.getGuardIntervalCapability(); 1192 dvbtCaps.isT2Supported(); 1193 dvbtCaps.isMisoSupported(); 1194 } 1195 testIsdbs3FrontendCapabilities(FrontendCapabilities caps)1196 private void testIsdbs3FrontendCapabilities(FrontendCapabilities caps) throws Exception { 1197 assertTrue(caps instanceof Isdbs3FrontendCapabilities); 1198 Isdbs3FrontendCapabilities isdbs3Caps = (Isdbs3FrontendCapabilities) caps; 1199 isdbs3Caps.getModulationCapability(); 1200 isdbs3Caps.getCodeRateCapability(); 1201 } 1202 testIsdbsFrontendCapabilities(FrontendCapabilities caps)1203 private void testIsdbsFrontendCapabilities(FrontendCapabilities caps) throws Exception { 1204 assertTrue(caps instanceof IsdbsFrontendCapabilities); 1205 IsdbsFrontendCapabilities isdbsCaps = (IsdbsFrontendCapabilities) caps; 1206 isdbsCaps.getModulationCapability(); 1207 isdbsCaps.getCodeRateCapability(); 1208 } 1209 testIsdbtFrontendCapabilities(FrontendCapabilities caps)1210 private void testIsdbtFrontendCapabilities(FrontendCapabilities caps) throws Exception { 1211 assertTrue(caps instanceof IsdbtFrontendCapabilities); 1212 IsdbtFrontendCapabilities isdbtCaps = (IsdbtFrontendCapabilities) caps; 1213 isdbtCaps.getModeCapability(); 1214 isdbtCaps.getBandwidthCapability(); 1215 isdbtCaps.getModulationCapability(); 1216 isdbtCaps.getCodeRateCapability(); 1217 isdbtCaps.getGuardIntervalCapability(); 1218 isdbtCaps.getTimeInterleaveModeCapability(); 1219 isdbtCaps.isSegmentAutoSupported(); 1220 isdbtCaps.isFullSegmentSupported(); 1221 } 1222 testDtmbFrontendCapabilities(FrontendCapabilities caps)1223 private void testDtmbFrontendCapabilities(FrontendCapabilities caps) throws Exception { 1224 assertTrue(caps instanceof DtmbFrontendCapabilities); 1225 DtmbFrontendCapabilities dtmbCaps = (DtmbFrontendCapabilities) caps; 1226 dtmbCaps.getTimeInterleaveModeCapability(); 1227 dtmbCaps.getBandwidthCapability(); 1228 dtmbCaps.getModulationCapability(); 1229 dtmbCaps.getCodeRateCapability(); 1230 dtmbCaps.getTransmissionModeCapability(); 1231 dtmbCaps.getGuardIntervalCapability(); 1232 } 1233 hasTuner()1234 private boolean hasTuner() { 1235 return mContext.getPackageManager().hasSystemFeature("android.hardware.tv.tuner"); 1236 } 1237 } 1238