src/com/android/phone/CarrierXmlParser.java

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

import android.content.Context;
import android.content.res.XmlResourceParser;
import android.support.annotation.VisibleForTesting;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.Log;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * CarrierXmlParser is a xml parser. It parses the carrier's ussd format from carrier_ss_string.xml.
 * The carrier_ss_string.xml defines carrier's ussd structure and meaning in res/xml folder.
 * Some carrier has specific ussd structure ,developer can add new xml and xml is named
 * carrier_ss_string_carrierId.xml. The carrierId is a number and is defined in
 * <a href="https://android.googlesource.com/platform/packages/providers/TelephonyProvider/+/master/assets/carrier_list.textpb">here</a>
 * For example: carrier_ss_string_850.xml
 * <p>
 * How do use CarrierXmlParser?
 * For example:
 * @see CallForwardEditPreference
 *     TelephonyManager telephonyManager = new TelephonyManager(getContext(),phone.getSubId());
 *     CarrierXmlParser  = new CarrierXmlParser(getContext(), telephonyManager.getSimCarrierId());
 *
 *     //make a ussd command
 *     String newUssdCommand = mCarrierXmlParser.getFeature(
 *             CarrierXmlParser.FEATURE_CALL_FORWARDING).makeCommand(inputAction, inputCfInfo);
 *     //analyze ussd result
 *     HashMap<String, String> analysisResult = mCarrierXmlParser.getFeature(
 *             CarrierXmlParser.FEATURE_CALL_FORWARDING)
 *             .getResponseSet(mSsAction, response.toString());
 */
public class CarrierXmlParser {
    public static final String LOG_TAG = "CarrierXmlParser";
    private static final boolean DEBUG = true;

    private static final String STAR_SIGN = "*";
    private static final String POUND_SIGN = "#";

    private static final String TAG_SIGN = "tag_";

    // To define feature's item name in xml
    public static final String FEATURE_CALL_FORWARDING = "callforwarding";
    public static final String FEATURE_CALLER_ID = "callerid";

    // COMMAND_NAME is xml's command name.
    public static final String TAG_COMMAND_NAME_QUERY = "query";
    public static final String TAG_COMMAND_NAME_ACTIVATE = "activate";
    public static final String TAG_COMMAND_NAME_DEACTIVATE = "deactivate";

    // To define string level in xml.
    // level 1
    private static final String TAG_FEATURE = "feature";
    private static final String TAG_REGULAR_PARSER = "regular_parser";
    // level 2
    private static final String TAG_COMMAND = "command";
    // level 3
    private static final String TAG_SERVICE_CODE = "service_code";
    private static final String TAG_ACTION_CODE = "action_code";
    private static final String TAG_PARAMETER = "parameter";
    private static final String TAG_RESPONSE_FORMAT = "response_format";
    private static final String TAG_COMMAND_RESULT = "command_result";
    // level 4
    private static final String TAG_ENTRY = "entry";

    private static final String ATTR_NAME = "name";
    private static final String ATTR_PARAMETER_NUM = "number";
    private static final String ATTR_POSITION = "position";
    private static final String ATTR_RESULT_KEY = "key";
    private static final String ATTR_DEFINITION_KEY = "definition";

    HashMap<String, SsFeature> mFeatureMaps;

    @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
    static String sParserFormat = "";

    // TAG_ENTRY_NUMBER and TAG_ENTRY_TIME is xml's entry value.
    // This is mapping user's input value. For example: number,time ...
    // When UI makes command ,it will map the value and insert this value at position location.
    // How to use it?
    //      The UI calls CarrierXmlParser's makeCommand function and inputs the hashmap which
    //      includes tag_name and user's input value.
    //      For example: User calls CarrierXmlParser's makeCommand in call forwarding , and inputs
    //      the hashmap {<TAG_ENTRY_NUMBER,0123456789>,<TAG_ENTRY_TIME,20>}
    // If developer wants to add new one, xml string should the same as hashmap's name.
    public static final String TAG_ENTRY_NUMBER = "tag_number";
    public static final String TAG_ENTRY_TIME = "tag_time";

