The
UUID
class defines universally unique identifiers. These
128-bit unsigned integers are guaranteed to be unique across all time and
space. Accordingly, an instance of this class is immutable.
The Bluetooth specification provides an algorithm describing how a 16-bit or
32-bit UUID could be promoted to a 128-bit UUID. Accordingly, this class
provides an interface that assists applications in creating 16-bit, 32-bit,
and 128-bit long UUIDs. The methods supported by this class allow equality
testing of two UUID objects.
The Bluetooth Assigned Numbers document (
http://www.bluetooth.org/foundry/assignnumb/document/service_discovery
)
defines a large number of UUIDs for protocols and service classes. The table
below provides a short list of the most common UUIDs defined in the Bluetooth
Assigned Numbers document.
Value
Base UUID Value (Used in promoting 16-bit and 32-bit UUIDs to 128-bit
UUIDs)
0x0000000000001000800000805F9B34FB
128-bit
0x0001
16-bit
RFCOMM
0x0003
16-bit
0x0008
16-bit
0x000C
16-bit
L2CAP
0x0100
16-bit
0x000F
16-bit
Serial Port
0x1101
16-bit
ServiceDiscoveryServerServiceClassID
0x1000
16-bit
BrowseGroupDescriptorServiceClassID
0x1001
16-bit
PublicBrowseGroup
0x1002
16-bit
OBEX Object Push Profile
0x1105
16-bit
OBEX File Transfer Profile
0x1106
16-bit
Personal Area Networking User
0x1115
16-bit
Network Access Point
0x1116
16-bit
Group Network
0x1117
16-bit
Creates a
UUID
object from
long
value
uuidValue
. A UUID
is defined as an unsigned integer whose value can range from
[0 to 2
128
-1]. However, this constructor allows only
those values that are in the range of [0 to 2
32
-1].
Negative values and values in the range of [2
32
,
2
63
-1] are not
allowed and will cause an
IllegalArgumentException
to
be thrown.
Parameters:
uuidValue
- the 16-bit or 32-bit value of the UUID
Throws:
IllegalArgumentException
- if
uuidValue
is not in the range [0, 2
32
-1]
Creates a
UUID
object from the string provided. The
characters in the string must be from the hexadecimal set [0-9,
a-f, A-F]. It is important to note that the prefix "0x" generally
used for hex representation of numbers is not allowed. If the
string does not have characters from the hexadecimal set, an
exception will be thrown. The string length has to be positive
and less than or equal to 32. A string length that exceeds 32 is
illegal and will cause an exception. Finally, a
null
input
is also considered illegal and causes an exception.
If
shortUUID
is
true
,
uuidValue
represents a 16-bit or 32-bit UUID. If
uuidValue
is in
the range 0x0000 to 0xFFFF then this constructor will create a
16-bit UUID. If
uuidValue
is in the range
0x000010000 to 0xFFFFFFFF, then this constructor will create
a 32-bit UUID. Therefore,
uuidValue
may only be 8 characters
long.
On the other hand, if
shortUUID
is
false
, then
uuidValue
represents a 128-bit UUID. Therefore,
uuidValue
may only be 32 character long
Parameters:
uuidValue
- the string representation of a 16-bit,
32-bit or 128-bit UUID
shortUUID
- indicates the size of the UUID to be constructed;
true
is used to indicate short UUIDs,
i.e. either 16-bit or 32-bit;
false
indicates an 128-bit
Throws:
NumberFormatException
- if
uuidValue
has characters that are not defined in the hexadecimal set [0-9,
a-f, A-F]
IllegalArgumentException
- if
uuidValue
length is zero; if
shortUUID
is
true
and
uuidValue
's length is greater than 8; if
shortUUID
is
false
and
uuidValue
's length is greater than 32
NullPointerException
- if
uuidValue
is
public
String
toString
()
Returns the string representation of the 128-bit UUID object. The string
being returned represents a UUID that contains characters from the
hexadecimal set, [0-9, A-F]. It does not include the prefix "0x" that is
generally used for hex representation of numbers. Leading zeros MUST be
removed; for example, the string
00000000000000000000000000000000
will not be returned to
represent
0
. The return value will never be
null
.
Overrides:
toString
in class
Object
Returns:
the string representation of the UUID
public boolean
equals
(
Object
value)
Determines if two
UUID
s are equal. They are equal
if their 128 bit values are the same. This method will return
false
if
value
is
null
or is not a
UUID
object.
Overrides:
equals
in class
Object
Parameters:
value
- the object to compare to
Returns:
true
if the 128 bit values of the two
objects are equal, otherwise
false
Computes the hash code for this object.
This method retains the same semantic contract as defined in
the class
java.lang.Object
while overriding the
implementation.
Overrides:
hashCode
in class
Object
Returns:
the hash code for this object