src/com/android/im/imps/PtsPrimitiveParser.java - platform/packages/apps/IM - Git at Google

 /*
  * Copyright (C) 2007 Esmertec AG.
  * Copyright (C) 2007 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.im.imps;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map.Entry;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import com.android.im.imps.Primitive.TransactionMode;

 /**
  * PTS/SMS encoded IMPS messages parser. Only response transactions and
  * server initiated requests are supported.
  */
 public class PtsPrimitiveParser implements PrimitiveParser {

     // WVaaBBcccDD <parameters>
     //   aa - version number; 12 for 1.2, 13 for 1.3; "XX" for version discovery
     //   BB - message type, case insensitive
     //   ccc - transaction id in range 0-999 without preceding zero
     //   DD - multiple SMSes identifier
     private static final Pattern sPreamplePattern =
         Pattern.compile("\\AWV(\\d{2})(\\p{Alpha}{2})(\\d{1,3})(\\p{Alpha}{2})?(\\z| .*)");

     private char mReadBuf[] = new char[256];
     private StringBuilder mStringBuf = new StringBuilder();
     private int mPos;

     private static int UNCERTAIN_GROUP_SIZE = -1;

     public Primitive parse(InputStream in) throws ParserException, IOException {
         // assuming PTS data is always short
         BufferedReader reader = new BufferedReader(
                 new InputStreamReader(in, "UTF-8"), 128);
         mStringBuf.setLength(0);
         mPos = 0;
         int len;
         while ((len = reader.read(mReadBuf)) != -1) {
             mStringBuf.append(mReadBuf, 0, len);
         }
         return parsePrim();
     }

     private Primitive parsePrim() throws ParserException
     {
         Matcher m = sPreamplePattern.matcher(mStringBuf);
         if (!m.matches()) {
             throw new ParserException("Invalid PTS encoded message");
         }

         Primitive p = new Primitive();

         // TODO: handle WV version in m.group(1)

         String type = m.group(2).toUpperCase();
         String transactionType = PtsCodes.getTransaction(type);
         if (transactionType == null) {
             throw new ParserException("Unrecognized transaction code " + type);
         }
         p.setContentElement(transactionType);

         if (PtsCodes.isServerRequestCode(type)) {
             p.setTransactionMode(TransactionMode.Request);
         } else {
             p.setTransactionMode(TransactionMode.Response);
         }

         p.setTransactionId(m.group(3));
         mPos = m.start(5);

         if (mPos < mStringBuf.length()) {
             match(' ');

             HashMap<String, ParamValue> params = parseParams();
             for (Entry<String, ParamValue> param : params.entrySet()) {
                 translateParam(p, param.getKey(), param.getValue());
             }
         }
         return p;
     }

     private static HashMap<String, Integer> sInfoElemTypeMap;
     private static final int ELEM_OTHER_SIMPLE         = 0;
     private static final int ELEM_SESSION_ID           = 1;
     private static final int ELEM_RESULT               = 2;
     private static final int ELEM_ALL_FUNCTIONS        = 3;
     private static final int ELEM_NOT_AVAIL_FUNCS      = 4;
     private static final int ELEM_CAPABILITY_LIST      = 5;
     private static final int ELEM_CONTACT_LIST         = 6;
     private static final int ELEM_DEFAULT_CONTACT_LIST = 7;
     private static final int ELEM_USER_NICK_LIST       = 8;
     private static final int ELEM_CONTACT_LIST_PROPS   = 9;
     private static final int ELEM_PRESENCE             = 10;

     /*
     private static final int ELEM_RESULT_CLIST  = 3;
     private static final int ELEM_RESULT_DOMAIN = 4;
     private static final int ELEM_RESULT_GROUP  = 5;
     private static final int ELEM_RESULT_MSGID  = 6;
     private static final int ELEM_RESULT_SCRNAME = 7;
     private static final int ELEM_RESULT_USER   = 8;
     */

     static {
         sInfoElemTypeMap = new HashMap<String, Integer>();
         sInfoElemTypeMap.put(PtsCodes.SessionID, ELEM_SESSION_ID);
         sInfoElemTypeMap.put(PtsCodes.Status, ELEM_RESULT);
         sInfoElemTypeMap.put(PtsCodes.NotAvailableFunctions, ELEM_NOT_AVAIL_FUNCS);
         sInfoElemTypeMap.put(PtsCodes.AllFunctions, ELEM_ALL_FUNCTIONS);
         sInfoElemTypeMap.put(PtsCodes.AgreedCapabilityList, ELEM_CAPABILITY_LIST);
         sInfoElemTypeMap.put(PtsCodes.ContactList, ELEM_CONTACT_LIST);
         sInfoElemTypeMap.put(PtsCodes.DefaultContactList, ELEM_DEFAULT_CONTACT_LIST);
         sInfoElemTypeMap.put(PtsCodes.UserNickList, ELEM_USER_NICK_LIST);
         sInfoElemTypeMap.put(PtsCodes.ContactListProps, ELEM_CONTACT_LIST_PROPS);
         sInfoElemTypeMap.put(PtsCodes.Presence, ELEM_PRESENCE);
     }

     private static void translateParam(Primitive p, String elemCode,
             ParamValue elemValue) throws ParserException {
         int type;
         elemCode = elemCode.toUpperCase();

         // FIXME: Should be refactored when we had concrete situation of the null value case
         if (elemValue == null) {
             throw new ParserException("Parameter " + elemCode + " must have value.");
         }

         if (sInfoElemTypeMap.containsKey(elemCode)) {
             type = sInfoElemTypeMap.get(elemCode);
             /*
             if (type == ELEM_RESULT_CLIST && p.getType().equals(ImpsTags.Login_Response)) {
                 // Fix up DigestSchema which shares a same code with
                 // ContactListID. It appears only in Login_Response.
                 type = ELEM_OTHER_SIMPLE;
             }
             */
         } else {
             type = ELEM_OTHER_SIMPLE;
         }

         switch (type) {
         case ELEM_SESSION_ID:
             if (elemValue.mStrValue == null) {
                 throw new ParserException("Element SessionID must have string value!");
             }

             if (p.getType().equals(ImpsTags.Login_Response)) {
                 p.addElement(ImpsTags.SessionID, elemValue.mStrValue);
             } else {
                 p.setSession(elemValue.mStrValue);
             }
             break;

         case ELEM_RESULT:
             // ST=<StatusCode>
             // ST=(<StatusCode>,<Description>)
             PrimitiveElement result = p.addElement(ImpsTags.Result);

             if (elemValue.mStrValue != null) {
                 result.addChild(ImpsTags.Code, elemValue.mStrValue);
             } else {
                 checkGroupValue(elemValue.mValueGroup, 2);

                 result.addChild(ImpsTags.Code, elemValue.mValueGroup.get(0).mStrValue);
                 result.addChild(ImpsTags.Description, elemValue.mValueGroup.get(1).mStrValue);
             }
             break;

         case ELEM_ALL_FUNCTIONS:
         case ELEM_NOT_AVAIL_FUNCS:
             p.addElement(translateServiceTree(elemCode, elemValue));
             break;

         case ELEM_CAPABILITY_LIST:
             p.addElement(translateCapabilityList(elemValue));
             break;

         case ELEM_CONTACT_LIST:
             if (elemValue.mStrValue != null) {
                 p.addElement(ImpsTags.ContactList, elemValue.mStrValue);
             } else {
                 checkGroupValue(elemValue.mValueGroup, UNCERTAIN_GROUP_SIZE);
                 for (ParamValue value : elemValue.mValueGroup) {
                     p.addElement(ImpsTags.ContactList, value.mStrValue);
                 }
             }
             break;

         case ELEM_DEFAULT_CONTACT_LIST:
             if (elemValue.mStrValue == null) {
                 throw new ParserException("Deafult Contact List must have string value!");
             }

             p.addElement(ImpsTags.DefaultContactList, elemValue.mStrValue);
             break;

         case ELEM_USER_NICK_LIST:
         {
             checkGroupValue(elemValue.mValueGroup, UNCERTAIN_GROUP_SIZE);

             PrimitiveElement nicklistElem = p.addElement(ImpsTags.NickList);

             int groupSize = elemValue.mValueGroup.size();
             for (int i = 0; i < groupSize; i++) {
                 ArrayList<ParamValue> valueGroup = elemValue.mValueGroup.get(i).mValueGroup;
                 checkGroupValue(valueGroup, 2);

                 String nickname = valueGroup.get(0).mStrValue;
                 String address  = valueGroup.get(1).mStrValue;
                 if (nickname == null || address == null) {
                     throw new ParserException("Null value found for NickName: " + nickname
                             + "-" + address);
                 }

                 PrimitiveElement nicknameElem = nicklistElem.addChild(ImpsTags.NickName);
                 nicknameElem.addChild(ImpsTags.Name, "".equals(nickname) ? null : nickname);
                 nicknameElem.addChild(ImpsTags.UserID, address);
             }
         }
             break;

         case ELEM_CONTACT_LIST_PROPS:
         {
             checkGroupValue(elemValue.mValueGroup, UNCERTAIN_GROUP_SIZE);

             PrimitiveElement propertiesElem = p.addElement(ImpsTags.ContactListProperties);

             int groupSize = elemValue.mValueGroup.size();
             for (int i = 0; i < groupSize; i++) {
                 ArrayList<ParamValue> valueGroup = elemValue.mValueGroup.get(i).mValueGroup;
                 checkGroupValue(valueGroup, 2);

                 String name  = valueGroup.get(0).mStrValue;
                 String value = valueGroup.get(1).mStrValue;
                 if (name == null || value == null) {
                     throw new ParserException("Null value found for property: " + name + "-" + value);
                 }

                 if (PtsCodes.DisplayName.equals(name)) {
                     name = ImpsConstants.DisplayName;
                 } else if (PtsCodes.Default.equals(name)) {
                     name = ImpsConstants.Default;
                 } else {
                     throw new ParserException("Unrecognized property " + name);
                 }

                 PrimitiveElement propertyElem = propertiesElem.addChild(ImpsTags.Property);
                 propertyElem.addChild(ImpsTags.Name, name);
                 propertyElem.addChild(ImpsTags.Value, value);
             }
         }
             break;

         case ELEM_PRESENCE:
             //PR=(<UserID>[,<PresenceSubList>])
             //PR=((<UserID>[,<PresenceSubList>]),(<UserID>[,<PresenceSubList>]))
             checkGroupValue(elemValue.mValueGroup, UNCERTAIN_GROUP_SIZE);

             if (elemValue.mValueGroup.size() == 1) {
                 // PR=(<UserID>)
                 ParamValue value = elemValue.mValueGroup.get(0);
                 if (value.mStrValue != null) {
                     p.addElement(ImpsTags.Presence).addChild(ImpsTags.UserID, value.mStrValue);
                 } else {
                     // workaround for OZ server
                     p.addElement(translatePresence(value.mValueGroup));
                 }

             } else {
                 if (elemValue.mValueGroup.get(0).mStrValue == null) {
                     // PR=((<UserID>[,<PresenceSubList>]),(<UserID>[,<PresenceSubList>]))
                     int groupSize = elemValue.mValueGroup.size();
                     for (int i = 0; i < groupSize; i++) {
                         ParamValue value = elemValue.mValueGroup.get(i);
                         if (value.mStrValue != null) {
                             p.addElement(ImpsTags.Presence).addChild(ImpsTags.UserID, value.mStrValue);
                         } else {
                             p.addElement(translatePresence(value.mValueGroup));
                         }
                     }
                 } else {
                     // PR=(<UserID>,<PresenceSubList>)
                     p.addElement(translatePresence(elemValue.mValueGroup));
                 }
             }
             break;

         case ELEM_OTHER_SIMPLE:
             p.addElement(translateSimpleElem(elemCode, elemValue));
             break;

         default:
             throw new ParserException("Unsupported element " + elemValue);
         }
     }

     private static PrimitiveElement translatePresence(ArrayList<ParamValue> valueGroup)
             throws ParserException {
         checkGroupValue(valueGroup, UNCERTAIN_GROUP_SIZE);

         PrimitiveElement presence = new PrimitiveElement(ImpsTags.Presence);
         if (valueGroup.get(0).mStrValue == null) {
             throw new ParserException("UserID must have string value!");
         }
         presence.addChild(ImpsTags.UserID, valueGroup.get(0).mStrValue);

         if (valueGroup.size() > 1) {
             // has presence sub list
             presence.addChild(translatePresenceSubList(valueGroup.get(1)));
         }

         return presence;
     }

     private static PrimitiveElement translatePresenceSubList(ParamValue value)
             throws ParserException {
         checkGroupValue(value.mValueGroup, UNCERTAIN_GROUP_SIZE);

         PrimitiveElement presenceSubList = new PrimitiveElement(ImpsTags.PresenceSubList);

         int groupSize = value.mValueGroup.size();
         for (int i = 0; i < groupSize; i++) {
             ParamValue v = value.mValueGroup.get(i);
             if (v.mStrValue != null) {
                 throw new ParserException("Unexpected string value for presence attribute");
             }

             presenceSubList.addChild(translatePresenceAttribute(v.mValueGroup));
         }

         return presenceSubList;
     }

     // <attribute>[,<qualifier>][,<value>]
     // <attribute>[,<qualifier>,<sub-attribute>]
     private static PrimitiveElement translatePresenceAttribute(
             ArrayList<ParamValue> valueGroup) throws ParserException {
         String type = valueGroup.get(0).mStrValue;
         if (type == null) {
             return null;
         }

         String tag = PtsCodes.getPresenceAttributeElement(type);
         if (tag == null) {
             return null;
         }

         PrimitiveElement paElem = new PrimitiveElement(tag);
         if (valueGroup.size() == 2) {
             // no qualifier
             translateAttributeValue(paElem, valueGroup.get(1), false);
         }else if (valueGroup.size() == 3) {
             // has qualifier, and it should has no group value
             ParamValue qualifierValue = valueGroup.get(1);
             if (qualifierValue.mStrValue == null) {
                 throw new ParserException("Qualifier value can't be group value!");
             }

             if (!"".equals(qualifierValue.mStrValue)) {
                 paElem.addChild(ImpsTags.Qualifier, qualifierValue.mStrValue);
             }

             translateAttributeValue(paElem, valueGroup.get(2), true);
         } else {
             return null;
         }

         return paElem;
     }

     private static void translateAttributeValue(PrimitiveElement paElem,
             ParamValue v, boolean hasQualifier) throws ParserException {
         if (v.mStrValue == null) {
             // sub-attribute as value
             checkGroupValue(v.mValueGroup, UNCERTAIN_GROUP_SIZE);
             if (v.mValueGroup.get(0).mStrValue != null) {
                 paElem.addChild(translatePresenceAttribute(v.mValueGroup));
             } else {
                 int groupSize = v.mValueGroup.size();
                 for (int i = 0; i < groupSize; i++) {
                     ParamValue value = v.mValueGroup.get(i);
                     if (value.mStrValue != null) {
                         throw new ParserException("Presence Attribute value error!");
                     }

                     checkGroupValue(value.mValueGroup, UNCERTAIN_GROUP_SIZE);
                     paElem.addChild(translatePresenceAttribute(value.mValueGroup));
                 }
             }
         } else {
             // single simple value
             if (hasQualifier) {
                 paElem.addChild(ImpsTags.PresenceValue, PtsCodes.getPAValue(v.mStrValue));
             } else {
                 paElem.setContents(PtsCodes.getPAValue(v.mStrValue));
             }
         }
     }

     private static void checkGroupValue(ArrayList<ParamValue> valueGroup,
             int expectedGroupSize) throws ParserException {
         if (valueGroup == null
                 || (expectedGroupSize != UNCERTAIN_GROUP_SIZE
                         && valueGroup.size() != expectedGroupSize)) {
             throw new ParserException("Invalid group value!");
         }

         int groupSize = valueGroup.size();
         for (int i = 0; i < groupSize; i++) {
             if (valueGroup.get(i) == null) {
                 throw new ParserException("Invalid group value!");
             }
         }
     }

     private static PrimitiveElement translateCapabilityList(ParamValue elemValue)
             throws ParserException {
         PrimitiveElement elem = new PrimitiveElement(ImpsTags.AgreedCapabilityList);
         ArrayList<ParamValue> params = elemValue.mValueGroup;
         if (params != null) {
             checkGroupValue(params, UNCERTAIN_GROUP_SIZE);
             int paramsSize = params.size();
             for (int i = 0; i < paramsSize; i++) {
                 ArrayList<ParamValue> capElemGroup = params.get(i).mValueGroup;
                 checkGroupValue(capElemGroup, 2);

                 String capElemCode = capElemGroup.get(0).mStrValue;
                 String capElemName;
                 if (capElemCode == null
                         || (capElemName = PtsCodes.getCapElement(capElemCode)) == null) {
                     throw new ParserException("Unknown capability element "
                             + capElemCode);
                 }
                 String capElemValue = capElemGroup.get(1).mStrValue;
                 if (capElemValue == null) {
                     throw new ParserException("Illegal capability value for "
                             + capElemCode);
                 }
                 capElemValue = PtsCodes.getCapValue(capElemValue);

                 elem.addChild(capElemName, capElemValue);
             }
         }
         return elem;
     }

     private static PrimitiveElement translateServiceTree(String elemCode,
             ParamValue elemValue) throws ParserException {
         String elemName = PtsCodes.getElement(elemCode);
         PrimitiveElement elem = new PrimitiveElement(elemName);
         // TODO: translate the service tree.
         return elem;
     }

     private static PrimitiveElement translateSimpleElem(String elemCode, ParamValue value)
             throws ParserException {
         String elemName = PtsCodes.getElement(elemCode);
         if (elemName == null) {
             throw new ParserException("Unrecognized parameter " + elemCode);
         }

         PrimitiveElement elem = new PrimitiveElement(elemName);
         if (value.mStrValue != null) {
             elem.setContents(value.mStrValue);
         } else {
             throw new ParserException("Don't know how to handle parameters for "
                     + elemName);
         }

         return elem;
     }

     private HashMap<String, ParamValue> parseParams() throws ParserException {
         int pos = mPos;
         StringBuilder buf = mStringBuf;
         int len = buf.length();
         HashMap<String, ParamValue> ret = new HashMap<String, ParamValue>();

         String paramName;
         ParamValue paramValue;

         while (pos < len) {
             int nameStart = pos;
             while (pos < len) {
                 char ch = buf.charAt(pos);
                 if (ch == ' ' || ch == '=') {
                     break;
                 }
                 pos++;
             }
             if (nameStart == pos) {
                 throw new ParserException("Missing parameter name near " + pos);
             }
             paramName = buf.substring(nameStart, pos);
             if (pos < len && buf.charAt(pos) == '=') {
                 pos++;
                 mPos = pos;
                 paramValue = parseParamValue();
                 pos = mPos;
             } else {
                 paramValue = null;
             }
             ret.put(paramName, paramValue);

             if (pos < len) {
                 // more parameters ahead
                 match(' ');
                 pos = mPos;
             }
         }

         return ret;
     }

     private ParamValue parseParamValue() throws ParserException {
         int pos = mPos;
         StringBuilder buf = mStringBuf;
         int len = buf.length();

         if (pos == len) {
             throw new ParserException("Missing parameter value near " + pos);
         }
         ParamValue value = new ParamValue();

         char ch = buf.charAt(pos);
         if (ch == '(') {
             // value list
             pos++;
             ArrayList<ParamValue> valueGroup = new ArrayList<ParamValue>();
             while (pos < len) {
                 mPos = pos;
                 valueGroup.add(parseParamValue());
                 pos = mPos;
                 if (pos == len) {
                     throw new ParserException("Unexpected parameter end");
                 }
                 if (buf.charAt(pos) != ',') {
                     break;
                 }
                 pos++;
             }
             mPos = pos;
             match(')');
             if (valueGroup.isEmpty()) {
                 throw new ParserException("Empty value group near " + mPos);
             }
             value.mValueGroup = valueGroup;
         } else {
             // single value
             if (ch == '"') {
                 // quoted value
                 pos++;
                 StringBuilder escapedValue = new StringBuilder();
                 boolean quotedEnd = false;
                 while (pos < len) {
                     ch = buf.charAt(pos);
                     pos++;
                     if (ch == '"') {
                         if (pos < len && buf.charAt(pos) == '"') {
                             // "doubled" quote
                             pos++;
                         } else {
                             quotedEnd = true;
                             break;
                         }
                     }
                     escapedValue.append(ch);
                 }
                 if (!quotedEnd) {
                     throw new ParserException("Unexpected quoted parameter end");
                 }
                 value.mStrValue = escapedValue.toString();
             } else {
                 int valueStart = pos;
                 while (pos < len) {
                     ch = buf.charAt(pos);
                     if (ch == ',' || ch == ')' || ch == ' ') {
                         break;
                     }
                     if ("\"(=&".indexOf(ch) != -1) {
                         throw new ParserException("Special character " + ch
                                 + " must be quoted");
                     }
                     pos++;
                 }
                 value.mStrValue = buf.substring(valueStart, pos);
             }
             mPos = pos;
         }

         return value;
     }

     private void match(char c) throws ParserException {
         if (mStringBuf.charAt(mPos) != c) {
             throw new ParserException("Expected " + c + " at pos " + mPos);
         }
         mPos++;
     }

     /**
      * Detect if this short message is a PTS encoded WV-primitive.
      */
     public static boolean isPtsPrimitive(CharSequence msg)
     {
         if (msg == null) {
             return false;
         }
         Matcher m = sPreamplePattern.matcher(msg);
         return m.matches();
     }

     static final class ParamValue {
         public String mStrValue;
         public ArrayList<ParamValue> mValueGroup;
     }
 }
	/*
	* Copyright (C) 2007 Esmertec AG.
	* Copyright (C) 2007 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.im.imps;

	import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.Map.Entry;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import com.android.im.imps.Primitive.TransactionMode;

	/**
	* PTS/SMS encoded IMPS messages parser. Only response transactions and
	* server initiated requests are supported.
	*/
	public class PtsPrimitiveParser implements PrimitiveParser {

	// WVaaBBcccDD <parameters>
	// aa - version number; 12 for 1.2, 13 for 1.3; "XX" for version discovery
	// BB - message type, case insensitive
	// ccc - transaction id in range 0-999 without preceding zero
	// DD - multiple SMSes identifier
	private static final Pattern sPreamplePattern =
	Pattern.compile("\\AWV(\\d{2})(\\p{Alpha}{2})(\\d{1,3})(\\p{Alpha}{2})?(\\z\| .*)");

	private char mReadBuf[] = new char[256];
	private StringBuilder mStringBuf = new StringBuilder();
	private int mPos;

	private static int UNCERTAIN_GROUP_SIZE = -1;

	public Primitive parse(InputStream in) throws ParserException, IOException {
	// assuming PTS data is always short
	BufferedReader reader = new BufferedReader(
	new InputStreamReader(in, "UTF-8"), 128);
	mStringBuf.setLength(0);
	mPos = 0;
	int len;
	while ((len = reader.read(mReadBuf)) != -1) {
	mStringBuf.append(mReadBuf, 0, len);
	}
	return parsePrim();
	}

	private Primitive parsePrim() throws ParserException
	{
	Matcher m = sPreamplePattern.matcher(mStringBuf);
	if (!m.matches()) {
	throw new ParserException("Invalid PTS encoded message");
	}

	Primitive p = new Primitive();

	// TODO: handle WV version in m.group(1)

	String type = m.group(2).toUpperCase();
	String transactionType = PtsCodes.getTransaction(type);
	if (transactionType == null) {
	throw new ParserException("Unrecognized transaction code " + type);
	}
	p.setContentElement(transactionType);

	if (PtsCodes.isServerRequestCode(type)) {
	p.setTransactionMode(TransactionMode.Request);
	} else {
	p.setTransactionMode(TransactionMode.Response);
	}

	p.setTransactionId(m.group(3));
	mPos = m.start(5);

	if (mPos < mStringBuf.length()) {
	match(' ');

	HashMap<String, ParamValue> params = parseParams();
	for (Entry<String, ParamValue> param : params.entrySet()) {
	translateParam(p, param.getKey(), param.getValue());
	}
	}
	return p;
	}

	private static HashMap<String, Integer> sInfoElemTypeMap;
	private static final int ELEM_OTHER_SIMPLE = 0;
	private static final int ELEM_SESSION_ID = 1;
	private static final int ELEM_RESULT = 2;
	private static final int ELEM_ALL_FUNCTIONS = 3;
	private static final int ELEM_NOT_AVAIL_FUNCS = 4;
	private static final int ELEM_CAPABILITY_LIST = 5;
	private static final int ELEM_CONTACT_LIST = 6;
	private static final int ELEM_DEFAULT_CONTACT_LIST = 7;
	private static final int ELEM_USER_NICK_LIST = 8;
	private static final int ELEM_CONTACT_LIST_PROPS = 9;
	private static final int ELEM_PRESENCE = 10;

	/*
	private static final int ELEM_RESULT_CLIST = 3;
	private static final int ELEM_RESULT_DOMAIN = 4;
	private static final int ELEM_RESULT_GROUP = 5;
	private static final int ELEM_RESULT_MSGID = 6;
	private static final int ELEM_RESULT_SCRNAME = 7;
	private static final int ELEM_RESULT_USER = 8;
	*/

	static {
	sInfoElemTypeMap = new HashMap<String, Integer>();
	sInfoElemTypeMap.put(PtsCodes.SessionID, ELEM_SESSION_ID);
	sInfoElemTypeMap.put(PtsCodes.Status, ELEM_RESULT);
	sInfoElemTypeMap.put(PtsCodes.NotAvailableFunctions, ELEM_NOT_AVAIL_FUNCS);
	sInfoElemTypeMap.put(PtsCodes.AllFunctions, ELEM_ALL_FUNCTIONS);
	sInfoElemTypeMap.put(PtsCodes.AgreedCapabilityList, ELEM_CAPABILITY_LIST);
	sInfoElemTypeMap.put(PtsCodes.ContactList, ELEM_CONTACT_LIST);
	sInfoElemTypeMap.put(PtsCodes.DefaultContactList, ELEM_DEFAULT_CONTACT_LIST);
	sInfoElemTypeMap.put(PtsCodes.UserNickList, ELEM_USER_NICK_LIST);
	sInfoElemTypeMap.put(PtsCodes.ContactListProps, ELEM_CONTACT_LIST_PROPS);
	sInfoElemTypeMap.put(PtsCodes.Presence, ELEM_PRESENCE);
	}

	private static void translateParam(Primitive p, String elemCode,
	ParamValue elemValue) throws ParserException {
	int type;
	elemCode = elemCode.toUpperCase();

	// FIXME: Should be refactored when we had concrete situation of the null value case
	if (elemValue == null) {
	throw new ParserException("Parameter " + elemCode + " must have value.");
	}

	if (sInfoElemTypeMap.containsKey(elemCode)) {
	type = sInfoElemTypeMap.get(elemCode);
	/*
	if (type == ELEM_RESULT_CLIST && p.getType().equals(ImpsTags.Login_Response)) {
	// Fix up DigestSchema which shares a same code with
	// ContactListID. It appears only in Login_Response.
	type = ELEM_OTHER_SIMPLE;
	}
	*/
	} else {
	type = ELEM_OTHER_SIMPLE;
	}

	switch (type) {
	case ELEM_SESSION_ID:
	if (elemValue.mStrValue == null) {
	throw new ParserException("Element SessionID must have string value!");
	}

	if (p.getType().equals(ImpsTags.Login_Response)) {
	p.addElement(ImpsTags.SessionID, elemValue.mStrValue);
	} else {
	p.setSession(elemValue.mStrValue);
	}
	break;

	case ELEM_RESULT:
	// ST=<StatusCode>
	// ST=(<StatusCode>,<Description>)
	PrimitiveElement result = p.addElement(ImpsTags.Result);

	if (elemValue.mStrValue != null) {
	result.addChild(ImpsTags.Code, elemValue.mStrValue);
	} else {
	checkGroupValue(elemValue.mValueGroup, 2);

	result.addChild(ImpsTags.Code, elemValue.mValueGroup.get(0).mStrValue);
	result.addChild(ImpsTags.Description, elemValue.mValueGroup.get(1).mStrValue);
	}
	break;

	case ELEM_ALL_FUNCTIONS:
	case ELEM_NOT_AVAIL_FUNCS:
	p.addElement(translateServiceTree(elemCode, elemValue));
	break;

	case ELEM_CAPABILITY_LIST:
	p.addElement(translateCapabilityList(elemValue));
	break;

	case ELEM_CONTACT_LIST:
	if (elemValue.mStrValue != null) {
	p.addElement(ImpsTags.ContactList, elemValue.mStrValue);
	} else {
	checkGroupValue(elemValue.mValueGroup, UNCERTAIN_GROUP_SIZE);
	for (ParamValue value : elemValue.mValueGroup) {
	p.addElement(ImpsTags.ContactList, value.mStrValue);
	}
	}
	break;

	case ELEM_DEFAULT_CONTACT_LIST:
	if (elemValue.mStrValue == null) {
	throw new ParserException("Deafult Contact List must have string value!");
	}

	p.addElement(ImpsTags.DefaultContactList, elemValue.mStrValue);
	break;

	case ELEM_USER_NICK_LIST:
	{
	checkGroupValue(elemValue.mValueGroup, UNCERTAIN_GROUP_SIZE);

	PrimitiveElement nicklistElem = p.addElement(ImpsTags.NickList);

	int groupSize = elemValue.mValueGroup.size();
	for (int i = 0; i < groupSize; i++) {
	ArrayList<ParamValue> valueGroup = elemValue.mValueGroup.get(i).mValueGroup;
	checkGroupValue(valueGroup, 2);

	String nickname = valueGroup.get(0).mStrValue;
	String address = valueGroup.get(1).mStrValue;
	if (nickname == null \|\| address == null) {
	throw new ParserException("Null value found for NickName: " + nickname
	+ "-" + address);
	}

	PrimitiveElement nicknameElem = nicklistElem.addChild(ImpsTags.NickName);
	nicknameElem.addChild(ImpsTags.Name, "".equals(nickname) ? null : nickname);
	nicknameElem.addChild(ImpsTags.UserID, address);
	}
	}
	break;

	case ELEM_CONTACT_LIST_PROPS:
	{
	checkGroupValue(elemValue.mValueGroup, UNCERTAIN_GROUP_SIZE);

	PrimitiveElement propertiesElem = p.addElement(ImpsTags.ContactListProperties);

	int groupSize = elemValue.mValueGroup.size();
	for (int i = 0; i < groupSize; i++) {
	ArrayList<ParamValue> valueGroup = elemValue.mValueGroup.get(i).mValueGroup;
	checkGroupValue(valueGroup, 2);

	String name = valueGroup.get(0).mStrValue;
	String value = valueGroup.get(1).mStrValue;
	if (name == null \|\| value == null) {
	throw new ParserException("Null value found for property: " + name + "-" + value);
	}

	if (PtsCodes.DisplayName.equals(name)) {
	name = ImpsConstants.DisplayName;
	} else if (PtsCodes.Default.equals(name)) {
	name = ImpsConstants.Default;
	} else {
	throw new ParserException("Unrecognized property " + name);
	}

	PrimitiveElement propertyElem = propertiesElem.addChild(ImpsTags.Property);
	propertyElem.addChild(ImpsTags.Name, name);
	propertyElem.addChild(ImpsTags.Value, value);
	}
	}
	break;

	case ELEM_PRESENCE:
	//PR=(<UserID>[,<PresenceSubList>])
	//PR=((<UserID>[,<PresenceSubList>]),(<UserID>[,<PresenceSubList>]))
	checkGroupValue(elemValue.mValueGroup, UNCERTAIN_GROUP_SIZE);

	if (elemValue.mValueGroup.size() == 1) {
	// PR=(<UserID>)
	ParamValue value = elemValue.mValueGroup.get(0);
	if (value.mStrValue != null) {
	p.addElement(ImpsTags.Presence).addChild(ImpsTags.UserID, value.mStrValue);
	} else {
	// workaround for OZ server
	p.addElement(translatePresence(value.mValueGroup));
	}

	} else {
	if (elemValue.mValueGroup.get(0).mStrValue == null) {
	// PR=((<UserID>[,<PresenceSubList>]),(<UserID>[,<PresenceSubList>]))
	int groupSize = elemValue.mValueGroup.size();
	for (int i = 0; i < groupSize; i++) {
	ParamValue value = elemValue.mValueGroup.get(i);
	if (value.mStrValue != null) {
	p.addElement(ImpsTags.Presence).addChild(ImpsTags.UserID, value.mStrValue);
	} else {
	p.addElement(translatePresence(value.mValueGroup));
	}
	}
	} else {
	// PR=(<UserID>,<PresenceSubList>)
	p.addElement(translatePresence(elemValue.mValueGroup));
	}
	}
	break;

	case ELEM_OTHER_SIMPLE:
	p.addElement(translateSimpleElem(elemCode, elemValue));
	break;

	default:
	throw new ParserException("Unsupported element " + elemValue);
	}
	}

	private static PrimitiveElement translatePresence(ArrayList<ParamValue> valueGroup)
	throws ParserException {
	checkGroupValue(valueGroup, UNCERTAIN_GROUP_SIZE);

	PrimitiveElement presence = new PrimitiveElement(ImpsTags.Presence);
	if (valueGroup.get(0).mStrValue == null) {
	throw new ParserException("UserID must have string value!");
	}
	presence.addChild(ImpsTags.UserID, valueGroup.get(0).mStrValue);

	if (valueGroup.size() > 1) {
	// has presence sub list
	presence.addChild(translatePresenceSubList(valueGroup.get(1)));
	}

	return presence;
	}

	private static PrimitiveElement translatePresenceSubList(ParamValue value)
	throws ParserException {
	checkGroupValue(value.mValueGroup, UNCERTAIN_GROUP_SIZE);

	PrimitiveElement presenceSubList = new PrimitiveElement(ImpsTags.PresenceSubList);

	int groupSize = value.mValueGroup.size();
	for (int i = 0; i < groupSize; i++) {
	ParamValue v = value.mValueGroup.get(i);
	if (v.mStrValue != null) {
	throw new ParserException("Unexpected string value for presence attribute");
	}

	presenceSubList.addChild(translatePresenceAttribute(v.mValueGroup));
	}

	return presenceSubList;
	}

	// <attribute>[,<qualifier>][,<value>]
	// <attribute>[,<qualifier>,<sub-attribute>]
	private static PrimitiveElement translatePresenceAttribute(
	ArrayList<ParamValue> valueGroup) throws ParserException {
	String type = valueGroup.get(0).mStrValue;
	if (type == null) {
	return null;
	}

	String tag = PtsCodes.getPresenceAttributeElement(type);
	if (tag == null) {
	return null;
	}

	PrimitiveElement paElem = new PrimitiveElement(tag);
	if (valueGroup.size() == 2) {
	// no qualifier
	translateAttributeValue(paElem, valueGroup.get(1), false);
	}else if (valueGroup.size() == 3) {
	// has qualifier, and it should has no group value
	ParamValue qualifierValue = valueGroup.get(1);
	if (qualifierValue.mStrValue == null) {
	throw new ParserException("Qualifier value can't be group value!");
	}

	if (!"".equals(qualifierValue.mStrValue)) {
	paElem.addChild(ImpsTags.Qualifier, qualifierValue.mStrValue);
	}

	translateAttributeValue(paElem, valueGroup.get(2), true);
	} else {
	return null;
	}

	return paElem;
	}

	private static void translateAttributeValue(PrimitiveElement paElem,
	ParamValue v, boolean hasQualifier) throws ParserException {
	if (v.mStrValue == null) {
	// sub-attribute as value
	checkGroupValue(v.mValueGroup, UNCERTAIN_GROUP_SIZE);
	if (v.mValueGroup.get(0).mStrValue != null) {
	paElem.addChild(translatePresenceAttribute(v.mValueGroup));
	} else {
	int groupSize = v.mValueGroup.size();
	for (int i = 0; i < groupSize; i++) {
	ParamValue value = v.mValueGroup.get(i);
	if (value.mStrValue != null) {
	throw new ParserException("Presence Attribute value error!");
	}

	checkGroupValue(value.mValueGroup, UNCERTAIN_GROUP_SIZE);
	paElem.addChild(translatePresenceAttribute(value.mValueGroup));
	}
	}
	} else {
	// single simple value
	if (hasQualifier) {
	paElem.addChild(ImpsTags.PresenceValue, PtsCodes.getPAValue(v.mStrValue));
	} else {
	paElem.setContents(PtsCodes.getPAValue(v.mStrValue));
	}
	}
	}

	private static void checkGroupValue(ArrayList<ParamValue> valueGroup,
	int expectedGroupSize) throws ParserException {
	if (valueGroup == null
	\|\| (expectedGroupSize != UNCERTAIN_GROUP_SIZE
	&& valueGroup.size() != expectedGroupSize)) {
	throw new ParserException("Invalid group value!");
	}

	int groupSize = valueGroup.size();
	for (int i = 0; i < groupSize; i++) {
	if (valueGroup.get(i) == null) {
	throw new ParserException("Invalid group value!");
	}
	}
	}

	private static PrimitiveElement translateCapabilityList(ParamValue elemValue)
	throws ParserException {
	PrimitiveElement elem = new PrimitiveElement(ImpsTags.AgreedCapabilityList);
	ArrayList<ParamValue> params = elemValue.mValueGroup;
	if (params != null) {
	checkGroupValue(params, UNCERTAIN_GROUP_SIZE);
	int paramsSize = params.size();
	for (int i = 0; i < paramsSize; i++) {
	ArrayList<ParamValue> capElemGroup = params.get(i).mValueGroup;
	checkGroupValue(capElemGroup, 2);

	String capElemCode = capElemGroup.get(0).mStrValue;
	String capElemName;
	if (capElemCode == null
	\|\| (capElemName = PtsCodes.getCapElement(capElemCode)) == null) {
	throw new ParserException("Unknown capability element "
	+ capElemCode);
	}
	String capElemValue = capElemGroup.get(1).mStrValue;
	if (capElemValue == null) {
	throw new ParserException("Illegal capability value for "
	+ capElemCode);
	}
	capElemValue = PtsCodes.getCapValue(capElemValue);

	elem.addChild(capElemName, capElemValue);
	}
	}
	return elem;
	}

	private static PrimitiveElement translateServiceTree(String elemCode,
	ParamValue elemValue) throws ParserException {
	String elemName = PtsCodes.getElement(elemCode);
	PrimitiveElement elem = new PrimitiveElement(elemName);
	// TODO: translate the service tree.
	return elem;
	}

	private static PrimitiveElement translateSimpleElem(String elemCode, ParamValue value)
	throws ParserException {
	String elemName = PtsCodes.getElement(elemCode);
	if (elemName == null) {
	throw new ParserException("Unrecognized parameter " + elemCode);
	}

	PrimitiveElement elem = new PrimitiveElement(elemName);
	if (value.mStrValue != null) {
	elem.setContents(value.mStrValue);
	} else {
	throw new ParserException("Don't know how to handle parameters for "
	+ elemName);
	}

	return elem;
	}

	private HashMap<String, ParamValue> parseParams() throws ParserException {
	int pos = mPos;
	StringBuilder buf = mStringBuf;
	int len = buf.length();
	HashMap<String, ParamValue> ret = new HashMap<String, ParamValue>();

	String paramName;
	ParamValue paramValue;

	while (pos < len) {
	int nameStart = pos;
	while (pos < len) {
	char ch = buf.charAt(pos);
	if (ch == ' ' \|\| ch == '=') {
	break;
	}
	pos++;
	}
	if (nameStart == pos) {
	throw new ParserException("Missing parameter name near " + pos);
	}
	paramName = buf.substring(nameStart, pos);
	if (pos < len && buf.charAt(pos) == '=') {
	pos++;
	mPos = pos;
	paramValue = parseParamValue();
	pos = mPos;
	} else {
	paramValue = null;
	}
	ret.put(paramName, paramValue);

	if (pos < len) {
	// more parameters ahead
	match(' ');
	pos = mPos;
	}
	}

	return ret;
	}

	private ParamValue parseParamValue() throws ParserException {
	int pos = mPos;
	StringBuilder buf = mStringBuf;
	int len = buf.length();

	if (pos == len) {
	throw new ParserException("Missing parameter value near " + pos);
	}
	ParamValue value = new ParamValue();

	char ch = buf.charAt(pos);
	if (ch == '(') {
	// value list
	pos++;
	ArrayList<ParamValue> valueGroup = new ArrayList<ParamValue>();
	while (pos < len) {
	mPos = pos;
	valueGroup.add(parseParamValue());
	pos = mPos;
	if (pos == len) {
	throw new ParserException("Unexpected parameter end");
	}
	if (buf.charAt(pos) != ',') {
	break;
	}
	pos++;
	}
	mPos = pos;
	match(')');
	if (valueGroup.isEmpty()) {
	throw new ParserException("Empty value group near " + mPos);
	}
	value.mValueGroup = valueGroup;
	} else {
	// single value
	if (ch == '"') {
	// quoted value
	pos++;
	StringBuilder escapedValue = new StringBuilder();
	boolean quotedEnd = false;
	while (pos < len) {
	ch = buf.charAt(pos);
	pos++;
	if (ch == '"') {
	if (pos < len && buf.charAt(pos) == '"') {
	// "doubled" quote
	pos++;
	} else {
	quotedEnd = true;
	break;
	}
	}
	escapedValue.append(ch);
	}
	if (!quotedEnd) {
	throw new ParserException("Unexpected quoted parameter end");
	}
	value.mStrValue = escapedValue.toString();
	} else {
	int valueStart = pos;
	while (pos < len) {
	ch = buf.charAt(pos);
	if (ch == ',' \|\| ch == ')' \|\| ch == ' ') {
	break;
	}
	if ("\"(=&".indexOf(ch) != -1) {
	throw new ParserException("Special character " + ch
	+ " must be quoted");
	}
	pos++;
	}
	value.mStrValue = buf.substring(valueStart, pos);
	}
	mPos = pos;
	}

	return value;
	}

	private void match(char c) throws ParserException {
	if (mStringBuf.charAt(mPos) != c) {
	throw new ParserException("Expected " + c + " at pos " + mPos);
	}
	mPos++;
	}

	/**
	* Detect if this short message is a PTS encoded WV-primitive.
	*/
	public static boolean isPtsPrimitive(CharSequence msg)
	{
	if (msg == null) {
	return false;
	}
	Matcher m = sPreamplePattern.matcher(msg);
	return m.matches();
	}

	static final class ParamValue {
	public String mStrValue;
	public ArrayList<ParamValue> mValueGroup;
	}
	}