/*
* Copyright (C) 2010 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 android.telephony;
import android.text.format.Time;
import android.util.Log;
import com.android.internal.telephony.GsmAlphabet;
import com.android.internal.telephony.IccUtils;
import com.android.internal.telephony.gsm.SmsCbHeader;
import java.io.UnsupportedEncodingException;
/**
* Describes an SMS-CB message.
*
* {@hide}
*/
public class SmsCbMessage {
/**
* Cell wide immediate geographical scope
*/
public static final int GEOGRAPHICAL_SCOPE_CELL_WIDE_IMMEDIATE = 0;
/**
* PLMN wide geographical scope
*/
public static final int GEOGRAPHICAL_SCOPE_PLMN_WIDE = 1;
/**
* Location / service area wide geographical scope
*/
public static final int GEOGRAPHICAL_SCOPE_LA_WIDE = 2;
/**
* Cell wide geographical scope
*/
public static final int GEOGRAPHICAL_SCOPE_CELL_WIDE = 3;
/**
* Create an instance of this class from a received PDU
*
* @param pdu PDU bytes
* @return An instance of this class, or null if invalid pdu
*/
public static SmsCbMessage createFromPdu(byte[] pdu) {
try {
return new SmsCbMessage(pdu);
} catch (IllegalArgumentException e) {
Log.w(LOG_TAG, "Failed parsing SMS-CB pdu", e);
return null;
}
}
private static final String LOG_TAG = "SMSCB";
/**
* Languages in the 0000xxxx DCS group as defined in 3GPP TS 23.038, section 5.
*/
private static final String[] LANGUAGE_CODES_GROUP_0 = {
"de", "en", "it", "fr", "es", "nl", "sv", "da", "pt", "fi", "no", "el", "tr", "hu",
"pl", null
};
/**
* Languages in the 0010xxxx DCS group as defined in 3GPP TS 23.038, section 5.
*/
private static final String[] LANGUAGE_CODES_GROUP_2 = {
"cs", "he", "ar", "ru", "is", null, null, null, null, null, null, null, null, null,
null, null
};
private static final char CARRIAGE_RETURN = 0x0d;
private static final int PDU_BODY_PAGE_LENGTH = 82;
private SmsCbHeader mHeader;
private String mLanguage;
private String mBody;
/** Timestamp of ETWS primary notification with security. */
private long mPrimaryNotificationTimestamp;
/** 43 byte digital signature of ETWS primary notification with security. */
private byte[] mPrimaryNotificationDigitalSignature;
private SmsCbMessage(byte[] pdu) throws IllegalArgumentException {
mHeader = new SmsCbHeader(pdu);
if (mHeader.format == SmsCbHeader.FORMAT_ETWS_PRIMARY) {
mBody = "ETWS";
// ETWS primary notification with security is 56 octets in length
if (pdu.length >= SmsCbHeader.PDU_LENGTH_ETWS) {
mPrimaryNotificationTimestamp = getTimestampMillis(pdu);
mPrimaryNotificationDigitalSignature = new byte[43];
// digital signature starts after 6 byte header and 7 byte timestamp
System.arraycopy(pdu, 13, mPrimaryNotificationDigitalSignature, 0, 43);
}
} else {
parseBody(pdu);
}
}
/**
* Return the geographical scope of this message, one of
* {@link #GEOGRAPHICAL_SCOPE_CELL_WIDE_IMMEDIATE},
* {@link #GEOGRAPHICAL_SCOPE_PLMN_WIDE},
* {@link #GEOGRAPHICAL_SCOPE_LA_WIDE},
* {@link #GEOGRAPHICAL_SCOPE_CELL_WIDE}
*
* @return Geographical scope
*/
public int getGeographicalScope() {
return mHeader.geographicalScope;
}
/**
* Get the ISO-639-1 language code for this message, or null if unspecified
*
* @return Language code
*/
public String getLanguageCode() {
return mLanguage;
}
/**
* Get the body of this message, or null if no body available
*
* @return Body, or null
*/
public String getMessageBody() {
return mBody;
}
/**
* Get the message identifier of this message (0-65535)
*
* @return Message identifier
*/
public int getMessageIdentifier() {
return mHeader.messageIdentifier;
}
/**
* Get the message code of this message (0-1023)
*
* @return Message code
*/
public int getMessageCode() {
return mHeader.messageCode;
}
/**
* Get the update number of this message (0-15)
*
* @return Update number
*/
public int getUpdateNumber() {
return mHeader.updateNumber;
}
/**
* Get the format of this message.
* @return {@link SmsCbHeader#FORMAT_GSM}, {@link SmsCbHeader#FORMAT_UMTS}, or
* {@link SmsCbHeader#FORMAT_ETWS_PRIMARY}
*/
public int getMessageFormat() {
return mHeader.format;
}
/**
* For ETWS primary notifications, return the emergency user alert flag.
* @return true to notify terminal to activate emergency user alert; false otherwise
*/
public boolean getEtwsEmergencyUserAlert() {
return mHeader.etwsEmergencyUserAlert;
}
/**
* For ETWS primary notifications, return the popup flag.
* @return true to notify terminal to activate display popup; false otherwise
*/
public boolean getEtwsPopup() {
return mHeader.etwsPopup;
}
/**
* For ETWS primary notifications, return the warning type.
* @return a value such as {@link SmsCbConstants#ETWS_WARNING_TYPE_EARTHQUAKE}
*/
public int getEtwsWarningType() {
return mHeader.etwsWarningType;
}
/**
* For ETWS primary notifications, return the Warning-Security-Information timestamp.
* @return a timestamp in System.currentTimeMillis() format.
*/
public long getEtwsSecurityTimestamp() {
return mPrimaryNotificationTimestamp;
}
/**
* For ETWS primary notifications, return the 43 byte digital signature.
* @return a byte array containing a copy of the digital signature
*/
public byte[] getEtwsSecuritySignature() {
return mPrimaryNotificationDigitalSignature.clone();
}
/**
* Parse and unpack the body text according to the encoding in the DCS.
* After completing successfully this method will have assigned the body
* text into mBody, and optionally the language code into mLanguage
*
* @param pdu The pdu
*/
private void parseBody(byte[] pdu) {
int encoding;
boolean hasLanguageIndicator = false;
// Extract encoding and language from DCS, as defined in 3gpp TS 23.038,
// section 5.
switch ((mHeader.dataCodingScheme & 0xf0) >> 4) {
case 0x00:
encoding = SmsMessage.ENCODING_7BIT;
mLanguage = LANGUAGE_CODES_GROUP_0[mHeader.dataCodingScheme & 0x0f];
break;
case 0x01:
hasLanguageIndicator = true;
if ((mHeader.dataCodingScheme & 0x0f) == 0x01) {
encoding = SmsMessage.ENCODING_16BIT;
} else {
encoding = SmsMessage.ENCODING_7BIT;
}
break;
case 0x02:
encoding = SmsMessage.ENCODING_7BIT;
mLanguage = LANGUAGE_CODES_GROUP_2[mHeader.dataCodingScheme & 0x0f];
break;
case 0x03:
encoding = SmsMessage.ENCODING_7BIT;
break;
case 0x04:
case 0x05:
switch ((mHeader.dataCodingScheme & 0x0c) >> 2) {
case 0x01:
encoding = SmsMessage.ENCODING_8BIT;
break;
case 0x02:
encoding = SmsMessage.ENCODING_16BIT;
break;
case 0x00:
default:
encoding = SmsMessage.ENCODING_7BIT;
break;
}
break;
case 0x06:
case 0x07:
// Compression not supported
case 0x09:
// UDH structure not supported
case 0x0e:
// Defined by the WAP forum not supported
encoding = SmsMessage.ENCODING_UNKNOWN;
break;
case 0x0f:
if (((mHeader.dataCodingScheme & 0x04) >> 2) == 0x01) {
encoding = SmsMessage.ENCODING_8BIT;
} else {
encoding = SmsMessage.ENCODING_7BIT;
}
break;
default:
// Reserved values are to be treated as 7-bit
encoding = SmsMessage.ENCODING_7BIT;
break;
}
if (mHeader.format == SmsCbHeader.FORMAT_UMTS) {
// Payload may contain multiple pages
int nrPages = pdu[SmsCbHeader.PDU_HEADER_LENGTH];
if (pdu.length < SmsCbHeader.PDU_HEADER_LENGTH + 1 + (PDU_BODY_PAGE_LENGTH + 1)
* nrPages) {
throw new IllegalArgumentException("Pdu length " + pdu.length + " does not match "
+ nrPages + " pages");
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < nrPages; i++) {
// Each page is 82 bytes followed by a length octet indicating
// the number of useful octets within those 82
int offset = SmsCbHeader.PDU_HEADER_LENGTH + 1 + (PDU_BODY_PAGE_LENGTH + 1) * i;
int length = pdu[offset + PDU_BODY_PAGE_LENGTH];
if (length > PDU_BODY_PAGE_LENGTH) {
throw new IllegalArgumentException("Page length " + length
+ " exceeds maximum value " + PDU_BODY_PAGE_LENGTH);
}
sb.append(unpackBody(pdu, encoding, offset, length, hasLanguageIndicator));
}
mBody = sb.toString();
} else {
// Payload is one single page
int offset = SmsCbHeader.PDU_HEADER_LENGTH;
int length = pdu.length - offset;
mBody = unpackBody(pdu, encoding, offset, length, hasLanguageIndicator);
}
}
/**
* Unpack body text from the pdu using the given encoding, position and
* length within the pdu
*
* @param pdu The pdu
* @param encoding The encoding, as derived from the DCS
* @param offset Position of the first byte to unpack
* @param length Number of bytes to unpack
* @param hasLanguageIndicator true if the body text is preceded by a
* language indicator. If so, this method will as a side-effect
* assign the extracted language code into mLanguage
* @return Body text
*/
private String unpackBody(byte[] pdu, int encoding, int offset, int length,
boolean hasLanguageIndicator) {
String body = null;
switch (encoding) {
case SmsMessage.ENCODING_7BIT:
body = GsmAlphabet.gsm7BitPackedToString(pdu, offset, length * 8 / 7);
if (hasLanguageIndicator && body != null && body.length() > 2) {
// Language is two GSM characters followed by a CR.
// The actual body text is offset by 3 characters.
mLanguage = body.substring(0, 2);
body = body.substring(3);
}
break;
case SmsMessage.ENCODING_16BIT:
if (hasLanguageIndicator && pdu.length >= offset + 2) {
// Language is two GSM characters.
// The actual body text is offset by 2 bytes.
mLanguage = GsmAlphabet.gsm7BitPackedToString(pdu, offset, 2);
offset += 2;
length -= 2;
}
try {
body = new String(pdu, offset, (length & 0xfffe), "utf-16");
} catch (UnsupportedEncodingException e) {
// Eeeek
}
break;
default:
break;
}
if (body != null) {
// Remove trailing carriage return
for (int i = body.length() - 1; i >= 0; i--) {
if (body.charAt(i) != CARRIAGE_RETURN) {
body = body.substring(0, i + 1);
break;
}
}
} else {
body = "";
}
return body;
}
/**
* Parses an ETWS primary notification timestamp and returns a currentTimeMillis()-style
* timestamp. Copied from com.android.internal.telephony.gsm.SmsMessage.
* @param pdu the ETWS primary notification PDU to decode
* @return the UTC timestamp from the Warning-Security-Information parameter
*/
private long getTimestampMillis(byte[] pdu) {
// Timestamp starts after CB header, in pdu[6]
int year = IccUtils.gsmBcdByteToInt(pdu[6]);
int month = IccUtils.gsmBcdByteToInt(pdu[7]);
int day = IccUtils.gsmBcdByteToInt(pdu[8]);
int hour = IccUtils.gsmBcdByteToInt(pdu[9]);
int minute = IccUtils.gsmBcdByteToInt(pdu[10]);
int second = IccUtils.gsmBcdByteToInt(pdu[11]);
// For the timezone, the most significant bit of the
// least significant nibble is the sign byte
// (meaning the max range of this field is 79 quarter-hours,
// which is more than enough)
byte tzByte = pdu[12];
// Mask out sign bit.
int timezoneOffset = IccUtils.gsmBcdByteToInt((byte) (tzByte & (~0x08)));
timezoneOffset = ((tzByte & 0x08) == 0) ? timezoneOffset : -timezoneOffset;
Time time = new Time(Time.TIMEZONE_UTC);
// It's 2006. Should I really support years < 2000?
time.year = year >= 90 ? year + 1900 : year + 2000;
time.month = month - 1;
time.monthDay = day;
time.hour = hour;
time.minute = minute;
time.second = second;
// Timezone offset is in quarter hours.
return time.toMillis(true) - (timezoneOffset * 15 * 60 * 1000);
}
/**
* Append text to the message body. This is used to concatenate multi-page GSM broadcasts.
* @param body the text to append to this message
*/
public void appendToBody(String body) {
mBody = mBody + body;
}
@Override
public String toString() {
return "SmsCbMessage{" + mHeader.toString() + ", language=" + mLanguage +
", body=\"" + mBody + "\"}";
}
}