From 1a5af20b97993437f5bc4af15028208d07eb62ff Mon Sep 17 00:00:00 2001 From: Scott Brissenden Date: Tue, 30 Dec 2014 01:39:37 +0000 Subject: Revert "smdk4412-qcom: remove Operators" This reverts commit 1a8a957fab47f46a9248e0f93d3353ba9d8d1a8f. Need to change authorship Change-Id: Icd767638d9e8f1832b1b81ac362ac20c77c91ea5 --- .../com/android/internal/telephony/Operators.java | 151 +++++++++++++++++++++ 1 file changed, 151 insertions(+) create mode 100644 ril/telephony/java/com/android/internal/telephony/Operators.java diff --git a/ril/telephony/java/com/android/internal/telephony/Operators.java b/ril/telephony/java/com/android/internal/telephony/Operators.java new file mode 100644 index 0000000..51359ed --- /dev/null +++ b/ril/telephony/java/com/android/internal/telephony/Operators.java @@ -0,0 +1,151 @@ +/* + * Copyright (C) 2013-2014 The CyanogenMod 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 java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.util.Collections; +import java.util.Map; +import java.util.HashMap; + +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +import android.os.Environment; +import android.telephony.Rlog; +import android.util.Xml; + +import com.android.internal.util.XmlUtils; + +public class Operators{ + + + // Initialize list of Operator codes + // this will be taken care of when garbage collection starts. + private HashMap initList() { + HashMap init = new HashMap(); + //taken from spnOveride.java + + FileReader spnReader; + + final File spnFile = new File(Environment.getRootDirectory(), + "etc/selective-spn-conf.xml"); + + try { + spnReader = new FileReader(spnFile); + } catch (FileNotFoundException e) { + Rlog.w("Operatorcheck", "Can not open " + + Environment.getRootDirectory() + "/etc/selective-spn-conf.xml"); + return init; + } + + try { + XmlPullParser parser = Xml.newPullParser(); + parser.setInput(spnReader); + + XmlUtils.beginDocument(parser, "spnOverrides"); + + while (true) { + XmlUtils.nextElement(parser); + + String name = parser.getName(); + if (!"spnOverride".equals(name)) { + break; + } + + String numeric = parser.getAttributeValue(null, "numeric"); + String data = parser.getAttributeValue(null, "spn"); + + init.put(numeric, data); + } + } catch (XmlPullParserException e) { + Rlog.w("Operatorcheck", "Exception in spn-conf parser " + e); + } catch (IOException e) { + Rlog.w("Operatorcheck", "Exception in spn-conf parser " + e); + } + return init; + } + //this will stay persistant in memory when called + private static String stored = null; + private static String storedOperators = null; + + public static String operatorReplace(String response){ + // sanity checking if the value is actually not equal to the range apn + // numerics + // if it is null, check your ril class. + if(response == null || + (5 != response.length() && response.length() != 6)){ + return response; + } + // this will check if the stored value is equal to other. + // this uses a technique called last known of good value. + // along with sanity checking + if(storedOperators != null && stored != null && stored.equals(response)){ + return storedOperators; + } + stored = response; + try { + // this will find out if it a number then it will catch it based + // on invalid chars. + Integer.parseInt(response); + } catch(NumberFormatException E){ + // not a number, pass it along to stored operator until the next + // round. + storedOperators = response; + return storedOperators; + } + // this code will be taking care of when garbage collection start + Operators init = new Operators(); + Map operators = init.initList(); + storedOperators = operators.containsKey(response) ? operators.get(response) : response; + return storedOperators; + } + + // this will not stay persistant in memory, this will be taken care of + // iin garbage collection routiene. + private Map unOptOperators = null; + // unoptimized version of operatorreplace for responseOperatorInfos + // this will provide a little more flexiblilty in a loop like sisuation + // same numbers of checks like before + // this is for the search network functionality + public String unOptimizedOperatorReplace(String response){ + // sanity checking if the value is actually not equal to the range apn + // numerics + // if it is null, check your ril class. + if(response == null || + (5 != response.length() && response.length() != 6)){ + return response; + } + + try { + // this will find out if it a number then it will catch it based + // on invalid chars. + Integer.parseInt(response); + } catch(NumberFormatException E){ + // an illegal char is found i.e a word + return response; + } + + if (unOptOperators == null){ + unOptOperators = initList(); + } + + return unOptOperators.containsKey(response) ? unOptOperators.get(response) : response; + } +} -- cgit v1.2.3