    // "response_format" key
    // The key of "response_format" should define as below in xml.
    // The UI will use it to define value from the response command
    // and use the data show the screen.
    public static final String TAG_RESPONSE_STATUS = "status_code";
    public static final String TAG_RESPONSE_STATUS_ERROR = "RESPONSE_ERROR";
    public static final String TAG_RESPONSE_NUMBER = "number";
    public static final String TAG_RESPONSE_TIME = "time";

    // This is the definition for the entry's key in response_format.
    // Xml's COMMAND_RESULT_DEFINITION should same as below.
    public static final String TAG_COMMAND_RESULT_DEFINITION_ACTIVATE = "activate";
    public static final String TAG_COMMAND_RESULT_DEFINITION_DEACTIVATE = "deactivate";
    public static final String TAG_COMMAND_RESULT_DEFINITION_UNREGISTER = "unregister";
    public static final String TAG_COMMAND_RESULT_DEFINITION_OK = "ok";
    public static final String TAG_COMMAND_RESULT_DEFINITION_FAIL = "fail";

    /**
     * UssdParser is a string parser. It parses the USSD response message.
     */
    public static class UssdParser {
        private Vector<String> mParserStr = new Vector<String>();
        private Pattern mPatternSuppServiceResponse;

        public UssdParser(String inputParserFormat) {
            mPatternSuppServiceResponse = Pattern.compile(inputParserFormat);
        }

        /**
         * This function is a parser and analyzes the USSD responses message.
         *
         * @param responseString The USSD responses message.
         */
        public void newFromResponseString(String responseString) {
            Matcher m;
            m = mPatternSuppServiceResponse.matcher(responseString);
            if (m.matches()) {
                mParserStr.clear();
                int groupSize = m.groupCount();
                for (int i = 0; i <= groupSize; i++) {
                    if (!TextUtils.isEmpty(m.group(i))) {
                        mParserStr.add(m.group(i));
                    } else {
                        mParserStr.add("");
                    }
                }
            } else {
                Log.d(LOG_TAG, "no match");
            }
        }

        /**
         * To get the UssdParser result.
         */
        public Vector<String> getResult() {
            return mParserStr;
        }
    }

    /**
     * CarrierXmlParser parses command from xml and saves in SsEntry class.
     */
    public static class SsEntry {
        public enum SSAction {
            UNKNOWN,
            QUERY,
            UPDATE_ACTIVATE,
            UPDATE_DEACTIVATE
        }

        public String serviceCode;
        public SSAction ssAction = SSAction.UNKNOWN;
        public String actionCode;
        public HashMap<Integer, String> commandParameter = new HashMap<Integer, String>();
        public HashMap<Integer, String> responseFormat = new HashMap<Integer, String>();

        public SsEntry(String action) {
            if (action.equals(TAG_COMMAND_NAME_QUERY)) {
                ssAction = SSAction.QUERY;
            } else if (action.equals(TAG_COMMAND_NAME_ACTIVATE)) {
                ssAction = SSAction.UPDATE_ACTIVATE;
            } else if (action.equals(TAG_COMMAND_NAME_DEACTIVATE)) {
                ssAction = SSAction.UPDATE_DEACTIVATE;
            }
        }

        @Override
        public String toString() {
            return "SsEntry serviceCode:" + serviceCode
                    + ", ssAction:" + ssAction
                    + ", actionCode:" + actionCode
                    + ", commandParameter:" + commandParameter.toString()
                    + ", responseFormat:" + responseFormat.toString();
        }

        /**
         * To get the caller id command by xml's structure.
         */
        public String getCommandStructure() {
            String result = actionCode + serviceCode;
            int mapSize = commandParameter.size();
            int parameterIndex = 0;
            while (parameterIndex < mapSize) {
                parameterIndex++;
                if (commandParameter.containsKey(parameterIndex)) {
                    if (commandParameter.get(parameterIndex) != null) {
                        result = result + STAR_SIGN + commandParameter.get(parameterIndex);
                    }
                }
            }
            result = result + POUND_SIGN;
            Log.d(LOG_TAG, "getCommandStructure result:" + result);
            return result;
        }

