1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.messaging.sms; 18 19 import android.content.ContentValues; 20 import android.provider.Telephony; 21 22 import com.android.messaging.util.Assert; 23 import com.android.messaging.util.LogUtil; 24 import com.android.messaging.util.PhoneUtils; 25 import com.google.common.collect.Maps; 26 27 import org.xmlpull.v1.XmlPullParser; 28 import org.xmlpull.v1.XmlPullParserException; 29 30 import java.io.IOException; 31 import java.util.Map; 32 33 /* 34 * XML processor for the following files: 35 * 1. res/xml/apns.xml 36 * 2. res/xml/mms_config.xml (or related overlay files) 37 */ 38 class ApnsXmlProcessor { 39 public interface ApnHandler { process(ContentValues apnValues)40 public void process(ContentValues apnValues); 41 } 42 43 public interface MmsConfigHandler { process(String mccMnc, String key, String value, String type)44 public void process(String mccMnc, String key, String value, String type); 45 } 46 47 private static final String TAG = LogUtil.BUGLE_TAG; 48 49 private static final Map<String, String> APN_ATTRIBUTE_MAP = Maps.newHashMap(); 50 static { 51 APN_ATTRIBUTE_MAP.put("mcc", Telephony.Carriers.MCC); 52 APN_ATTRIBUTE_MAP.put("mnc", Telephony.Carriers.MNC); 53 APN_ATTRIBUTE_MAP.put("carrier", Telephony.Carriers.NAME); 54 APN_ATTRIBUTE_MAP.put("apn", Telephony.Carriers.APN); 55 APN_ATTRIBUTE_MAP.put("mmsc", Telephony.Carriers.MMSC); 56 APN_ATTRIBUTE_MAP.put("mmsproxy", Telephony.Carriers.MMSPROXY); 57 APN_ATTRIBUTE_MAP.put("mmsport", Telephony.Carriers.MMSPORT); 58 APN_ATTRIBUTE_MAP.put("type", Telephony.Carriers.TYPE); 59 APN_ATTRIBUTE_MAP.put("user", Telephony.Carriers.USER); 60 APN_ATTRIBUTE_MAP.put("password", Telephony.Carriers.PASSWORD); 61 APN_ATTRIBUTE_MAP.put("authtype", Telephony.Carriers.AUTH_TYPE); 62 APN_ATTRIBUTE_MAP.put("mvno_match_data", Telephony.Carriers.MVNO_MATCH_DATA); 63 APN_ATTRIBUTE_MAP.put("mvno_type", Telephony.Carriers.MVNO_TYPE); 64 APN_ATTRIBUTE_MAP.put("protocol", Telephony.Carriers.PROTOCOL); 65 APN_ATTRIBUTE_MAP.put("bearer", Telephony.Carriers.BEARER); 66 APN_ATTRIBUTE_MAP.put("server", Telephony.Carriers.SERVER); 67 APN_ATTRIBUTE_MAP.put("roaming_protocol", Telephony.Carriers.ROAMING_PROTOCOL); 68 APN_ATTRIBUTE_MAP.put("proxy", Telephony.Carriers.PROXY); 69 APN_ATTRIBUTE_MAP.put("port", Telephony.Carriers.PORT); 70 APN_ATTRIBUTE_MAP.put("carrier_enabled", Telephony.Carriers.CARRIER_ENABLED); 71 } 72 73 private static final String TAG_APNS = "apns"; 74 private static final String TAG_APN = "apn"; 75 private static final String TAG_MMS_CONFIG = "mms_config"; 76 77 // Handler to process one apn 78 private ApnHandler mApnHandler; 79 // Handler to process one mms_config key/value pair 80 private MmsConfigHandler mMmsConfigHandler; 81 82 private final StringBuilder mLogStringBuilder = new StringBuilder(); 83 84 private final XmlPullParser mInputParser; 85 ApnsXmlProcessor(XmlPullParser parser)86 private ApnsXmlProcessor(XmlPullParser parser) { 87 mInputParser = parser; 88 mApnHandler = null; 89 mMmsConfigHandler = null; 90 } 91 get(XmlPullParser parser)92 public static ApnsXmlProcessor get(XmlPullParser parser) { 93 Assert.notNull(parser); 94 return new ApnsXmlProcessor(parser); 95 } 96 setApnHandler(ApnHandler handler)97 public ApnsXmlProcessor setApnHandler(ApnHandler handler) { 98 mApnHandler = handler; 99 return this; 100 } 101 setMmsConfigHandler(MmsConfigHandler handler)102 public ApnsXmlProcessor setMmsConfigHandler(MmsConfigHandler handler) { 103 mMmsConfigHandler = handler; 104 return this; 105 } 106 107 /** 108 * Move XML parser forward to next event type or the end of doc 109 * 110 * @param eventType 111 * @return The final event type we meet 112 * @throws XmlPullParserException 113 * @throws IOException 114 */ advanceToNextEvent(int eventType)115 private int advanceToNextEvent(int eventType) throws XmlPullParserException, IOException { 116 for (;;) { 117 int nextEvent = mInputParser.next(); 118 if (nextEvent == eventType 119 || nextEvent == XmlPullParser.END_DOCUMENT) { 120 return nextEvent; 121 } 122 } 123 } 124 process()125 public void process() { 126 try { 127 // Find the first element 128 if (advanceToNextEvent(XmlPullParser.START_TAG) != XmlPullParser.START_TAG) { 129 throw new XmlPullParserException("ApnsXmlProcessor: expecting start tag @" 130 + xmlParserDebugContext()); 131 } 132 // A single ContentValues object for holding the parsing result of 133 // an apn element 134 final ContentValues values = new ContentValues(); 135 String tagName = mInputParser.getName(); 136 // Top level tag can be "apns" (apns.xml) 137 // or "mms_config" (mms_config.xml) 138 if (TAG_APNS.equals(tagName)) { 139 // For "apns", there could be "apn" or both "apn" and "mms_config" 140 for (;;) { 141 if (advanceToNextEvent(XmlPullParser.START_TAG) != XmlPullParser.START_TAG) { 142 break; 143 } 144 tagName = mInputParser.getName(); 145 if (TAG_APN.equals(tagName)) { 146 processApn(values); 147 } else if (TAG_MMS_CONFIG.equals(tagName)) { 148 processMmsConfig(); 149 } 150 } 151 } else if (TAG_MMS_CONFIG.equals(tagName)) { 152 // mms_config.xml resource 153 processMmsConfig(); 154 } 155 } catch (IOException e) { 156 LogUtil.e(TAG, "ApnsXmlProcessor: I/O failure " + e, e); 157 } catch (XmlPullParserException e) { 158 LogUtil.e(TAG, "ApnsXmlProcessor: parsing failure " + e, e); 159 } 160 } 161 parseInt(String text, Integer defaultValue, String logHint)162 private Integer parseInt(String text, Integer defaultValue, String logHint) { 163 Integer value = defaultValue; 164 try { 165 value = Integer.parseInt(text); 166 } catch (Exception e) { 167 LogUtil.e(TAG, 168 "Invalid value " + text + "for" + logHint + " @" + xmlParserDebugContext()); 169 } 170 return value; 171 } 172 parseBoolean(String text, Boolean defaultValue, String logHint)173 private Boolean parseBoolean(String text, Boolean defaultValue, String logHint) { 174 Boolean value = defaultValue; 175 try { 176 value = Boolean.parseBoolean(text); 177 } catch (Exception e) { 178 LogUtil.e(TAG, 179 "Invalid value " + text + "for" + logHint + " @" + xmlParserDebugContext()); 180 } 181 return value; 182 } 183 xmlParserEventString(int event)184 private static String xmlParserEventString(int event) { 185 switch (event) { 186 case XmlPullParser.START_DOCUMENT: return "START_DOCUMENT"; 187 case XmlPullParser.END_DOCUMENT: return "END_DOCUMENT"; 188 case XmlPullParser.START_TAG: return "START_TAG"; 189 case XmlPullParser.END_TAG: return "END_TAG"; 190 case XmlPullParser.TEXT: return "TEXT"; 191 } 192 return Integer.toString(event); 193 } 194 195 /** 196 * @return The debugging information of the parser's current position 197 */ xmlParserDebugContext()198 private String xmlParserDebugContext() { 199 mLogStringBuilder.setLength(0); 200 if (mInputParser != null) { 201 try { 202 final int eventType = mInputParser.getEventType(); 203 mLogStringBuilder.append(xmlParserEventString(eventType)); 204 if (eventType == XmlPullParser.START_TAG 205 || eventType == XmlPullParser.END_TAG 206 || eventType == XmlPullParser.TEXT) { 207 mLogStringBuilder.append('<').append(mInputParser.getName()); 208 for (int i = 0; i < mInputParser.getAttributeCount(); i++) { 209 mLogStringBuilder.append(' ') 210 .append(mInputParser.getAttributeName(i)) 211 .append('=') 212 .append(mInputParser.getAttributeValue(i)); 213 } 214 mLogStringBuilder.append("/>"); 215 } 216 return mLogStringBuilder.toString(); 217 } catch (XmlPullParserException e) { 218 LogUtil.e(TAG, "xmlParserDebugContext: " + e, e); 219 } 220 } 221 return "Unknown"; 222 } 223 224 /** 225 * Process one apn 226 * 227 * @param apnValues Where we store the parsed apn 228 * @throws IOException 229 * @throws XmlPullParserException 230 */ processApn(ContentValues apnValues)231 private void processApn(ContentValues apnValues) throws IOException, XmlPullParserException { 232 Assert.notNull(apnValues); 233 apnValues.clear(); 234 // Collect all the attributes 235 for (int i = 0; i < mInputParser.getAttributeCount(); i++) { 236 final String key = APN_ATTRIBUTE_MAP.get(mInputParser.getAttributeName(i)); 237 if (key != null) { 238 apnValues.put(key, mInputParser.getAttributeValue(i)); 239 } 240 } 241 // Set numeric to be canonicalized mcc/mnc like "310120", always 6 digits 242 final String canonicalMccMnc = PhoneUtils.canonicalizeMccMnc( 243 apnValues.getAsString(Telephony.Carriers.MCC), 244 apnValues.getAsString(Telephony.Carriers.MNC)); 245 apnValues.put(Telephony.Carriers.NUMERIC, canonicalMccMnc); 246 // Some of the values should not be string type, converting them to desired types 247 final String authType = apnValues.getAsString(Telephony.Carriers.AUTH_TYPE); 248 if (authType != null) { 249 apnValues.put(Telephony.Carriers.AUTH_TYPE, parseInt(authType, -1, "apn authtype")); 250 } 251 final String carrierEnabled = apnValues.getAsString(Telephony.Carriers.CARRIER_ENABLED); 252 if (carrierEnabled != null) { 253 apnValues.put(Telephony.Carriers.CARRIER_ENABLED, 254 parseBoolean(carrierEnabled, null, "apn carrierEnabled")); 255 } 256 final String bearer = apnValues.getAsString(Telephony.Carriers.BEARER); 257 if (bearer != null) { 258 apnValues.put(Telephony.Carriers.BEARER, parseInt(bearer, 0, "apn bearer")); 259 } 260 // We are at the end tag 261 if (mInputParser.next() != XmlPullParser.END_TAG) { 262 throw new XmlPullParserException("Apn: expecting end tag @" 263 + xmlParserDebugContext()); 264 } 265 // We are done parsing one APN, call the handler 266 if (mApnHandler != null) { 267 mApnHandler.process(apnValues); 268 } 269 } 270 271 /** 272 * Process one mms_config. 273 * 274 * @throws IOException 275 * @throws XmlPullParserException 276 */ processMmsConfig()277 private void processMmsConfig() 278 throws IOException, XmlPullParserException { 279 // Get the mcc and mnc attributes 280 final String canonicalMccMnc = PhoneUtils.canonicalizeMccMnc( 281 mInputParser.getAttributeValue(null, "mcc"), 282 mInputParser.getAttributeValue(null, "mnc")); 283 // We are at the start tag 284 for (;;) { 285 int nextEvent; 286 // Skipping spaces 287 while ((nextEvent = mInputParser.next()) == XmlPullParser.TEXT) { 288 } 289 if (nextEvent == XmlPullParser.START_TAG) { 290 // Parse one mms config key/value 291 processMmsConfigKeyValue(canonicalMccMnc); 292 } else if (nextEvent == XmlPullParser.END_TAG) { 293 break; 294 } else { 295 throw new XmlPullParserException("MmsConfig: expecting start or end tag @" 296 + xmlParserDebugContext()); 297 } 298 } 299 } 300 301 /** 302 * Process one mms_config key/value pair 303 * 304 * @param mccMnc The mcc and mnc of this mms_config 305 * @throws IOException 306 * @throws XmlPullParserException 307 */ processMmsConfigKeyValue(String mccMnc)308 private void processMmsConfigKeyValue(String mccMnc) 309 throws IOException, XmlPullParserException { 310 final String key = mInputParser.getAttributeValue(null, "name"); 311 // We are at the start tag, the name of the tag is the type 312 // e.g. <int name="key">value</int> 313 final String type = mInputParser.getName(); 314 int nextEvent = mInputParser.next(); 315 String value = null; 316 if (nextEvent == XmlPullParser.TEXT) { 317 value = mInputParser.getText(); 318 nextEvent = mInputParser.next(); 319 } 320 if (nextEvent != XmlPullParser.END_TAG) { 321 throw new XmlPullParserException("ApnsXmlProcessor: expecting end tag @" 322 + xmlParserDebugContext()); 323 } 324 // We are done parsing one mms_config key/value, call the handler 325 if (mMmsConfigHandler != null) { 326 mMmsConfigHandler.process(mccMnc, key, value, type); 327 } 328 } 329 } 330