1/*
2 * Copyright (C) 2008 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
17package com.android.internal.telephony.cdma.sms;
18
19import android.util.SparseBooleanArray;
20
21import com.android.internal.telephony.SmsAddress;
22import com.android.internal.telephony.cdma.sms.UserData;
23import com.android.internal.util.HexDump;
24
25public class CdmaSmsAddress extends SmsAddress {
26
27    /**
28     * Digit Mode Indicator is a 1-bit value that indicates whether
29     * the address digits are 4-bit DTMF codes or 8-bit codes.  (See
30     * 3GPP2 C.S0015-B, v2, 3.4.3.3)
31     */
32    static public final int DIGIT_MODE_4BIT_DTMF              = 0x00;
33    static public final int DIGIT_MODE_8BIT_CHAR              = 0x01;
34
35    public int digitMode;
36
37    /**
38     * Number Mode Indicator is 1-bit value that indicates whether the
39     * address type is a data network address or not.  (See 3GPP2
40     * C.S0015-B, v2, 3.4.3.3)
41     */
42    static public final int NUMBER_MODE_NOT_DATA_NETWORK      = 0x00;
43    static public final int NUMBER_MODE_DATA_NETWORK          = 0x01;
44
45    public int numberMode;
46
47    /**
48     * Number Types for data networks.
49     * (See 3GPP2 C.S005-D, table2.7.1.3.2.4-2 for complete table)
50     * (See 3GPP2 C.S0015-B, v2, 3.4.3.3 for data network subset)
51     * NOTE: value is stored in the parent class ton field.
52     */
53    static public final int TON_UNKNOWN                   = 0x00;
54    static public final int TON_INTERNATIONAL_OR_IP       = 0x01;
55    static public final int TON_NATIONAL_OR_EMAIL         = 0x02;
56    static public final int TON_NETWORK                   = 0x03;
57    static public final int TON_SUBSCRIBER                = 0x04;
58    static public final int TON_ALPHANUMERIC              = 0x05;
59    static public final int TON_ABBREVIATED               = 0x06;
60    static public final int TON_RESERVED                  = 0x07;
61
62    /**
63     * Maximum lengths for fields as defined in ril_cdma_sms.h.
64     */
65    static public final int SMS_ADDRESS_MAX          =  36;
66    static public final int SMS_SUBADDRESS_MAX       =  36;
67
68    /**
69     * This field shall be set to the number of address digits
70     * (See 3GPP2 C.S0015-B, v2, 3.4.3.3)
71     */
72    public int numberOfDigits;
73
74    /**
75     * Numbering Plan identification is a 0 or 4-bit value that
76     * indicates which numbering plan identification is set.  (See
77     * 3GPP2, C.S0015-B, v2, 3.4.3.3 and C.S005-D, table2.7.1.3.2.4-3)
78     */
79    static public final int NUMBERING_PLAN_UNKNOWN           = 0x0;
80    static public final int NUMBERING_PLAN_ISDN_TELEPHONY    = 0x1;
81    //static protected final int NUMBERING_PLAN_DATA              = 0x3;
82    //static protected final int NUMBERING_PLAN_TELEX             = 0x4;
83    //static protected final int NUMBERING_PLAN_PRIVATE           = 0x9;
84
85    public int numberPlan;
86
87    /**
88     * NOTE: the parsed string address and the raw byte array values
89     * are stored in the parent class address and origBytes fields,
90     * respectively.
91     */
92
93    public CdmaSmsAddress(){
94    }
95
96    @Override
97    public String toString() {
98        StringBuilder builder = new StringBuilder();
99        builder.append("CdmaSmsAddress ");
100        builder.append("{ digitMode=" + digitMode);
101        builder.append(", numberMode=" + numberMode);
102        builder.append(", numberPlan=" + numberPlan);
103        builder.append(", numberOfDigits=" + numberOfDigits);
104        builder.append(", ton=" + ton);
105        builder.append(", address=\"" + address + "\"");
106        builder.append(", origBytes=" + HexDump.toHexString(origBytes));
107        builder.append(" }");
108        return builder.toString();
109    }
110
111    /*
112     * TODO(cleanup): Refactor the parsing for addresses to better
113     * share code and logic with GSM.  Also, gather all DTMF/BCD
114     * processing code in one place.
115     */
116
117    private static byte[] parseToDtmf(String address) {
118        int digits = address.length();
119        byte[] result = new byte[digits];
120        for (int i = 0; i < digits; i++) {
121            char c = address.charAt(i);
122            int val = 0;
123            if ((c >= '1') && (c <= '9')) val = c - '0';
124            else if (c == '0') val = 10;
125            else if (c == '*') val = 11;
126            else if (c == '#') val = 12;
127            else return null;
128            result[i] = (byte)val;
129        }
130        return result;
131    }
132
133    private static final char[] numericCharsDialable = {
134        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '*', '#'
135    };
136
137    private static final char[] numericCharsSugar = {
138        '(', ')', ' ', '-', '+', '.', '/', '\\'
139    };
140
141    private static final SparseBooleanArray numericCharDialableMap = new SparseBooleanArray (
142            numericCharsDialable.length + numericCharsSugar.length);
143    static {
144        for (int i = 0; i < numericCharsDialable.length; i++) {
145            numericCharDialableMap.put(numericCharsDialable[i], true);
146        }
147        for (int i = 0; i < numericCharsSugar.length; i++) {
148            numericCharDialableMap.put(numericCharsSugar[i], false);
149        }
150    }
151
152    /**
153     * Given a numeric address string, return the string without
154     * syntactic sugar, meaning parens, spaces, hyphens/minuses, or
155     * plus signs.  If the input string contains non-numeric
156     * non-punctuation characters, return null.
157     */
158    private static String filterNumericSugar(String address) {
159        StringBuilder builder = new StringBuilder();
160        int len = address.length();
161        for (int i = 0; i < len; i++) {
162            char c = address.charAt(i);
163            int mapIndex = numericCharDialableMap.indexOfKey(c);
164            if (mapIndex < 0) return null;
165            if (! numericCharDialableMap.valueAt(mapIndex)) continue;
166            builder.append(c);
167        }
168        return builder.toString();
169    }
170
171    /**
172     * Given a string, return the string without whitespace,
173     * including CR/LF.
174     */
175    private static String filterWhitespace(String address) {
176        StringBuilder builder = new StringBuilder();
177        int len = address.length();
178        for (int i = 0; i < len; i++) {
179            char c = address.charAt(i);
180            if ((c == ' ') || (c == '\r') || (c == '\n') || (c == '\t')) continue;
181            builder.append(c);
182        }
183        return builder.toString();
184    }
185
186    /**
187     * Given a string, create a corresponding CdmaSmsAddress object.
188     *
189     * The result will be null if the input string is not
190     * representable using printable ASCII.
191     *
192     * For numeric addresses, the string is cleaned up by removing
193     * common punctuation.  For alpha addresses, the string is cleaned
194     * up by removing whitespace.
195     */
196    public static CdmaSmsAddress parse(String address) {
197        CdmaSmsAddress addr = new CdmaSmsAddress();
198        addr.address = address;
199        addr.ton = CdmaSmsAddress.TON_UNKNOWN;
200        byte[] origBytes = null;
201        String filteredAddr = filterNumericSugar(address);
202        if (filteredAddr != null) {
203            origBytes = parseToDtmf(filteredAddr);
204        }
205        if (origBytes != null) {
206            addr.digitMode = DIGIT_MODE_4BIT_DTMF;
207            addr.numberMode = NUMBER_MODE_NOT_DATA_NETWORK;
208            if (address.indexOf('+') != -1) {
209                addr.ton = TON_INTERNATIONAL_OR_IP;
210            }
211        } else {
212            filteredAddr = filterWhitespace(address);
213            origBytes = UserData.stringToAscii(filteredAddr);
214            if (origBytes == null) {
215                return null;
216            }
217            addr.digitMode = DIGIT_MODE_8BIT_CHAR;
218            addr.numberMode = NUMBER_MODE_DATA_NETWORK;
219            if (address.indexOf('@') != -1) {
220                addr.ton = TON_NATIONAL_OR_EMAIL;
221            }
222        }
223        addr.origBytes = origBytes;
224        addr.numberOfDigits = origBytes.length;
225        return addr;
226    }
227
228}
229