Adding bearer_bitmask support.
[android/platform/frameworks/opt/telephony.git] / src / java / com / android / internal / telephony / dataconnection / ApnSetting.java
1 /*
2  * Copyright (C) 2006 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.internal.telephony.dataconnection;
18
19 import android.telephony.ServiceState;
20 import android.text.TextUtils;
21
22 import com.android.internal.telephony.PhoneConstants;
23 import com.android.internal.telephony.RILConstants;
24
25 import java.util.ArrayList;
26 import java.util.List;
27 import java.util.Locale;
28
29 /**
30  * This class represents a apn setting for create PDP link
31  */
32 public class ApnSetting {
33
34     static final String V2_FORMAT_REGEX = "^\\[ApnSettingV2\\]\\s*";
35     static final String V3_FORMAT_REGEX = "^\\[ApnSettingV3\\]\\s*";
36
37     public final String carrier;
38     public final String apn;
39     public final String proxy;
40     public final String port;
41     public final String mmsc;
42     public final String mmsProxy;
43     public final String mmsPort;
44     public final String user;
45     public final String password;
46     public final int authType;
47     public final String[] types;
48     public final int id;
49     public final String numeric;
50     public final String protocol;
51     public final String roamingProtocol;
52     public final int mtu;
53
54     /**
55       * Current status of APN
56       * true : enabled APN, false : disabled APN.
57       */
58     public final boolean carrierEnabled;
59     /**
60      * Radio Access Technology info
61      * To check what values can hold, refer to ServiceState.java.
62      * This should be spread to other technologies,
63      * but currently only used for LTE(14) and EHRPD(13).
64      */
65     private final int bearer;
66     /**
67       * Radio Access Technology info
68       * To check what values can hold, refer to ServiceState.java. This is a bitmask of radio
69       * technologies in ServiceState.
70       * This should be spread to other technologies,
71       * but currently only used for LTE(14) and EHRPD(13).
72       */
73     public final int bearerBitmask;
74
75     /* ID of the profile in the modem */
76     public final int profileId;
77     public final boolean modemCognitive;
78     public final int maxConns;
79     public final int waitTime;
80     public final int maxConnsTime;
81
82     /**
83       * MVNO match type. Possible values:
84       *   "spn": Service provider name.
85       *   "imsi": IMSI.
86       *   "gid": Group identifier level 1.
87       */
88     public final String mvnoType;
89     /**
90       * MVNO data. Examples:
91       *   "spn": A MOBILE, BEN NL
92       *   "imsi": 302720x94, 2060188
93       *   "gid": 4E, 33
94       */
95     public final String mvnoMatchData;
96
97     public ApnSetting(int id, String numeric, String carrier, String apn,
98             String proxy, String port,
99             String mmsc, String mmsProxy, String mmsPort,
100             String user, String password, int authType, String[] types,
101             String protocol, String roamingProtocol, boolean carrierEnabled, int bearer,
102             int bearerBitmask, int profileId, boolean modemCognitive, int maxConns, int waitTime,
103             int maxConnsTime, int mtu, String mvnoType, String mvnoMatchData) {
104         this.id = id;
105         this.numeric = numeric;
106         this.carrier = carrier;
107         this.apn = apn;
108         this.proxy = proxy;
109         this.port = port;
110         this.mmsc = mmsc;
111         this.mmsProxy = mmsProxy;
112         this.mmsPort = mmsPort;
113         this.user = user;
114         this.password = password;
115         this.authType = authType;
116         this.types = new String[types.length];
117         for (int i = 0; i < types.length; i++) {
118             this.types[i] = types[i].toLowerCase(Locale.ROOT);
119         }
120         this.protocol = protocol;
121         this.roamingProtocol = roamingProtocol;
122         this.carrierEnabled = carrierEnabled;
123         this.bearer = bearer;
124         this.bearerBitmask = (bearerBitmask | ServiceState.getBitmaskForTech(bearer));
125         this.profileId = profileId;
126         this.modemCognitive = modemCognitive;
127         this.maxConns = maxConns;
128         this.waitTime = waitTime;
129         this.maxConnsTime = maxConnsTime;
130         this.mtu = mtu;
131         this.mvnoType = mvnoType;
132         this.mvnoMatchData = mvnoMatchData;
133
134     }
135
136     /**
137      * Creates an ApnSetting object from a string.
138      *
139      * @param data the string to read.
140      *
141      * The string must be in one of two formats (newlines added for clarity,
142      * spaces are optional):
143      *
144      * v1 format:
145      *   <carrier>, <apn>, <proxy>, <port>, <user>, <password>, <server>,
146      *   <mmsc>, <mmsproxy>, <mmsport>, <mcc>, <mnc>, <authtype>,
147      *   <type>[| <type>...],
148      *
149      * v2 format:
150      *   [ApnSettingV2] <carrier>, <apn>, <proxy>, <port>, <user>, <password>, <server>,
151      *   <mmsc>, <mmsproxy>, <mmsport>, <mcc>, <mnc>, <authtype>,
152      *   <type>[| <type>...], <protocol>, <roaming_protocol>, <carrierEnabled>, <bearerBitmask>,
153      *
154      * v3 format:
155      *   [ApnSettingV3] <carrier>, <apn>, <proxy>, <port>, <user>, <password>, <server>,
156      *   <mmsc>, <mmsproxy>, <mmsport>, <mcc>, <mnc>, <authtype>,
157      *   <type>[| <type>...], <protocol>, <roaming_protocol>, <carrierEnabled>, <bearerBitmask>,
158      *   <profileId>, <modemCognitive>, <maxConns>, <waitTime>, <maxConnsTime>, <mtu>,
159      *   <mvnoType>, <mvnoMatchData>
160      *
161      * Note that the strings generated by toString() do not contain the username
162      * and password and thus cannot be read by this method.
163      */
164     public static ApnSetting fromString(String data) {
165         if (data == null) return null;
166
167         int version;
168         // matches() operates on the whole string, so append .* to the regex.
169         if (data.matches(V3_FORMAT_REGEX + ".*")) {
170             version = 3;
171             data = data.replaceFirst(V3_FORMAT_REGEX, "");
172         } else if (data.matches(V2_FORMAT_REGEX + ".*")) {
173             version = 2;
174             data = data.replaceFirst(V2_FORMAT_REGEX, "");
175         } else {
176             version = 1;
177         }
178
179         String[] a = data.split("\\s*,\\s*");
180         if (a.length < 14) {
181             return null;
182         }
183
184         int authType;
185         try {
186             authType = Integer.parseInt(a[12]);
187         } catch (NumberFormatException e) {
188             authType = 0;
189         }
190
191         String[] typeArray;
192         String protocol, roamingProtocol;
193         boolean carrierEnabled;
194         int bearerBitmask = 0;
195         int profileId = 0;
196         boolean modemCognitive = false;
197         int maxConns = 0;
198         int waitTime = 0;
199         int maxConnsTime = 0;
200         int mtu = PhoneConstants.UNSET_MTU;
201         String mvnoType = "";
202         String mvnoMatchData = "";
203         if (version == 1) {
204             typeArray = new String[a.length - 13];
205             System.arraycopy(a, 13, typeArray, 0, a.length - 13);
206             protocol = RILConstants.SETUP_DATA_PROTOCOL_IP;
207             roamingProtocol = RILConstants.SETUP_DATA_PROTOCOL_IP;
208             carrierEnabled = true;
209         } else {
210             if (a.length < 18) {
211                 return null;
212             }
213             typeArray = a[13].split("\\s*\\|\\s*");
214             protocol = a[14];
215             roamingProtocol = a[15];
216             carrierEnabled = Boolean.parseBoolean(a[16]);
217
218             bearerBitmask = ServiceState.getBitmaskFromString(a[17]);
219
220             if (a.length > 22) {
221                 modemCognitive = Boolean.parseBoolean(a[19]);
222                 try {
223                     profileId = Integer.parseInt(a[18]);
224                     maxConns = Integer.parseInt(a[20]);
225                     waitTime = Integer.parseInt(a[21]);
226                     maxConnsTime = Integer.parseInt(a[22]);
227                 } catch (NumberFormatException e) {
228                 }
229             }
230             if (a.length > 23) {
231                 try {
232                     mtu = Integer.parseInt(a[23]);
233                 } catch (NumberFormatException e) {
234                 }
235             }
236             if (a.length > 25) {
237                 mvnoType = a[24];
238                 mvnoMatchData = a[25];
239             }
240         }
241
242         return new ApnSetting(-1,a[10]+a[11],a[0],a[1],a[2],a[3],a[7],a[8],
243                 a[9],a[4],a[5],authType,typeArray,protocol,roamingProtocol,carrierEnabled,0,
244                 bearerBitmask, profileId, modemCognitive, maxConns, waitTime, maxConnsTime, mtu,
245                 mvnoType, mvnoMatchData);
246     }
247
248     /**
249      * Creates an array of ApnSetting objects from a string.
250      *
251      * @param data the string to read.
252      *
253      * Builds on top of the same format used by fromString, but allows for multiple entries
254      * separated by "; ".
255      */
256     public static List<ApnSetting> arrayFromString(String data) {
257         List<ApnSetting> retVal = new ArrayList<ApnSetting>();
258         if (TextUtils.isEmpty(data)) {
259             return retVal;
260         }
261         String[] apnStrings = data.split("\\s*;\\s*");
262         for (String apnString : apnStrings) {
263             ApnSetting apn = fromString(apnString);
264             if (apn != null) {
265                 retVal.add(apn);
266             }
267         }
268         return retVal;
269     }
270
271     @Override
272     public String toString() {
273         StringBuilder sb = new StringBuilder();
274         sb.append("[ApnSettingV3] ")
275         .append(carrier)
276         .append(", ").append(id)
277         .append(", ").append(numeric)
278         .append(", ").append(apn)
279         .append(", ").append(proxy)
280         .append(", ").append(mmsc)
281         .append(", ").append(mmsProxy)
282         .append(", ").append(mmsPort)
283         .append(", ").append(port)
284         .append(", ").append(authType).append(", ");
285         for (int i = 0; i < types.length; i++) {
286             sb.append(types[i]);
287             if (i < types.length - 1) {
288                 sb.append(" | ");
289             }
290         }
291         sb.append(", ").append(protocol);
292         sb.append(", ").append(roamingProtocol);
293         sb.append(", ").append(carrierEnabled);
294         sb.append(", ").append(bearer);
295         sb.append(", ").append(bearerBitmask);
296         sb.append(", ").append(profileId);
297         sb.append(", ").append(modemCognitive);
298         sb.append(", ").append(maxConns);
299         sb.append(", ").append(waitTime);
300         sb.append(", ").append(maxConnsTime);
301         sb.append(", ").append(mtu);
302         sb.append(", ").append(mvnoType);
303         sb.append(", ").append(mvnoMatchData);
304         return sb.toString();
305     }
306
307     /**
308      * Returns true if there are MVNO params specified.
309      */
310     public boolean hasMvnoParams() {
311         return !TextUtils.isEmpty(mvnoType) && !TextUtils.isEmpty(mvnoMatchData);
312     }
313
314     public boolean canHandleType(String type) {
315         if (!carrierEnabled) return false;
316         for (String t : types) {
317             // DEFAULT handles all, and HIPRI is handled by DEFAULT
318             if (t.equalsIgnoreCase(type) ||
319                     t.equalsIgnoreCase(PhoneConstants.APN_TYPE_ALL) ||
320                     (t.equalsIgnoreCase(PhoneConstants.APN_TYPE_DEFAULT) &&
321                     type.equalsIgnoreCase(PhoneConstants.APN_TYPE_HIPRI))) {
322                 return true;
323             }
324         }
325         return false;
326     }
327
328     // TODO - if we have this function we should also have hashCode.
329     // Also should handle changes in type order and perhaps case-insensitivity
330     @Override
331     public boolean equals(Object o) {
332         if (o instanceof ApnSetting == false) return false;
333         return (toString().equals(o.toString()));
334     }
335 }