        /**
         * To make ussd command by xml's structure.
         *
         * @param inputInformationSet This is a map which includes parameters from UI.
         *                            The name of map is mapping parameter's key of entry in xml.
         */
        public String makeCommand(Map<String, String> inputInformationSet) {
            String result = actionCode + serviceCode;
            int mapSize = commandParameter.size();
            int parameterIndex = 0;
            int counter = 1;
            Map<String, String> informationSet = inputInformationSet;
            while (parameterIndex < mapSize) {
                if (commandParameter.containsKey(counter)) {
                    String getInputValue = "";
                    // need to handle tag_XXXX
                    if (informationSet != null && informationSet.size() > 0
                            && informationSet.containsKey(commandParameter.get(counter))) {
                        getInputValue = informationSet.get(commandParameter.get(counter));
                    }
                    if (TextUtils.isEmpty(getInputValue)) {
                        result = result + STAR_SIGN + commandParameter.get(counter);
                    } else {
                        result = result + STAR_SIGN + informationSet.get(
                                commandParameter.get(counter));
                    }
                    parameterIndex++;
                } else {
                    result = result + STAR_SIGN;
                }
                counter++;
            }
            result = result + POUND_SIGN;
            return result;
        }

        /**
         * To parse the specific key and value from response message.
         *
         * @param inputResponse  This is a ussd response message from network.
         * @param responseDefine This is the definition for "command_result" in xml.
         */
        public HashMap<String, String> getResponseSet(String inputResponse,
                HashMap<String, ArrayList<SsResultEntry>> responseDefine) {
            HashMap<String, String> responseSet = new HashMap<String, String>();
            if (TextUtils.isEmpty(sParserFormat)) {
                return responseSet;
            }
            UssdParser parserResult = new UssdParser(sParserFormat);
            parserResult.newFromResponseString(inputResponse);
            if (parserResult == null) {
                return responseSet;
            }

            Vector<String> result = parserResult.getResult();

            if (result == null) {
                return responseSet;
            }
            for (int i = 0; i < result.size(); i++) {
                if (responseFormat.containsKey(i)) {
                    String defineString = "";
                    if (responseDefine.containsKey(responseFormat.get(i))) {
                        for (int x = 0; x < responseDefine.get(responseFormat.get(i)).size(); x++) {
                            defineString = ((SsResultEntry) responseDefine.get(
                                    responseFormat.get(i)).get(x)).getDefinitionByCompareValue(
                                    result.get(i));
                            if (!TextUtils.isEmpty(defineString)) {
                                break;
                            }
                        }
                        // if status_code do not match definition value, we will set command error.
                        if (TAG_RESPONSE_STATUS.equals(responseFormat.get(i))) {
                            if (TextUtils.isEmpty(defineString)) {
                                responseSet.put(TAG_RESPONSE_STATUS_ERROR,
                                        TAG_RESPONSE_STATUS_ERROR);
                            }
                        }
                    }
                    if (TextUtils.isEmpty(defineString)) {
                        responseSet.put(responseFormat.get(i), result.get(i));
                    } else {
                        responseSet.put(responseFormat.get(i), defineString);
                    }
                }
            }
            return responseSet;
        }
    }

    /**
     * CarrierXmlParser parses command_result from xml and saves in SsResultEntry class.
     */
    public static class SsResultEntry {
        String mDefinition;
        String mCompareValue;

        public SsResultEntry() {
        }

        @Override
        public String toString() {
            return "SsResultEntry mDefinition:" + mDefinition
                    + ", mCompareValue:" + mCompareValue;
        }

        /**
         * If mCompareValue item is the same as compare value,it will return the mDefinition.
         *
         * @param inputValue This is the entry of response command's value.
         * @return mDefinition or null.
         */
        public String getDefinitionByCompareValue(String inputValue) {
            if (mCompareValue.equals(inputValue)) {
                return mDefinition;
            }
            return null;
        }
    }

    /**
     * CarrierXmlParser parses feature from xml and saves in SsFeature class.
     */
    public class SsFeature {
        public HashMap<SsEntry.SSAction, SsEntry> ssEntryHashMap =
                new HashMap<SsEntry.SSAction, SsEntry>();
        public HashMap<String, ArrayList<SsResultEntry>> responseCode =
                new HashMap<String, ArrayList<SsResultEntry>>();

