com/android/internal/telephony/gsm/GsmSmsCbMessage.java - platform/prebuilts/fullsdk/sources/android-29 - Git at Google

 /*
  * 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.gsm;

 import static android.telephony.SmsCbEtwsInfo.ETWS_WARNING_TYPE_EARTHQUAKE;
 import static android.telephony.SmsCbEtwsInfo.ETWS_WARNING_TYPE_EARTHQUAKE_AND_TSUNAMI;
 import static android.telephony.SmsCbEtwsInfo.ETWS_WARNING_TYPE_OTHER_EMERGENCY;
 import static android.telephony.SmsCbEtwsInfo.ETWS_WARNING_TYPE_TEST_MESSAGE;
 import static android.telephony.SmsCbEtwsInfo.ETWS_WARNING_TYPE_TSUNAMI;

 import android.content.Context;
 import android.content.res.Resources;
 import android.telephony.SmsCbLocation;
 import android.telephony.SmsCbMessage;
 import android.util.Pair;

 import com.android.internal.R;
 import com.android.internal.telephony.GsmAlphabet;
 import com.android.internal.telephony.SmsConstants;

 import java.io.UnsupportedEncodingException;
 import java.util.Locale;

 /**
  * Parses a GSM or UMTS format SMS-CB message into an {@link SmsCbMessage} object. The class is
  * public because {@link #createSmsCbMessage(SmsCbLocation, byte[][])} is used by some test cases.
  */
 public class GsmSmsCbMessage {

     /**
      * Languages in the 0000xxxx DCS group as defined in 3GPP TS 23.038, section 5.
      */
     private static final String[] LANGUAGE_CODES_GROUP_0 = {
             Locale.GERMAN.getLanguage(),        // German
             Locale.ENGLISH.getLanguage(),       // English
             Locale.ITALIAN.getLanguage(),       // Italian
             Locale.FRENCH.getLanguage(),        // French
             new Locale("es").getLanguage(),     // Spanish
             new Locale("nl").getLanguage(),     // Dutch
             new Locale("sv").getLanguage(),     // Swedish
             new Locale("da").getLanguage(),     // Danish
             new Locale("pt").getLanguage(),     // Portuguese
             new Locale("fi").getLanguage(),     // Finnish
             new Locale("nb").getLanguage(),     // Norwegian
             new Locale("el").getLanguage(),     // Greek
             new Locale("tr").getLanguage(),     // Turkish
             new Locale("hu").getLanguage(),     // Hungarian
             new Locale("pl").getLanguage(),     // Polish
             null
     };

     /**
      * Languages in the 0010xxxx DCS group as defined in 3GPP TS 23.038, section 5.
      */
     private static final String[] LANGUAGE_CODES_GROUP_2 = {
             new Locale("cs").getLanguage(),     // Czech
             new Locale("he").getLanguage(),     // Hebrew
             new Locale("ar").getLanguage(),     // Arabic
             new Locale("ru").getLanguage(),     // Russian
             new Locale("is").getLanguage(),     // Icelandic
             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;

     /** Utility class with only static methods. */
     private GsmSmsCbMessage() { }

     /**
      * Get built-in ETWS primary messages by category. ETWS primary message does not contain text,
      * so we have to show the pre-built messages to the user.
      *
      * @param context Device context
      * @param category ETWS message category defined in SmsCbConstants
      * @return ETWS text message in string. Return an empty string if no match.
      */
     private static String getEtwsPrimaryMessage(Context context, int category) {
         final Resources r = context.getResources();
         switch (category) {
             case ETWS_WARNING_TYPE_EARTHQUAKE:
                 return r.getString(R.string.etws_primary_default_message_earthquake);
             case ETWS_WARNING_TYPE_TSUNAMI:
                 return r.getString(R.string.etws_primary_default_message_tsunami);
             case ETWS_WARNING_TYPE_EARTHQUAKE_AND_TSUNAMI:
                 return r.getString(R.string.etws_primary_default_message_earthquake_and_tsunami);
             case ETWS_WARNING_TYPE_TEST_MESSAGE:
                 return r.getString(R.string.etws_primary_default_message_test);
             case ETWS_WARNING_TYPE_OTHER_EMERGENCY:
                 return r.getString(R.string.etws_primary_default_message_others);
             default:
                 return "";
         }
     }

     /**
      * Create a new SmsCbMessage object from a header object plus one or more received PDUs.
      *
      * @param pdus PDU bytes
      */
     public static SmsCbMessage createSmsCbMessage(Context context, SmsCbHeader header,
                                                   SmsCbLocation location, byte[][] pdus)
             throws IllegalArgumentException {
         if (header.isEtwsPrimaryNotification()) {
             // ETSI TS 23.041 ETWS Primary Notification message
             // ETWS primary message only contains 4 fields including serial number,
             // message identifier, warning type, and warning security information.
             // There is no field for the content/text so we get the text from the resources.
             return new SmsCbMessage(SmsCbMessage.MESSAGE_FORMAT_3GPP, header.getGeographicalScope(),
                     header.getSerialNumber(), location, header.getServiceCategory(), null,
                     getEtwsPrimaryMessage(context, header.getEtwsInfo().getWarningType()),
                     SmsCbMessage.MESSAGE_PRIORITY_EMERGENCY, header.getEtwsInfo(),
                     header.getCmasInfo());
         } else {
             String language = null;
             StringBuilder sb = new StringBuilder();
             for (byte[] pdu : pdus) {
                 Pair<String, String> p = parseBody(header, pdu);
                 language = p.first;
                 sb.append(p.second);
             }
             int priority = header.isEmergencyMessage() ? SmsCbMessage.MESSAGE_PRIORITY_EMERGENCY
                     : SmsCbMessage.MESSAGE_PRIORITY_NORMAL;

             return new SmsCbMessage(SmsCbMessage.MESSAGE_FORMAT_3GPP,
                     header.getGeographicalScope(), header.getSerialNumber(), location,
                     header.getServiceCategory(), language, sb.toString(), priority,
                     header.getEtwsInfo(), header.getCmasInfo());
         }
     }

     /**
      * 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 header the message header to use
      * @param pdu the PDU to decode
      * @return a Pair of Strings containing the language and body of the message
      */
     private static Pair<String, String> parseBody(SmsCbHeader header, byte[] pdu) {
         int encoding;
         String language = null;
         boolean hasLanguageIndicator = false;
         int dataCodingScheme = header.getDataCodingScheme();

         // Extract encoding and language from DCS, as defined in 3gpp TS 23.038,
         // section 5.
         switch ((dataCodingScheme & 0xf0) >> 4) {
             case 0x00:
                 encoding = SmsConstants.ENCODING_7BIT;
                 language = LANGUAGE_CODES_GROUP_0[dataCodingScheme & 0x0f];
                 break;

             case 0x01:
                 hasLanguageIndicator = true;
                 if ((dataCodingScheme & 0x0f) == 0x01) {
                     encoding = SmsConstants.ENCODING_16BIT;
                 } else {
                     encoding = SmsConstants.ENCODING_7BIT;
                 }
                 break;

             case 0x02:
                 encoding = SmsConstants.ENCODING_7BIT;
                 language = LANGUAGE_CODES_GROUP_2[dataCodingScheme & 0x0f];
                 break;

             case 0x03:
                 encoding = SmsConstants.ENCODING_7BIT;
                 break;

             case 0x04:
             case 0x05:
                 switch ((dataCodingScheme & 0x0c) >> 2) {
                     case 0x01:
                         encoding = SmsConstants.ENCODING_8BIT;
                         break;

                     case 0x02:
                         encoding = SmsConstants.ENCODING_16BIT;
                         break;

                     case 0x00:
                     default:
                         encoding = SmsConstants.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
                 throw new IllegalArgumentException("Unsupported GSM dataCodingScheme "
                         + dataCodingScheme);

             case 0x0f:
                 if (((dataCodingScheme & 0x04) >> 2) == 0x01) {
                     encoding = SmsConstants.ENCODING_8BIT;
                 } else {
                     encoding = SmsConstants.ENCODING_7BIT;
                 }
                 break;

             default:
                 // Reserved values are to be treated as 7-bit
                 encoding = SmsConstants.ENCODING_7BIT;
                 break;
         }

         if (header.isUmtsFormat()) {
             // 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);
                 }

                 Pair<String, String> p = unpackBody(pdu, encoding, offset, length,
                         hasLanguageIndicator, language);
                 language = p.first;
                 sb.append(p.second);
             }
             return new Pair<String, String>(language, sb.toString());
         } else {
             // Payload is one single page
             int offset = SmsCbHeader.PDU_HEADER_LENGTH;
             int length = pdu.length - offset;

             return unpackBody(pdu, encoding, offset, length, hasLanguageIndicator, language);
         }
     }

     /**
      * 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
      * @param language the language to return if hasLanguageIndicator is false
      * @return a Pair of Strings containing the language and body of the message
      */
     private static Pair<String, String> unpackBody(byte[] pdu, int encoding, int offset, int length,
             boolean hasLanguageIndicator, String language) {
         String body = null;

         switch (encoding) {
             case SmsConstants.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.
                     language = body.substring(0, 2);
                     body = body.substring(3);
                 }
                 break;

             case SmsConstants.ENCODING_16BIT:
                 if (hasLanguageIndicator && pdu.length >= offset + 2) {
                     // Language is two GSM characters.
                     // The actual body text is offset by 2 bytes.
                     language = GsmAlphabet.gsm7BitPackedToString(pdu, offset, 2);
                     offset += 2;
                     length -= 2;
                 }

                 try {
                     body = new String(pdu, offset, (length & 0xfffe), "utf-16");
                 } catch (UnsupportedEncodingException e) {
                     // Apparently it wasn't valid UTF-16.
                     throw new IllegalArgumentException("Error decoding UTF-16 message", e);
                 }
                 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 new Pair<String, String>(language, body);
     }
 }
	/*
	* 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.gsm;

	import static android.telephony.SmsCbEtwsInfo.ETWS_WARNING_TYPE_EARTHQUAKE;
	import static android.telephony.SmsCbEtwsInfo.ETWS_WARNING_TYPE_EARTHQUAKE_AND_TSUNAMI;
	import static android.telephony.SmsCbEtwsInfo.ETWS_WARNING_TYPE_OTHER_EMERGENCY;
	import static android.telephony.SmsCbEtwsInfo.ETWS_WARNING_TYPE_TEST_MESSAGE;
	import static android.telephony.SmsCbEtwsInfo.ETWS_WARNING_TYPE_TSUNAMI;

	import android.content.Context;
	import android.content.res.Resources;
	import android.telephony.SmsCbLocation;
	import android.telephony.SmsCbMessage;
	import android.util.Pair;

	import com.android.internal.R;
	import com.android.internal.telephony.GsmAlphabet;
	import com.android.internal.telephony.SmsConstants;

	import java.io.UnsupportedEncodingException;
	import java.util.Locale;

	/**
	* Parses a GSM or UMTS format SMS-CB message into an {@link SmsCbMessage} object. The class is
	* public because {@link #createSmsCbMessage(SmsCbLocation, byte[][])} is used by some test cases.
	*/
	public class GsmSmsCbMessage {

	/**
	* Languages in the 0000xxxx DCS group as defined in 3GPP TS 23.038, section 5.
	*/
	private static final String[] LANGUAGE_CODES_GROUP_0 = {
	Locale.GERMAN.getLanguage(), // German
	Locale.ENGLISH.getLanguage(), // English
	Locale.ITALIAN.getLanguage(), // Italian
	Locale.FRENCH.getLanguage(), // French
	new Locale("es").getLanguage(), // Spanish
	new Locale("nl").getLanguage(), // Dutch
	new Locale("sv").getLanguage(), // Swedish
	new Locale("da").getLanguage(), // Danish
	new Locale("pt").getLanguage(), // Portuguese
	new Locale("fi").getLanguage(), // Finnish
	new Locale("nb").getLanguage(), // Norwegian
	new Locale("el").getLanguage(), // Greek
	new Locale("tr").getLanguage(), // Turkish
	new Locale("hu").getLanguage(), // Hungarian
	new Locale("pl").getLanguage(), // Polish
	null
	};

	/**
	* Languages in the 0010xxxx DCS group as defined in 3GPP TS 23.038, section 5.
	*/
	private static final String[] LANGUAGE_CODES_GROUP_2 = {
	new Locale("cs").getLanguage(), // Czech
	new Locale("he").getLanguage(), // Hebrew
	new Locale("ar").getLanguage(), // Arabic
	new Locale("ru").getLanguage(), // Russian
	new Locale("is").getLanguage(), // Icelandic
	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;

	/** Utility class with only static methods. */
	private GsmSmsCbMessage() { }

	/**
	* Get built-in ETWS primary messages by category. ETWS primary message does not contain text,
	* so we have to show the pre-built messages to the user.
	*
	* @param context Device context
	* @param category ETWS message category defined in SmsCbConstants
	* @return ETWS text message in string. Return an empty string if no match.
	*/
	private static String getEtwsPrimaryMessage(Context context, int category) {
	final Resources r = context.getResources();
	switch (category) {
	case ETWS_WARNING_TYPE_EARTHQUAKE:
	return r.getString(R.string.etws_primary_default_message_earthquake);
	case ETWS_WARNING_TYPE_TSUNAMI:
	return r.getString(R.string.etws_primary_default_message_tsunami);
	case ETWS_WARNING_TYPE_EARTHQUAKE_AND_TSUNAMI:
	return r.getString(R.string.etws_primary_default_message_earthquake_and_tsunami);
	case ETWS_WARNING_TYPE_TEST_MESSAGE:
	return r.getString(R.string.etws_primary_default_message_test);
	case ETWS_WARNING_TYPE_OTHER_EMERGENCY:
	return r.getString(R.string.etws_primary_default_message_others);
	default:
	return "";
	}
	}

	/**
	* Create a new SmsCbMessage object from a header object plus one or more received PDUs.
	*
	* @param pdus PDU bytes
	*/
	public static SmsCbMessage createSmsCbMessage(Context context, SmsCbHeader header,
	SmsCbLocation location, byte[][] pdus)
	throws IllegalArgumentException {
	if (header.isEtwsPrimaryNotification()) {
	// ETSI TS 23.041 ETWS Primary Notification message
	// ETWS primary message only contains 4 fields including serial number,
	// message identifier, warning type, and warning security information.
	// There is no field for the content/text so we get the text from the resources.
	return new SmsCbMessage(SmsCbMessage.MESSAGE_FORMAT_3GPP, header.getGeographicalScope(),
	header.getSerialNumber(), location, header.getServiceCategory(), null,
	getEtwsPrimaryMessage(context, header.getEtwsInfo().getWarningType()),
	SmsCbMessage.MESSAGE_PRIORITY_EMERGENCY, header.getEtwsInfo(),
	header.getCmasInfo());
	} else {
	String language = null;
	StringBuilder sb = new StringBuilder();
	for (byte[] pdu : pdus) {
	Pair<String, String> p = parseBody(header, pdu);
	language = p.first;
	sb.append(p.second);
	}
	int priority = header.isEmergencyMessage() ? SmsCbMessage.MESSAGE_PRIORITY_EMERGENCY
	: SmsCbMessage.MESSAGE_PRIORITY_NORMAL;

	return new SmsCbMessage(SmsCbMessage.MESSAGE_FORMAT_3GPP,
	header.getGeographicalScope(), header.getSerialNumber(), location,
	header.getServiceCategory(), language, sb.toString(), priority,
	header.getEtwsInfo(), header.getCmasInfo());
	}
	}

	/**
	* 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 header the message header to use
	* @param pdu the PDU to decode
	* @return a Pair of Strings containing the language and body of the message
	*/
	private static Pair<String, String> parseBody(SmsCbHeader header, byte[] pdu) {
	int encoding;
	String language = null;
	boolean hasLanguageIndicator = false;
	int dataCodingScheme = header.getDataCodingScheme();

	// Extract encoding and language from DCS, as defined in 3gpp TS 23.038,
	// section 5.
	switch ((dataCodingScheme & 0xf0) >> 4) {
	case 0x00:
	encoding = SmsConstants.ENCODING_7BIT;
	language = LANGUAGE_CODES_GROUP_0[dataCodingScheme & 0x0f];
	break;

	case 0x01:
	hasLanguageIndicator = true;
	if ((dataCodingScheme & 0x0f) == 0x01) {
	encoding = SmsConstants.ENCODING_16BIT;
	} else {
	encoding = SmsConstants.ENCODING_7BIT;
	}
	break;

	case 0x02:
	encoding = SmsConstants.ENCODING_7BIT;
	language = LANGUAGE_CODES_GROUP_2[dataCodingScheme & 0x0f];
	break;

	case 0x03:
	encoding = SmsConstants.ENCODING_7BIT;
	break;

	case 0x04:
	case 0x05:
	switch ((dataCodingScheme & 0x0c) >> 2) {
	case 0x01:
	encoding = SmsConstants.ENCODING_8BIT;
	break;

	case 0x02:
	encoding = SmsConstants.ENCODING_16BIT;
	break;

	case 0x00:
	default:
	encoding = SmsConstants.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
	throw new IllegalArgumentException("Unsupported GSM dataCodingScheme "
	+ dataCodingScheme);

	case 0x0f:
	if (((dataCodingScheme & 0x04) >> 2) == 0x01) {
	encoding = SmsConstants.ENCODING_8BIT;
	} else {
	encoding = SmsConstants.ENCODING_7BIT;
	}
	break;

	default:
	// Reserved values are to be treated as 7-bit
	encoding = SmsConstants.ENCODING_7BIT;
	break;
	}

	if (header.isUmtsFormat()) {
	// 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);
	}

	Pair<String, String> p = unpackBody(pdu, encoding, offset, length,
	hasLanguageIndicator, language);
	language = p.first;
	sb.append(p.second);
	}
	return new Pair<String, String>(language, sb.toString());
	} else {
	// Payload is one single page
	int offset = SmsCbHeader.PDU_HEADER_LENGTH;
	int length = pdu.length - offset;

	return unpackBody(pdu, encoding, offset, length, hasLanguageIndicator, language);
	}
	}

	/**
	* 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
	* @param language the language to return if hasLanguageIndicator is false
	* @return a Pair of Strings containing the language and body of the message
	*/
	private static Pair<String, String> unpackBody(byte[] pdu, int encoding, int offset, int length,
	boolean hasLanguageIndicator, String language) {
	String body = null;

	switch (encoding) {
	case SmsConstants.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.
	language = body.substring(0, 2);
	body = body.substring(3);
	}
	break;

	case SmsConstants.ENCODING_16BIT:
	if (hasLanguageIndicator && pdu.length >= offset + 2) {
	// Language is two GSM characters.
	// The actual body text is offset by 2 bytes.
	language = GsmAlphabet.gsm7BitPackedToString(pdu, offset, 2);
	offset += 2;
	length -= 2;
	}

	try {
	body = new String(pdu, offset, (length & 0xfffe), "utf-16");
	} catch (UnsupportedEncodingException e) {
	// Apparently it wasn't valid UTF-16.
	throw new IllegalArgumentException("Error decoding UTF-16 message", e);
	}
	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 new Pair<String, String>(language, body);
	}
	}