Java DataElement.U_INT_2属性代码示例

public static synchronized byte[] serialize(ServiceRecord record) {
    DataElement seq = new DataElement(DataElement.DATSEQ);
    int[] attrIDs = record.getAttributeIDs();
    for (int i = 0; i < attrIDs.length; i++) {
        DataElement attrID = new DataElement(DataElement.U_INT_2,
                attrIDs[i]);
        DataElement attrValue = record.getAttributeValue(attrIDs[i]);
        if (attrValue != null) {
            seq.addElement(attrID);
            seq.addElement(attrValue);
        }
    }
    try {
        return des.serialize(seq);
    } catch (IOException e) {
        return null;
    }
}
 

public long getDataSize(DataElement data) {
    int type = data.getDataType();
    long size = getPureDataSize(data);
    if ((type == DataElement.NULL) || (type == DataElement.BOOL)
            || (type == DataElement.INT_1) || (type == DataElement.U_INT_1)
            || (type == DataElement.INT_2) || (type == DataElement.U_INT_2)
            || (type == DataElement.INT_4) || (type == DataElement.U_INT_4)
            || (type == DataElement.INT_8) || (type == DataElement.U_INT_8)
            || (type == DataElement.INT_16)
            || (type == DataElement.U_INT_16)
            || (type == DataElement.UUID)) {
        return size + 1;
    } else if ((type == DataElement.DATSEQ)
            || (type == DataElement.DATALT) || (type == DataElement.STRING)
            || (type == DataElement.URL)) {
        if (size <= 0xffL) {
            return size + 2;
        } else if (size <= 0xffffL) {
            return size + 3;
        } else if (size <= 0xffffffffL) {
            return size + 5;
        } else {
            throw new RuntimeException("Data size is too large.");
        }
    } else {
        throw new RuntimeException("Unexpected data type.");
    }
}
 

public long getPureDataSize(DataElement data) {
    switch (data.getDataType()) {
        case DataElement.NULL:
            return 0;
        case DataElement.BOOL:
        case DataElement.INT_1:
        case DataElement.U_INT_1:
            return 1;
        case DataElement.INT_2:
        case DataElement.U_INT_2:
            return 2;
        case DataElement.INT_4:
        case DataElement.U_INT_4:
            return 4;
        case DataElement.INT_8:
        case DataElement.U_INT_8:
            return 8;
        case DataElement.INT_16:
        case DataElement.U_INT_16:
            return 16;
        case DataElement.DATSEQ:
        case DataElement.DATALT:
            long size = 0;
            Enumeration elements = (Enumeration)data.getValue();
            while (elements.hasMoreElements()) {
                size += getDataSize((DataElement)elements.nextElement());
            }
            return size;
        case DataElement.STRING:
        case DataElement.URL:
            return ((String)data.getValue()).length();
        case DataElement.UUID:
            return 16;
        default:
            throw new RuntimeException("Unknown data type.");
    }
}
 

void loadByteArray(byte data[]) throws IOException {
	DataElement element = (new SDPInputStream(new ByteArrayInputStream(data))).readElement();
	if (element.getDataType() != DataElement.DATSEQ) {
		throw new IOException("DATSEQ expected instead of " + element.getDataType());
	}
	Enumeration en = (Enumeration) element.getValue();
	while (en.hasMoreElements()) {
		DataElement id = (DataElement) en.nextElement();
		if (id.getDataType() != DataElement.U_INT_2) {
			throw new IOException("U_INT_2 expected instead of " + id.getDataType());
		}
		DataElement value = (DataElement) en.nextElement();
		this.populateAttributeValue((int) id.getLong(), value);
	}
}
 

/**
 * Tests for simple types
 */
private void validateConversion(DataElement element) throws IOException {
    int type = element.getDataType();
    switch (type) {
    case DataElement.NULL:
        validateConversion(element, 0, type, 0, null);
        break;
    case DataElement.BOOL:
        validateConversion(element, 0, type, element.getBoolean() ? 1 : 0, null);
        break;
    case DataElement.U_INT_1:
    case DataElement.INT_1:
    case DataElement.U_INT_2:
    case DataElement.INT_2:
    case DataElement.U_INT_4:
    case DataElement.INT_4:
    case DataElement.INT_8:
        validateConversion(element, 0, type, element.getLong(), null);
        break;
    case DataElement.U_INT_8:
    case DataElement.U_INT_16:
    case DataElement.INT_16:
        validateConversion(element, 0, type, 0, (byte[]) element.getValue());
        break;
    case DataElement.UUID:
        validateConversion(element, 0, type, 0, Utils.UUIDToByteArray((UUID) element.getValue()));
        break;
    case DataElement.STRING:
        byte[] bs = Utils.getUTF8Bytes((String) element.getValue());
        validateConversion(element, 0, type, 0, bs);
        break;
    case DataElement.URL:
        byte[] bu = Utils.getASCIIBytes((String) element.getValue());
        validateConversion(element, 0, type, 0, bu);
        break;
    default:
        throw new IllegalArgumentException();
    }
}
 

