android/cellbroadcastreceiver/CellBroadcastChannelManager.java

/*
 * Copyright (C) 2016 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.cellbroadcastreceiver;

import static android.telephony.ServiceState.ROAMING_TYPE_NOT_ROAMING;

import static com.android.cellbroadcastreceiver.CellBroadcastReceiver.VDBG;
import static com.android.cellbroadcastservice.CellBroadcastMetrics.ERRSRC_CBR;
import static com.android.cellbroadcastservice.CellBroadcastMetrics.ERRTYPE_CHANNELRANGEPARSE;

import android.annotation.NonNull;
import android.annotation.Nullable;
import android.content.Context;
import android.content.res.Resources;
import android.os.SystemProperties;
import android.telephony.AccessNetworkConstants;
import android.telephony.NetworkRegistrationInfo;
import android.telephony.ServiceState;
import android.telephony.SmsCbMessage;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.ArrayMap;
import android.util.Log;
import android.util.Pair;

import androidx.annotation.VisibleForTesting;

import com.android.cellbroadcastreceiver.CellBroadcastAlertService.AlertType;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * CellBroadcastChannelManager handles the additional cell broadcast channels that
 * carriers might enable through resources.
 * Syntax: "<channel id range>:[type=<alert type>], [emergency=true/false]"
 * For example,
 * <string-array name="additional_cbs_channels_strings" translatable="false">
 *     <item>"43008:type=earthquake, emergency=true"</item>
 *     <item>"0xAFEE:type=tsunami, emergency=true"</item>
 *     <item>"0xAC00-0xAFED:type=other"</item>
 *     <item>"1234-5678"</item>
 * </string-array>
 * If no tones are specified, the alert type will be set to DEFAULT. If emergency is not set,
 * by default it's not emergency.
 */
public class CellBroadcastChannelManager {

    private static final String TAG = "CBChannelManager";

    private static final int MAX_CACHE_SIZE = 3;
    private static List<Integer> sCellBroadcastRangeResourceKeys = new ArrayList<>(
            Arrays.asList(R.array.additional_cbs_channels_strings,
                    R.array.emergency_alerts_channels_range_strings,
                    R.array.cmas_presidential_alerts_channels_range_strings,
                    R.array.cmas_alert_extreme_channels_range_strings,
                    R.array.cmas_alerts_severe_range_strings,
                    R.array.cmas_amber_alerts_channels_range_strings,
                    R.array.required_monthly_test_range_strings,
                    R.array.exercise_alert_range_strings,
                    R.array.operator_defined_alert_range_strings,
                    R.array.etws_alerts_range_strings,
                    R.array.etws_test_alerts_range_strings,
                    R.array.public_safety_messages_channels_range_strings,
                    R.array.state_local_test_alert_range_strings,
                    R.array.geo_fencing_trigger_messages_range_strings
            ));

    private static Map<Integer, Map<Integer, List<CellBroadcastChannelRange>>>
            sAllCellBroadcastChannelRangesPerSub = new ArrayMap<>();
    private static Map<String, Map<Integer, List<CellBroadcastChannelRange>>>
            sAllCellBroadcastChannelRangesPerOperator = new ArrayMap<>();

    private static final Object mChannelRangesLock = new Object();

    private final Context mContext;

    private final int mSubId;

    private final String mOperator;

    private boolean mIsDebugBuild = false;