        public SsFeature() {
        }

        private String getResponseCodeString() {
            String result = "";
            for (Map.Entry<String, ArrayList<SsResultEntry>> entry : responseCode.entrySet()) {
                ArrayList<SsResultEntry> values = entry.getValue();
                for (int i = 0; i < values.size(); i++) {
                    result += "value of i is " + ((SsResultEntry) values.get(i)).toString();
                }
            }
            return result;
        }

        @Override
        public String toString() {
            return getResponseCodeString();
        }

        /**
         * To get the caller id command by xml's structure.
         *
         * @param inputAction This is action_code of command item from xml.
         */
        public String getCommandStructure(SsEntry.SSAction inputAction) {
            SsEntry entry = ssEntryHashMap.get(inputAction);
            return entry.getCommandStructure();
        }

        /**
         * To make the ussd command by xml structure
         *
         * @param inputAction         This is action_code of command item from xml.
         * @param inputInformationSet This is for parameter of command.
         * @return The ussd command string.
         */
        public String makeCommand(SsEntry.SSAction inputAction,
                Map<String, String> inputInformationSet) {
            SsEntry entry = ssEntryHashMap.get(inputAction);
            return entry.makeCommand(inputInformationSet);
        }

        /**
         * To parse the special key and value from response message.
         *
         * @param inputAction   This is action_code of command item from xml.
         * @param inputResponse This is response message from network.
         * @return The set includes specific key and value.
         */
        public HashMap<String, String> getResponseSet(SsEntry.SSAction inputAction,
                String inputResponse) {
            SsEntry entry = ssEntryHashMap.get(inputAction);
            return entry.getResponseSet(inputResponse, responseCode);
        }
    }

    /**
     * @param context context to get res's xml
     * @param carrierId carrier id of the current subscription. The carrier ID is an Android
     * platform-wide identifier for a carrier. AOSP maintains carrier ID assignments in
     * <a href="https://android.googlesource.com/platform/packages/providers/TelephonyProvider/+/master/assets/carrier_list.textpb">here</a>
     */
    public CarrierXmlParser(Context context, int carrierId) {
        try {
            int xmlResId = 0;
            if (carrierId != TelephonyManager.UNKNOWN_CARRIER_ID) {
                String xmlResIdName = "carrier_ss_string" + "_" + carrierId;
                xmlResId = context.getResources().getIdentifier(xmlResIdName, "xml",
                        context.getPackageName());
            }
            if (xmlResId == 0) {
                xmlResId = R.xml.carrier_ss_string;
            }
            Log.d(LOG_TAG, "carrierId: " + carrierId);

            XmlResourceParser parser = context.getResources().getXml(xmlResId);
            mFeatureMaps = parseXml(parser);
        } catch (Exception e) {
            Log.d(LOG_TAG, "Error parsing XML " + e.toString());
        }
    }

    private HashMap<String, SsFeature> parseXml(XmlResourceParser parser) throws IOException {
        HashMap<String, SsFeature> features = new HashMap<String, SsFeature>();
        try {
            int eventType = parser.getEventType();
            while (eventType != XmlPullParser.END_DOCUMENT) {
                if (eventType == XmlPullParser.START_TAG) {
                    if (TAG_REGULAR_PARSER.equals(parser.getName())) {
                        sParserFormat = readText(parser);
                        Log.d(LOG_TAG, "sParserFormat " + sParserFormat);
                    } else if (TAG_FEATURE.equals(parser.getName())) {
                        String featureName = getSpecificAttributeValue(parser, ATTR_NAME);
                        if (!TextUtils.isEmpty(featureName)) {
                            SsFeature feature = generateFeatureList(parser);
                            features.put(featureName, feature);
                            Log.d(LOG_TAG, "add " + featureName + " to map:" + feature.toString());
                        }
                    }
                }
                parser.next();
                eventType = parser.getEventType();
            }
        } catch (XmlPullParserException e) {
            e.printStackTrace();
        }
        return features;
    }

