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