    /**
     * Cell broadcast channel range
     * A range is consisted by starting channel id, ending channel id, and the alert type
     */
    public static class CellBroadcastChannelRange {
        /** Defines the type of the alert. */
        private static final String KEY_TYPE = "type";
        /** Defines if the alert is emergency. */
        private static final String KEY_EMERGENCY = "emergency";
        /** Defines the network RAT for the alert. */
        private static final String KEY_RAT = "rat";
        /** Defines the scope of the alert. */
        private static final String KEY_SCOPE = "scope";
        /** Defines the vibration pattern of the alert. */
        private static final String KEY_VIBRATION = "vibration";
        /** Defines the duration of the alert. */
        private static final String KEY_ALERT_DURATION = "alert_duration";
        /** Defines if Do Not Disturb should be overridden for this alert */
        private static final String KEY_OVERRIDE_DND = "override_dnd";
        /** Defines whether writing alert message should exclude from SMS inbox. */
        private static final String KEY_EXCLUDE_FROM_SMS_INBOX = "exclude_from_sms_inbox";
        /** Define whether to display this cellbroadcast messages. */
        private static final String KEY_DISPLAY = "display";
        /** Define whether to enable this only in test/debug mode. */
        private static final String KEY_TESTING_MODE_ONLY = "testing_mode";
        /** Define the channels which not allow opt-out. */
        private static final String KEY_ALWAYS_ON = "always_on";
        /** Define the duration of screen on in milliseconds. */
        private static final String KEY_SCREEN_ON_DURATION = "screen_on_duration";
        /** Define whether to display warning icon in the alert dialog. */
        private static final String KEY_DISPLAY_ICON = "display_icon";
        /** Define whether to dismiss the alert dialog for outside touches */
        private static final String KEY_DISMISS_ON_OUTSIDE_TOUCH = "dismiss_on_outside_touch";
        /** Define whether to enable this only in userdebug/eng build. */
        private static final String KEY_DEBUG_BUILD_ONLY = "debug_build";
        /** Define the ISO-639-1 language code associated with the alert message. */
        private static final String KEY_LANGUAGE_CODE = "language";
        /** Define whether to display dialog and notification */
        private static final String KEY_DIALOG_WITH_NOTIFICATION = "dialog_with_notification";
        /** Define the pulsation pattern of the alert. */
        private static final String KEY_PULSATION = "pulsation";
        /**
         * Defines whether the channel needs language filter or not. True indicates that the alert
         * will only pop-up when the alert's language matches the device's language.
         */
        private static final String KEY_FILTER_LANGUAGE = "filter_language";


        public static final int SCOPE_UNKNOWN       = 0;
        public static final int SCOPE_CARRIER       = 1;
        public static final int SCOPE_DOMESTIC      = 2;
        public static final int SCOPE_INTERNATIONAL = 3;

        public static final int LEVEL_UNKNOWN          = 0;
        public static final int LEVEL_NOT_EMERGENCY    = 1;
        public static final int LEVEL_EMERGENCY        = 2;

        public int mStartId;
        public int mEndId;
        public AlertType mAlertType;
        public int mEmergencyLevel;
        public int mRanType;
        public int mScope;
        public int[] mVibrationPattern;
        public boolean mFilterLanguage;
        public boolean mDisplay;
        public boolean mTestMode;
        // by default no custom alert duration. play the alert tone with the tone's duration.
        public int mAlertDuration = -1;
        public boolean mOverrideDnd = false;
        // If enable_write_alerts_to_sms_inbox is true, write to sms inbox is enabled by default
        // for all channels except for channels which explicitly set to exclude from sms inbox.
        public boolean mWriteToSmsInbox = true;
        // only set to true for channels not allow opt-out. e.g, presidential alert.
        public boolean mAlwaysOn = false;
        // de default screen duration is 1min;
        public int mScreenOnDuration = 60000;
        // whether to display warning icon in the pop-up dialog;
        public boolean mDisplayIcon = true;
        // whether to dismiss the alert dialog on outside touch. Typically this should be false
        // to avoid accidental dismisses of emergency messages
        public boolean mDismissOnOutsideTouch = false;
        // Whether the channels are disabled
        public boolean mIsDebugBuildOnly = false;
        // This is used to override dialog title language
        public String mLanguageCode;
        // Display both ways dialog and notification
        public boolean mDisplayDialogWithNotification = false;
        // The pulsation pattern of the alert. The 1st parameter indicates the color to be changed.
        // The 2nd parameter indicates how long the pulsation will last. The 3rd and 4th parameters
        // indicate the intervals to set highlight color on/off.
        public int[] mPulsationPattern;