    private SsFeature generateFeatureList(XmlResourceParser parser)
            throws XmlPullParserException, IOException {
        SsFeature ssfeature = new SsFeature();
        int outerDepth = parser.getDepth();

        Log.d(LOG_TAG, "generateFeatureList outerDepth" + outerDepth);

        while (parser.next() != XmlPullParser.END_DOCUMENT) {
            Log.d(LOG_TAG, "generateFeatureList parser.getDepth()" + parser.getDepth());

            int eventType = parser.getEventType();
            if (eventType == XmlPullParser.END_TAG
                    && outerDepth == parser.getDepth()) {
                break;
            }

            if (eventType != XmlPullParser.START_TAG) {
                continue;
            }
            String name = parser.getName();
            // Starts by looking for the command tag.
            if (TAG_COMMAND.equals(name)) {
                SsEntry entry = readCommandEntry(parser);
                ssfeature.ssEntryHashMap.put(entry.ssAction, entry);
            } else if (TAG_COMMAND_RESULT.equals(name)) {
                readCommandResultEntry(parser, ssfeature);
            }
        }
        return ssfeature;
    }

    private void readCommandResultEntry(XmlResourceParser parser, SsFeature ssFeature)
            throws XmlPullParserException, IOException {
        while (parser.next() != XmlPullParser.END_DOCUMENT) {
            int eventType = parser.getEventType();
            if (eventType == XmlPullParser.END_TAG
                    && TAG_COMMAND_RESULT.equals(parser.getName())) {
                break;
            }
            if (eventType == XmlPullParser.START_TAG
                    && TAG_ENTRY.equals(parser.getName())) {
                String key = getSpecificAttributeValue(parser, ATTR_RESULT_KEY);
                if (!TextUtils.isEmpty(key)) {
                    SsResultEntry entry = new SsResultEntry();
                    entry.mDefinition = getSpecificAttributeValue(parser, ATTR_DEFINITION_KEY);
                    entry.mCompareValue = readText(parser);
                    if (ssFeature.responseCode.containsKey(key)) {
                        ssFeature.responseCode.get(key).add(entry);
                    } else {
                        ArrayList<SsResultEntry> arrayList = new ArrayList<>();
                        arrayList.add(entry);
                        ssFeature.responseCode.put(key, arrayList);
                    }
                }
            }
        }
    }

    private SsEntry readCommandEntry(XmlResourceParser parser)
            throws XmlPullParserException, IOException {
        int outerDepth = parser.getDepth();
        String command_action = getSpecificAttributeValue(parser, ATTR_NAME);
        SsEntry entry = new SsEntry(command_action);

        while (parser.next() != XmlPullParser.END_DOCUMENT) {
            int eventType = parser.getEventType();
            if (eventType == XmlPullParser.END_TAG
                    && outerDepth == parser.getDepth()) {
                break;
            }

            if (eventType != XmlPullParser.START_TAG) {
                continue;
            }

            String name = parser.getName();
            if (TAG_SERVICE_CODE.equals(name)) {
                entry.serviceCode = readText(parser);
            } else if (TAG_ACTION_CODE.equals(name)) {
                entry.actionCode = readText(parser);
            } else if (TAG_PARAMETER.equals(name)) {
                String number = getSpecificAttributeValue(parser, ATTR_PARAMETER_NUM);
                if (!TextUtils.isEmpty(number)) {
                    readParameters(parser, entry, Integer.valueOf(number), TAG_PARAMETER);
                }
            } else if (TAG_RESPONSE_FORMAT.equals(name)) {
                String number = getSpecificAttributeValue(parser, ATTR_PARAMETER_NUM);
                if (!TextUtils.isEmpty(number)) {
                    readParameters(parser, entry, Integer.valueOf(number), TAG_RESPONSE_FORMAT);
                }
            }
        }
        Log.d(LOG_TAG, "ssEntry:" + entry.toString());
        return entry;
    }

