From 748e76ba8253acadd416170a779074eba7cb061c Mon Sep 17 00:00:00 2001 From: Hakjun Choi Date: Thu, 5 Oct 2023 15:35:04 +0000 Subject: Add non-terrestrial signal strength related APIs to satellite client wrapper requestNtnSignalStrength, registerForNtnSignalStrengthChanged, unregisterForNtnSignalStrengthChanged are added Bug: 301511156 Test: manual 1. pushed SatelliteClient.jar into /system_ext/framework/ 2. pushed android.telephony.satellite.xml into /system_ext/etc/sysconfig/ 3. added dependency uses-library android:name="android.telephony.satellite"/> to the build.gradle of test app 4. added CompileOnly option to the build.gradle of test app 5. check whether SatelliteManagerWrapper.registerNtnSignalStrengthChangedWrapper and subsequent APIs are called Change-Id: I57d3fc326ebcb6be4da3bf4b482334fb6d675d07 --- .../wrapper/NtnSignalStrengthCallbackWrapper.java | 34 +++++++++++ .../wrapper/NtnSignalStrengthWrapper.java | 67 ++++++++++++++++++++++ .../satellite/wrapper/SatelliteManagerWrapper.java | 63 +++++++++++++++++++- 3 files changed, 162 insertions(+), 2 deletions(-) create mode 100644 satellite_client/src/android/telephony/satellite/wrapper/NtnSignalStrengthCallbackWrapper.java create mode 100644 satellite_client/src/android/telephony/satellite/wrapper/NtnSignalStrengthWrapper.java diff --git a/satellite_client/src/android/telephony/satellite/wrapper/NtnSignalStrengthCallbackWrapper.java b/satellite_client/src/android/telephony/satellite/wrapper/NtnSignalStrengthCallbackWrapper.java new file mode 100644 index 0000000..46aef62 --- /dev/null +++ b/satellite_client/src/android/telephony/satellite/wrapper/NtnSignalStrengthCallbackWrapper.java @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2023 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.telephony.satellite.wrapper; + +import android.annotation.FlaggedApi; +import android.annotation.NonNull; +import com.android.internal.telephony.flags.Flags; + +/** + * Encapsulates the callback class for notifying satellite signal strength change. + */ +@FlaggedApi(Flags.FLAG_OEM_ENABLED_SATELLITE_FLAG) +public interface NtnSignalStrengthCallbackWrapper { + /** + * Called when non-terrestrial network signal strength changes. + * @param ntnSignalStrength The new non-terrestrial network signal strength. + */ + @FlaggedApi(Flags.FLAG_OEM_ENABLED_SATELLITE_FLAG) + void onNtnSignalStrengthChanged(@NonNull NtnSignalStrengthWrapper ntnSignalStrength); +} diff --git a/satellite_client/src/android/telephony/satellite/wrapper/NtnSignalStrengthWrapper.java b/satellite_client/src/android/telephony/satellite/wrapper/NtnSignalStrengthWrapper.java new file mode 100644 index 0000000..5198457 --- /dev/null +++ b/satellite_client/src/android/telephony/satellite/wrapper/NtnSignalStrengthWrapper.java @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2023 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.telephony.satellite.wrapper; + +import android.annotation.FlaggedApi; +import android.annotation.IntDef; +import android.annotation.NonNull; +import com.android.internal.telephony.flags.Flags; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +/** Encapsulates the non-terrestrial network signal strength related information. */ +@FlaggedApi(Flags.FLAG_OEM_ENABLED_SATELLITE_FLAG) +public final class NtnSignalStrengthWrapper { + + /** Non-terrestrial network signal strength is not available. */ + @FlaggedApi(Flags.FLAG_OEM_ENABLED_SATELLITE_FLAG) + public static final int NTN_SIGNAL_STRENGTH_NONE = 0; + /** Non-terrestrial network signal strength is poor. */ + @FlaggedApi(Flags.FLAG_OEM_ENABLED_SATELLITE_FLAG) + public static final int NTN_SIGNAL_STRENGTH_POOR = 1; + /** Non-terrestrial network signal strength is moderate. */ + @FlaggedApi(Flags.FLAG_OEM_ENABLED_SATELLITE_FLAG) + public static final int NTN_SIGNAL_STRENGTH_MODERATE = 2; + /** Non-terrestrial network signal strength is good. */ + @FlaggedApi(Flags.FLAG_OEM_ENABLED_SATELLITE_FLAG) + public static final int NTN_SIGNAL_STRENGTH_GOOD = 3; + /** Non-terrestrial network signal strength is great. */ + @FlaggedApi(Flags.FLAG_OEM_ENABLED_SATELLITE_FLAG) + public static final int NTN_SIGNAL_STRENGTH_GREAT = 4; + @NtnSignalStrengthLevel private final int mLevel; + + /** @hide */ + @IntDef(prefix = "NTN_SIGNAL_STRENGTH_", value = { + NTN_SIGNAL_STRENGTH_NONE, + NTN_SIGNAL_STRENGTH_POOR, + NTN_SIGNAL_STRENGTH_MODERATE, + NTN_SIGNAL_STRENGTH_GOOD, + NTN_SIGNAL_STRENGTH_GREAT + }) + @Retention(RetentionPolicy.SOURCE) + public @interface NtnSignalStrengthLevel {} + + @FlaggedApi(Flags.FLAG_OEM_ENABLED_SATELLITE_FLAG) + public NtnSignalStrengthWrapper(@NonNull @NtnSignalStrengthLevel int level) { + this.mLevel = level; + } + + @FlaggedApi(Flags.FLAG_OEM_ENABLED_SATELLITE_FLAG) + @NtnSignalStrengthLevel public int getLevel() { + return mLevel; + } +} diff --git a/satellite_client/src/android/telephony/satellite/wrapper/SatelliteManagerWrapper.java b/satellite_client/src/android/telephony/satellite/wrapper/SatelliteManagerWrapper.java index de3a8a4..28fb8b6 100644 --- a/satellite_client/src/android/telephony/satellite/wrapper/SatelliteManagerWrapper.java +++ b/satellite_client/src/android/telephony/satellite/wrapper/SatelliteManagerWrapper.java @@ -19,6 +19,7 @@ package android.telephony.satellite.wrapper; import static android.telephony.satellite.SatelliteManager.SatelliteException; import android.annotation.CallbackExecutor; +import android.annotation.FlaggedApi; import android.annotation.IntDef; import android.annotation.NonNull; import android.annotation.Nullable; @@ -26,6 +27,8 @@ import android.content.Context; import android.os.CancellationSignal; import android.os.OutcomeReceiver; import android.telephony.satellite.AntennaPosition; +import android.telephony.satellite.NtnSignalStrength; +import android.telephony.satellite.NtnSignalStrengthCallback; import android.telephony.satellite.PointingInfo; import android.telephony.satellite.SatelliteCapabilities; import android.telephony.satellite.SatelliteDatagram; @@ -34,6 +37,7 @@ import android.telephony.satellite.SatelliteManager; import android.telephony.satellite.SatelliteProvisionStateCallback; import android.telephony.satellite.SatelliteStateCallback; import android.telephony.satellite.SatelliteTransmissionUpdateCallback; +import com.android.internal.telephony.flags.Flags; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.time.Duration; @@ -50,6 +54,10 @@ import java.util.function.Consumer; public class SatelliteManagerWrapper { private static final String TAG = "SatelliteManagerWrapper"; + private static final ConcurrentHashMap< + SatelliteDatagramCallbackWrapper, SatelliteDatagramCallback> + sSatelliteDatagramCallbackWrapperMap = new ConcurrentHashMap<>(); + private static final ConcurrentHashMap< SatelliteProvisionStateCallbackWrapper, SatelliteProvisionStateCallback> sSatelliteProvisionStateCallbackWrapperMap = new ConcurrentHashMap<>(); @@ -62,8 +70,8 @@ public class SatelliteManagerWrapper { sSatelliteTransmissionUpdateCallbackWrapperMap = new ConcurrentHashMap<>(); private static final ConcurrentHashMap< - SatelliteDatagramCallbackWrapper, SatelliteDatagramCallback> - sSatelliteDatagramCallbackWrapperMap = new ConcurrentHashMap<>(); + NtnSignalStrengthCallbackWrapper, NtnSignalStrengthCallback> + sNtnSignalStrengthCallbackWrapperMap = new ConcurrentHashMap<>(); private final SatelliteManager mSatelliteManager; @@ -752,4 +760,55 @@ public class SatelliteManagerWrapper { return output; } + + /** Request to get the signal strength of the satellite connection. */ + @FlaggedApi(Flags.FLAG_OEM_ENABLED_SATELLITE_FLAG) + @NonNull + public void requestNtnSignalStrength( + @NonNull @CallbackExecutor Executor executor, + @NonNull OutcomeReceiver callback) { + OutcomeReceiver internalCallback = + new OutcomeReceiver() { + @Override + public void onResult(NtnSignalStrength result) { + callback.onResult(new NtnSignalStrengthWrapper(result.getLevel())); + } + + @Override + public void onError(SatelliteException exception) { + callback.onError(new SatelliteExceptionWrapper(exception.getErrorCode())); + } + }; + mSatelliteManager.requestNtnSignalStrength(executor, internalCallback); + } + + /** Registers for NTN signal strength changed from satellite modem. */ + @FlaggedApi(Flags.FLAG_OEM_ENABLED_SATELLITE_FLAG) + @SatelliteResult public int registerForNtnSignalStrengthChanged( + @NonNull @CallbackExecutor Executor executor, + @NonNull NtnSignalStrengthCallbackWrapper callback) { + NtnSignalStrengthCallback internalCallback = + new NtnSignalStrengthCallback() { + @Override + public void onNtnSignalStrengthChanged(@NonNull NtnSignalStrength ntnSignalStrength) { + callback.onNtnSignalStrengthChanged( + new NtnSignalStrengthWrapper(ntnSignalStrength.getLevel())); + } + }; + sNtnSignalStrengthCallbackWrapperMap.put(callback, internalCallback); + return mSatelliteManager.registerForNtnSignalStrengthChanged(executor, internalCallback); + } + + /** + * Unregisters for NTN signal strength changed from satellite modem. + * If callback was not registered before, the request will be ignored. + */ + @FlaggedApi(Flags.FLAG_OEM_ENABLED_SATELLITE_FLAG) + public void unregisterForNtnSignalStrengthChanged( + @NonNull NtnSignalStrengthCallbackWrapper callback) { + NtnSignalStrengthCallback internalCallback = sNtnSignalStrengthCallbackWrapperMap.get(callback); + if (internalCallback != null) { + mSatelliteManager.unregisterForNtnSignalStrengthChanged(internalCallback); + } + } } -- cgit v1.2.3