| /* |
| * Copyright (C) 2022 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; |
| |
| import android.annotation.FlaggedApi; |
| import android.annotation.IntDef; |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.annotation.SuppressLint; |
| import android.annotation.SystemApi; |
| import android.app.Service; |
| import android.content.Intent; |
| import android.net.Uri; |
| import android.os.Build; |
| import android.os.CancellationSignal; |
| import android.os.IBinder; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.os.RemoteException; |
| import android.telephony.Annotation.DisconnectCauses; |
| import android.telephony.Annotation.PreciseDisconnectCauses; |
| import android.telephony.ims.ImsReasonInfo; |
| import android.text.TextUtils; |
| import android.util.Log; |
| |
| import com.android.internal.telephony.IDomainSelectionServiceController; |
| import com.android.internal.telephony.IDomainSelector; |
| import com.android.internal.telephony.ITransportSelectorCallback; |
| import com.android.internal.telephony.ITransportSelectorResultCallback; |
| import com.android.internal.telephony.IWwanSelectorCallback; |
| import com.android.internal.telephony.IWwanSelectorResultCallback; |
| import com.android.internal.telephony.flags.Flags; |
| import com.android.internal.telephony.util.TelephonyUtils; |
| import com.android.telephony.Rlog; |
| |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.lang.ref.WeakReference; |
| import java.util.List; |
| import java.util.Objects; |
| import java.util.concurrent.CancellationException; |
| import java.util.concurrent.CompletableFuture; |
| import java.util.concurrent.CompletionException; |
| import java.util.concurrent.Executor; |
| import java.util.function.Consumer; |
| |
| /** |
| * Base domain selection implementation. |
| * <p> |
| * Services that extend {@link DomainSelectionService} must register the service in their |
| * AndroidManifest.xml to be detected by the framework. |
| * <p> |
| * 1) The application must declare that they use the |
| * android.permission.BIND_DOMAIN_SELECTION_SERVICE permission. |
| * <p> |
| * 2) The DomainSelectionService definition in the manifest must follow this format: |
| * <pre> |
| * {@code |
| * ... |
| * <service android:name=".EgDomainSelectionService" |
| * android:permission="android.permission.BIND_DOMAIN_SELECTION_SERVICE" > |
| * <intent-filter> |
| * <action android:name="android.telephony.DomainSelectionService" /> |
| * </intent-filter> |
| * </service> |
| * ... |
| * } |
| * </pre> |
| * <p> |
| * The ComponentName corresponding to this DomainSelectionService component MUST also be set |
| * as the system domain selection implementation in order to be bound. |
| * The system domain selection implementation is set in the device overlay for |
| * {@code config_domain_selection_service_component_name} |
| * in {@code packages/services/Telephony/res/values/config.xml}. |
| * |
| * @hide |
| */ |
| @SystemApi |
| @FlaggedApi(Flags.FLAG_USE_OEM_DOMAIN_SELECTION_SERVICE) |
| public abstract class DomainSelectionService extends Service { |
| |
| private static final String LOG_TAG = "DomainSelectionService"; |
| |
| /** |
| * The intent that must be defined as an intent-filter in the AndroidManifest of the |
| * {@link DomainSelectionService}. |
| * |
| * @hide |
| */ |
| public static final String SERVICE_INTERFACE = "android.telephony.DomainSelectionService"; |
| |
| /** @hide */ |
| @Retention(RetentionPolicy.SOURCE) |
| @IntDef(prefix = "SELECTOR_TYPE_", |
| value = { |
| SELECTOR_TYPE_CALLING, |
| SELECTOR_TYPE_SMS}) |
| public @interface SelectorType {} |
| |
| /** Indicates the domain selector type for calling. */ |
| public static final int SELECTOR_TYPE_CALLING = 1; |
| /** Indicates the domain selector type for sms. */ |
| public static final int SELECTOR_TYPE_SMS = 2; |
| |
| /** Indicates that the modem can scan for emergency service as per modem’s implementation. */ |
| public static final int SCAN_TYPE_NO_PREFERENCE = 0; |
| |
| /** Indicates that the modem will scan for emergency service in limited service mode. */ |
| public static final int SCAN_TYPE_LIMITED_SERVICE = 1; |
| |
| /** Indicates that the modem will scan for emergency service in full service mode. */ |
| public static final int SCAN_TYPE_FULL_SERVICE = 2; |
| |
| /** @hide */ |
| @Retention(RetentionPolicy.SOURCE) |
| @IntDef(prefix = "SCAN_TYPE_", |
| value = { |
| SCAN_TYPE_NO_PREFERENCE, |
| SCAN_TYPE_LIMITED_SERVICE, |
| SCAN_TYPE_FULL_SERVICE}) |
| public @interface EmergencyScanType {} |
| |
| /** |
| * Contains attributes required to determine the domain for a telephony service. |
| */ |
| @FlaggedApi(Flags.FLAG_USE_OEM_DOMAIN_SELECTION_SERVICE) |
| public static final class SelectionAttributes implements Parcelable { |
| |
| private static final String TAG = "SelectionAttributes"; |
| |
| private int mSlotIndex; |
| private int mSubId; |
| private @Nullable String mCallId; |
| private @Nullable Uri mAddress; |
| private @SelectorType int mSelectorType; |
| private boolean mIsVideoCall; |
| private boolean mIsEmergency; |
| private boolean mIsTestEmergencyNumber; |
| private boolean mIsExitedFromAirplaneMode; |
| private @Nullable ImsReasonInfo mImsReasonInfo; |
| private @PreciseDisconnectCauses int mCause; |
| private @Nullable EmergencyRegistrationResult mEmergencyRegistrationResult; |
| |
| /** |
| * @param slotIndex The logical slot index. |
| * @param subscriptionId The subscription identifier. |
| * @param callId The call identifier. |
| * @param address The dialed address. |
| * @param selectorType Indicates the requested domain selector type. |
| * @param video Indicates it's a video call. |
| * @param emergency Indicates it's emergency service. |
| * @param isTest Indicates it's a test emergency number. |
| * @param exited {@code true} if the request caused the device to move out of airplane mode. |
| * @param imsReasonInfo The reason why the last PS attempt failed. |
| * @param cause The reason why the last CS attempt failed. |
| * @param regResult The current registration result for emergency services. |
| */ |
| private SelectionAttributes(int slotIndex, int subscriptionId, @Nullable String callId, |
| @Nullable Uri address, @SelectorType int selectorType, |
| boolean video, boolean emergency, boolean isTest, boolean exited, |
| @Nullable ImsReasonInfo imsReasonInfo, @PreciseDisconnectCauses int cause, |
| @Nullable EmergencyRegistrationResult regResult) { |
| mSlotIndex = slotIndex; |
| mSubId = subscriptionId; |
| mCallId = callId; |
| mAddress = address; |
| mSelectorType = selectorType; |
| mIsVideoCall = video; |
| mIsEmergency = emergency; |
| mIsTestEmergencyNumber = isTest; |
| mIsExitedFromAirplaneMode = exited; |
| mImsReasonInfo = imsReasonInfo; |
| mCause = cause; |
| mEmergencyRegistrationResult = regResult; |
| } |
| |
| /** |
| * Copy constructor. |
| * |
| * @param s Source selection attributes. |
| * @hide |
| */ |
| public SelectionAttributes(@NonNull SelectionAttributes s) { |
| mSlotIndex = s.mSlotIndex; |
| mSubId = s.mSubId; |
| mCallId = s.mCallId; |
| mAddress = s.mAddress; |
| mSelectorType = s.mSelectorType; |
| mIsEmergency = s.mIsEmergency; |
| mIsTestEmergencyNumber = s.mIsTestEmergencyNumber; |
| mIsExitedFromAirplaneMode = s.mIsExitedFromAirplaneMode; |
| mImsReasonInfo = s.mImsReasonInfo; |
| mCause = s.mCause; |
| mEmergencyRegistrationResult = s.mEmergencyRegistrationResult; |
| } |
| |
| /** |
| * Constructs a SelectionAttributes object from the given parcel. |
| */ |
| private SelectionAttributes(@NonNull Parcel in) { |
| readFromParcel(in); |
| } |
| |
| /** |
| * @return The logical slot index. |
| */ |
| public int getSlotIndex() { |
| return mSlotIndex; |
| } |
| |
| /** |
| * @return The subscription identifier. |
| */ |
| public int getSubscriptionId() { |
| return mSubId; |
| } |
| |
| /** |
| * @return The call identifier. |
| */ |
| public @Nullable String getCallId() { |
| return mCallId; |
| } |
| |
| /** |
| * @return The dialed address. |
| */ |
| public @Nullable Uri getAddress() { |
| return mAddress; |
| } |
| |
| /** |
| * @return The domain selector type. |
| */ |
| public @SelectorType int getSelectorType() { |
| return mSelectorType; |
| } |
| |
| /** |
| * @return {@code true} if the request is for a video call. |
| */ |
| public boolean isVideoCall() { |
| return mIsVideoCall; |
| } |
| |
| /** |
| * @return {@code true} if the request is for emergency services. |
| */ |
| public boolean isEmergency() { |
| return mIsEmergency; |
| } |
| |
| /** |
| * @return {@code true} if the dialed number is a test emergency number. |
| */ |
| public boolean isTestEmergencyNumber() { |
| return mIsTestEmergencyNumber; |
| } |
| |
| /** |
| * @return {@code true} if the request caused the device to move out of airplane mode. |
| */ |
| public boolean isExitedFromAirplaneMode() { |
| return mIsExitedFromAirplaneMode; |
| } |
| |
| /** |
| * @return The PS disconnect cause if trying over PS resulted in a failure and |
| * reselection is required. |
| */ |
| public @Nullable ImsReasonInfo getPsDisconnectCause() { |
| return mImsReasonInfo; |
| } |
| |
| /** |
| * @return The CS disconnect cause if trying over CS resulted in a failure and |
| * reselection is required. |
| */ |
| public @PreciseDisconnectCauses int getCsDisconnectCause() { |
| return mCause; |
| } |
| |
| /** |
| * @return The current registration state of cellular network. |
| */ |
| public @Nullable EmergencyRegistrationResult getEmergencyRegistrationResult() { |
| return mEmergencyRegistrationResult; |
| } |
| |
| @Override |
| public @NonNull String toString() { |
| return "{ slotIndex=" + mSlotIndex |
| + ", subId=" + mSubId |
| + ", callId=" + mCallId |
| + ", address=" + (Build.IS_DEBUGGABLE ? mAddress : "***") |
| + ", type=" + mSelectorType |
| + ", videoCall=" + mIsVideoCall |
| + ", emergency=" + mIsEmergency |
| + ", isTest=" + mIsTestEmergencyNumber |
| + ", airplaneMode=" + mIsExitedFromAirplaneMode |
| + ", reasonInfo=" + mImsReasonInfo |
| + ", cause=" + mCause |
| + ", regResult=" + mEmergencyRegistrationResult |
| + " }"; |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (this == o) return true; |
| if (o == null || getClass() != o.getClass()) return false; |
| SelectionAttributes that = (SelectionAttributes) o; |
| return mSlotIndex == that.mSlotIndex && mSubId == that.mSubId |
| && TextUtils.equals(mCallId, that.mCallId) |
| && equalsHandlesNulls(mAddress, that.mAddress) |
| && mSelectorType == that.mSelectorType && mIsVideoCall == that.mIsVideoCall |
| && mIsEmergency == that.mIsEmergency |
| && mIsTestEmergencyNumber == that.mIsTestEmergencyNumber |
| && mIsExitedFromAirplaneMode == that.mIsExitedFromAirplaneMode |
| && equalsHandlesNulls(mImsReasonInfo, that.mImsReasonInfo) |
| && mCause == that.mCause |
| && equalsHandlesNulls(mEmergencyRegistrationResult, |
| that.mEmergencyRegistrationResult); |
| } |
| |
| @Override |
| public int hashCode() { |
| return Objects.hash(mCallId, mAddress, mImsReasonInfo, |
| mIsVideoCall, mIsEmergency, mIsTestEmergencyNumber, mIsExitedFromAirplaneMode, |
| mEmergencyRegistrationResult, mSlotIndex, mSubId, mSelectorType, mCause); |
| } |
| |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| |
| @Override |
| public void writeToParcel(@NonNull Parcel out, int flags) { |
| out.writeInt(mSlotIndex); |
| out.writeInt(mSubId); |
| out.writeString8(mCallId); |
| out.writeParcelable(mAddress, 0); |
| out.writeInt(mSelectorType); |
| out.writeBoolean(mIsVideoCall); |
| out.writeBoolean(mIsEmergency); |
| out.writeBoolean(mIsTestEmergencyNumber); |
| out.writeBoolean(mIsExitedFromAirplaneMode); |
| out.writeParcelable(mImsReasonInfo, 0); |
| out.writeInt(mCause); |
| out.writeParcelable(mEmergencyRegistrationResult, 0); |
| } |
| |
| private void readFromParcel(@NonNull Parcel in) { |
| mSlotIndex = in.readInt(); |
| mSubId = in.readInt(); |
| mCallId = in.readString8(); |
| mAddress = in.readParcelable(Uri.class.getClassLoader(), |
| android.net.Uri.class); |
| mSelectorType = in.readInt(); |
| mIsVideoCall = in.readBoolean(); |
| mIsEmergency = in.readBoolean(); |
| mIsTestEmergencyNumber = in.readBoolean(); |
| mIsExitedFromAirplaneMode = in.readBoolean(); |
| mImsReasonInfo = in.readParcelable(ImsReasonInfo.class.getClassLoader(), |
| android.telephony.ims.ImsReasonInfo.class); |
| mCause = in.readInt(); |
| mEmergencyRegistrationResult = in.readParcelable( |
| EmergencyRegistrationResult.class.getClassLoader(), |
| EmergencyRegistrationResult.class); |
| } |
| |
| public static final @NonNull Creator<SelectionAttributes> CREATOR = |
| new Creator<SelectionAttributes>() { |
| @Override |
| public SelectionAttributes createFromParcel(@NonNull Parcel in) { |
| return new SelectionAttributes(in); |
| } |
| |
| @Override |
| public SelectionAttributes[] newArray(int size) { |
| return new SelectionAttributes[size]; |
| } |
| }; |
| |
| private static boolean equalsHandlesNulls(Object a, Object b) { |
| return (a == null) ? (b == null) : a.equals(b); |
| } |
| |
| /** |
| * Builder class creating a new instance. |
| */ |
| @FlaggedApi(Flags.FLAG_USE_OEM_DOMAIN_SELECTION_SERVICE) |
| public static final class Builder { |
| private final int mSlotIndex; |
| private final int mSubId; |
| private @Nullable String mCallId; |
| private @Nullable Uri mAddress; |
| private final @SelectorType int mSelectorType; |
| private boolean mIsVideoCall; |
| private boolean mIsEmergency; |
| private boolean mIsTestEmergencyNumber; |
| private boolean mIsExitedFromAirplaneMode; |
| private @Nullable ImsReasonInfo mImsReasonInfo; |
| private @PreciseDisconnectCauses int mCause; |
| private @Nullable EmergencyRegistrationResult mEmergencyRegistrationResult; |
| |
| /** |
| * Default constructor for Builder. |
| */ |
| public Builder(int slotIndex, int subscriptionId, @SelectorType int selectorType) { |
| mSlotIndex = slotIndex; |
| mSubId = subscriptionId; |
| mSelectorType = selectorType; |
| } |
| |
| /** |
| * Sets the call identifier. |
| * |
| * @param callId The call identifier. |
| * @return The same instance of the builder. |
| */ |
| public @NonNull Builder setCallId(@Nullable String callId) { |
| mCallId = callId; |
| return this; |
| } |
| |
| /** |
| * Sets the dialed address. |
| * |
| * @param address The dialed address. |
| * @return The same instance of the builder. |
| */ |
| public @NonNull Builder setAddress(@Nullable Uri address) { |
| mAddress = address; |
| return this; |
| } |
| |
| /** |
| * Sets whether it's a video call or not. |
| * |
| * @param isVideo Indicates it's a video call. |
| * @return The same instance of the builder. |
| */ |
| public @NonNull Builder setVideoCall(boolean isVideo) { |
| mIsVideoCall = isVideo; |
| return this; |
| } |
| |
| /** |
| * Sets whether it's an emergency service or not. |
| * |
| * @param isEmergency Indicates it's emergency service. |
| * @return The same instance of the builder. |
| */ |
| public @NonNull Builder setEmergency(boolean isEmergency) { |
| mIsEmergency = isEmergency; |
| return this; |
| } |
| |
| /** |
| * Sets whether it's a test emergency number or not. |
| * |
| * @param isTest Indicates it's a test emergency number. |
| * @return The same instance of the builder. |
| */ |
| public @NonNull Builder setTestEmergencyNumber(boolean isTest) { |
| mIsTestEmergencyNumber = isTest; |
| return this; |
| } |
| |
| /** |
| * Sets whether the request caused the device to move out of airplane mode. |
| * |
| * @param exited {@code true} if the request caused the device to move out of |
| * airplane mode. |
| * @return The same instance of the builder. |
| */ |
| public @NonNull Builder setExitedFromAirplaneMode(boolean exited) { |
| mIsExitedFromAirplaneMode = exited; |
| return this; |
| } |
| |
| /** |
| * Sets an optional reason why the last PS attempt failed. |
| * |
| * @param info The reason why the last PS attempt failed. |
| * @return The same instance of the builder. |
| */ |
| public @NonNull Builder setPsDisconnectCause(@Nullable ImsReasonInfo info) { |
| mImsReasonInfo = info; |
| return this; |
| } |
| |
| /** |
| * Sets an optional reason why the last CS attempt failed. |
| * |
| * @param cause The reason why the last CS attempt failed. |
| * @return The same instance of the builder. |
| */ |
| public @NonNull Builder setCsDisconnectCause(@PreciseDisconnectCauses int cause) { |
| mCause = cause; |
| return this; |
| } |
| |
| /** |
| * Sets the current registration result for emergency services. |
| * |
| * @param regResult The current registration result for emergency services. |
| * @return The same instance of the builder. |
| */ |
| public @NonNull Builder setEmergencyRegistrationResult( |
| @Nullable EmergencyRegistrationResult regResult) { |
| mEmergencyRegistrationResult = regResult; |
| return this; |
| } |
| |
| /** |
| * Build the SelectionAttributes. |
| * @return The SelectionAttributes object. |
| */ |
| public @NonNull SelectionAttributes build() { |
| return new SelectionAttributes(mSlotIndex, mSubId, mCallId, mAddress, |
| mSelectorType, mIsVideoCall, mIsEmergency, mIsTestEmergencyNumber, |
| mIsExitedFromAirplaneMode, mImsReasonInfo, |
| mCause, mEmergencyRegistrationResult); |
| } |
| } |
| } |
| |
| /** |
| * A wrapper class for ITransportSelectorCallback interface. |
| */ |
| private final class TransportSelectorCallbackWrapper implements TransportSelectorCallback { |
| private static final String TAG = "TransportSelectorCallbackWrapper"; |
| |
| private final @NonNull ITransportSelectorCallback mCallback; |
| private final @NonNull Executor mExecutor; |
| |
| private @Nullable ITransportSelectorResultCallbackAdapter mResultCallback; |
| private @Nullable DomainSelectorWrapper mSelectorWrapper; |
| |
| TransportSelectorCallbackWrapper(@NonNull ITransportSelectorCallback cb, |
| @NonNull Executor executor) { |
| mCallback = cb; |
| mExecutor = executor; |
| } |
| |
| @Override |
| public void onCreated(@NonNull DomainSelector selector) { |
| try { |
| mSelectorWrapper = new DomainSelectorWrapper(selector, mExecutor); |
| mCallback.onCreated(mSelectorWrapper.getCallbackBinder()); |
| } catch (Exception e) { |
| Rlog.e(TAG, "onCreated e=" + e); |
| } |
| } |
| |
| @Override |
| public void onWlanSelected(boolean useEmergencyPdn) { |
| try { |
| mCallback.onWlanSelected(useEmergencyPdn); |
| } catch (Exception e) { |
| Rlog.e(TAG, "onWlanSelected e=" + e); |
| } |
| } |
| |
| @Override |
| public void onWwanSelected(Consumer<WwanSelectorCallback> consumer) { |
| try { |
| mResultCallback = new ITransportSelectorResultCallbackAdapter(consumer, mExecutor); |
| mCallback.onWwanSelectedAsync(mResultCallback); |
| } catch (Exception e) { |
| Rlog.e(TAG, "onWwanSelected e=" + e); |
| executeMethodAsyncNoException(mExecutor, |
| () -> consumer.accept(null), TAG, "onWwanSelectedAsync-Exception"); |
| } |
| } |
| |
| @Override |
| public void onSelectionTerminated(@DisconnectCauses int cause) { |
| try { |
| mCallback.onSelectionTerminated(cause); |
| mSelectorWrapper = null; |
| } catch (Exception e) { |
| Rlog.e(TAG, "onSelectionTerminated e=" + e); |
| } |
| } |
| |
| private class ITransportSelectorResultCallbackAdapter |
| extends ITransportSelectorResultCallback.Stub { |
| private final @NonNull Consumer<WwanSelectorCallback> mConsumer; |
| private final @NonNull Executor mExecutor; |
| |
| ITransportSelectorResultCallbackAdapter( |
| @NonNull Consumer<WwanSelectorCallback> consumer, |
| @NonNull Executor executor) { |
| mConsumer = consumer; |
| mExecutor = executor; |
| } |
| |
| @Override |
| public void onCompleted(@NonNull IWwanSelectorCallback cb) { |
| if (mConsumer == null) return; |
| |
| WwanSelectorCallback callback = new WwanSelectorCallbackWrapper(cb, mExecutor); |
| executeMethodAsyncNoException(mExecutor, |
| () -> mConsumer.accept(callback), TAG, "onWwanSelectedAsync-Completed"); |
| } |
| } |
| } |
| |
| /** |
| * A wrapper class for IDomainSelector interface. |
| */ |
| private final class DomainSelectorWrapper { |
| private static final String TAG = "DomainSelectorWrapper"; |
| |
| private @NonNull IDomainSelector mCallbackBinder; |
| |
| DomainSelectorWrapper(@NonNull DomainSelector cb, @NonNull Executor executor) { |
| mCallbackBinder = new IDomainSelectorAdapter(cb, executor); |
| } |
| |
| private class IDomainSelectorAdapter extends IDomainSelector.Stub { |
| private final @NonNull WeakReference<DomainSelector> mDomainSelectorWeakRef; |
| private final @NonNull Executor mExecutor; |
| |
| IDomainSelectorAdapter(@NonNull DomainSelector domainSelector, |
| @NonNull Executor executor) { |
| mDomainSelectorWeakRef = |
| new WeakReference<DomainSelector>(domainSelector); |
| mExecutor = executor; |
| } |
| |
| @Override |
| public void reselectDomain(@NonNull SelectionAttributes attr) { |
| final DomainSelector domainSelector = mDomainSelectorWeakRef.get(); |
| if (domainSelector == null) return; |
| |
| executeMethodAsyncNoException(mExecutor, |
| () -> domainSelector.reselectDomain(attr), TAG, "reselectDomain"); |
| } |
| |
| @Override |
| public void finishSelection() { |
| final DomainSelector domainSelector = mDomainSelectorWeakRef.get(); |
| if (domainSelector == null) return; |
| |
| executeMethodAsyncNoException(mExecutor, |
| () -> domainSelector.finishSelection(), TAG, "finishSelection"); |
| } |
| } |
| |
| public @NonNull IDomainSelector getCallbackBinder() { |
| return mCallbackBinder; |
| } |
| } |
| |
| /** |
| * A wrapper class for IWwanSelectorCallback and IWwanSelectorResultCallback. |
| */ |
| private final class WwanSelectorCallbackWrapper |
| implements WwanSelectorCallback, CancellationSignal.OnCancelListener { |
| private static final String TAG = "WwanSelectorCallbackWrapper"; |
| |
| private final @NonNull IWwanSelectorCallback mCallback; |
| private final @NonNull Executor mExecutor; |
| |
| private @Nullable IWwanSelectorResultCallbackAdapter mResultCallback; |
| |
| WwanSelectorCallbackWrapper(@NonNull IWwanSelectorCallback cb, |
| @NonNull Executor executor) { |
| mCallback = cb; |
| mExecutor = executor; |
| } |
| |
| @Override |
| public void onCancel() { |
| try { |
| mCallback.onCancel(); |
| } catch (Exception e) { |
| Rlog.e(TAG, "onCancel e=" + e); |
| } |
| } |
| |
| @Override |
| public void onRequestEmergencyNetworkScan(@NonNull List<Integer> preferredNetworks, |
| @EmergencyScanType int scanType, boolean resetScan, |
| @NonNull CancellationSignal signal, |
| @NonNull Consumer<EmergencyRegistrationResult> consumer) { |
| try { |
| if (signal != null) signal.setOnCancelListener(this); |
| mResultCallback = new IWwanSelectorResultCallbackAdapter(consumer, mExecutor); |
| mCallback.onRequestEmergencyNetworkScan( |
| preferredNetworks.stream().mapToInt(Integer::intValue).toArray(), |
| scanType, resetScan, mResultCallback); |
| } catch (Exception e) { |
| Rlog.e(TAG, "onRequestEmergencyNetworkScan e=" + e); |
| } |
| } |
| |
| @Override |
| public void onDomainSelected(@NetworkRegistrationInfo.Domain int domain, |
| boolean useEmergencyPdn) { |
| try { |
| mCallback.onDomainSelected(domain, useEmergencyPdn); |
| } catch (Exception e) { |
| Rlog.e(TAG, "onDomainSelected e=" + e); |
| } |
| } |
| |
| private class IWwanSelectorResultCallbackAdapter |
| extends IWwanSelectorResultCallback.Stub { |
| private final @NonNull Consumer<EmergencyRegistrationResult> mConsumer; |
| private final @NonNull Executor mExecutor; |
| |
| IWwanSelectorResultCallbackAdapter( |
| @NonNull Consumer<EmergencyRegistrationResult> consumer, |
| @NonNull Executor executor) { |
| mConsumer = consumer; |
| mExecutor = executor; |
| } |
| |
| @Override |
| public void onComplete(@NonNull EmergencyRegistrationResult result) { |
| if (mConsumer == null) return; |
| |
| executeMethodAsyncNoException(mExecutor, |
| () -> mConsumer.accept(result), TAG, "onScanComplete"); |
| } |
| } |
| } |
| |
| private final Object mExecutorLock = new Object(); |
| |
| /** Executor used to execute methods called remotely by the framework. */ |
| private @NonNull Executor mExecutor; |
| |
| /** |
| * Selects a calling domain given the SelectionAttributes of the call request. |
| * <p> |
| * When the framework generates a request to place a call, {@link #onDomainSelection} |
| * will be called in order to determine the domain (CS or PS). For PS calls, the transport |
| * (WWAN or WLAN) will also need to be determined. |
| * <p> |
| * Once the domain/transport has been selected or an error has occurred, |
| * {@link TransportSelectorCallback} must be used to communicate the result back |
| * to the framework. |
| * |
| * @param attr Required to determine the domain. |
| * @param callback The callback instance being registered. |
| */ |
| public abstract void onDomainSelection(@NonNull SelectionAttributes attr, |
| @NonNull TransportSelectorCallback callback); |
| |
| /** |
| * Notifies the change in {@link ServiceState} for a specific logical slot index. |
| * |
| * @param slotIndex For which the state changed. |
| * @param subscriptionId For which the state changed. |
| * @param serviceState Updated {@link ServiceState}. |
| */ |
| public void onServiceStateUpdated(int slotIndex, int subscriptionId, |
| @NonNull ServiceState serviceState) { |
| } |
| |
| /** |
| * Notifies the change in {@link BarringInfo} for a specific logical slot index. |
| * |
| * @param slotIndex For which the state changed. |
| * @param subscriptionId For which the state changed. |
| * @param info Updated {@link BarringInfo}. |
| */ |
| public void onBarringInfoUpdated(int slotIndex, int subscriptionId, @NonNull BarringInfo info) { |
| } |
| |
| private final IBinder mDomainSelectionServiceController = |
| new IDomainSelectionServiceController.Stub() { |
| @Override |
| public void selectDomain(@NonNull SelectionAttributes attr, |
| @NonNull ITransportSelectorCallback callback) throws RemoteException { |
| executeMethodAsync(getCachedExecutor(), |
| () -> DomainSelectionService.this.onDomainSelection(attr, |
| new TransportSelectorCallbackWrapper(callback, getCachedExecutor())), |
| LOG_TAG, "onDomainSelection"); |
| } |
| |
| @Override |
| public void updateServiceState(int slotIndex, int subscriptionId, |
| @NonNull ServiceState serviceState) { |
| executeMethodAsyncNoException(getCachedExecutor(), |
| () -> DomainSelectionService.this.onServiceStateUpdated(slotIndex, |
| subscriptionId, serviceState), LOG_TAG, "onServiceStateUpdated"); |
| } |
| |
| @Override |
| public void updateBarringInfo(int slotIndex, int subscriptionId, |
| @NonNull BarringInfo info) { |
| executeMethodAsyncNoException(getCachedExecutor(), |
| () -> DomainSelectionService.this.onBarringInfoUpdated(slotIndex, |
| subscriptionId, info), |
| LOG_TAG, "onBarringInfoUpdated"); |
| } |
| }; |
| |
| private static void executeMethodAsync(@NonNull Executor executor, @NonNull Runnable r, |
| @NonNull String tag, @NonNull String errorLogName) throws RemoteException { |
| try { |
| CompletableFuture.runAsync( |
| () -> TelephonyUtils.runWithCleanCallingIdentity(r), executor).join(); |
| } catch (CancellationException | CompletionException e) { |
| Rlog.w(tag, "Binder - " + errorLogName + " exception: " + e.getMessage()); |
| throw new RemoteException(e.getMessage()); |
| } |
| } |
| |
| private void executeMethodAsyncNoException(@NonNull Executor executor, @NonNull Runnable r, |
| @NonNull String tag, @NonNull String errorLogName) { |
| try { |
| CompletableFuture.runAsync( |
| () -> TelephonyUtils.runWithCleanCallingIdentity(r), executor); |
| } catch (CancellationException | CompletionException e) { |
| Rlog.w(tag, "Binder - " + errorLogName + " exception: " + e.getMessage()); |
| } |
| } |
| |
| /** @hide */ |
| @Override |
| public final @Nullable IBinder onBind(@Nullable Intent intent) { |
| if (intent == null) return null; |
| if (SERVICE_INTERFACE.equals(intent.getAction())) { |
| Log.i(LOG_TAG, "DomainSelectionService Bound."); |
| return mDomainSelectionServiceController; |
| } |
| return null; |
| } |
| |
| /** |
| * The Executor to use when calling callback methods from the framework. |
| * <p> |
| * By default, calls from the framework will use Binder threads to call these methods. |
| * |
| * @return an {@link Executor} used to execute methods called remotely by the framework. |
| */ |
| @SuppressLint("OnNameExpected") |
| public @NonNull Executor getCreateExecutor() { |
| return Runnable::run; |
| } |
| |
| /** |
| * Gets the {@link Executor} which executes methods of this service. |
| * This method should be private when this service is implemented in a separated process |
| * other than telephony framework. |
| * @return {@link Executor} instance. |
| * @hide |
| */ |
| public final @NonNull Executor getCachedExecutor() { |
| synchronized (mExecutorLock) { |
| if (mExecutor == null) { |
| Executor e = getCreateExecutor(); |
| mExecutor = (e != null) ? e : Runnable::run; |
| } |
| return mExecutor; |
| } |
| } |
| |
| /** |
| * Returns a string representation of the domain. |
| * @param domain The domain. |
| * @return The name of the domain. |
| * @hide |
| */ |
| public static @NonNull String getDomainName(@NetworkRegistrationInfo.Domain int domain) { |
| return NetworkRegistrationInfo.domainToString(domain); |
| } |
| } |