protected boolean compareDataElements(DataElement first,
        DataElement second) {
    boolean ret = false;
    int valueType = first.getDataType();
    if (ret = (valueType == second.getDataType())) {
        switch (valueType) {
        case DataElement.BOOL:
            ret = first.getBoolean() == second.getBoolean();
            break;
        case DataElement.U_INT_1:
        case DataElement.U_INT_2:
        case DataElement.U_INT_4:
        case DataElement.INT_1:
        case DataElement.INT_2:
        case DataElement.INT_4:
        case DataElement.INT_8:
            ret = first.getLong() == second.getLong();
            break;
        default:
            Object v1 = first.getValue();
            Object v2 = second.getValue();
            if (v1 instanceof Enumeration && v2 instanceof Enumeration) {
                Enumeration e1 = (Enumeration)v1;
                Enumeration e2 = (Enumeration)v2;
                ret = true;
                while (e1.hasMoreElements() &&
                       e2.hasMoreElements() && ret) {
                    ret &= e1.nextElement().equals(e2.nextElement());
                }
                ret = ret &&
                    !(e1.hasMoreElements() ||
                      e2.hasMoreElements());
            } else if (v1 instanceof byte[] && v2 instanceof byte[]) {
                byte[] a1 = (byte[])v1;
                byte[] a2 = (byte[])v2;
                ret = a1.length == a2.length;
                for (int i = a1.length; --i >= 0 && ret; ) {
                    ret &= (a1[i] == a2[i]);
                }
            } else {
                ret = v1.equals(v2);
            }
            break;
        }
    }
    return ret;
}
 

private void sdpServiceAddAttribute(long handle, char handleType, int attrID, DataElement element) throws ServiceRegistrationException {
    int type = element.getDataType();
    switch (type) {
    case DataElement.NULL:
        sdpServiceAddAttribute(handle, handleType, attrID, type, 0, null);
        break;
    case DataElement.BOOL:
        sdpServiceAddAttribute(handle, handleType, attrID, type, element.getBoolean() ? 1 : 0, null);
        break;
    case DataElement.U_INT_1:
    case DataElement.INT_1:
    case DataElement.U_INT_2:
    case DataElement.INT_2:
    case DataElement.U_INT_4:
    case DataElement.INT_4:
    case DataElement.INT_8:
        sdpServiceAddAttribute(handle, handleType, attrID, type, element.getLong(), null);
        break;
    case DataElement.U_INT_8:
    case DataElement.U_INT_16:
    case DataElement.INT_16:
        sdpServiceAddAttribute(handle, handleType, attrID, type, 0, (byte[]) element.getValue());
        break;
    case DataElement.UUID:
        sdpServiceAddAttribute(handle, handleType, attrID, type, 0, Utils.UUIDToByteArray((UUID) element.getValue()));
        break;
    case DataElement.STRING:
        byte[] bs = Utils.getUTF8Bytes((String) element.getValue());
        sdpServiceAddAttribute(handle, handleType, attrID, type, 0, bs);
        break;
    case DataElement.URL:
        byte[] bu = Utils.getASCIIBytes((String) element.getValue());
        sdpServiceAddAttribute(handle, handleType, attrID, type, 0, bu);
        break;
    case DataElement.DATSEQ:
    case DataElement.DATALT:
        sdpServiceSequenceAttributeStart(handle, handleType, attrID, type);
        for (Enumeration e = (Enumeration) element.getValue(); e.hasMoreElements();) {
            DataElement child = (DataElement) e.nextElement();
            sdpServiceAddAttribute(handle, handleType, -1, child);
        }
        sdpServiceSequenceAttributeEnd(handle, handleType, attrID);
        break;
    default:
        throw new IllegalArgumentException();
    }
}
 

int getChannel(UUID protocolUUID) {

		int channel = -1;

		DataElement protocolDescriptor = getAttributeValue(BluetoothConsts.ProtocolDescriptorList);
		if ((protocolDescriptor == null) || (protocolDescriptor.getDataType() != DataElement.DATSEQ)) {
			return -1;
		}

		/*
		 * get RFCOMM Channel or L2CAP PSM ProtocolDescriptorList is DATSEQ of
		 * DATSEQ of UUID and optional parameters
		 */

		for (Enumeration protocolsSeqEnum = (Enumeration) protocolDescriptor.getValue(); protocolsSeqEnum
				.hasMoreElements();) {
			DataElement elementSeq = (DataElement) protocolsSeqEnum.nextElement();

			if (elementSeq.getDataType() == DataElement.DATSEQ) {
				Enumeration elementSeqEnum = (Enumeration) elementSeq.getValue();

				if (elementSeqEnum.hasMoreElements()) {
					DataElement protocolElement = (DataElement) elementSeqEnum.nextElement();
					if (protocolElement.getDataType() != DataElement.UUID) {
						continue;
					}
					Object uuid = protocolElement.getValue();
					if (elementSeqEnum.hasMoreElements() && (protocolUUID.equals(uuid))) {

						DataElement protocolPSMElement = (DataElement) elementSeqEnum.nextElement();

						switch (protocolPSMElement.getDataType()) {
						case DataElement.U_INT_1:
						case DataElement.U_INT_2:
						case DataElement.U_INT_4:
						case DataElement.INT_1:
						case DataElement.INT_2:
						case DataElement.INT_4:
						case DataElement.INT_8:
							channel = (int) protocolPSMElement.getLong();
							break;
						}
					}
				}
			}
		}
		return channel;
	}
 