    private void readParameters(XmlResourceParser parser, SsEntry entry, int num, String parentTag)
            throws IOException, XmlPullParserException {
        Log.d(LOG_TAG, "readParameters() nume:" + num);
        int i = 0;
        while (i < num) {
            if (parser.next() == XmlPullParser.START_TAG) {
                String name = parser.getName();
                if (TAG_ENTRY.equals(name)) {
                    String position = getSpecificAttributeValue(parser, ATTR_POSITION);
                    if (!TextUtils.isEmpty(position)) {
                        if (TAG_PARAMETER.equals(parentTag)) {
                            String value = readText(parser);
                            if (!TextUtils.isEmpty(value)) {
                                entry.commandParameter.put(Integer.valueOf(position), value);
                            }
                        } else if (TAG_RESPONSE_FORMAT.equals(parentTag)) {
                            String key = getSpecificAttributeValue(parser, ATTR_RESULT_KEY);
                            if (!TextUtils.isEmpty(key)) {
                                entry.responseFormat.put(Integer.valueOf(position), key);
                            }
                        }
                        i++;
                    }
                }
            }
        }
    }

    private String getSpecificAttributeValue(XmlResourceParser parser, String attrTag) {
        String value = "";
        for (int i = 0; i < parser.getAttributeCount(); i++) {
            if (attrTag.equals(parser.getAttributeName(i))) {
                value = parser.getAttributeValue(i);
            }
        }
        return value;
    }

    private String readText(XmlResourceParser parser) throws IOException, XmlPullParserException {
        String result = "";
        if (parser.next() == XmlPullParser.TEXT) {
            result = parser.getText();
            parser.nextTag();
        }
        return result;
    }

    /**
     * CarrierXmlParser parses the xml and saves in mFeatureMap.
     * To use this function get feature from the mFeatureMaps.
     *
     * @param inputFeatureName This is feature's name from xml.
     */
    public SsFeature getFeature(String inputFeatureName) {
        return mFeatureMaps.get(inputFeatureName);
    }

    /**
     * To check the command which is dialed by user is caller id command.
     * <p>
     * If it is a caller id command which sets to activate, return the {@code
     * SsEntry.SSAction.UPDATE_ACTIVATE}.
     * If it is a caller id command which sets to deactivate, return the {@code
     * SsEntry.SSAction.UPDATE_DEACTIVATE}.
     * If it is not a caller id command, return the {@code SsEntry.SSAction.UNKNOWN}.
     *
     * @param inputCommand This is caller id's ussd command which is dialed by user.
     * @return {@link SsEntry.SSAction}
     */
    public SsEntry.SSAction getCallerIdUssdCommandAction(String inputCommand) {
        if (isCallerIdActivate(inputCommand)) {
            return SsEntry.SSAction.UPDATE_ACTIVATE;
        }
        if (isCallerIdDeactivate(inputCommand)) {
            return SsEntry.SSAction.UPDATE_DEACTIVATE;
        }
        return SsEntry.SSAction.UNKNOWN;
    }

    private String getCallerIdActivateCommandFromXml() {
        return getFeature(FEATURE_CALLER_ID).getCommandStructure(SsEntry.SSAction.UPDATE_ACTIVATE);
    }

    private String getCallerIdDeactivateCommandFromXml() {
        return getFeature(FEATURE_CALLER_ID).getCommandStructure(
                SsEntry.SSAction.UPDATE_DEACTIVATE);
    }

    private boolean isCallerIdActivate(String inputStr) {
        String activateStr = getCallerIdActivateCommandFromXml();
        return compareCommand(activateStr, inputStr);
    }

    private boolean isCallerIdDeactivate(String inputStr) {
        String activateStr = getCallerIdDeactivateCommandFromXml();
        return compareCommand(activateStr, inputStr);
    }

    private boolean compareCommand(String activateStr, String inputStr) {
        String[] activateArray = activateStr.split("\\" + STAR_SIGN);
        String[] inputArray = inputStr.split("\\" + STAR_SIGN);

        if (activateArray.length == 0 || inputArray.length == 0) {
            return false;
        }
        for (int i = 0; i < activateArray.length; i++) {
            if (activateArray[i].startsWith(TAG_SIGN)) {
                continue;
            }
            if (!activateArray[i].equals(inputArray[i])) {
                Log.d(LOG_TAG, "compare fails:" + activateStr + "," + inputStr);
                return false;
            }
        }
        Log.d(LOG_TAG, "compare success");
        return true;
    }
}