        public CellBroadcastChannelRange(Context context, int subId,
                Resources res, String channelRange) {
            mAlertType = AlertType.DEFAULT;
            mEmergencyLevel = LEVEL_UNKNOWN;
            mRanType = SmsCbMessage.MESSAGE_FORMAT_3GPP;
            mScope = SCOPE_UNKNOWN;

            mVibrationPattern = res.getIntArray(R.array.default_vibration_pattern);
            mFilterLanguage = false;
            // by default all received messages should be displayed.
            mDisplay = true;
            mTestMode = false;
            boolean hasVibrationPattern = false;
            mPulsationPattern = res.getIntArray(R.array.default_pulsation_pattern);

            int colonIndex = channelRange.indexOf(':');
            if (colonIndex != -1) {
                // Parse the alert type and emergency flag
                String[] pairs = channelRange.substring(colonIndex + 1).trim().split(",");
                for (String pair : pairs) {
                    pair = pair.trim();
                    String[] tokens = pair.split("=");
                    if (tokens.length == 2) {
                        String key = tokens[0].trim();
                        String value = tokens[1].trim();
                        switch (key) {
                            case KEY_TYPE:
                                mAlertType = AlertType.valueOf(value.toUpperCase());
                                break;
                            case KEY_EMERGENCY:
                                if (value.equalsIgnoreCase("true")) {
                                    mEmergencyLevel = LEVEL_EMERGENCY;
                                } else if (value.equalsIgnoreCase("false")) {
                                    mEmergencyLevel = LEVEL_NOT_EMERGENCY;
                                }
                                break;
                            case KEY_RAT:
                                mRanType = value.equalsIgnoreCase("cdma")
                                        ? SmsCbMessage.MESSAGE_FORMAT_3GPP2 :
                                        SmsCbMessage.MESSAGE_FORMAT_3GPP;
                                break;
                            case KEY_SCOPE:
                                if (value.equalsIgnoreCase("carrier")) {
                                    mScope = SCOPE_CARRIER;
                                } else if (value.equalsIgnoreCase("domestic")) {
                                    mScope = SCOPE_DOMESTIC;
                                } else if (value.equalsIgnoreCase("international")) {
                                    mScope = SCOPE_INTERNATIONAL;
                                }
                                break;
                            case KEY_VIBRATION:
                                String[] vibration = value.split("\\|");
                                if (vibration.length > 0) {
                                    mVibrationPattern = new int[vibration.length];
                                    for (int i = 0; i < vibration.length; i++) {
                                        mVibrationPattern[i] = Integer.parseInt(vibration[i]);
                                    }
                                    hasVibrationPattern = true;
                                }
                                break;
                            case KEY_FILTER_LANGUAGE:
                                if (value.equalsIgnoreCase("true")) {
                                    mFilterLanguage = true;
                                }
                                break;
                            case KEY_ALERT_DURATION:
                                mAlertDuration = Integer.parseInt(value);
                                break;
                            case KEY_OVERRIDE_DND:
                                if (value.equalsIgnoreCase("true")) {
                                    mOverrideDnd = true;
                                }
                                break;
                            case KEY_EXCLUDE_FROM_SMS_INBOX:
                                if (value.equalsIgnoreCase("true")) {
                                    mWriteToSmsInbox = false;
                                }
                                break;
                            case KEY_DISPLAY:
                                if (value.equalsIgnoreCase("false")) {
                                    mDisplay = false;
                                }
                                break;
                            case KEY_TESTING_MODE_ONLY:
                                if (value.equalsIgnoreCase("true")) {
                                    mTestMode = true;
                                }
                                break;
                            case KEY_ALWAYS_ON:
                                if (value.equalsIgnoreCase("true")) {
                                    mAlwaysOn = true;
                                }
                                break;
                            case KEY_SCREEN_ON_DURATION:
                                mScreenOnDuration = Integer.parseInt(value);
                                break;
                            case KEY_DISPLAY_ICON:
                                if (value.equalsIgnoreCase("false")) {
                                    mDisplayIcon = false;
                                }
                                break;
                            case KEY_DISMISS_ON_OUTSIDE_TOUCH:
                                if (value.equalsIgnoreCase("true")) {
                                    mDismissOnOutsideTouch = true;
                                }
                                break;
                            case KEY_DEBUG_BUILD_ONLY:
                                if (value.equalsIgnoreCase("true")) {
                                    mIsDebugBuildOnly = true;
                                }
                                break;
                            case KEY_LANGUAGE_CODE:
                                mLanguageCode = value;
                                break;
                            case KEY_DIALOG_WITH_NOTIFICATION:
                                if (value.equalsIgnoreCase("true")) {
                                    mDisplayDialogWithNotification = true;
                                }
                                break;
                            case KEY_PULSATION:
                                String[] pulsation = value.split("\\|");
                                if (pulsation.length > 0) {
                                    mPulsationPattern = new int[pulsation.length];
                                    for (int i = 0; i < pulsation.length; i++) {
                                        try {
                                            mPulsationPattern[i] = Long.decode(
                                                    pulsation[i]).intValue();
                                        } catch (NumberFormatException e) {
                                            Log.wtf(TAG, "Bad pulsation pattern[" + i + "]:"
                                                    + pulsation[i]);
                                        }
                                    }
                                }
                                break;
                        }
                    }
                }
                channelRange = channelRange.substring(0, colonIndex).trim();
            }

            // If alert type is info, override vibration pattern
            if (!hasVibrationPattern && mAlertType.equals(AlertType.INFO)) {
                mVibrationPattern = res.getIntArray(R.array.default_notification_vibration_pattern);
            }

            // Parse the channel range
            int dashIndex = channelRange.indexOf('-');
            if (dashIndex != -1) {
                // range that has start id and end id
                mStartId = Integer.decode(channelRange.substring(0, dashIndex).trim());
                mEndId = Integer.decode(channelRange.substring(dashIndex + 1).trim());
            } else {
                // Not a range, only a single id
                mStartId = mEndId = Integer.decode(channelRange);
            }
        }

