Telephony: Add OperatorReplace api to framework:

this converts the operator number into carrier name, 2 API

this one load once if the number is the same through the life span of the SIM.
public static String operatorReplace(String response)

This one is for loop based sisuation, doesn't lazy load the selective-spn.xml,

public String unOptimizedOperatorReplace(String response)

Change-Id: I4273e6091df8c0e59ca86ac6d69bd8e40e9c4d44

src/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<String, String>  initList() {
+        HashMap<String, String> init = new HashMap<String, String>();
+        //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<String, String> 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<String, String> 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;
+    }
+}