/*
* Copyright (C) 2012 The Android Open Source 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.cdma;
import android.os.Parcel;
import android.telephony.SmsCbCmasInfo;
import android.telephony.SmsCbMessage;
import android.telephony.cdma.CdmaSmsCbProgramData;
import android.test.AndroidTestCase;
import android.telephony.Rlog;
import com.android.internal.telephony.GsmAlphabet;
import com.android.internal.telephony.cdma.sms.BearerData;
import com.android.internal.telephony.cdma.sms.CdmaSmsAddress;
import com.android.internal.telephony.cdma.sms.SmsEnvelope;
import com.android.internal.telephony.cdma.sms.UserData;
import com.android.internal.telephony.uicc.IccUtils;
import com.android.internal.util.BitwiseOutputStream;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
/**
* Test cases for basic SmsCbMessage operation for CDMA.
*/
public class CdmaSmsCbTest extends AndroidTestCase {
/* Copy of private subparameter identifier constants from BearerData class. */
private static final byte SUBPARAM_MESSAGE_IDENTIFIER = (byte) 0x00;
private static final byte SUBPARAM_USER_DATA = (byte) 0x01;
private static final byte SUBPARAM_PRIORITY_INDICATOR = (byte) 0x08;
private static final byte SUBPARAM_LANGUAGE_INDICATOR = (byte) 0x0D;
private static final byte SUBPARAM_SERVICE_CATEGORY_PROGRAM_DATA = 0x12;
/**
* Initialize a Parcel for an incoming CDMA cell broadcast. The caller will write the
* bearer data and then convert it to an SmsMessage.
* @param serviceCategory the CDMA service category
* @return the initialized Parcel
*/
private static Parcel createBroadcastParcel(int serviceCategory) {
Parcel p = Parcel.obtain();
p.writeInt(SmsEnvelope.TELESERVICE_NOT_SET);
p.writeByte((byte) 1); // non-zero for MESSAGE_TYPE_BROADCAST
p.writeInt(serviceCategory);
// dummy address (RIL may generate a different dummy address for broadcasts)
p.writeInt(CdmaSmsAddress.DIGIT_MODE_4BIT_DTMF); // sAddress.digit_mode
p.writeInt(CdmaSmsAddress.NUMBER_MODE_NOT_DATA_NETWORK); // sAddress.number_mode
p.writeInt(CdmaSmsAddress.TON_UNKNOWN); // sAddress.number_type
p.writeInt(CdmaSmsAddress.NUMBERING_PLAN_ISDN_TELEPHONY); // sAddress.number_plan
p.writeByte((byte) 0); // sAddress.number_of_digits
p.writeInt((byte) 0); // sSubAddress.subaddressType
p.writeByte((byte) 0); // sSubAddress.odd
p.writeByte((byte) 0); // sSubAddress.number_of_digits
return p;
}
/**
* Initialize a BitwiseOutputStream with the CDMA bearer data subparameters except for
* user data. The caller will append the user data and add it to the parcel.
* @param messageId the 16-bit message identifier
* @param priority message priority
* @param language message language code
* @return the initialized BitwiseOutputStream
*/
private static BitwiseOutputStream createBearerDataStream(int messageId, int priority,
int language) throws BitwiseOutputStream.AccessException {
BitwiseOutputStream bos = new BitwiseOutputStream(10);
bos.write(8, SUBPARAM_MESSAGE_IDENTIFIER);
bos.write(8, 3); // length: 3 bytes
bos.write(4, BearerData.MESSAGE_TYPE_DELIVER);
bos.write(8, ((messageId >>> 8) & 0xff));
bos.write(8, (messageId & 0xff));
bos.write(1, 0); // no User Data Header
bos.write(3, 0); // reserved
if (priority != -1) {
bos.write(8, SUBPARAM_PRIORITY_INDICATOR);
bos.write(8, 1); // length: 1 byte
bos.write(2, (priority & 0x03));
bos.write(6, 0); // reserved
}
if (language != -1) {
bos.write(8, SUBPARAM_LANGUAGE_INDICATOR);
bos.write(8, 1); // length: 1 byte
bos.write(8, (language & 0xff));
}
return bos;
}
/**
* Write the bearer data array to the parcel, then return a new SmsMessage from the parcel.
* @param p the parcel containing the CDMA SMS headers
* @param bearerData the bearer data byte array to append to the parcel
* @return the new SmsMessage created from the parcel
*/
private static SmsMessage createMessageFromParcel(Parcel p, byte[] bearerData) {
p.writeInt(bearerData.length);
for (byte b : bearerData) {
p.writeByte(b);
}
p.setDataPosition(0); // reset position for reading
SmsMessage message = SmsMessage.newFromParcel(p);
p.recycle();
return message;
}
/**
* Create a parcel for an incoming CMAS broadcast, then return a new SmsMessage created
* from the parcel.
* @param serviceCategory the CDMA service category
* @param messageId the 16-bit message identifier
* @param priority message priority
* @param language message language code
* @param body message body
* @param cmasCategory CMAS category (or -1 to skip adding CMAS type 1 elements record)
* @param responseType CMAS response type
* @param severity CMAS severity
* @param urgency CMAS urgency
* @param certainty CMAS certainty
* @return the newly created SmsMessage object
*/
private static SmsMessage createCmasSmsMessage(int serviceCategory, int messageId, int priority,
int language, int encoding, String body, int cmasCategory, int responseType,
int severity, int urgency, int certainty) throws Exception {
BitwiseOutputStream cmasBos = new BitwiseOutputStream(10);
cmasBos.write(8, 0); // CMAE protocol version 0
if (body != null) {
cmasBos.write(8, 0); // Type 0 elements (alert text)
encodeBody(encoding, body, true, cmasBos);
}
if (cmasCategory != SmsCbCmasInfo.CMAS_CATEGORY_UNKNOWN) {
cmasBos.write(8, 1); // Type 1 elements
cmasBos.write(8, 4); // length: 4 bytes
cmasBos.write(8, (cmasCategory & 0xff));
cmasBos.write(8, (responseType & 0xff));
cmasBos.write(4, (severity & 0x0f));
cmasBos.write(4, (urgency & 0x0f));
cmasBos.write(4, (certainty & 0x0f));
cmasBos.write(4, 0); // pad to octet boundary
}
byte[] cmasUserData = cmasBos.toByteArray();
Parcel p = createBroadcastParcel(serviceCategory);
BitwiseOutputStream bos = createBearerDataStream(messageId, priority, language);
bos.write(8, SUBPARAM_USER_DATA);
bos.write(8, cmasUserData.length + 2); // add 2 bytes for msg_encoding and num_fields
bos.write(5, UserData.ENCODING_OCTET);
bos.write(8, cmasUserData.length);
bos.writeByteArray(cmasUserData.length * 8, cmasUserData);
bos.write(3, 0); // pad to byte boundary
return createMessageFromParcel(p, bos.toByteArray());
}
/**
* Create a parcel for an incoming CDMA cell broadcast, then return a new SmsMessage created
* from the parcel.
* @param serviceCategory the CDMA service category
* @param messageId the 16-bit message identifier
* @param priority message priority
* @param language message language code
* @param encoding user data encoding method
* @param body the message body
* @return the newly created SmsMessage object
*/
private static SmsMessage createBroadcastSmsMessage(int serviceCategory, int messageId,
int priority, int language, int encoding, String body) throws Exception {
Parcel p = createBroadcastParcel(serviceCategory);
BitwiseOutputStream bos = createBearerDataStream(messageId, priority, language);
bos.write(8, SUBPARAM_USER_DATA);
encodeBody(encoding, body, false, bos);
return createMessageFromParcel(p, bos.toByteArray());
}
/**
* Append the message length, encoding, and body to the BearerData output stream.
* This is used for writing the User Data subparameter for non-CMAS broadcasts and for
* writing the alert text for CMAS broadcasts.
* @param encoding one of the CDMA UserData encoding values
* @param body the message body
* @param isCmasRecord true if this is a CMAS type 0 elements record; false for user data
* @param bos the BitwiseOutputStream to write to
* @throws Exception on any encoding error
*/
private static void encodeBody(int encoding, String body, boolean isCmasRecord,
BitwiseOutputStream bos) throws Exception {
if (encoding == UserData.ENCODING_7BIT_ASCII || encoding == UserData.ENCODING_IA5) {
int charCount = body.length();
int recordBits = (charCount * 7) + 5; // add 5 bits for char set field
int recordOctets = (recordBits + 7) / 8; // round up to octet boundary
int padBits = (recordOctets * 8) - recordBits;
if (!isCmasRecord) {
recordOctets++; // add 8 bits for num_fields
}
bos.write(8, recordOctets);
bos.write(5, (encoding & 0x1f));
if (!isCmasRecord) {
bos.write(8, charCount);
}
for (int i = 0; i < charCount; i++) {
bos.write(7, body.charAt(i));
}
bos.write(padBits, 0); // pad to octet boundary
} else if (encoding == UserData.ENCODING_GSM_7BIT_ALPHABET
|| encoding == UserData.ENCODING_GSM_DCS) {
// convert to 7-bit packed encoding with septet count in index 0 of byte array
byte[] encodedBody = GsmAlphabet.stringToGsm7BitPacked(body);
int charCount = encodedBody[0]; // septet count
int recordBits = (charCount * 7) + 5; // add 5 bits for char set field
int recordOctets = (recordBits + 7) / 8; // round up to octet boundary
int padBits = (recordOctets * 8) - recordBits;
if (!isCmasRecord) {
recordOctets++; // add 8 bits for num_fields
if (encoding == UserData.ENCODING_GSM_DCS) {
recordOctets++; // add 8 bits for DCS (message type)
}
}
bos.write(8, recordOctets);
bos.write(5, (encoding & 0x1f));
if (!isCmasRecord && encoding == UserData.ENCODING_GSM_DCS) {
bos.write(8, 0); // GSM DCS: 7 bit default alphabet, no msg class
}
if (!isCmasRecord) {
bos.write(8, charCount);
}
byte[] bodySeptets = Arrays.copyOfRange(encodedBody, 1, encodedBody.length);
bos.writeByteArray(charCount * 7, bodySeptets);
bos.write(padBits, 0); // pad to octet boundary
} else if (encoding == UserData.ENCODING_IS91_EXTENDED_PROTOCOL) {
// 6 bit packed encoding with 0x20 offset (ASCII 0x20 - 0x60)
int charCount = body.length();
int recordBits = (charCount * 6) + 21; // add 21 bits for header fields
int recordOctets = (recordBits + 7) / 8; // round up to octet boundary
int padBits = (recordOctets * 8) - recordBits;
bos.write(8, recordOctets);
bos.write(5, (encoding & 0x1f));
bos.write(8, UserData.IS91_MSG_TYPE_SHORT_MESSAGE);
bos.write(8, charCount);
for (int i = 0; i < charCount; i++) {
bos.write(6, ((int) body.charAt(i) - 0x20));
}
bos.write(padBits, 0); // pad to octet boundary
} else {
byte[] encodedBody;
switch (encoding) {
case UserData.ENCODING_UNICODE_16:
encodedBody = body.getBytes("UTF-16BE");
break;
case UserData.ENCODING_SHIFT_JIS:
encodedBody = body.getBytes("Shift_JIS");
break;
case UserData.ENCODING_KOREAN:
encodedBody = body.getBytes("KSC5601");
break;
case UserData.ENCODING_LATIN_HEBREW:
encodedBody = body.getBytes("ISO-8859-8");
break;
case UserData.ENCODING_LATIN:
default:
encodedBody = body.getBytes("ISO-8859-1");
break;
}
int charCount = body.length(); // use actual char count for num fields
int recordOctets = encodedBody.length + 1; // add 1 byte for encoding and pad bits
if (!isCmasRecord) {
recordOctets++; // add 8 bits for num_fields
}
bos.write(8, recordOctets);
bos.write(5, (encoding & 0x1f));
if (!isCmasRecord) {
bos.write(8, charCount);
}
bos.writeByteArray(encodedBody.length * 8, encodedBody);
bos.write(3, 0); // pad to octet boundary
}
}
private static final String TEST_TEXT = "This is a test CDMA cell broadcast message..."
+ "678901234567890123456789012345678901234567890";
private static final String PRES_ALERT =
"THE PRESIDENT HAS ISSUED AN EMERGENCY ALERT. CHECK LOCAL MEDIA FOR MORE DETAILS";
private static final String EXTREME_ALERT = "FLASH FLOOD WARNING FOR SOUTH COCONINO COUNTY"
+ " - NORTH CENTRAL ARIZONA UNTIL 415 PM MST";
private static final String SEVERE_ALERT = "SEVERE WEATHER WARNING FOR SOMERSET COUNTY"
+ " - NEW JERSEY UNTIL 415 PM MST";
private static final String AMBER_ALERT =
"AMBER ALERT:Mountain View,CA VEH'07 Blue Honda Civic CA LIC 5ABC123";
private static final String MONTHLY_TEST_ALERT = "This is a test of the emergency alert system."
+ " This is only a test. 89012345678901234567890";
private static final String IS91_TEXT = "IS91 SHORT MSG"; // max length 14 chars
/**
* Verify that the SmsCbMessage has the correct values for CDMA.
* @param cbMessage the message to test
*/
private static void verifyCbValues(SmsCbMessage cbMessage) {
assertEquals(SmsCbMessage.MESSAGE_FORMAT_3GPP2, cbMessage.getMessageFormat());
assertEquals(SmsCbMessage.GEOGRAPHICAL_SCOPE_PLMN_WIDE, cbMessage.getGeographicalScope());
assertEquals(false, cbMessage.isEtwsMessage()); // ETWS on CDMA not currently supported
}
private static void doTestNonEmergencyBroadcast(int encoding) throws Exception {
SmsMessage msg = createBroadcastSmsMessage(123, 456, BearerData.PRIORITY_NORMAL,
BearerData.LANGUAGE_ENGLISH, encoding, TEST_TEXT);
SmsCbMessage cbMessage = msg.parseBroadcastSms();
verifyCbValues(cbMessage);
assertEquals(123, cbMessage.getServiceCategory());
assertEquals(456, cbMessage.getSerialNumber());
assertEquals(SmsCbMessage.MESSAGE_PRIORITY_NORMAL, cbMessage.getMessagePriority());
assertEquals("en", cbMessage.getLanguageCode());
assertEquals(TEST_TEXT, cbMessage.getMessageBody());
assertEquals(false, cbMessage.isEmergencyMessage());
assertEquals(false, cbMessage.isCmasMessage());
}
public void testNonEmergencyBroadcast7bitAscii() throws Exception {
doTestNonEmergencyBroadcast(UserData.ENCODING_7BIT_ASCII);
}
public void testNonEmergencyBroadcast7bitGsm() throws Exception {
doTestNonEmergencyBroadcast(UserData.ENCODING_GSM_7BIT_ALPHABET);
}
public void testNonEmergencyBroadcast16bitUnicode() throws Exception {
doTestNonEmergencyBroadcast(UserData.ENCODING_UNICODE_16);
}
public void testNonEmergencyBroadcastIs91Extended() throws Exception {
// IS-91 doesn't support language or priority subparameters, max 14 chars text
SmsMessage msg = createBroadcastSmsMessage(987, 654, -1, -1,
UserData.ENCODING_IS91_EXTENDED_PROTOCOL, IS91_TEXT);
SmsCbMessage cbMessage = msg.parseBroadcastSms();
verifyCbValues(cbMessage);
assertEquals(987, cbMessage.getServiceCategory());
assertEquals(654, cbMessage.getSerialNumber());
assertEquals(SmsCbMessage.MESSAGE_PRIORITY_NORMAL, cbMessage.getMessagePriority());
assertEquals(null, cbMessage.getLanguageCode());
assertEquals(IS91_TEXT, cbMessage.getMessageBody());
assertEquals(false, cbMessage.isEmergencyMessage());
assertEquals(false, cbMessage.isCmasMessage());
}
private static void doTestCmasBroadcast(int serviceCategory, int messageClass, String body)
throws Exception {
SmsMessage msg = createCmasSmsMessage(
serviceCategory, 1234, BearerData.PRIORITY_EMERGENCY, BearerData.LANGUAGE_ENGLISH,
UserData.ENCODING_7BIT_ASCII, body, -1, -1, -1, -1, -1);
SmsCbMessage cbMessage = msg.parseBroadcastSms();
verifyCbValues(cbMessage);
assertEquals(serviceCategory, cbMessage.getServiceCategory());
assertEquals(1234, cbMessage.getSerialNumber());
assertEquals(SmsCbMessage.MESSAGE_PRIORITY_EMERGENCY, cbMessage.getMessagePriority());
assertEquals("en", cbMessage.getLanguageCode());
assertEquals(body, cbMessage.getMessageBody());
assertEquals(true, cbMessage.isEmergencyMessage());
assertEquals(true, cbMessage.isCmasMessage());
SmsCbCmasInfo cmasInfo = cbMessage.getCmasWarningInfo();
assertEquals(messageClass, cmasInfo.getMessageClass());
assertEquals(SmsCbCmasInfo.CMAS_CATEGORY_UNKNOWN, cmasInfo.getCategory());
assertEquals(SmsCbCmasInfo.CMAS_RESPONSE_TYPE_UNKNOWN, cmasInfo.getResponseType());
assertEquals(SmsCbCmasInfo.CMAS_SEVERITY_UNKNOWN, cmasInfo.getSeverity());
assertEquals(SmsCbCmasInfo.CMAS_URGENCY_UNKNOWN, cmasInfo.getUrgency());
assertEquals(SmsCbCmasInfo.CMAS_CERTAINTY_UNKNOWN, cmasInfo.getCertainty());
}
public void testCmasPresidentialAlert() throws Exception {
doTestCmasBroadcast(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT,
SmsCbCmasInfo.CMAS_CLASS_PRESIDENTIAL_LEVEL_ALERT, PRES_ALERT);
}
public void testCmasExtremeAlert() throws Exception {
doTestCmasBroadcast(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT,
SmsCbCmasInfo.CMAS_CLASS_EXTREME_THREAT, EXTREME_ALERT);
}
public void testCmasSevereAlert() throws Exception {
doTestCmasBroadcast(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT,
SmsCbCmasInfo.CMAS_CLASS_SEVERE_THREAT, SEVERE_ALERT);
}
public void testCmasAmberAlert() throws Exception {
doTestCmasBroadcast(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY,
SmsCbCmasInfo.CMAS_CLASS_CHILD_ABDUCTION_EMERGENCY, AMBER_ALERT);
}
public void testCmasTestMessage() throws Exception {
doTestCmasBroadcast(SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE,
SmsCbCmasInfo.CMAS_CLASS_REQUIRED_MONTHLY_TEST, MONTHLY_TEST_ALERT);
}
public void testCmasExtremeAlertType1Elements() throws Exception {
SmsMessage msg = createCmasSmsMessage(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT,
5678, BearerData.PRIORITY_EMERGENCY, BearerData.LANGUAGE_ENGLISH,
UserData.ENCODING_7BIT_ASCII, EXTREME_ALERT, SmsCbCmasInfo.CMAS_CATEGORY_ENV,
SmsCbCmasInfo.CMAS_RESPONSE_TYPE_MONITOR, SmsCbCmasInfo.CMAS_SEVERITY_SEVERE,
SmsCbCmasInfo.CMAS_URGENCY_EXPECTED, SmsCbCmasInfo.CMAS_CERTAINTY_LIKELY);
SmsCbMessage cbMessage = msg.parseBroadcastSms();
verifyCbValues(cbMessage);
assertEquals(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT,
cbMessage.getServiceCategory());
assertEquals(5678, cbMessage.getSerialNumber());
assertEquals(SmsCbMessage.MESSAGE_PRIORITY_EMERGENCY, cbMessage.getMessagePriority());
assertEquals("en", cbMessage.getLanguageCode());
assertEquals(EXTREME_ALERT, cbMessage.getMessageBody());
assertEquals(true, cbMessage.isEmergencyMessage());
assertEquals(true, cbMessage.isCmasMessage());
SmsCbCmasInfo cmasInfo = cbMessage.getCmasWarningInfo();
assertEquals(SmsCbCmasInfo.CMAS_CLASS_EXTREME_THREAT, cmasInfo.getMessageClass());
assertEquals(SmsCbCmasInfo.CMAS_CATEGORY_ENV, cmasInfo.getCategory());
assertEquals(SmsCbCmasInfo.CMAS_RESPONSE_TYPE_MONITOR, cmasInfo.getResponseType());
assertEquals(SmsCbCmasInfo.CMAS_SEVERITY_SEVERE, cmasInfo.getSeverity());
assertEquals(SmsCbCmasInfo.CMAS_URGENCY_EXPECTED, cmasInfo.getUrgency());
assertEquals(SmsCbCmasInfo.CMAS_CERTAINTY_LIKELY, cmasInfo.getCertainty());
}
// VZW requirement is to discard message with unsupported charset. Verify that we return null
// for this unsupported character set.
public void testCmasUnsupportedCharSet() throws Exception {
SmsMessage msg = createCmasSmsMessage(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT,
12345, BearerData.PRIORITY_EMERGENCY, BearerData.LANGUAGE_ENGLISH,
UserData.ENCODING_GSM_DCS, EXTREME_ALERT, -1, -1, -1, -1, -1);
SmsCbMessage cbMessage = msg.parseBroadcastSms();
assertNull("expected null for unsupported charset", cbMessage);
}
// VZW requirement is to discard message with unsupported charset. Verify that we return null
// for this unsupported character set.
public void testCmasUnsupportedCharSet2() throws Exception {
SmsMessage msg = createCmasSmsMessage(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT,
67890, BearerData.PRIORITY_EMERGENCY, BearerData.LANGUAGE_ENGLISH,
UserData.ENCODING_KOREAN, EXTREME_ALERT, -1, -1, -1, -1, -1);
SmsCbMessage cbMessage = msg.parseBroadcastSms();
assertNull("expected null for unsupported charset", cbMessage);
}
// VZW requirement is to discard message without record type 0. The framework will decode it
// and the app will discard it.
public void testCmasNoRecordType0() throws Exception {
SmsMessage msg = createCmasSmsMessage(
SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT, 1234,
BearerData.PRIORITY_EMERGENCY, BearerData.LANGUAGE_ENGLISH,
UserData.ENCODING_7BIT_ASCII, null, -1, -1, -1, -1, -1);
SmsCbMessage cbMessage = msg.parseBroadcastSms();
verifyCbValues(cbMessage);
assertEquals(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT,
cbMessage.getServiceCategory());
assertEquals(1234, cbMessage.getSerialNumber());
assertEquals(SmsCbMessage.MESSAGE_PRIORITY_EMERGENCY, cbMessage.getMessagePriority());
assertEquals("en", cbMessage.getLanguageCode());
assertEquals(null, cbMessage.getMessageBody());
assertEquals(true, cbMessage.isEmergencyMessage());
assertEquals(true, cbMessage.isCmasMessage());
SmsCbCmasInfo cmasInfo = cbMessage.getCmasWarningInfo();
assertEquals(SmsCbCmasInfo.CMAS_CLASS_PRESIDENTIAL_LEVEL_ALERT, cmasInfo.getMessageClass());
assertEquals(SmsCbCmasInfo.CMAS_CATEGORY_UNKNOWN, cmasInfo.getCategory());
assertEquals(SmsCbCmasInfo.CMAS_RESPONSE_TYPE_UNKNOWN, cmasInfo.getResponseType());
assertEquals(SmsCbCmasInfo.CMAS_SEVERITY_UNKNOWN, cmasInfo.getSeverity());
assertEquals(SmsCbCmasInfo.CMAS_URGENCY_UNKNOWN, cmasInfo.getUrgency());
assertEquals(SmsCbCmasInfo.CMAS_CERTAINTY_UNKNOWN, cmasInfo.getCertainty());
}
// Make sure we don't throw an exception if we feed completely random data to BearerStream.
public void testRandomBearerStreamData() {
Random r = new Random(54321);
for (int run = 0; run < 1000; run++) {
int len = r.nextInt(140);
byte[] data = new byte[len];
for (int i = 0; i < len; i++) {
data[i] = (byte) r.nextInt(256);
}
// Rlog.d("CdmaSmsCbTest", "trying random bearer data run " + run + " length " + len);
try {
int category = 0x0ff0 + r.nextInt(32); // half CMAS, half non-CMAS
Parcel p = createBroadcastParcel(category);
SmsMessage msg = createMessageFromParcel(p, data);
SmsCbMessage cbMessage = msg.parseBroadcastSms();
// with random input, cbMessage will almost always be null (log when it isn't)
if (cbMessage != null) {
Rlog.d("CdmaSmsCbTest", "success: " + cbMessage);
}
} catch (Exception e) {
Rlog.d("CdmaSmsCbTest", "exception thrown", e);
fail("Exception in decoder at run " + run + " length " + len + ": " + e);
}
}
}
// Make sure we don't throw an exception if we put random data in the UserData subparam.
public void testRandomUserData() {
Random r = new Random(94040);
for (int run = 0; run < 1000; run++) {
int category = 0x0ff0 + r.nextInt(32); // half CMAS, half non-CMAS
Parcel p = createBroadcastParcel(category);
int len = r.nextInt(140);
// Rlog.d("CdmaSmsCbTest", "trying random user data run " + run + " length " + len);
try {
BitwiseOutputStream bos = createBearerDataStream(r.nextInt(65536), r.nextInt(4),
r.nextInt(256));
bos.write(8, SUBPARAM_USER_DATA);
bos.write(8, len);
for (int i = 0; i < len; i++) {
bos.write(8, r.nextInt(256));
}
SmsMessage msg = createMessageFromParcel(p, bos.toByteArray());
SmsCbMessage cbMessage = msg.parseBroadcastSms();
} catch (Exception e) {
Rlog.d("CdmaSmsCbTest", "exception thrown", e);
fail("Exception in decoder at run " + run + " length " + len + ": " + e);
}
}
}
/**
* Initialize a Parcel for incoming Service Category Program Data teleservice. The caller will
* write the bearer data and then convert it to an SmsMessage.
* @return the initialized Parcel
*/
private static Parcel createServiceCategoryProgramDataParcel() {
Parcel p = Parcel.obtain();
p.writeInt(SmsEnvelope.TELESERVICE_SCPT);
p.writeByte((byte) 0); // non-zero for MESSAGE_TYPE_BROADCAST
p.writeInt(0);
// dummy address (RIL may generate a different dummy address for broadcasts)
p.writeInt(CdmaSmsAddress.DIGIT_MODE_4BIT_DTMF); // sAddress.digit_mode
p.writeInt(CdmaSmsAddress.NUMBER_MODE_NOT_DATA_NETWORK); // sAddress.number_mode
p.writeInt(CdmaSmsAddress.TON_UNKNOWN); // sAddress.number_type
p.writeInt(CdmaSmsAddress.NUMBERING_PLAN_ISDN_TELEPHONY); // sAddress.number_plan
p.writeByte((byte) 0); // sAddress.number_of_digits
p.writeInt((byte) 0); // sSubAddress.subaddressType
p.writeByte((byte) 0); // sSubAddress.odd
p.writeByte((byte) 0); // sSubAddress.number_of_digits
return p;
}
private static final String CAT_EXTREME_THREAT = "Extreme Threat to Life and Property";
private static final String CAT_SEVERE_THREAT = "Severe Threat to Life and Property";
private static final String CAT_AMBER_ALERTS = "AMBER Alerts";
public void testServiceCategoryProgramDataAddCategory() throws Exception {
Parcel p = createServiceCategoryProgramDataParcel();
BitwiseOutputStream bos = createBearerDataStream(123, -1, -1);
int categoryNameLength = CAT_EXTREME_THREAT.length();
int subparamLengthBits = (53 + (categoryNameLength * 7));
int subparamLengthBytes = (subparamLengthBits + 7) / 8;
int subparamPadBits = (subparamLengthBytes * 8) - subparamLengthBits;
bos.write(8, SUBPARAM_SERVICE_CATEGORY_PROGRAM_DATA);
bos.write(8, subparamLengthBytes);
bos.write(5, UserData.ENCODING_7BIT_ASCII);
bos.write(4, CdmaSmsCbProgramData.OPERATION_ADD_CATEGORY);
bos.write(8, (SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT >>> 8));
bos.write(8, (SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT & 0xff));
bos.write(8, BearerData.LANGUAGE_ENGLISH);
bos.write(8, 100); // max messages
bos.write(4, CdmaSmsCbProgramData.ALERT_OPTION_DEFAULT_ALERT);
bos.write(8, categoryNameLength);
for (int i = 0; i < categoryNameLength; i++) {
bos.write(7, CAT_EXTREME_THREAT.charAt(i));
}
bos.write(subparamPadBits, 0);
SmsMessage msg = createMessageFromParcel(p, bos.toByteArray());
assertNotNull(msg);
msg.parseSms();
List<CdmaSmsCbProgramData> programDataList = msg.getSmsCbProgramData();
assertNotNull(programDataList);
assertEquals(1, programDataList.size());
CdmaSmsCbProgramData programData = programDataList.get(0);
assertEquals(CdmaSmsCbProgramData.OPERATION_ADD_CATEGORY, programData.getOperation());
assertEquals(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT, programData.getCategory());
assertEquals(CAT_EXTREME_THREAT, programData.getCategoryName());
assertEquals(BearerData.LANGUAGE_ENGLISH, programData.getLanguage());
assertEquals(100, programData.getMaxMessages());
assertEquals(CdmaSmsCbProgramData.ALERT_OPTION_DEFAULT_ALERT, programData.getAlertOption());
}
public void testServiceCategoryProgramDataDeleteTwoCategories() throws Exception {
Parcel p = createServiceCategoryProgramDataParcel();
BitwiseOutputStream bos = createBearerDataStream(456, -1, -1);
int category1NameLength = CAT_SEVERE_THREAT.length();
int category2NameLength = CAT_AMBER_ALERTS.length();
int subparamLengthBits = (101 + (category1NameLength * 7) + (category2NameLength * 7));
int subparamLengthBytes = (subparamLengthBits + 7) / 8;
int subparamPadBits = (subparamLengthBytes * 8) - subparamLengthBits;
bos.write(8, SUBPARAM_SERVICE_CATEGORY_PROGRAM_DATA);
bos.write(8, subparamLengthBytes);
bos.write(5, UserData.ENCODING_7BIT_ASCII);
bos.write(4, CdmaSmsCbProgramData.OPERATION_DELETE_CATEGORY);
bos.write(8, (SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT >>> 8));
bos.write(8, (SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT & 0xff));
bos.write(8, BearerData.LANGUAGE_ENGLISH);
bos.write(8, 0); // max messages
bos.write(4, CdmaSmsCbProgramData.ALERT_OPTION_NO_ALERT);
bos.write(8, category1NameLength);
for (int i = 0; i < category1NameLength; i++) {
bos.write(7, CAT_SEVERE_THREAT.charAt(i));
}
bos.write(4, CdmaSmsCbProgramData.OPERATION_DELETE_CATEGORY);
bos.write(8, (SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY >>> 8));
bos.write(8, (SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY & 0xff));
bos.write(8, BearerData.LANGUAGE_ENGLISH);
bos.write(8, 0); // max messages
bos.write(4, CdmaSmsCbProgramData.ALERT_OPTION_NO_ALERT);
bos.write(8, category2NameLength);
for (int i = 0; i < category2NameLength; i++) {
bos.write(7, CAT_AMBER_ALERTS.charAt(i));
}
bos.write(subparamPadBits, 0);
SmsMessage msg = createMessageFromParcel(p, bos.toByteArray());
assertNotNull(msg);
msg.parseSms();
List<CdmaSmsCbProgramData> programDataList = msg.getSmsCbProgramData();
assertNotNull(programDataList);
assertEquals(2, programDataList.size());
CdmaSmsCbProgramData programData = programDataList.get(0);
assertEquals(CdmaSmsCbProgramData.OPERATION_DELETE_CATEGORY, programData.getOperation());
assertEquals(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT, programData.getCategory());
assertEquals(CAT_SEVERE_THREAT, programData.getCategoryName());
assertEquals(BearerData.LANGUAGE_ENGLISH, programData.getLanguage());
assertEquals(0, programData.getMaxMessages());
assertEquals(CdmaSmsCbProgramData.ALERT_OPTION_NO_ALERT, programData.getAlertOption());
programData = programDataList.get(1);
assertEquals(CdmaSmsCbProgramData.OPERATION_DELETE_CATEGORY, programData.getOperation());
assertEquals(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY,
programData.getCategory());
assertEquals(CAT_AMBER_ALERTS, programData.getCategoryName());
assertEquals(BearerData.LANGUAGE_ENGLISH, programData.getLanguage());
assertEquals(0, programData.getMaxMessages());
assertEquals(CdmaSmsCbProgramData.ALERT_OPTION_NO_ALERT, programData.getAlertOption());
}
private static final byte[] CMAS_TEST_BEARER_DATA = {
0x00, 0x03, 0x1C, 0x78, 0x00, 0x01, 0x59, 0x02, (byte) 0xB8, 0x00, 0x02, 0x10, (byte) 0xAA,
0x68, (byte) 0xD3, (byte) 0xCD, 0x06, (byte) 0x9E, 0x68, 0x30, (byte) 0xA0, (byte) 0xE9,
(byte) 0x97, (byte) 0x9F, 0x44, 0x1B, (byte) 0xF3, 0x20, (byte) 0xE9, (byte) 0xA3,
0x2A, 0x08, 0x7B, (byte) 0xF6, (byte) 0xED, (byte) 0xCB, (byte) 0xCB, 0x1E, (byte) 0x9C,
0x3B, 0x10, 0x4D, (byte) 0xDF, (byte) 0x8B, 0x4E,
(byte) 0xCC, (byte) 0xA8, 0x20, (byte) 0xEC, (byte) 0xCB, (byte) 0xCB, (byte) 0xA2, 0x0A,
0x7E, 0x79, (byte) 0xF4, (byte) 0xCB, (byte) 0xB5, 0x72, 0x0A, (byte) 0x9A, 0x34,
(byte) 0xF3, 0x41, (byte) 0xA7, (byte) 0x9A, 0x0D, (byte) 0xFB, (byte) 0xB6, 0x79, 0x41,
(byte) 0x85, 0x07, 0x4C, (byte) 0xBC, (byte) 0xFA, 0x2E, 0x00, 0x08, 0x20, 0x58, 0x38,
(byte) 0x88, (byte) 0x80, 0x10, 0x54, 0x06, 0x38, 0x20, 0x60,
0x30, (byte) 0xA8, (byte) 0x81, (byte) 0x90, 0x20, 0x08
};
// Test case for CMAS test message received on the Sprint network.
public void testDecodeRawBearerData() throws Exception {
Parcel p = createBroadcastParcel(SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE);
SmsMessage msg = createMessageFromParcel(p, CMAS_TEST_BEARER_DATA);
SmsCbMessage cbMessage = msg.parseBroadcastSms();
assertNotNull("expected non-null for bearer data", cbMessage);
assertEquals("geoScope", cbMessage.getGeographicalScope(), 1);
assertEquals("serialNumber", cbMessage.getSerialNumber(), 51072);
assertEquals("serviceCategory", cbMessage.getServiceCategory(),
SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE);
assertEquals("payload", cbMessage.getMessageBody(),
"This is a test of the Commercial Mobile Alert System. This is only a test.");
SmsCbCmasInfo cmasInfo = cbMessage.getCmasWarningInfo();
assertNotNull("expected non-null for CMAS info", cmasInfo);
assertEquals("category", cmasInfo.getCategory(), SmsCbCmasInfo.CMAS_CATEGORY_OTHER);
assertEquals("responseType", cmasInfo.getResponseType(),
SmsCbCmasInfo.CMAS_RESPONSE_TYPE_NONE);
assertEquals("severity", cmasInfo.getSeverity(), SmsCbCmasInfo.CMAS_SEVERITY_SEVERE);
assertEquals("urgency", cmasInfo.getUrgency(), SmsCbCmasInfo.CMAS_URGENCY_EXPECTED);
assertEquals("certainty", cmasInfo.getCertainty(), SmsCbCmasInfo.CMAS_CERTAINTY_LIKELY);
}
}
|