        @Override
        public String toString() {
            return "Range:[channels=" + mStartId + "-" + mEndId + ",emergency level="
                    + mEmergencyLevel + ",type=" + mAlertType + ",scope=" + mScope + ",vibration="
                    + Arrays.toString(mVibrationPattern) + ",alertDuration=" + mAlertDuration
                    + ",filter_language=" + mFilterLanguage + ",override_dnd=" + mOverrideDnd
                    + ",display=" + mDisplay + ",testMode=" + mTestMode + ",mAlwaysOn="
                    + mAlwaysOn + ",ScreenOnDuration=" + mScreenOnDuration + ", displayIcon="
                    + mDisplayIcon + "dismissOnOutsideTouch=" + mDismissOnOutsideTouch
                    + ", mIsDebugBuildOnly =" + mIsDebugBuildOnly
                    + ", languageCode=" + mLanguageCode
                    + ", mDisplayDialogWithNotification=" + mDisplayDialogWithNotification
                    + ", mPulsationPattern=" + Arrays.toString(mPulsationPattern) + "]";
        }
    }

    /**
     * Constructor
     *
     * @param context Context
     * @param subId Subscription index
     */
    public CellBroadcastChannelManager(Context context, int subId) {
        this(context, subId, CellBroadcastReceiver.getRoamingOperatorSupported(context),
                SystemProperties.getInt("ro.debuggable", 0) == 1);
    }

    public CellBroadcastChannelManager(Context context, int subId, @Nullable String operator) {
        this(context, subId, operator, SystemProperties.getInt("ro.debuggable", 0) == 1);
    }

    @VisibleForTesting
    public CellBroadcastChannelManager(Context context, int subId,
            String operator, boolean isDebugBuild) {
        mContext = context;
        mSubId = subId;
        mOperator = operator;
        mIsDebugBuild = isDebugBuild;
        initAsNeeded();
    }

    /**
     * Parse channel ranges from resources, and initialize the cache as needed
     */
    private void initAsNeeded() {
        if (!TextUtils.isEmpty(mOperator)) {
            synchronized (mChannelRangesLock) {
                if (!sAllCellBroadcastChannelRangesPerOperator.containsKey(mOperator)) {
                    if (VDBG) {
                        log("init for operator: " + mOperator);
                    }
                    if (sAllCellBroadcastChannelRangesPerOperator.size() == MAX_CACHE_SIZE) {
                        sAllCellBroadcastChannelRangesPerOperator.clear();
                    }
                    sAllCellBroadcastChannelRangesPerOperator.put(mOperator,
                            getChannelRangesMapFromResoures(CellBroadcastSettings
                                    .getResourcesByOperator(mContext, mSubId, mOperator)));
                }
            }
        }

        synchronized (mChannelRangesLock) {
            if (!sAllCellBroadcastChannelRangesPerSub.containsKey(mSubId)) {
                if (sAllCellBroadcastChannelRangesPerSub.size() == MAX_CACHE_SIZE) {
                    sAllCellBroadcastChannelRangesPerSub.clear();
                }
                if (VDBG) {
                    log("init for sub: " + mSubId);
                }
                sAllCellBroadcastChannelRangesPerSub.put(mSubId,
                        getChannelRangesMapFromResoures(CellBroadcastSettings
                                .getResources(mContext, mSubId)));
            }
        }
    }

