/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.hardware.hdmi;
import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.util.Log;
/**
* Container for record source used for one touch record.
* Use one of helper method by source type.
* <ul>
* <li>Own source: {@link #ofOwnSource()}
* <li>Digital service(channel id): {@link #ofDigitalChannelId(int, DigitalChannelData)}
* <li>Digital service(ARIB): {@link #ofArib(int, AribData)}
* <li>Digital service(ATSC): {@link #ofAtsc(int, AtscData)}
* <li>Digital service(DVB): {@link #ofDvb(int, DvbData)}
* <li>Analogue: {@link #ofAnalogue(int, int, int)}
* <li>External plug: {@link #ofExternalPlug(int)}
* <li>External physical address: {@link #ofExternalPhysicalAddress(int)}.
* <ul>
*
* @hide
*/
@SystemApi
public final class HdmiRecordSources {
private static final String TAG = "HdmiRecordSources";
/** Record source type for "Own Source". */
private static final int RECORD_SOURCE_TYPE_OWN_SOURCE = 1;
/** Record source type for "Digital Service". */
private static final int RECORD_SOURCE_TYPE_DIGITAL_SERVICE = 2;
/** Record source type for "Analogue Service". */
private static final int RECORD_SOURCE_TYPE_ANALOGUE_SERVICE = 3;
/** Record source type for "Exteranl Plug". */
private static final int RECORD_SOURCE_TYPE_EXTERNAL_PLUG = 4;
/** Record source type for "External Physical Address". */
private static final int RECORD_SOURCE_TYPE_EXTERNAL_PHYSICAL_ADDRESS = 5;
private HdmiRecordSources() {}
/**
* Base class for each record source.
* @hide
*/
@SystemApi
public static abstract class RecordSource {
/* package */ final int mSourceType;
/* package */ final int mExtraDataSize;
/* package */ RecordSource(int sourceType, int extraDataSize) {
mSourceType = sourceType;
mExtraDataSize = extraDataSize;
}
/* package */ abstract int extraParamToByteArray(byte[] data, int index);
/* package */ final int getDataSize(boolean includeType) {
return includeType ? mExtraDataSize + 1 : mExtraDataSize;
}
/* package */ final int toByteArray(boolean includeType, byte[] data, int index) {
if (includeType) {
// 1 to 8 bytes (depends on source).
// {[Record Source Type]} |
// {[Record Source Type] [Digital Service Identification]} |
// {[Record Source Type] [Analogue Broadcast Type] [Analogue Frequency]
// [Broadcast System]} |
// {[Record Source Type] [External Plug]} |
// {[Record Source Type] [External Physical Address]}
// The first byte is used for record source type.
data[index++] = (byte) mSourceType;
}
extraParamToByteArray(data, index);
return getDataSize(includeType);
}
}
// ---------------------------------------------------------------------------------------------
// ---- Own source -----------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------
/**
* Creates {@link OwnSource} of own source.
*/
public static OwnSource ofOwnSource() {
return new OwnSource();
}
/**
* @hide
*/
@SystemApi
public static final class OwnSource extends RecordSource {
private static final int EXTRA_DATA_SIZE = 0;
private OwnSource() {
super(RECORD_SOURCE_TYPE_OWN_SOURCE, EXTRA_DATA_SIZE);
}
@Override
int extraParamToByteArray(byte[] data, int index) {
return 0;
}
}
// ---------------------------------------------------------------------------------------------
// ---- Digital service data -------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------
/**
* Digital broadcast general types
*/
/** @hide */
public static final int DIGITAL_BROADCAST_TYPE_ARIB = 0x0;
/** @hide */
public static final int DIGITAL_BROADCAST_TYPE_ATSC = 0x1;
/** @hide */
public static final int DIGITAL_BROADCAST_TYPE_DVB = 0x2;
/**
* Digital broadcast specific types
*/
/** @hide */
public static final int DIGITAL_BROADCAST_TYPE_ARIB_BS = 0x8;
/** @hide */
public static final int DIGITAL_BROADCAST_TYPE_ARIB_CS = 0x9;
/** @hide */
public static final int DIGITAL_BROADCAST_TYPE_ARIB_T = 0xA;
/** @hide */
public static final int DIGITAL_BROADCAST_TYPE_ATSC_CABLE = 0x10;
/** @hide */
public static final int DIGITAL_BROADCAST_TYPE_ATSC_SATELLITE = 0x11;
/** @hide */
public static final int DIGITAL_BROADCAST_TYPE_ATSC_TERRESTRIAL = 0x12;
/** @hide */
public static final int DIGITAL_BROADCAST_TYPE_DVB_C = 0x18;
/** @hide */
public static final int DIGITAL_BROADCAST_TYPE_DVB_S = 0x19;
/** @hide */
public static final int DIGITAL_BROADCAST_TYPE_DVB_S2 = 0x1A;
/** @hide */
public static final int DIGITAL_BROADCAST_TYPE_DVB_T = 0x1B;
/** Channel number formats. */
private static final int CHANNEL_NUMBER_FORMAT_1_PART = 0x01;
private static final int CHANNEL_NUMBER_FORMAT_2_PART = 0x02;
/**
* Interface for digital source identification.
*/
private interface DigitalServiceIdentification {
int toByteArray(byte[] data, int index);
}
/**
* Digital service identification for ARIB.
* <p>
* It consists of the following fields
* <ul>
* <li>transport stream id: 2bytes
* <li>service id: 2bytes
* <li>original network id: 2bytes
* </ul>
* @hide
*/
public static final class AribData implements DigitalServiceIdentification {
/** The transport_stream_ID of the transport stream carrying the required service */
private final int mTransportStreamId;
/** The service_ID of the required service */
private final int mServiceId;
/**
* The original_network_ID of the network carrying the transport stream for the required
* service
*/
private final int mOriginalNetworkId;
public AribData(int transportStreamId, int serviceId, int originalNetworkId) {
mTransportStreamId = transportStreamId;
mServiceId = serviceId;
mOriginalNetworkId = originalNetworkId;
}
@Override
public int toByteArray(byte[] data, int index) {
return threeFieldsToSixBytes(mTransportStreamId, mServiceId, mOriginalNetworkId, data,
index);
}
}
/**
* Digital service identification for ATSC.
* <p>
* It consists of the following fields
* <ul>
* <li>transport stream id: 2bytes
* <li>program number: 2bytes
* <li>reserved: 2bytes
* </ul>
* @hide
*/
public static final class AtscData implements DigitalServiceIdentification {
/** The transport_stream_ID of the transport stream carrying the required service */
private final int mTransportStreamId;
/** The Program_number of the required service */
private final int mProgramNumber;
public AtscData(int transportStreamId, int programNumber) {
mTransportStreamId = transportStreamId;
mProgramNumber = programNumber;
}
@Override
public int toByteArray(byte[] data, int index) {
return threeFieldsToSixBytes(mTransportStreamId, mProgramNumber, 0, data, index);
}
}
/**
* Digital service identification for DVB.
* <p>
* It consists of the following fields
* <ul>
* <li>transport stream id: 2bytes
* <li>service id: 2bytes
* <li>original network id: 2bytes
* </ul>
* @hide
*/
public static final class DvbData implements DigitalServiceIdentification {
/** The transport_stream_ID of the transport stream carrying the required service */
private final int mTransportStreamId;
/** The service_ID of the required service */
private final int mServiceId;
/**
* The original_network_ID of the network carrying the transport stream for the required
* service
*/
private final int mOriginalNetworkId;
public DvbData(int transportStreamId, int serviceId, int originalNetworkId) {
mTransportStreamId = transportStreamId;
mServiceId = serviceId;
mOriginalNetworkId = originalNetworkId;
}
@Override
public int toByteArray(byte[] data, int index) {
return threeFieldsToSixBytes(mTransportStreamId, mServiceId, mOriginalNetworkId, data,
index);
}
}
/**
* Identifies a 1-part Logical or Virtual Channel Number or a 2-part Major and Minor channel
* combination.
*/
private static final class ChannelIdentifier {
/** Identifies Channel Format */
private final int mChannelNumberFormat;
/**
* Major Channel Number (if Channel Number Format is 2-part). If format is
* CHANNEL_NUMBER_FORMAT_1_PART, this will be ignored(0).
*/
private final int mMajorChannelNumber;
/**
* 1-part Channel Number, or a Minor Channel Number (if Channel Number Format is 2-part).
*/
private final int mMinorChannelNumber;
private ChannelIdentifier(int format, int majorNumber, int minorNumer) {
mChannelNumberFormat = format;
mMajorChannelNumber = majorNumber;
mMinorChannelNumber = minorNumer;
}
private int toByteArray(byte[] data, int index) {
// The first 6 bits for format, the 10 bits for major number.
data[index] = (byte) (((mChannelNumberFormat << 2) | (mMajorChannelNumber >>> 8) & 0x3));
data[index + 1] = (byte) (mMajorChannelNumber & 0xFF);
// Minor number uses the next 16 bits.
shortToByteArray((short) mMinorChannelNumber, data, index + 2);
return 4;
}
}
/**
* Digital channel id.
* <p>
* It consists of the following fields
* <ul>
* <li>channel number format: 6bits
* <li>major number: 10bits
* <li>minor number: 16bits
* <li>reserved: 2bytes
* </ul>
* @hide
*/
public static final class DigitalChannelData implements DigitalServiceIdentification {
/** Identifies the logical or virtual channel number of a service. */
private final ChannelIdentifier mChannelIdentifier;
public static DigitalChannelData ofTwoNumbers(int majorNumber, int minorNumber) {
return new DigitalChannelData(
new ChannelIdentifier(CHANNEL_NUMBER_FORMAT_2_PART, majorNumber, minorNumber));
}
public static DigitalChannelData ofOneNumber(int number) {
return new DigitalChannelData(
new ChannelIdentifier(CHANNEL_NUMBER_FORMAT_1_PART, 0, number));
}
private DigitalChannelData(ChannelIdentifier id) {
mChannelIdentifier = id;
}
@Override
public int toByteArray(byte[] data, int index) {
mChannelIdentifier.toByteArray(data, index);
// The last 2 bytes is reserved for future use.
data[index + 4] = 0;
data[index + 5] = 0;
return 6;
}
}
/**
* Creates {@link DigitalServiceSource} with channel type.
*
* @param broadcastSystem digital broadcast system. It should be one of
* <ul>
* <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB}
* <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC}
* <li>{@link #DIGITAL_BROADCAST_TYPE_DVB}
* <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB_BS}
* <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB_CS}
* <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB_T}
* <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC_CABLE}
* <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC_SATELLITE}
* <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC_TERRESTRIAL}
* <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_C}
* <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_S}
* <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_S2}
* <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_T}
* </ul>
* @hide
*/
public static DigitalServiceSource ofDigitalChannelId(int broadcastSystem,
DigitalChannelData data) {
if (data == null) {
throw new IllegalArgumentException("data should not be null.");
}
switch (broadcastSystem) {
case DIGITAL_BROADCAST_TYPE_ARIB:
case DIGITAL_BROADCAST_TYPE_ATSC:
case DIGITAL_BROADCAST_TYPE_DVB:
case DIGITAL_BROADCAST_TYPE_ARIB_BS:
case DIGITAL_BROADCAST_TYPE_ARIB_CS:
case DIGITAL_BROADCAST_TYPE_ARIB_T:
case DIGITAL_BROADCAST_TYPE_ATSC_CABLE:
case DIGITAL_BROADCAST_TYPE_ATSC_SATELLITE:
case DIGITAL_BROADCAST_TYPE_ATSC_TERRESTRIAL:
case DIGITAL_BROADCAST_TYPE_DVB_C:
case DIGITAL_BROADCAST_TYPE_DVB_S:
case DIGITAL_BROADCAST_TYPE_DVB_S2:
case DIGITAL_BROADCAST_TYPE_DVB_T:
return new DigitalServiceSource(
DigitalServiceSource.DIGITAL_SERVICE_IDENTIFIED_BY_CHANNEL,
broadcastSystem,
data);
default:
Log.w(TAG, "Invalid broadcast type:" + broadcastSystem);
throw new IllegalArgumentException(
"Invalid broadcast system value:" + broadcastSystem);
}
}
/**
* Creates {@link DigitalServiceSource} of ARIB type.
*
* @param aribType ARIB type. It should be one of
* <ul>
* <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB}
* <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB_BS}
* <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB_CS}
* <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB_T}
* </ul>
* @hide
*/
@Nullable
public static DigitalServiceSource ofArib(int aribType, AribData data) {
if (data == null) {
throw new IllegalArgumentException("data should not be null.");
}
switch (aribType) {
case DIGITAL_BROADCAST_TYPE_ARIB:
case DIGITAL_BROADCAST_TYPE_ARIB_BS:
case DIGITAL_BROADCAST_TYPE_ARIB_CS:
case DIGITAL_BROADCAST_TYPE_ARIB_T:
return new DigitalServiceSource(
DigitalServiceSource.DIGITAL_SERVICE_IDENTIFIED_BY_DIGITAL_ID,
aribType, data);
default:
Log.w(TAG, "Invalid ARIB type:" + aribType);
throw new IllegalArgumentException("type should not be null.");
}
}
/**
* Creates {@link DigitalServiceSource} of ATSC type.
*
* @param atscType ATSC type. It should be one of
* <ul>
* <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC}
* <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC_CABLE}
* <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC_SATELLITE}
* <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC_TERRESTRIAL}
* </ul>
* @hide
*/
@Nullable
public static DigitalServiceSource ofAtsc(int atscType, AtscData data) {
if (data == null) {
throw new IllegalArgumentException("data should not be null.");
}
switch (atscType) {
case DIGITAL_BROADCAST_TYPE_ATSC:
case DIGITAL_BROADCAST_TYPE_ATSC_CABLE:
case DIGITAL_BROADCAST_TYPE_ATSC_SATELLITE:
case DIGITAL_BROADCAST_TYPE_ATSC_TERRESTRIAL:
return new DigitalServiceSource(
DigitalServiceSource.DIGITAL_SERVICE_IDENTIFIED_BY_DIGITAL_ID,
atscType, data);
default:
Log.w(TAG, "Invalid ATSC type:" + atscType);
throw new IllegalArgumentException("Invalid ATSC type:" + atscType);
}
}
/**
* Creates {@link DigitalServiceSource} of ATSC type.
*
* @param dvbType DVB type. It should be one of
* <ul>
* <li>{@link #DIGITAL_BROADCAST_TYPE_DVB}
* <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_C}
* <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_S}
* <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_S2}
* <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_T}
* </ul>
* @hide
*/
@Nullable
public static DigitalServiceSource ofDvb(int dvbType, DvbData data) {
if (data == null) {
throw new IllegalArgumentException("data should not be null.");
}
switch (dvbType) {
case DIGITAL_BROADCAST_TYPE_DVB:
case DIGITAL_BROADCAST_TYPE_DVB_C:
case DIGITAL_BROADCAST_TYPE_DVB_S:
case DIGITAL_BROADCAST_TYPE_DVB_S2:
case DIGITAL_BROADCAST_TYPE_DVB_T:
return new DigitalServiceSource(
DigitalServiceSource.DIGITAL_SERVICE_IDENTIFIED_BY_DIGITAL_ID,
dvbType, data);
default:
Log.w(TAG, "Invalid DVB type:" + dvbType);
throw new IllegalArgumentException("Invalid DVB type:" + dvbType);
}
}
/**
* Record source container for "Digital Service".
* <ul>
* <li>[Record Source Type] - 1 byte
* <li>[Digital Identification] - 7 bytes
* </ul>
* @hide
*/
@SystemApi
public static final class DigitalServiceSource extends RecordSource {
/** Indicates that a service is identified by digital service IDs. */
private static final int DIGITAL_SERVICE_IDENTIFIED_BY_DIGITAL_ID = 0;
/** Indicates that a service is identified by a logical or virtual channel number. */
private static final int DIGITAL_SERVICE_IDENTIFIED_BY_CHANNEL = 1;
static final int EXTRA_DATA_SIZE = 7;
/**
* Type of identification. It should be one of DIGITAL_SERVICE_IDENTIFIED_BY_DIGITAL_ID and
* DIGITAL_SERVICE_IDENTIFIED_BY_CHANNEL
*/
private final int mIdentificationMethod;
/**
* Indicates the Digital Broadcast System of required service. This is present irrespective
* of the state of [Service Identification Method].
*/
private final int mBroadcastSystem;
/**
* Extra parameter for digital service identification.
*/
private final DigitalServiceIdentification mIdentification;
private DigitalServiceSource(int identificatinoMethod, int broadcastSystem,
DigitalServiceIdentification identification) {
super(RECORD_SOURCE_TYPE_DIGITAL_SERVICE, EXTRA_DATA_SIZE);
mIdentificationMethod = identificatinoMethod;
mBroadcastSystem = broadcastSystem;
mIdentification = identification;
}
@Override
int extraParamToByteArray(byte[] data, int index) {
data[index] = (byte) ((mIdentificationMethod << 7) | (mBroadcastSystem & 0x7F));
mIdentification.toByteArray(data, index + 1);
return EXTRA_DATA_SIZE;
}
}
// ---------------------------------------------------------------------------------------------
// ---- Analogue service data ------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------
/**
* Analogue broadcast types.
*/
/** @hide */
public static final int ANALOGUE_BROADCAST_TYPE_CABLE = 0x0;
/** @hide */
public static final int ANALOGUE_BROADCAST_TYPE_SATELLITE = 0x1;
/** @hide */
public static final int ANALOGUE_BROADCAST_TYPE_TERRESTRIAL = 0x2;
/**
* Broadcast system values.
*/
/** @hide */
public static final int BROADCAST_SYSTEM_PAL_BG = 0;
/** @hide */
public static final int BROADCAST_SYSTEM_SECAM_LP = 1;
/** @hide */
public static final int BROADCAST_SYSTEM_PAL_M = 2;
/** @hide */
public static final int BROADCAST_SYSTEM_NTSC_M = 3;
/** @hide */
public static final int BROADCAST_SYSTEM_PAL_I = 4;
/** @hide */
public static final int BROADCAST_SYSTEM_SECAM_DK = 5;
/** @hide */
public static final int BROADCAST_SYSTEM_SECAM_BG = 6;
/** @hide */
public static final int BROADCAST_SYSTEM_SECAM_L = 7;
/** @hide */
public static final int BROADCAST_SYSTEM_PAL_DK = 8;
/** @hide */
public static final int BROADCAST_SYSTEM_PAL_OTHER_SYSTEM = 31;
/**
* Creates {@link AnalogueServiceSource} of analogue service.
*
* @param broadcastType
* @param frequency
* @param broadcastSystem
* @hide
*/
@Nullable
public static AnalogueServiceSource ofAnalogue(int broadcastType, int frequency,
int broadcastSystem){
if (broadcastType < ANALOGUE_BROADCAST_TYPE_CABLE
|| broadcastType > ANALOGUE_BROADCAST_TYPE_TERRESTRIAL) {
Log.w(TAG, "Invalid Broadcast type:" + broadcastType);
throw new IllegalArgumentException("Invalid Broadcast type:" + broadcastType);
}
if (frequency < 0 || frequency > 0xFFFF) {
Log.w(TAG, "Invalid frequency value[0x0000-0xFFFF]:" + frequency);
throw new IllegalArgumentException(
"Invalid frequency value[0x0000-0xFFFF]:" + frequency);
}
if (broadcastSystem < BROADCAST_SYSTEM_PAL_BG
|| broadcastSystem > BROADCAST_SYSTEM_PAL_OTHER_SYSTEM) {
Log.w(TAG, "Invalid Broadcast system:" + broadcastSystem);
throw new IllegalArgumentException(
"Invalid Broadcast system:" + broadcastSystem);
}
return new AnalogueServiceSource(broadcastType, frequency, broadcastSystem);
}
/**
* Record source for analogue service data. It consists of
* <ul>
* <li>[Record Source Type] - 1 byte
* <li>[Analogue Broadcast Type] - 1 byte
* <li>[Analogue Frequency] - 2 bytes
* <li>[Broadcast System] - 1 byte
* </ul>
* @hide
*/
@SystemApi
public static final class AnalogueServiceSource extends RecordSource {
/* package */ static final int EXTRA_DATA_SIZE = 4;
/** Indicates the Analogue broadcast type. */
private final int mBroadcastType;
/** Used to specify the frequency used by an analogue tuner. 0x0000<N<0xFFFF. */
private final int mFrequency;
/**
* This specifies information about the color system, the sound carrier and the
* IF-frequency.
*/
private final int mBroadcastSystem;
private AnalogueServiceSource(int broadcastType, int frequency, int broadcastSystem) {
super(RECORD_SOURCE_TYPE_ANALOGUE_SERVICE, EXTRA_DATA_SIZE);
mBroadcastType = broadcastType;
mFrequency = frequency;
mBroadcastSystem = broadcastSystem;
}
@Override
/* package */ int extraParamToByteArray(byte[] data, int index) {
// [Analogue Broadcast Type] - 1 byte
data[index] = (byte) mBroadcastType;
// [Analogue Frequency] - 2 bytes
shortToByteArray((short) mFrequency, data, index + 1);
// [Broadcast System] - 1 byte
data[index + 3] = (byte) mBroadcastSystem;
return EXTRA_DATA_SIZE;
}
}
// ---------------------------------------------------------------------------------------------
// ---- External plug data ---------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------
/**
* Creates {@link ExternalPlugData} of external plug type.
*
* @param plugNumber plug number. It should be in range of [1, 255]
* @hide
*/
public static ExternalPlugData ofExternalPlug(int plugNumber) {
if (plugNumber < 1 || plugNumber > 255) {
Log.w(TAG, "Invalid plug number[1-255]" + plugNumber);
throw new IllegalArgumentException("Invalid plug number[1-255]" + plugNumber);
}
return new ExternalPlugData(plugNumber);
}
/**
* Record source for external plug (external non-HDMI device connect) type.
* <ul>
* <li>[Record Source Type] - 1 byte
* <li>[External Plug] - 1 byte
* </ul>
* @hide
*/
@SystemApi
public static final class ExternalPlugData extends RecordSource {
static final int EXTRA_DATA_SIZE = 1;
/** External Plug number on the Recording Device. */
private final int mPlugNumber;
private ExternalPlugData(int plugNumber) {
super(RECORD_SOURCE_TYPE_EXTERNAL_PLUG, EXTRA_DATA_SIZE);
mPlugNumber = plugNumber;
}
@Override
int extraParamToByteArray(byte[] data, int index) {
data[index] = (byte) mPlugNumber;
return EXTRA_DATA_SIZE;
}
}
// ---------------------------------------------------------------------------------------------
// ---- External physical address --------------------------------------------------------------
// ---------------------------------------------------------------------------------------------
/**
* Creates {@link ExternalPhysicalAddress} of external physical address.
*
* @param physicalAddress
* @hide
*/
public static ExternalPhysicalAddress ofExternalPhysicalAddress(int physicalAddress) {
if ((physicalAddress & ~0xFFFF) != 0) {
Log.w(TAG, "Invalid physical address:" + physicalAddress);
throw new IllegalArgumentException("Invalid physical address:" + physicalAddress);
}
return new ExternalPhysicalAddress(physicalAddress);
}
/**
* Record source for external physical address.
* <ul>
* <li>[Record Source Type] - 1 byte
* <li>[Physical address] - 2 byte
* </ul>
* @hide
*/
@SystemApi
public static final class ExternalPhysicalAddress extends RecordSource {
static final int EXTRA_DATA_SIZE = 2;
private final int mPhysicalAddress;
private ExternalPhysicalAddress(int physicalAddress) {
super(RECORD_SOURCE_TYPE_EXTERNAL_PHYSICAL_ADDRESS, EXTRA_DATA_SIZE);
mPhysicalAddress = physicalAddress;
}
@Override
int extraParamToByteArray(byte[] data, int index) {
shortToByteArray((short) mPhysicalAddress, data, index);
return EXTRA_DATA_SIZE;
}
}
// ---------------------------------------------------------------------------------------------
// ------- Helper methods ----------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------
private static int threeFieldsToSixBytes(int first, int second, int third, byte[] data,
int index) {
shortToByteArray((short) first, data, index);
shortToByteArray((short) second, data, index + 2);
shortToByteArray((short) third, data, index + 4);
return 6;
}
private static int shortToByteArray(short value, byte[] byteArray, int index) {
byteArray[index] = (byte) ((value >>> 8) & 0xFF);
byteArray[index + 1] = (byte) (value & 0xFF);
return 2;
}
/**
* Checks the byte array of record source.
* @hide
*/
@SystemApi
public static boolean checkRecordSource(byte[] recordSource) {
if (recordSource == null || recordSource.length == 0) return false;
int recordSourceType = recordSource[0];
int extraDataSize = recordSource.length - 1;
switch (recordSourceType) {
case RECORD_SOURCE_TYPE_OWN_SOURCE:
return extraDataSize == OwnSource.EXTRA_DATA_SIZE;
case RECORD_SOURCE_TYPE_DIGITAL_SERVICE:
return extraDataSize == DigitalServiceSource.EXTRA_DATA_SIZE;
case RECORD_SOURCE_TYPE_ANALOGUE_SERVICE:
return extraDataSize == AnalogueServiceSource.EXTRA_DATA_SIZE;
case RECORD_SOURCE_TYPE_EXTERNAL_PLUG:
return extraDataSize == ExternalPlugData.EXTRA_DATA_SIZE;
case RECORD_SOURCE_TYPE_EXTERNAL_PHYSICAL_ADDRESS:
return extraDataSize == ExternalPhysicalAddress.EXTRA_DATA_SIZE;
default:
return false;
}
}
}
|
