RemoteAuthClient
public final class RemoteAuthClient implements AutoCloseable
Provides a client for supporting remote authentication on Wear. The authentication session will be opened on the user's paired phone.
-
The following example triggers an authorization session to open on the phone.
// PKCE (Proof Key for Code Exchange) is required for the auth
private var codeVerifier: CodeVerifier
// Late initialization in place where it's used, or to be initialized in onCreate()
private var lateinit authClient: RemoteAuthClient
override public fun onDestroy() {
authClient.close();
super.onDestroy();
}
public fun startAuthFlow() {
// PKCE (Proof Key for Code Exchange) is required, store this code verifier here .
// To access the resource later, both the auth token and code verifier are needed.
codeVerifier = CodeVerifier()
// Construct your auth request.
authClient = RemoteAuthClient.create(this);
authClient.sendAuthorizationRequest(
OAuthRequest.Builder(this.applicationContext)
.setAuthProviderUrl(Uri.parse("https://...."))
.setCodeChallenge(CodeChallenge(codeVerifier))
.build(),
Executors.newSingleThreadExecutor(),
new MyAuthCallback()
);
}
private class MyAuthCallback: RemoteAuthClient.Callback {
override public fun onAuthorizationResponse(
request: OAuthRequest,
response: OAuthResponse
) {
// Parse the result token out of the response and store it, e.g. in SharedPreferences,
// so you can use it later (Note, use together with code verifier from version R)
// You'll also want to display a success UI.
...
}
override fun onAuthorizationError(request: OAuthRequest, errorCode: Int) {
// Compare against codes available in RemoteAuthClient.ErrorCode
// You'll also want to display an error UI.
...
}
}
Summary
Nested types |
|---|
public abstract class RemoteAuthClient.CallbackThis callback is notified when an async remote authentication request completes. |
Constants |
|
|---|---|
static final int |
Indicates no phone is connected, or the phone connected doesn't support 3p auth |
static final int |
Indicates 3p authentication isn't supported by Wear OS |
static final int |
Indicates 3p authentication is finished without error |
static final int |
STATUS_AVAILABLE = 3Indicates that remote auth is available with a connected device capable to handle the remote interaction. |
static final int |
Indicates that remote auth is temporarily unavailable. |
static final int |
Indicates that remote auth is unavailable because there is no paired device capable of handling the remote interaction. |
static final int |
STATUS_UNKNOWN = 0The remote auth's availability is unknown. |
Public methods |
|
|---|---|
void |
Frees any resources used by the client, dropping any outstanding requests. |
static final @NonNull RemoteAuthClient |
Return a client that can be used to make async remote authorization requests |
final @NonNull Flow<@NonNull Integer> |
Returns status indicating whether remote auth operation (such as |
final void |
@UiThreadSend a remote auth request. |
Protected methods |
|
|---|---|
final void |
finalize()Check that the explicit termination method 'close' is called |
Constants
ERROR_PHONE_UNAVAILABLE
public static final int ERROR_PHONE_UNAVAILABLE = 1
Indicates no phone is connected, or the phone connected doesn't support 3p auth
ERROR_UNSUPPORTED
public static final int ERROR_UNSUPPORTED = 0
Indicates 3p authentication isn't supported by Wear OS
STATUS_AVAILABLE
public static final int STATUS_AVAILABLE = 3
Indicates that remote auth is available with a connected device capable to handle the remote interaction.
STATUS_TEMPORARILY_UNAVAILABLE
public static final int STATUS_TEMPORARILY_UNAVAILABLE = 2
Indicates that remote auth is temporarily unavailable.
There is a known paired device, but it is not currently connected or reachable to handle the remote interaction.
STATUS_UNAVAILABLE
public static final int STATUS_UNAVAILABLE = 1
Indicates that remote auth is unavailable because there is no paired device capable of handling the remote interaction.
STATUS_UNKNOWN
public static final int STATUS_UNKNOWN = 0
The remote auth's availability is unknown.
On older devices, STATUS_UNKNOWN is returned as we can not determine the availability states. To preserve compatibility with existing devices behavior, try sendAuthorizationRequest and handle error codes accordingly.
Public methods
close
@UiThread
public void close()
Frees any resources used by the client, dropping any outstanding requests. The client cannot be used to make requests thereafter.
create
public static final @NonNull RemoteAuthClient create(@NonNull Context context)
Return a client that can be used to make async remote authorization requests
getAvailabilityStatus
public final @NonNull Flow<@NonNull Integer> getAvailabilityStatus()
Returns status indicating whether remote auth operation (such as sendAuthorizationRequest) is available.
In scenarios of restricted connection or temporary disconnection with a paired device, remote auth operations will not be available. Please check status before sendAuthorizationRequest to provide better experience for the user.
On older wear devices which do not support availability status, it will always return STATUS_UNKNOWN. Wear devices start to support determining the availability status from Wear Sdk WEAR_TIRAMISU_4.
import androidx.wear.phone.interactions.authentication.RemoteAuthClient
remoteAuthClient.availabilityStatus.collect {
status -> when (status) {
RemoteAuthClient.STATUS_UNAVAILABLE ->
TODO("Present alternative flow as remote auth is not available")
RemoteAuthClient.STATUS_TEMPORARILY_UNAVAILABLE ->
TODO("Present education to user to connect devices or bring to proximity.")
RemoteAuthClient.STATUS_AVAILABLE, RemoteAuthClient.STATUS_UNKNOWN ->
// Present normal auth flow when we don't know (old devices)
// or when we know it is available.
remoteAuthClient.sendAuthorizationRequest(
oAuthRequest,
Runnable::run,
myAuthCallback)
} }
| Returns | |
|---|---|
@NonNull Flow<@NonNull Integer> |
a |
sendAuthorizationRequest
@UiThread
public final void sendAuthorizationRequest(
@NonNull OAuthRequest request,
@NonNull Executor executor,
@NonNull RemoteAuthClient.Callback clientCallback
)
Send a remote auth request. This will cause an authorization UI to be presented on the user's phone. This request is asynchronous; the callback provided will be be notified when the request completes.
| Parameters | |
|---|---|
@NonNull OAuthRequest request |
Request that will be sent to the phone. The auth response should redirect to the Wear OS companion. See |
@NonNull Executor executor |
The executor that callback will called on. |
@NonNull RemoteAuthClient.Callback clientCallback |
The callback that will be notified when request is completed. |
| Throws | |
|---|---|
kotlin.RuntimeException |
if the service has error to open the request |
Protected methods
finalize
protected final void finalize()
Check that the explicit termination method 'close' is called
| Throws | |
|---|---|
kotlin.RuntimeException |
if the 'close' method was not called |