| /* |
| * Copyright 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 com.android.internal.telephony; |
| |
| import android.annotation.NonNull; |
| import android.os.AsyncResult; |
| import android.os.Build; |
| import android.os.Handler; |
| import android.os.HandlerExecutor; |
| import android.os.Message; |
| import android.telephony.CellBroadcastIdRange; |
| import android.telephony.SmsCbMessage; |
| import android.telephony.SubscriptionManager; |
| import android.telephony.TelephonyManager; |
| import android.util.IndentingPrintWriter; |
| import android.util.LocalLog; |
| |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo; |
| import com.android.internal.telephony.gsm.SmsBroadcastConfigInfo; |
| import com.android.internal.util.State; |
| import com.android.internal.util.StateMachine; |
| |
| import java.io.FileDescriptor; |
| import java.io.PrintWriter; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.concurrent.CopyOnWriteArrayList; |
| import java.util.function.Consumer; |
| |
| /** |
| * This class is to track the state to set cell broadcast config |
| */ |
| |
| public final class CellBroadcastConfigTracker extends StateMachine { |
| private static final boolean DBG = Build.IS_DEBUGGABLE; |
| |
| private static final int EVENT_REQUEST = 1; |
| private static final int EVENT_CONFIGURATION_DONE = 2; |
| private static final int EVENT_ACTIVATION_DONE = 3; |
| private static final int EVENT_RADIO_OFF = 4; |
| private static final int EVENT_SUBSCRIPTION_CHANGED = 5; |
| @VisibleForTesting |
| public static final int EVENT_RADIO_RESET = 6; |
| |
| private static final int SMS_CB_CODE_SCHEME_MIN = 0; |
| private static final int SMS_CB_CODE_SCHEME_MAX = 255; |
| |
| // Cache of current cell broadcast id ranges of 3gpp |
| private List<CellBroadcastIdRange> mCbRanges3gpp = new CopyOnWriteArrayList<>(); |
| // Cache of current cell broadcast id ranges of 3gpp2 |
| private List<CellBroadcastIdRange> mCbRanges3gpp2 = new CopyOnWriteArrayList<>(); |
| private Phone mPhone; |
| private final LocalLog mLocalLog = new LocalLog(128); |
| @VisibleForTesting |
| public int mSubId; |
| @VisibleForTesting |
| public final SubscriptionManager.OnSubscriptionsChangedListener mSubChangedListener = |
| new SubscriptionManager.OnSubscriptionsChangedListener() { |
| @Override |
| public void onSubscriptionsChanged() { |
| sendMessage(EVENT_SUBSCRIPTION_CHANGED); |
| } |
| }; |
| |
| /** |
| * The class is to present the request to set cell broadcast id ranges |
| */ |
| private static class Request { |
| private final List<CellBroadcastIdRange> mCbRangesRequest3gpp = |
| new CopyOnWriteArrayList<>(); |
| private final List<CellBroadcastIdRange> mCbRangesRequest3gpp2 = |
| new CopyOnWriteArrayList<>(); |
| Consumer<Integer> mCallback; |
| |
| Request(@NonNull List<CellBroadcastIdRange> ranges, @NonNull Consumer<Integer> callback) { |
| ranges.forEach(r -> { |
| if (r.getType() == SmsCbMessage.MESSAGE_FORMAT_3GPP) { |
| mCbRangesRequest3gpp.add(r); |
| } else { |
| mCbRangesRequest3gpp2.add(r); |
| } |
| }); |
| mCallback = callback; |
| } |
| |
| List<CellBroadcastIdRange> get3gppRanges() { |
| return mCbRangesRequest3gpp; |
| } |
| |
| List<CellBroadcastIdRange> get3gpp2Ranges() { |
| return mCbRangesRequest3gpp2; |
| } |
| |
| Consumer<Integer> getCallback() { |
| return mCallback; |
| } |
| |
| @Override |
| public String toString() { |
| return "Request[mCbRangesRequest3gpp = " + mCbRangesRequest3gpp + ", " |
| + "mCbRangesRequest3gpp2 = " + mCbRangesRequest3gpp2 + "]"; |
| } |
| } |
| |
| /** |
| * The default state. |
| */ |
| private class DefaultState extends State { |
| @Override |
| public void enter() { |
| mPhone.registerForRadioOffOrNotAvailable(getHandler(), EVENT_RADIO_OFF, null); |
| mPhone.mCi.registerForModemReset(getHandler(), EVENT_RADIO_RESET, null); |
| mPhone.getContext().getSystemService(SubscriptionManager.class) |
| .addOnSubscriptionsChangedListener(new HandlerExecutor(getHandler()), |
| mSubChangedListener); |
| } |
| |
| @Override |
| public void exit() { |
| mPhone.unregisterForRadioOffOrNotAvailable(getHandler()); |
| mPhone.mCi.unregisterForModemReset(getHandler()); |
| mPhone.getContext().getSystemService(SubscriptionManager.class) |
| .removeOnSubscriptionsChangedListener(mSubChangedListener); |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal = HANDLED; |
| if (DBG) { |
| logd("DefaultState message:" + msg.what); |
| } |
| switch (msg.what) { |
| case EVENT_RADIO_OFF: |
| case EVENT_RADIO_RESET: |
| resetConfig(); |
| break; |
| case EVENT_SUBSCRIPTION_CHANGED: |
| int subId = mPhone.getSubId(); |
| if (mSubId != subId) { |
| log("SubId changed from " + mSubId + " to " + subId); |
| mSubId = subId; |
| resetConfig(); |
| } |
| break; |
| default: |
| log("unexpected message!"); |
| break; |
| |
| } |
| |
| return retVal; |
| } |
| } |
| |
| private DefaultState mDefaultState = new DefaultState(); |
| |
| /* |
| * The idle state which does not have ongoing radio request. |
| */ |
| private class IdleState extends State { |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal = NOT_HANDLED; |
| if (DBG) { |
| logd("IdleState message:" + msg.what); |
| } |
| switch (msg.what) { |
| case EVENT_REQUEST: |
| Request request = (Request) msg.obj; |
| if (DBG) { |
| logd("IdleState handle EVENT_REQUEST with request:" + request); |
| mLocalLog.log("IdleState handle EVENT_REQUEST with request:" + request |
| + ", mCbRanges3gpp:" + mCbRanges3gpp |
| + ", mCbRanges3gpp2:" + mCbRanges3gpp2); |
| } |
| if (!mCbRanges3gpp.equals(request.get3gppRanges())) { |
| // set gsm config if the config is changed |
| setGsmConfig(request.get3gppRanges(), request); |
| transitionTo(mGsmConfiguringState); |
| } else if (!mCbRanges3gpp2.equals(request.get3gpp2Ranges())) { |
| // set cdma config directly if no gsm config change but cdma config is |
| // changed |
| setCdmaConfig(request.get3gpp2Ranges(), request); |
| transitionTo(mCdmaConfiguringState); |
| } else { |
| logd("Do nothing as the requested ranges are same as now"); |
| request.getCallback().accept( |
| TelephonyManager.CELL_BROADCAST_RESULT_SUCCESS); |
| } |
| retVal = HANDLED; |
| break; |
| default: |
| break; |
| } |
| return retVal; |
| } |
| } |
| private IdleState mIdleState = new IdleState(); |
| |
| /* |
| * The state waiting for the result to set gsm config. |
| */ |
| private class GsmConfiguringState extends State { |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal = NOT_HANDLED; |
| if (DBG) { |
| logd("GsmConfiguringState message:" + msg.what); |
| } |
| switch (msg.what) { |
| case EVENT_REQUEST: |
| deferMessage(msg); |
| retVal = HANDLED; |
| break; |
| case EVENT_CONFIGURATION_DONE: |
| AsyncResult ar = (AsyncResult) msg.obj; |
| Request request = (Request) ar.userObj; |
| if (DBG) { |
| logd("GsmConfiguringState handle EVENT_CONFIGURATION_DONE with request:" |
| + request); |
| } |
| if (ar.exception == null) { |
| // set gsm activation and transit to gsm activating state |
| setActivation(SmsCbMessage.MESSAGE_FORMAT_3GPP, |
| !request.get3gppRanges().isEmpty(), request); |
| transitionTo(mGsmActivatingState); |
| } else { |
| logd("Failed to set gsm config"); |
| mLocalLog.log("GsmConfiguringState Failed to set gsm config:" + request); |
| request.getCallback().accept( |
| TelephonyManager.CELL_BROADCAST_RESULT_FAIL_CONFIG); |
| // transit to idle state on the failure case |
| transitionTo(mIdleState); |
| } |
| retVal = HANDLED; |
| break; |
| default: |
| break; |
| } |
| return retVal; |
| } |
| } |
| private GsmConfiguringState mGsmConfiguringState = new GsmConfiguringState(); |
| |
| /* |
| * The state waiting for the result to set gsm activation. |
| */ |
| private class GsmActivatingState extends State { |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal = NOT_HANDLED; |
| if (DBG) { |
| logd("GsmActivatingState message:" + msg.what); |
| } |
| switch (msg.what) { |
| case EVENT_REQUEST: |
| deferMessage(msg); |
| retVal = HANDLED; |
| break; |
| case EVENT_ACTIVATION_DONE: |
| AsyncResult ar = (AsyncResult) msg.obj; |
| Request request = (Request) ar.userObj; |
| if (DBG) { |
| logd("GsmActivatingState handle EVENT_ACTIVATION_DONE with request:" |
| + request); |
| mLocalLog.log("GsmActivatingState EVENT_ACTIVATION_DONE, exception:" |
| + ar.exception + ", request:" + request); |
| } |
| if (ar.exception == null) { |
| mCbRanges3gpp = request.get3gppRanges(); |
| if (!mCbRanges3gpp2.equals(request.get3gpp2Ranges())) { |
| // set cdma config and transit to cdma configuring state if the config |
| // is changed. |
| setCdmaConfig(request.get3gpp2Ranges(), request); |
| transitionTo(mCdmaConfiguringState); |
| } else { |
| logd("Done as no need to update ranges for 3gpp2"); |
| request.getCallback().accept( |
| TelephonyManager.CELL_BROADCAST_RESULT_SUCCESS); |
| // transit to idle state if there is no cdma config change |
| transitionTo(mIdleState); |
| } |
| } else { |
| logd("Failed to set gsm activation"); |
| request.getCallback().accept( |
| TelephonyManager.CELL_BROADCAST_RESULT_FAIL_ACTIVATION); |
| // transit to idle state on the failure case |
| transitionTo(mIdleState); |
| } |
| retVal = HANDLED; |
| break; |
| default: |
| break; |
| } |
| return retVal; |
| } |
| } |
| private GsmActivatingState mGsmActivatingState = new GsmActivatingState(); |
| |
| /* |
| * The state waiting for the result to set cdma config. |
| */ |
| private class CdmaConfiguringState extends State { |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal = NOT_HANDLED; |
| if (DBG) { |
| logd("CdmaConfiguringState message:" + msg.what); |
| } |
| switch (msg.what) { |
| case EVENT_REQUEST: |
| deferMessage(msg); |
| retVal = HANDLED; |
| break; |
| case EVENT_CONFIGURATION_DONE: |
| AsyncResult ar = (AsyncResult) msg.obj; |
| Request request = (Request) ar.userObj; |
| if (DBG) { |
| logd("CdmaConfiguringState handle EVENT_ACTIVATION_DONE with request:" |
| + request); |
| } |
| if (ar.exception == null) { |
| // set cdma activation and transit to cdma activating state |
| setActivation(SmsCbMessage.MESSAGE_FORMAT_3GPP2, |
| !request.get3gpp2Ranges().isEmpty(), request); |
| transitionTo(mCdmaActivatingState); |
| } else { |
| logd("Failed to set cdma config"); |
| mLocalLog.log("CdmaConfiguringState Failed to set cdma config:" + request); |
| request.getCallback().accept( |
| TelephonyManager.CELL_BROADCAST_RESULT_FAIL_CONFIG); |
| // transit to idle state on the failure case |
| transitionTo(mIdleState); |
| } |
| retVal = HANDLED; |
| break; |
| default: |
| break; |
| } |
| return retVal; |
| } |
| } |
| private CdmaConfiguringState mCdmaConfiguringState = new CdmaConfiguringState(); |
| |
| /* |
| * The state waiting for the result to set cdma activation. |
| */ |
| private class CdmaActivatingState extends State { |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal = NOT_HANDLED; |
| if (DBG) { |
| logd("CdmaActivatingState message:" + msg.what); |
| } |
| switch (msg.what) { |
| case EVENT_REQUEST: |
| deferMessage(msg); |
| retVal = HANDLED; |
| break; |
| case EVENT_ACTIVATION_DONE: |
| AsyncResult ar = (AsyncResult) msg.obj; |
| Request request = (Request) ar.userObj; |
| if (DBG) { |
| logd("CdmaActivatingState handle EVENT_ACTIVATION_DONE with request:" |
| + request); |
| mLocalLog.log("CdmaActivatingState EVENT_ACTIVATION_DONE, exception:" |
| + ar.exception + ", request:" + request); |
| } |
| if (ar.exception == null) { |
| mCbRanges3gpp2 = request.get3gpp2Ranges(); |
| request.getCallback().accept( |
| TelephonyManager.CELL_BROADCAST_RESULT_SUCCESS); |
| } else { |
| logd("Failed to set cdma activation"); |
| request.getCallback().accept( |
| TelephonyManager.CELL_BROADCAST_RESULT_FAIL_ACTIVATION); |
| } |
| // transit to idle state anyway |
| transitionTo(mIdleState); |
| retVal = HANDLED; |
| break; |
| default: |
| break; |
| } |
| return retVal; |
| } |
| } |
| private CdmaActivatingState mCdmaActivatingState = new CdmaActivatingState(); |
| |
| private CellBroadcastConfigTracker(Phone phone) { |
| super("CellBroadcastConfigTracker-" + phone.getPhoneId()); |
| init(phone); |
| } |
| |
| private CellBroadcastConfigTracker(Phone phone, Handler handler) { |
| super("CellBroadcastConfigTracker-" + phone.getPhoneId(), handler); |
| init(phone); |
| } |
| |
| private void init(Phone phone) { |
| logd("init"); |
| mPhone = phone; |
| mSubId = mPhone.getSubId(); |
| |
| addState(mDefaultState); |
| addState(mIdleState, mDefaultState); |
| addState(mGsmConfiguringState, mDefaultState); |
| addState(mGsmActivatingState, mDefaultState); |
| addState(mCdmaConfiguringState, mDefaultState); |
| addState(mCdmaActivatingState, mDefaultState); |
| setInitialState(mIdleState); |
| } |
| |
| /** |
| * create a CellBroadcastConfigTracker instance for the phone |
| */ |
| public static CellBroadcastConfigTracker make(Phone phone, Handler handler, |
| boolean shouldStart) { |
| CellBroadcastConfigTracker tracker = handler == null |
| ? new CellBroadcastConfigTracker(phone) |
| : new CellBroadcastConfigTracker(phone, handler); |
| if (shouldStart) { |
| tracker.start(); |
| } |
| return tracker; |
| } |
| |
| /** |
| * Return current cell broadcast ranges. |
| */ |
| @NonNull public List<CellBroadcastIdRange> getCellBroadcastIdRanges() { |
| List<CellBroadcastIdRange> ranges = new ArrayList<>(); |
| ranges.addAll(mCbRanges3gpp); |
| ranges.addAll(mCbRanges3gpp2); |
| return ranges; |
| } |
| |
| /** |
| * Set reception of cell broadcast messages with the list of the given ranges. |
| */ |
| public void setCellBroadcastIdRanges( |
| @NonNull List<CellBroadcastIdRange> ranges, @NonNull Consumer<Integer> callback) { |
| if (DBG) { |
| logd("setCellBroadcastIdRanges with ranges:" + ranges); |
| } |
| ranges = mergeRangesAsNeeded(ranges); |
| sendMessage(EVENT_REQUEST, new Request(ranges, callback)); |
| } |
| |
| /** |
| * Merge the overlapped CellBroadcastIdRanges in the list as needed |
| * @param ranges the list of CellBroadcastIdRanges |
| * @return the list of CellBroadcastIdRanges without overlapping |
| * |
| * @throws IllegalArgumentException if there is conflict of the ranges. For instance, |
| * the channel is enabled in some range, but disable in others. |
| */ |
| @VisibleForTesting |
| public static @NonNull List<CellBroadcastIdRange> mergeRangesAsNeeded( |
| @NonNull List<CellBroadcastIdRange> ranges) throws IllegalArgumentException { |
| ranges.sort((r1, r2) -> r1.getType() != r2.getType() ? r1.getType() - r2.getType() |
| : (r1.getStartId() != r2.getStartId() ? r1.getStartId() - r2.getStartId() |
| : r2.getEndId() - r1.getEndId())); |
| final List<CellBroadcastIdRange> newRanges = new ArrayList<>(); |
| ranges.forEach(r -> { |
| if (newRanges.isEmpty() || newRanges.get(newRanges.size() - 1).getType() != r.getType() |
| || newRanges.get(newRanges.size() - 1).getEndId() + 1 < r.getStartId() |
| || (newRanges.get(newRanges.size() - 1).getEndId() + 1 == r.getStartId() |
| && newRanges.get(newRanges.size() - 1).isEnabled() != r.isEnabled())) { |
| newRanges.add(new CellBroadcastIdRange(r.getStartId(), r.getEndId(), |
| r.getType(), r.isEnabled())); |
| } else { |
| if (newRanges.get(newRanges.size() - 1).isEnabled() != r.isEnabled()) { |
| throw new IllegalArgumentException("range conflict " + r); |
| } |
| if (r.getEndId() > newRanges.get(newRanges.size() - 1).getEndId()) { |
| CellBroadcastIdRange range = newRanges.get(newRanges.size() - 1); |
| newRanges.set(newRanges.size() - 1, new CellBroadcastIdRange( |
| range.getStartId(), r.getEndId(), range.getType(), range.isEnabled())); |
| } |
| } |
| }); |
| return newRanges; |
| } |
| |
| private void resetConfig() { |
| mCbRanges3gpp.clear(); |
| mCbRanges3gpp2.clear(); |
| } |
| |
| private void setGsmConfig(List<CellBroadcastIdRange> ranges, Request request) { |
| if (DBG) { |
| logd("setGsmConfig with " + ranges); |
| } |
| |
| SmsBroadcastConfigInfo[] configs = new SmsBroadcastConfigInfo[ranges.size()]; |
| for (int i = 0; i < configs.length; i++) { |
| CellBroadcastIdRange r = ranges.get(i); |
| configs[i] = new SmsBroadcastConfigInfo(r.getStartId(), r.getEndId(), |
| SMS_CB_CODE_SCHEME_MIN, SMS_CB_CODE_SCHEME_MAX, r.isEnabled()); |
| } |
| |
| Message response = obtainMessage(EVENT_CONFIGURATION_DONE, request); |
| mPhone.mCi.setGsmBroadcastConfig(configs, response); |
| } |
| |
| private void setCdmaConfig(List<CellBroadcastIdRange> ranges, Request request) { |
| if (DBG) { |
| logd("setCdmaConfig with " + ranges); |
| } |
| |
| CdmaSmsBroadcastConfigInfo[] configs = |
| new CdmaSmsBroadcastConfigInfo[ranges.size()]; |
| for (int i = 0; i < configs.length; i++) { |
| CellBroadcastIdRange r = ranges.get(i); |
| configs[i] = new CdmaSmsBroadcastConfigInfo( |
| r.getStartId(), r.getEndId(), 1, r.isEnabled()); |
| } |
| |
| Message response = obtainMessage(EVENT_CONFIGURATION_DONE, request); |
| mPhone.mCi.setCdmaBroadcastConfig(configs, response); |
| } |
| |
| private void setActivation(int type, boolean activate, Request request) { |
| if (DBG) { |
| logd("setActivation(" + type + "." + activate + ')'); |
| } |
| |
| Message response = obtainMessage(EVENT_ACTIVATION_DONE, request); |
| |
| if (type == SmsCbMessage.MESSAGE_FORMAT_3GPP) { |
| mPhone.mCi.setGsmBroadcastActivation(activate, response); |
| } else if (type == SmsCbMessage.MESSAGE_FORMAT_3GPP2) { |
| mPhone.mCi.setCdmaBroadcastActivation(activate, response); |
| } |
| } |
| |
| /** |
| * Dump the state of CellBroadcastConfigTracker |
| * |
| * @param fd File descriptor |
| * @param printWriter Print writer |
| * @param args Arguments |
| */ |
| public void dump(FileDescriptor fd, PrintWriter printWriter, String[] args) { |
| IndentingPrintWriter pw = new IndentingPrintWriter(printWriter, " "); |
| pw.println(CellBroadcastConfigTracker.class.getSimpleName() |
| + "-" + mPhone.getPhoneId() + ":"); |
| pw.increaseIndent(); |
| pw.println("Current mCbRanges3gpp:" + mCbRanges3gpp); |
| pw.println("Current mCbRanges3gpp2:" + mCbRanges3gpp2); |
| pw.decreaseIndent(); |
| |
| pw.println("Local logs:"); |
| pw.increaseIndent(); |
| mLocalLog.dump(fd, pw, args); |
| pw.decreaseIndent(); |
| } |
| } |