    private @NonNull Map<Integer, List<CellBroadcastChannelRange>> getChannelRangesMapFromResoures(
            @NonNull Resources res) {
        Map<Integer, List<CellBroadcastChannelRange>> map = new ArrayMap<>();

        for (int key : sCellBroadcastRangeResourceKeys) {
            String[] ranges = res.getStringArray(key);
            if (ranges != null) {
                List<CellBroadcastChannelRange> rangesList = new ArrayList<>();
                for (String range : ranges) {
                    try {
                        if (VDBG) {
                            log("parse channel range: " + range);
                        }
                        CellBroadcastChannelRange r =
                                new CellBroadcastChannelRange(mContext, mSubId, res, range);
                        // Bypass if the range is disabled
                        if (r.mIsDebugBuildOnly && !mIsDebugBuild) {
                            continue;
                        }
                        rangesList.add(r);
                    } catch (Exception e) {
                        CellBroadcastReceiverMetrics.getInstance().logModuleError(
                                ERRSRC_CBR, ERRTYPE_CHANNELRANGEPARSE);
                        loge("Failed to parse \"" + range + "\". e=" + e);
                    }
                }
                map.put(key, rangesList);
            }
        }

        return map;
    }

    /**
     * Get cell broadcast channels enabled by the carriers from resource key
     *
     * @param key Resource key
     *
     * @return The list of channel ranges enabled by the carriers.
     */
    public @NonNull List<CellBroadcastChannelRange> getCellBroadcastChannelRanges(int key) {
        List<CellBroadcastChannelRange> result = null;

        synchronized (mChannelRangesLock) {
            initAsNeeded();

            // Check the config per network first if applicable
            if (!TextUtils.isEmpty(mOperator)) {
                result = sAllCellBroadcastChannelRangesPerOperator.get(mOperator).get(key);
            }

            if (result == null) {
                result = sAllCellBroadcastChannelRangesPerSub.get(mSubId).get(key);
            }
        }

        return result == null ? new ArrayList<>() : result;
    }

    /**
     * Get all cell broadcast channels
     *
     * @return all cell broadcast channels
     */
    public @NonNull List<CellBroadcastChannelRange> getAllCellBroadcastChannelRanges() {
        final List<CellBroadcastChannelRange> result = new ArrayList<>();
        synchronized (mChannelRangesLock) {
            if (!TextUtils.isEmpty(mOperator)
                    && sAllCellBroadcastChannelRangesPerOperator.containsKey(mOperator)) {
                sAllCellBroadcastChannelRangesPerOperator.get(mOperator).forEach(
                        (k, v)->result.addAll(v));
            }

            sAllCellBroadcastChannelRangesPerSub.get(mSubId).forEach((k, v)->result.addAll(v));
        }
        return result;
    }

    /**
     * Clear broadcast channel range list
     */
    public static void clearAllCellBroadcastChannelRanges() {
        synchronized (mChannelRangesLock) {
            Log.d(TAG, "Clear channel range list");
            sAllCellBroadcastChannelRangesPerSub.clear();
            sAllCellBroadcastChannelRangesPerOperator.clear();
        }
    }

    /**
     * @param channel Cell broadcast message channel
     * @param key Resource key
     *
     * @return {@code TRUE} if the input channel is within the channel range defined from resource.
     * return {@code FALSE} otherwise
     */
    public boolean checkCellBroadcastChannelRange(int channel, int key) {
        return getCellBroadcastChannelResourcesKey(channel) == key;
    }

    /**
     * Get the resources key for the channel
     * @param channel Cell broadcast message channel
     *
     * @return 0 if the key is not found, otherwise the value of the resources key
     */
    public int getCellBroadcastChannelResourcesKey(int channel) {
        Pair<Integer, CellBroadcastChannelRange> p = findChannelRange(channel);

        return p != null ? p.first : 0;
    }

    /**
     * Get the CellBroadcastChannelRange for the channel
     * @param channel Cell broadcast message channel
     *
     * @return the CellBroadcastChannelRange for the channel, null if not found
     */
    public @Nullable CellBroadcastChannelRange getCellBroadcastChannelRange(int channel) {
        Pair<Integer, CellBroadcastChannelRange> p = findChannelRange(channel);

        return p != null ? p.second : null;
    }

    private @Nullable Pair<Integer, CellBroadcastChannelRange> findChannelRange(int channel) {
        if (!TextUtils.isEmpty(mOperator)) {
            Pair<Integer, CellBroadcastChannelRange> p = findChannelRange(
                    sAllCellBroadcastChannelRangesPerOperator.get(mOperator), channel);
            if (p != null) {
                return p;
            }
        }

        return findChannelRange(sAllCellBroadcastChannelRangesPerSub.get(mSubId), channel);
    }

