diff options
Diffstat (limited to 'core/java')
| -rw-r--r-- | core/java/android/uwb/AdapterState.aidl | 38 | ||||
| -rw-r--r-- | core/java/android/uwb/AdapterStateListener.java | 63 | ||||
| -rw-r--r-- | core/java/android/uwb/IUwbAdapter.aidl | 13 | ||||
| -rw-r--r-- | core/java/android/uwb/IUwbAdapterStateCallbacks.aidl | 13 | ||||
| -rw-r--r-- | core/java/android/uwb/UwbManager.java | 48 |
5 files changed, 161 insertions, 14 deletions
diff --git a/core/java/android/uwb/AdapterState.aidl b/core/java/android/uwb/AdapterState.aidl new file mode 100644 index 000000000000..991f64a0c0ae --- /dev/null +++ b/core/java/android/uwb/AdapterState.aidl @@ -0,0 +1,38 @@ +/* + * Copyright 2021 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.uwb; + +/** + * @hide + */ +@Backing(type="int") +enum AdapterState { + /** + * The state when UWB is disabled. + */ + STATE_DISABLED, + + /** + * The state when UWB is enabled but has no active sessions. + */ + STATE_ENABLED_INACTIVE, + + /** + * The state when UWB is enabled and has active sessions. + */ + STATE_ENABLED_ACTIVE, +}
\ No newline at end of file diff --git a/core/java/android/uwb/AdapterStateListener.java b/core/java/android/uwb/AdapterStateListener.java index 8875af385238..b9900951591f 100644 --- a/core/java/android/uwb/AdapterStateListener.java +++ b/core/java/android/uwb/AdapterStateListener.java @@ -21,6 +21,7 @@ import android.os.Binder; import android.os.RemoteException; import android.util.Log; import android.uwb.UwbManager.AdapterStateCallback; +import android.uwb.UwbManager.AdapterStateCallback.State; import android.uwb.UwbManager.AdapterStateCallback.StateChangedReason; import java.util.HashMap; @@ -40,7 +41,8 @@ public class AdapterStateListener extends IUwbAdapterStateCallbacks.Stub { @StateChangedReason private int mAdapterStateChangeReason = AdapterStateCallback.STATE_CHANGED_REASON_ERROR_UNKNOWN; - private boolean mAdapterEnabledState = false; + @State + private int mAdapterState = AdapterStateCallback.STATE_DISABLED; public AdapterStateListener(@NonNull IUwbAdapter adapter) { mAdapter = adapter; @@ -66,7 +68,7 @@ public class AdapterStateListener extends IUwbAdapterStateCallbacks.Stub { mIsRegistered = true; } catch (RemoteException e) { Log.w(TAG, "Failed to register adapter state callback"); - executor.execute(() -> callback.onStateChanged(false, + executor.execute(() -> callback.onStateChanged(mAdapterState, AdapterStateCallback.STATE_CHANGED_REASON_ERROR_UNKNOWN)); } } else { @@ -99,6 +101,42 @@ public class AdapterStateListener extends IUwbAdapterStateCallbacks.Stub { } } + /** + * Sets the adapter enabled state + * + * @param isEnabled value of new adapter state + */ + public void setEnabled(boolean isEnabled) { + synchronized (this) { + if (!mIsRegistered) { + return; + } else { + try { + mAdapter.setEnabled(isEnabled); + } catch (RemoteException e) { + Log.w(TAG, "Failed to set adapter state"); + sendErrorState(); + } + } + } + } + + private void sendErrorState() { + synchronized (this) { + for (AdapterStateCallback callback: mCallbackMap.keySet()) { + Executor executor = mCallbackMap.get(callback); + + final long identity = Binder.clearCallingIdentity(); + try { + executor.execute(() -> callback.onStateChanged( + mAdapterState, mAdapterStateChangeReason)); + } finally { + Binder.restoreCallingIdentity(identity); + } + } + } + } + private void sendCurrentState(@NonNull AdapterStateCallback callback) { synchronized (this) { Executor executor = mCallbackMap.get(callback); @@ -106,7 +144,7 @@ public class AdapterStateListener extends IUwbAdapterStateCallbacks.Stub { final long identity = Binder.clearCallingIdentity(); try { executor.execute(() -> callback.onStateChanged( - mAdapterEnabledState, mAdapterStateChangeReason)); + mAdapterState, mAdapterStateChangeReason)); } finally { Binder.restoreCallingIdentity(identity); } @@ -114,12 +152,13 @@ public class AdapterStateListener extends IUwbAdapterStateCallbacks.Stub { } @Override - public void onAdapterStateChanged(boolean isEnabled, int reason) { + public void onAdapterStateChanged(int state, int reason) { synchronized (this) { @StateChangedReason int localReason = convertToStateChangedReason(reason); - mAdapterEnabledState = isEnabled; + @State int localState = convertToState(state); mAdapterStateChangeReason = localReason; + mAdapterState = localState; for (AdapterStateCallback cb : mCallbackMap.keySet()) { sendCurrentState(cb); } @@ -146,4 +185,18 @@ public class AdapterStateListener extends IUwbAdapterStateCallbacks.Stub { return AdapterStateCallback.STATE_CHANGED_REASON_ERROR_UNKNOWN; } } + + private static @State int convertToState(@AdapterState int state) { + switch (state) { + case AdapterState.STATE_ENABLED_INACTIVE: + return AdapterStateCallback.STATE_ENABLED_INACTIVE; + + case AdapterState.STATE_ENABLED_ACTIVE: + return AdapterStateCallback.STATE_ENABLED_ACTIVE; + + case AdapterState.STATE_DISABLED: + default: + return AdapterStateCallback.STATE_DISABLED; + } + } } diff --git a/core/java/android/uwb/IUwbAdapter.aidl b/core/java/android/uwb/IUwbAdapter.aidl index 62f1c0c3fa0d..29021c111dd1 100644 --- a/core/java/android/uwb/IUwbAdapter.aidl +++ b/core/java/android/uwb/IUwbAdapter.aidl @@ -148,6 +148,19 @@ interface IUwbAdapter { */ void closeRanging(in SessionHandle sessionHandle); + /** + * Disables or enables UWB for a user + * + * The provided callback's IUwbAdapterStateCallbacks#onAdapterStateChanged + * function must be called immediately following state change. + * + * @param enabled value representing intent to disable or enable UWB. If + * true, any subsequent calls to #openRanging will be allowed. If false, + * all active ranging sessions will be closed and subsequent calls to + * #openRanging will be disallowed. + */ + void setEnabled(boolean enabled); + /** * The maximum allowed time to open a ranging session. */ diff --git a/core/java/android/uwb/IUwbAdapterStateCallbacks.aidl b/core/java/android/uwb/IUwbAdapterStateCallbacks.aidl index d928eabae465..d3b34c632bcc 100644 --- a/core/java/android/uwb/IUwbAdapterStateCallbacks.aidl +++ b/core/java/android/uwb/IUwbAdapterStateCallbacks.aidl @@ -17,16 +17,17 @@ package android.uwb; import android.uwb.StateChangeReason; +import android.uwb.AdapterState; /** * @hide */ interface IUwbAdapterStateCallbacks { /** - * Called whenever the adapter state changes - * - * @param isEnabled true if the adapter is enabled, false otherwise - * @param reason the reason that the state has changed - */ - void onAdapterStateChanged(boolean isEnabled, StateChangeReason reason); + * Called whenever the adapter state changes + * + * @param state UWB state; enabled_active, enabled_inactive, or disabled. + * @param reason the reason that the state has changed + */ + void onAdapterStateChanged(AdapterState state, StateChangeReason reason); }
\ No newline at end of file diff --git a/core/java/android/uwb/UwbManager.java b/core/java/android/uwb/UwbManager.java index 95024b38575b..3c99f89c68b4 100644 --- a/core/java/android/uwb/UwbManager.java +++ b/core/java/android/uwb/UwbManager.java @@ -71,6 +71,16 @@ public final class UwbManager { @interface StateChangedReason {} /** + * @hide + */ + @Retention(RetentionPolicy.SOURCE) + @IntDef(value = { + STATE_ENABLED_INACTIVE, + STATE_ENABLED_ACTIVE, + STATE_DISABLED}) + @interface State {} + + /** * Indicates that the state change was due to opening of first UWB session */ int STATE_CHANGED_REASON_SESSION_STARTED = 0; @@ -96,22 +106,41 @@ public final class UwbManager { int STATE_CHANGED_REASON_ERROR_UNKNOWN = 4; /** + * Indicates that UWB is disabled on device + */ + int STATE_DISABLED = 0; + /** + * Indicates that UWB is enabled on device but has no active ranging sessions + */ + int STATE_ENABLED_INACTIVE = 1; + + /** + * Indicates that UWB is enabled and has active ranging session + */ + int STATE_ENABLED_ACTIVE = 2; + + /** * Invoked when underlying UWB adapter's state is changed * <p>Invoked with the adapter's current state after registering an * {@link AdapterStateCallback} using * {@link UwbManager#registerAdapterStateCallback(Executor, AdapterStateCallback)}. * - * <p>Possible values for the state to change are + * <p>Possible reasons for the state to change are * {@link #STATE_CHANGED_REASON_SESSION_STARTED}, * {@link #STATE_CHANGED_REASON_ALL_SESSIONS_CLOSED}, * {@link #STATE_CHANGED_REASON_SYSTEM_POLICY}, * {@link #STATE_CHANGED_REASON_SYSTEM_BOOT}, * {@link #STATE_CHANGED_REASON_ERROR_UNKNOWN}. * - * @param isEnabled true when UWB adapter is enabled, false when it is disabled + * <p>Possible values for the UWB state are + * {@link #STATE_ENABLED_INACTIVE}, + * {@link #STATE_ENABLED_ACTIVE}, + * {@link #STATE_DISABLED}. + * + * @param state the UWB state; inactive, active or disabled * @param reason the reason for the state change */ - void onStateChanged(boolean isEnabled, @StateChangedReason int reason); + void onStateChanged(@State int state, @StateChangedReason int reason); } /** @@ -248,4 +277,17 @@ public final class UwbManager { return mRangingManager.openSession( mContext.getAttributionSource(), parameters, executor, callbacks); } + + /** + * Disables or enables UWB for a user + * + * @param enabled value representing intent to disable or enable UWB. If true any subsequent + * calls to IUwbAdapter#openRanging will be allowed. If false, all active ranging sessions will + * be closed and subsequent calls to IUwbAdapter#openRanging will be disallowed. + * + * @hide + */ + public void setUwbEnabled(boolean enabled) { + mAdapterStateListener.setEnabled(enabled); + } } |