public static boolean equals(DataElement de1, DataElement de2) {
    if ((de1 == null) || (de2 == null)) {
        return false;
    }
    try {
        if (de1.getDataType() != de2.getDataType()) {
            return false;
        }
        switch (de1.getDataType()) {
        case DataElement.U_INT_1:
        case DataElement.U_INT_2:
        case DataElement.U_INT_4:
        case DataElement.INT_1:
        case DataElement.INT_2:
        case DataElement.INT_4:
        case DataElement.INT_8:
            return (de1.getLong() == de2.getLong());
        case DataElement.URL:
        case DataElement.STRING:
        case DataElement.UUID:
            return de1.getValue().equals(de2.getValue());
        case DataElement.INT_16:
        case DataElement.U_INT_8:
        case DataElement.U_INT_16:
            byte[] byteAray1 = (byte[]) de1.getValue();
            byte[] byteAray2 = (byte[]) de2.getValue();
            if (byteAray1.length != byteAray2.length) {
                return false;
            }
            for (int k = 0; k < byteAray1.length; k++) {
                if (byteAray1[k] != byteAray2[k]) {
                    return false;
                }
            }
            return true;
        case DataElement.NULL:
            return true;
        case DataElement.BOOL:
            return (de1.getBoolean() == de2.getBoolean());
        case DataElement.DATSEQ:
        case DataElement.DATALT:
            Enumeration en1 = (Enumeration) de1.getValue();
            Enumeration en2 = (Enumeration) de2.getValue();
            for (; en1.hasMoreElements() && en2.hasMoreElements();) {
                DataElement d1 = (DataElement) en1.nextElement();
                DataElement d2 = (DataElement) en2.nextElement();
                if (!equals(d1, d2)) {
                    return false;
                }
            }
            if (en1.hasMoreElements() || en2.hasMoreElements()) {
                return false;
            }
            return true;
        default:
            return false;
        }
    } catch (Throwable e) {
        e.printStackTrace();
        return false;
    }
}
 

public static void assertEquals(String message, DataElement de1, DataElement de2) {
	if ((de1 == null) || (de2 == null)) {
		fail(message + "NULL elements");
	}
	assertEquals(message + "Type", de1.getDataType(), de2.getDataType());
	switch (de1.getDataType()) {
	case DataElement.U_INT_1:
	case DataElement.U_INT_2:
	case DataElement.U_INT_4:
	case DataElement.INT_1:
	case DataElement.INT_2:
	case DataElement.INT_4:
	case DataElement.INT_8:
		assertEquals(message + "long", de1.getLong(), de2.getLong());
		return;
	case DataElement.URL:
	case DataElement.STRING:
	case DataElement.UUID:
		assertEquals(message + "value", de1.getValue(), de2.getValue());
		return;
	case DataElement.INT_16:
	case DataElement.U_INT_8:
	case DataElement.U_INT_16:
		byte[] byteAray1 = (byte[]) de1.getValue();
		byte[] byteAray2 = (byte[]) de2.getValue();
		assertEquals(message + "length", byteAray1.length, byteAray2.length);
		for (int k = 0; k < byteAray1.length; k++) {
			assertEquals(message + "byteAray[" + k + "]", byteAray1[k], byteAray2[k]);
		}
		return;
	case DataElement.NULL:
		return;
	case DataElement.BOOL:
		assertEquals(message + "boolean", de1.getBoolean(), de2.getBoolean());
		return;
	case DataElement.DATSEQ:
	case DataElement.DATALT:
		int i = 0;
		Enumeration en1 = (Enumeration) de1.getValue();
		Enumeration en2 = (Enumeration) de2.getValue();
		for (; en1.hasMoreElements() && en2.hasMoreElements();) {
			DataElement d1 = (DataElement) en1.nextElement();
			DataElement d2 = (DataElement) en2.nextElement();
			assertEquals(message + "DataElement[" + i + "]", d1, d2);
			i++;
		}
		if (en1.hasMoreElements() || en2.hasMoreElements()) {
			fail(message + "unknown hasMoreElements");
		}
		return;
	default:
		fail(message + "unknown type");
	}
}