PairingParams
public
final
class
PairingParams
extends Object
implements
Parcelable
java.lang.Object | |
↳ | com.google.android.things.bluetooth.PairingParams |
This class encapsulates the data for a particular pairing attempt. The caller can use it to determine the pairing approach and choose a suitable way to obtain user consent conclude the pairing process.
Summary
Constants | |
---|---|
int |
PAIRING_VARIANT_CONSENT
Pairing variant where the user is expected to consent to the pairing process. |
int |
PAIRING_VARIANT_DISPLAY_PASSKEY
Pairing variant where the user is notified of a pairing passkey. |
int |
PAIRING_VARIANT_DISPLAY_PIN
Same as |
int |
PAIRING_VARIANT_PASSKEY_CONFIRMATION
Pairing variant where the user must confirm pairing after verifying a passkey which is provided to them. |
int |
PAIRING_VARIANT_PIN
Pairing variant where the user is supposed to enter a pin to confirm and authenticate the pairing process. |
int |
PAIRING_VARIANT_PIN_16_DIGITS
Same as |
Inherited constants |
---|
From
interface
android.os.Parcelable
|
Fields | |
---|---|
public
static
final
Creator<PairingParams> |
CREATOR
|
Public methods | |
---|---|
int
|
describeContents()
|
boolean
|
equals(Object o)
Indicates whether some other object is "equal to" this one. |
String
|
getPairingPin()
|
int
|
getPairingType()
|
int
|
hashCode()
Returns a hash code value for the object. |
String
|
toString()
Returns a string representation of the object. |
void
|
writeToParcel(Parcel dest, int flags)
|
Inherited methods | |
---|---|
From
class
java.lang.Object
| |
From
interface
android.os.Parcelable
|
Constants
PAIRING_VARIANT_CONSENT
int PAIRING_VARIANT_CONSENT
Pairing variant where the user is expected to consent to the pairing process. The caller is responsible for ensuring the user is prompted appropriately and user consent obtained for pairing.
To conclude the pairing process, you must call
finishPairing(BluetoothDevice)
after obtaining user
consent.
Constant Value: 3 (0x00000003)
PAIRING_VARIANT_DISPLAY_PASSKEY
int PAIRING_VARIANT_DISPLAY_PASSKEY
Pairing variant where the user is notified of a pairing passkey. No action needs to be taken by the user on the local device. It is expected that the user will use the passkey information to perform pairing on the remote device.
Constant Value: 4 (0x00000004)
PAIRING_VARIANT_DISPLAY_PIN
int PAIRING_VARIANT_DISPLAY_PIN
Same as PAIRING_VARIANT_DISPLAY_PASSKEY
, except that the pairing key format is
different.
This variant can be thought of as the opposite of PAIRING_VARIANT_PIN
. On one
device the pin is displayed. On the other, the user enters it.
Constant Value: 5 (0x00000005)
PAIRING_VARIANT_PASSKEY_CONFIRMATION
int PAIRING_VARIANT_PASSKEY_CONFIRMATION
Pairing variant where the user must confirm pairing after verifying a passkey which is provided to them. It is expected the user should be able to verify it by matching the provided pairing key with the key displayed on the remote device.
The pin is available using getPairingPin()
. The pairing process can be
completed using finishPairing(BluetoothDevice)
.
Constant Value: 2 (0x00000002)
PAIRING_VARIANT_PIN
int PAIRING_VARIANT_PIN
Pairing variant where the user is supposed to enter a pin to confirm and authenticate the pairing process. It is expected the pin has been displayed in some way on the remote device.
To conclude the pairing process for this variant, you must call
finishPairing(BluetoothDevice, String)
after
obtaining the pin from the user through suitable user input.
Constant Value: 0 (0x00000000)
PAIRING_VARIANT_PIN_16_DIGITS
int PAIRING_VARIANT_PIN_16_DIGITS
Same as PAIRING_VARIANT_PIN
, with the additional caveat that the pin is 16 digits
in size.
To conclude the pairing process for this variant, you must call
finishPairing(BluetoothDevice, String)
after
obtaining the pin from the user through suitable user input.
Constant Value: 7 (0x00000007)
Fields
Public methods
describeContents
int describeContents ()
Returns | |
---|---|
int |
equals
boolean equals (Object o)
Indicates whether some other object is "equal to" this one.
The equals
method implements an equivalence relation
on non-null object references:
- It is reflexive: for any non-null reference value
x
,x.equals(x)
should returntrue
. - It is symmetric: for any non-null reference values
x
andy
,x.equals(y)
should returntrue
if and only ify.equals(x)
returnstrue
. - It is transitive: for any non-null reference values
x
,y
, andz
, ifx.equals(y)
returnstrue
andy.equals(z)
returnstrue
, thenx.equals(z)
should returntrue
. - It is consistent: for any non-null reference values
x
andy
, multiple invocations ofx.equals(y)
consistently returntrue
or consistently returnfalse
, provided no information used inequals
comparisons on the objects is modified. - For any non-null reference value
x
,x.equals(null)
should returnfalse
.
The equals
method for class Object
implements
the most discriminating possible equivalence relation on objects;
that is, for any non-null reference values x
and
y
, this method returns true
if and only
if x
and y
refer to the same object
(x == y
has the value true
).
Note that it is generally necessary to override the hashCode
method whenever this method is overridden, so as to maintain the
general contract for the hashCode
method, which states
that equal objects must have equal hash codes.
Parameters | |
---|---|
o |
Object : the reference object with which to compare. |
Returns | |
---|---|
boolean |
true if this object is the same as the obj
argument; false otherwise. |
getPairingPin
String getPairingPin ()
Returns | |
---|---|
String |
Pairing pin to notify the user for the pairing process. If not relevant to the current pairing process, it's null. |
getPairingType
int getPairingType ()
Returns | |
---|---|
int |
Pairing type for this pairing attempt. The Pairing type is based on the User Interface capabilities of both the pairing devices, and determines the process of pairing. |
hashCode
int hashCode ()
Returns a hash code value for the object. This method is
supported for the benefit of hash tables such as those provided by
HashMap
.
The general contract of hashCode
is:
- Whenever it is invoked on the same object more than once during
an execution of a Java application, the
hashCode
method must consistently return the same integer, provided no information used inequals
comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application. - If two objects are equal according to the
equals(Object)
method, then calling thehashCode
method on each of the two objects must produce the same integer result. - It is not required that if two objects are unequal
according to the
equals(java.lang.Object)
method, then calling thehashCode
method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables.
As much as is reasonably practical, the hashCode method defined by
class Object
does return distinct integers for distinct
objects. (This is typically implemented by converting the internal
address of the object into an integer, but this implementation
technique is not required by the
Java™ programming language.)
Returns | |
---|---|
int |
a hash code value for this object. |
toString
String toString ()
Returns a string representation of the object. In general, the
toString
method returns a string that
"textually represents" this object. The result should
be a concise but informative representation that is easy for a
person to read.
It is recommended that all subclasses override this method.
The toString
method for class Object
returns a string consisting of the name of the class of which the
object is an instance, the at-sign character `@
', and
the unsigned hexadecimal representation of the hash code of the
object. In other words, this method returns a string equal to the
value of:
getClass().getName() + '@' + Integer.toHexString(hashCode())
Returns | |
---|---|
String |
a string representation of the object. |