    private @Nullable Pair<Integer, CellBroadcastChannelRange> findChannelRange(
            Map<Integer, List<CellBroadcastChannelRange>> channelRangeMap, int channel) {
        if (channelRangeMap != null) {
            for (Map.Entry<Integer, List<CellBroadcastChannelRange>> entry
                    : channelRangeMap.entrySet()) {
                for (CellBroadcastChannelRange range : entry.getValue()) {
                    if (channel >= range.mStartId && channel <= range.mEndId
                            && checkScope(range.mScope)) {
                        return new Pair<>(entry.getKey(), range);
                    }
                }
            }
        }
        return null;
    }

    /**
     * Check if the channel scope matches the current network condition.
     *
     * @param rangeScope Range scope. Must be SCOPE_CARRIER, SCOPE_DOMESTIC, or SCOPE_INTERNATIONAL.
     * @return True if the scope matches the current network roaming condition.
     */
    public boolean checkScope(int rangeScope) {
        if (rangeScope == CellBroadcastChannelRange.SCOPE_UNKNOWN) return true;
        TelephonyManager tm =
                (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
        tm = tm.createForSubscriptionId(mSubId);
        ServiceState ss = tm.getServiceState();
        if (ss != null) {
            NetworkRegistrationInfo regInfo = ss.getNetworkRegistrationInfo(
                    NetworkRegistrationInfo.DOMAIN_CS,
                    AccessNetworkConstants.TRANSPORT_TYPE_WWAN);
            if (regInfo != null) {
                if (regInfo.getRegistrationState()
                        == NetworkRegistrationInfo.REGISTRATION_STATE_HOME
                        || regInfo.getRegistrationState()
                        == NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING
                        || regInfo.isEmergencyEnabled()) {
                    int voiceRoamingType = regInfo.getRoamingType();
                    if (voiceRoamingType == ROAMING_TYPE_NOT_ROAMING) {
                        return true;
                    } else if (voiceRoamingType == ServiceState.ROAMING_TYPE_DOMESTIC
                            && rangeScope == CellBroadcastChannelRange.SCOPE_DOMESTIC) {
                        return true;
                    } else if (voiceRoamingType == ServiceState.ROAMING_TYPE_INTERNATIONAL
                            && rangeScope == CellBroadcastChannelRange.SCOPE_INTERNATIONAL) {
                        return true;
                    }
                    return false;
                }
            }
        }
        // If we can't determine the scope, for safe we should assume it's in.
        return true;
    }

    /**
     * Return corresponding cellbroadcast range where message belong to
     *
     * @param message Cell broadcast message
     */
    public CellBroadcastChannelRange getCellBroadcastChannelRangeFromMessage(SmsCbMessage message) {
        if (mSubId != message.getSubscriptionId()) {
            Log.e(TAG, "getCellBroadcastChannelRangeFromMessage: This manager is created for "
                    + "sub " + mSubId + ", should not be used for message from sub "
                    + message.getSubscriptionId());
        }

        return getCellBroadcastChannelRange(message.getServiceCategory());
    }

    /**
     * Check if the cell broadcast message is an emergency message or not
     *
     * @param message Cell broadcast message
     * @return True if the message is an emergency message, otherwise false.
     */
    public boolean isEmergencyMessage(SmsCbMessage message) {
        if (message == null) {
            return false;
        }

        if (mSubId != message.getSubscriptionId()) {
            Log.e(TAG, "This manager is created for sub " + mSubId
                    + ", should not be used for message from sub " + message.getSubscriptionId());
        }

        int id = message.getServiceCategory();
        CellBroadcastChannelRange range = getCellBroadcastChannelRange(id);

        if (range != null) {
            switch (range.mEmergencyLevel) {
                case CellBroadcastChannelRange.LEVEL_EMERGENCY:
                    Log.d(TAG, "isEmergencyMessage: true, message id = " + id);
                    return true;
                case CellBroadcastChannelRange.LEVEL_NOT_EMERGENCY:
                    Log.d(TAG, "isEmergencyMessage: false, message id = " + id);
                    return false;
                case CellBroadcastChannelRange.LEVEL_UNKNOWN:
                default:
                    break;
            }
        }

        Log.d(TAG, "isEmergencyMessage: " + message.isEmergencyMessage()
                + ", message id = " + id);
        // If the configuration does not specify whether the alert is emergency or not, use the
        // emergency property from the message itself, which is checking if the channel is between
        // MESSAGE_ID_PWS_FIRST_IDENTIFIER (4352) and MESSAGE_ID_PWS_LAST_IDENTIFIER (6399).
        return message.isEmergencyMessage();
    }

    private static void log(String msg) {
        Log.d(TAG, msg);
    }

    private static void loge(String msg) {
        Log.e(TAG, msg);
    }
}