1 // Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "Gsmumain.h"

    17 #include "gsmuieoperations.h"

    18 #include "Gsmumsg.h"

    19 #include "gsmumsgadditionalattributes.h"

    20 #include "Gsmuelem.h"

    21 #include "smsstacklog.h"

    22 

    23 

    24 /**

    25  *  This is used by the CSmsMessage to create a CSmsIEOperation.

    26  *  Each instance is owned by the CSmsMessage which created it.

    27  *  Therefore only the CSmsMessage (GSMU component) is allowed to

    28  *  create and delete CSmsIEOperations.

    29  *  

    30  *  @param aId

    31  *  The ID for the CSmsInformationElement for whom an operation class needs to be created.

    32  *  @param aMessage

    33  *  The CSmsMessage that this operations class belongs to.

    34  *  @param aCharacterSetConverter

    35  *  A reference to a character set converter, needed by some derived operation classes.

    36  *  @param aFs

    37  *  A reference to the file server, needed by some derived operations classes.

    38  *  

    39  *  @internalComponent

    40  */

    41 CSmsIEOperation*  CSmsIEOperation::NewL(CSmsInformationElement::TSmsInformationElementIdentifier aId, CSmsMessage& aMessage, CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs)

    42 	{

    43 	LOGGSMU1("CSmsIEOperation::NewL()");

    44 

    45 	CSmsIEOperation* iEOperation = NULL;

    46 

    47 	switch (aId)

    48 	    {

    49 	    case CSmsInformationElement::ESmsHyperLinkFormat:

    50 	        iEOperation = new (ELeave)  CSmsHyperLinkOperations(aId,aMessage);

    51 	        break;

    52 	    case CSmsInformationElement::ESmsReplyAddressFormat:

    53 	        iEOperation = new (ELeave) CSmsReplyAddressOperations(aId, aMessage, aCharacterSetConverter, aFs);

    54 	        break;

    55 	    case CSmsInformationElement::ESmsEnhanceVoiceMailInformation:

    56 	        iEOperation = new (ELeave) CSmsEnhancedVoiceMailOperations(aId, aMessage, aCharacterSetConverter, aFs);

    57 	        break;

    58 	    case CSmsInformationElement::ESmsIEISpecialSMSMessageIndication:

    59 	        iEOperation = new (ELeave)  CSmsSpecialSMSMessageOperations(aId,aMessage);

    60 	        break;

    61 	    case CSmsInformationElement::ESmsIEISMSCControlParameters:

    62 	        iEOperation = new (ELeave)  CSmsSMSCCtrlParameterOperations(aId,aMessage); 

    63 	        break;

    64 	    default:

    65 	        User::Leave(KErrArgument);

    66 	        break;

    67 	    }

    68 

    69 	iEOperation->ConstructL();

    70 

    71 	return iEOperation;

    72 	} // CSmsIEOperation::NewL

    73 

    74 

    75 /**

    76  *  @publishedAll

    77  *  

    78  *  Identifies the information element which is supported by this operations class.

    79  *  

    80  *  @return The information element ID supported by this operations class.

    81  *  @capability None

    82  */

    83 EXPORT_C CSmsInformationElement::TSmsInformationElementIdentifier CSmsIEOperation::Id() const

    84 	{

    85 	LOGGSMU1("CSmsIEOperation::Id()");

    86 

    87 	return iId;

    88 	} // CSmsInformationElement::TSmsInformationElementIdentifier

    89 

    90 

    91 /**

    92  *  @internalComponent

    93  *  

    94  *  Identifies whether the message type supports is supported

    95  *  

    96  *  @return True if the message type is supported. False otherwise.

    97  */

    98 TBool CSmsIEOperation::MessageTypeSupported() const

    99 	{

   100 	LOGGSMU1("CSmsIEOperation::MessageTypeSupported()");

   101 

   102 	CSmsPDU::TSmsPDUType type = iMessage.Type();

   103 

   104     return ((type == CSmsPDU::ESmsDeliver) ||

   105             (type == CSmsPDU::ESmsSubmit));

   106 	} // CSmsIEOperation::MessageTypeSupported

   107 

   108 

   109 CSmsIEOperation::CSmsIEOperation(CSmsInformationElement::TSmsInformationElementIdentifier aId, CSmsMessage& aMessage) : iId(aId), iMessage(aMessage)

   110 	{

   111 	//NOP

   112 	} // CSmsIEOperation::CSmsIEOperation

   113 

   114 

   115 /**

   116  *  @internalComponent

   117  *  

   118  *  Prevent clients from using the assignment operator by including it in the class definition

   119  *  but making it protected and not exporting it.

   120  *  

   121  *  @capability None

   122  */

   123 void CSmsIEOperation::operator=(const CSmsIEOperation&)

   124     {

   125     // Ignore in code coverage - not intended to be used

   126     BULLSEYE_OFF    

   127     LOGGSMU1("CSmsIEOperation::operator=");

   128     Panic(KGsmuPanicMethodBodyNotImplemented1);

   129     BULLSEYE_RESTORE

   130     }

   131 

   132 /**

   133  *  @internalComponent

   134  *  

   135  *  Prevent clients from using the equality operator by including it in the class definition

   136  *  but making it protected and not exporting it.

   137  *  

   138  *  @capability None

   139  */

   140 TBool CSmsIEOperation::operator==(const CSmsIEOperation&)

   141     {

   142     // Ignore in code coverage - not intended to be used

   143     BULLSEYE_OFF    

   144     LOGGSMU1("CSmsIEOperation::operator==");

   145     Panic(KGsmuPanicMethodBodyNotImplemented1);

   146     return EFalse;

   147     BULLSEYE_RESTORE

   148     }

   149 

   150 /**

   151  *  @internalComponent

   152  *  

   153  *  Prevent clients from using the assignment operator by including it in the class definition

   154  *  but making it protected and not exporting it.

   155  *  

   156  *  @capability None

   157  */

   158 void CSmsCtrlOperation::operator=(const CSmsCtrlOperation&)

   159     {

   160     // Ignore in code coverage - not intended to be used

   161     BULLSEYE_OFF    

   162     LOGGSMU1("CSmsCtrlOperation::operator=");

   163     Panic(KGsmuPanicMethodBodyNotImplemented1);

   164     BULLSEYE_RESTORE

   165     }

   166 

   167 /**

   168  *  @internalComponent

   169  *  

   170  *  Prevent clients from using the equality operator by including it in the class definition

   171  *  but making it protected and not exporting it.

   172  *  

   173  *  @capability None

   174  */

   175 TBool CSmsCtrlOperation::operator==(const CSmsCtrlOperation&)

   176     {

   177     // Ignore in code coverage - not intended to be used

   178     BULLSEYE_OFF    

   179     LOGGSMU1("CSmsCtrlOperation::operator==");

   180     Panic(KGsmuPanicMethodBodyNotImplemented1);

   181     return EFalse;

   182     BULLSEYE_RESTORE

   183     }

   184 

   185 CSmsCtrlOperation::CSmsCtrlOperation(CSmsInformationElement::TSmsInformationElementIdentifier aId, CSmsMessage& aMessage) : CSmsIEOperation(aId, aMessage)

   186 	{

   187 	//NOP

   188 	} // CSmsCtrlOperation::CSmsCtrlOperation

   189 

   190 

   191 CSmsHyperLinkOperations::CSmsHyperLinkOperations(CSmsInformationElement::TSmsInformationElementIdentifier aId, CSmsMessage& aMessage) : CSmsCtrlOperation(aId, aMessage)

   192 	{

   193 	//NOP

   194 	} // CSmsHyperLinkOperations::CSmsHyperLinkOperations

   195 

   196 

   197 void CSmsIEOperation::ConstructL()

   198 	{

   199 	LOGGSMU1("CSmsIEOperation::ConstructL()");

   200 	} // CSmsIEOperation::ConstructL

   201 

   202 

   203 /**

   204  *  @internalComponent

   205  *  

   206  *  Prevent clients from using the assignment operator by including it in the class definition

   207  *  but making it protected and not exporting it.

   208  *  

   209  *  @capability None

   210  */

   211 void CSmsHyperLinkOperations::operator=(const CSmsHyperLinkOperations&)

   212     {

   213     // Ignore in code coverage - not intended to be used

   214     BULLSEYE_OFF    

   215     LOGGSMU1("CSmsHyperLinkOperations::operator=");

   216     Panic(KGsmuPanicMethodBodyNotImplemented1);

   217     BULLSEYE_RESTORE

   218     }

   219 

   220 /**

   221  *  @internalComponent

   222  *  

   223  *  Prevent clients from using the equality operator by including it in the class definition

   224  *  but making it protected and not exporting it.

   225  *  

   226  *  @capability None

   227  */

   228 TBool CSmsHyperLinkOperations::operator==(const CSmsHyperLinkOperations&)

   229     {

   230     // Ignore in code coverage - not intended to be used

   231     BULLSEYE_OFF    

   232     LOGGSMU1("CSmsHyperLinkOperations::operator==");

   233     Panic(KGsmuPanicMethodBodyNotImplemented1);

   234     return EFalse;

   235     BULLSEYE_RESTORE

   236     }

   237 

   238 /**

   239  *  @internalComponent

   240  *  

   241  *  Identifies whether the message type or version supports this operation

   242  *  

   243  *  @leave

   244  *  If the message type or version does not support this operation.

   245  */

   246 void CSmsHyperLinkOperations::ValidateOperationL() const

   247 	{

   248 	LOGGSMU1("CSmsHyperLinkOperations::ValidateOperationL()");

   249 

   250 	if (iMessage.Version() < CSmsMessage::ESmsMessageV1)

   251 	    {

   252 	    LOGGSMU2("CSmsHyperLinkOperations::AddHyperLinkL, Operation not supported, Msg Version %d", iMessage.Version());

   253 	    User::Leave(KErrNotSupported);

   254 	    }

   255 

   256 	if (!MessageTypeSupported())

   257 	    {

   258 	    LOGGSMU2("CSmsHyperLinkOperations::AddHyperLinkL, Operation not supported by this PDU type, type = %d", iMessage.Type());

   259 	    User::Leave(KErrNotSupported);

   260 	    }

   261 	} // CSmsHyperLinkOperations::ValidateOperationL

   262 

   263 

   264 /**

   265  *  @publishedAll

   266  *  

   267  *  This method adds a HyperLink to the CSmsMessage.

   268  *  

   269  *  @param aPosition

   270  *  The absolute character position within the message text.

   271  *  @param aTitle

   272  *  An integer representation of the number of characters in the hyperlink title.

   273  *  @param URL Length

   274  *  An integer representation of the number of characters in the URL.

   275  *  @leave KErrNotSupported

   276  *  If the message version or type does not support hyperlinks.

   277  *  @capability None

   278  */

   279 EXPORT_C void CSmsHyperLinkOperations::AddHyperLinkL(TUint aPosition, TUint8 aTitleLength,  TUint8  aURLLength) const

   280 	{

   281 	LOGGSMU1("CSmsHyperLinkOperations::AddHyperLinkL()");

   282 

   283 	ValidateOperationL();

   284 

   285 	CSmsMessageAdditionalAttributes& additionalAttributes = *((CSmsMessageAdditionalAttributes*) iMessage.AdditionalInfo());

   286 

   287 	TBuf8 <4> buffer;

   288 	buffer.SetLength(4);

   289 	buffer[0] = (TUint8) (aPosition >> 8); // lowest octet contains the

   290 	buffer[1] = (TUint8)  aPosition;       // most significant bits

   291 	buffer[2] = aTitleLength;

   292 	buffer[3] = aURLLength;

   293 

   294 	CSmsInformationElement* iE = CSmsInformationElement::NewL(CSmsInformationElement::ESmsHyperLinkFormat, buffer);

   295 	CleanupStack::PushL(iE);

   296 	additionalAttributes.AddControlInformationElementL(iE);

   297 	CleanupStack::Pop(iE);

   298 	} // CSmsHyperLinkOperations::AddHyperLinkL

   299 

   300 

   301 /**

   302  *  @publishedAll

   303  *  

   304  *  Returns the number of Hyper Link IEs contained in this message.

   305  *  @leave KErrNotSupported

   306  *  If this functionality is not supported by this version or type of message.

   307  *  @return

   308  *  The number of hyper links contained in this message.

   309  *  @capability None

   310  */

   311 EXPORT_C TUint CSmsHyperLinkOperations::NumberOfHyperLinksL() const

   312 	{

   313 	LOGGSMU1("CSmsHyperLinkOperations::NumberOfHyperLinks");

   314 

   315 	ValidateOperationL();

   316 

   317 	TUint numberOfHyperLinks = 0;

   318 

   319 	TSmsInformationElementCategories::TInformationElementCategory category;

   320 

   321 	if (TSmsInformationElementCategories::GetCategoryDefinition(CSmsInformationElement::ESmsHyperLinkFormat, category) == EFalse)

   322 			{

   323 		User::Leave(KErrArgument);

   324 		}

   325 

   326 	CSmsMessageAdditionalAttributes* additionalAttributes = (CSmsMessageAdditionalAttributes*) iMessage.AdditionalInfo();

   327 	TUint numberOfElements = additionalAttributes->NumberOfControlInformationElements(category);

   328 

   329 	for (TUint i = 0; i < numberOfElements; i++)

   330 	    {

   331 	    CSmsInformationElement::TSmsInformationElementIdentifier id = CSmsInformationElement::ESmsIEMaximum;

   332 	    

   333 	    // If function leaves, allow the error to propagate upwards

   334 	    id = additionalAttributes->GetControlInformationElementL(category, i).Identifier();

   335 

   336 	    if (id == CSmsInformationElement::ESmsHyperLinkFormat)

   337 	        {

   338 	        numberOfHyperLinks++;

   339 	        }

   340 	    }

   341 

   342 	return numberOfHyperLinks;

   343 	} // CSmsHyperLinkOperations::NumberOfHyperLinksL

   344 

   345 

   346 /**

   347  *  @publishedAll

   348  *  

   349  *  Copies the attributes of the specified hyperlink.

   350  *  aIndex has the range [0..[n-1]] where n is the

   351  *  value returned by NumberOfHyperLinks()

   352  *  

   353  *  @param aIndex

   354  *  Identifies the hyperlink to extract. Has the range [0..[n-1]]

   355  *  where n is the value returned by NumberOfHyperLinks().

   356  *  @param &aPosition

   357  *  The absolute character position within the message text.

   358  *  @param &aTitleLength

   359  *  An integer representation of the number of characters in the hyperlink title.

   360  *  @param &aURLLength

   361  *  An integer representation of the number of characters in the URL.

   362  *  @leave KErrNotSupported

   363  *  If the message version or type does not support hyperlinks.

   364  *  @leave KErrArgument

   365  *  If aIndex is out of range.

   366  *  @capability None

   367  */

   368 EXPORT_C void  CSmsHyperLinkOperations::CopyHyperLinkAtIndexL(TUint aIndex, TUint& aPosition, TUint8& aTitleLength,  TUint8&  aURLLength) const

   369 	{

   370 	LOGGSMU2("CSmsHyperLinkOperations::CopyHyperLinkAtIndexL(): aIndex=%d", aIndex);

   371 

   372 	ValidateOperationL();

   373 

   374 	TUint numberOfHyperLinks = 0;

   375 

   376 	TSmsInformationElementCategories::TInformationElementCategory category;

   377 	if (TSmsInformationElementCategories::GetCategoryDefinition(CSmsInformationElement::ESmsHyperLinkFormat, category) == EFalse)

   378 		{

   379 		User::Leave(KErrArgument);

   380 		}

   381 

   382 	CSmsMessageAdditionalAttributes* additionalAttributes = (CSmsMessageAdditionalAttributes*) iMessage.AdditionalInfo();

   383 	TUint numberOfElements = additionalAttributes->NumberOfControlInformationElements(category);

   384 

   385 	if (aIndex >= numberOfElements)

   386 	    {

   387 	    User::Leave(KErrArgument);

   388 	    }

   389 

   390 	for (TUint i = 0; i < numberOfElements; i++)

   391 	    {

   392 	    CSmsInformationElement::TSmsInformationElementIdentifier id = CSmsInformationElement::ESmsIEMaximum;

   393 	    

   394 	    // If function leaves, allow the error to propagate upwards

   395 	    id = additionalAttributes->GetControlInformationElementL(category, i).Identifier();

   396 

   397 	    if ((id == CSmsInformationElement::ESmsHyperLinkFormat) &&

   398 	        (numberOfHyperLinks++ == aIndex))

   399 	        {

   400 	        aPosition     = (additionalAttributes->GetControlInformationElementL(category, i).Data()[0] << 8);

   401 	        aPosition    +=  additionalAttributes->GetControlInformationElementL(category, i).Data()[1];

   402 

   403 	        aTitleLength = additionalAttributes->GetControlInformationElementL(category, i).Data()[2];

   404 	        aURLLength   = additionalAttributes->GetControlInformationElementL(category, i).Data()[3];

   405 	        break;

   406 	        }

   407 	    }

   408 	} // CSmsHyperLinkOperations::CopyHyperLinkAtIndexL

   409 

   410 

   411 /**

   412  *  @publishedAll

   413  *  

   414  *  Removes all hyper Link IEs contained in this message.

   415  *  

   416  *  @leave KErrNotSupported

   417  *  If the message version or type does not support hyperlinks.

   418  *  @capability None

   419  */

   420 EXPORT_C void  CSmsHyperLinkOperations::RemoveAllHyperLinksL() const

   421 	{

   422 	LOGGSMU1("CSmsHyperLinkOperations::RemoveAllHyperLinks");

   423 

   424 	ValidateOperationL();

   425 

   426 	TSmsInformationElementCategories::TInformationElementCategory category;

   427 

   428 	if (TSmsInformationElementCategories::GetCategoryDefinition(CSmsInformationElement::ESmsHyperLinkFormat, category) == EFalse)

   429 		{

   430 		User::Leave(KErrArgument);

   431 		}

   432 

   433 	CSmsMessageAdditionalAttributes* additionalAttributes = (CSmsMessageAdditionalAttributes*) iMessage.AdditionalInfo();

   434 	TUint i = additionalAttributes->NumberOfControlInformationElements(category);

   435 

   436 	while (i-- != 0)

   437 	    {

   438 	    CSmsInformationElement::TSmsInformationElementIdentifier id = CSmsInformationElement::ESmsIEMaximum;

   439 	    

   440 	    // If function leaves, allow the error to propagate upwards

   441 	    id = additionalAttributes->GetControlInformationElementL(category, i).Identifier();

   442 

   443 	    if (id == CSmsInformationElement::ESmsHyperLinkFormat)

   444 	        {

   445 	        additionalAttributes->DeleteControlInformationElement(category, i);

   446 	        }

   447 	    }

   448 	} // CSmsHyperLinkOperations::RemoveAllHyperLinksL

   449 

   450 

   451 /**

   452  *  @publishedAll

   453  *  

   454  *  Removes the indexed hyperlink from this message.

   455  *  

   456  *  @param aIndex

   457  *  aIndex has the range [0..[n-1]] where n is the

   458  *  value returned by NumberOfHyperLinks()

   459  *  @leave KErrNotSupported

   460  *  If the message version or type does not support hyperlinks.

   461  *  @leave KErrArgument

   462  *  If the index is out of range.

   463  *  @capability None

   464  */

   465 EXPORT_C void  CSmsHyperLinkOperations::RemoveHyperLinkL(TUint aIndex) const

   466 	{

   467 	LOGGSMU1("CSmsHyperLinkOperations::RemoveHyperLink");

   468 

   469 	ValidateOperationL();

   470 

   471 	TUint numberOfHyperLinks = 0;

   472 

   473 	TSmsInformationElementCategories::TInformationElementCategory category;

   474 

   475 	if (TSmsInformationElementCategories::GetCategoryDefinition(CSmsInformationElement::ESmsHyperLinkFormat, category) == EFalse)

   476 		{

   477 		User::Leave(KErrArgument);

   478 		}

   479 

   480 	CSmsMessageAdditionalAttributes* additionalAttributes = (CSmsMessageAdditionalAttributes*) iMessage.AdditionalInfo();

   481 	TUint numberOfElements = additionalAttributes->NumberOfControlInformationElements(category);

   482 

   483 	if (aIndex >= numberOfElements)

   484 	    {

   485 	    User::Leave(KErrArgument);

   486 	    }

   487 

   488 	for (TUint i = 0; i < numberOfElements; i++)

   489 	    {

   490 	    CSmsInformationElement::TSmsInformationElementIdentifier id = CSmsInformationElement::ESmsIEMaximum;

   491 

   492 	    // If function leaves, allow the error to propagate upwards

   493 	    id = additionalAttributes->GetControlInformationElementL(category, i).Identifier();

   494 

   495 	    if ((id == CSmsInformationElement::ESmsHyperLinkFormat) &&

   496 	        (numberOfHyperLinks++ == aIndex))

   497 	        {

   498 	        additionalAttributes->DeleteControlInformationElement(category, i);

   499 	        break;

   500 	        }

   501 	    }

   502 	} // CSmsHyperLinkOperations::RemoveHyperLinkL

   503 

   504 

   505 /**

   506  *  @internalComponent

   507  *  

   508  *  Prevent clients from using the assignment operator by including it in the class definition

   509  *  but making it protected and not exporting it.

   510  *  

   511  *  @capability None

   512  */

   513 void CSmsReplyAddressOperations::operator=(const CSmsReplyAddressOperations&)

   514     {

   515     // Ignore in code coverage - not intended to be used

   516     BULLSEYE_OFF    

   517     LOGGSMU1("CSmsReplyAddressOperations::operator=");

   518     Panic(KGsmuPanicMethodBodyNotImplemented1);

   519     BULLSEYE_RESTORE

   520     }

   521 

   522 /**

   523  *  @internalComponent

   524  *  

   525  *  Prevent clients from using the equality operator by including it in the class definition

   526  *  but making it protected and not exporting it.

   527  *  

   528  *  @capability None

   529  */

   530 TBool CSmsReplyAddressOperations::operator==(const CSmsReplyAddressOperations&)

   531     {

   532     // Ignore in code coverage - not intended to be used

   533     BULLSEYE_OFF    

   534     LOGGSMU1("CSmsReplyAddressOperations::operator==");

   535     Panic(KGsmuPanicMethodBodyNotImplemented1);

   536     return EFalse;

   537     BULLSEYE_RESTORE

   538     }

   539 

   540 /**

   541  *  @internalComponent

   542  *  

   543  *  Identifies whether the message type or version supports this operation

   544  *  

   545  *  @leave

   546  *  If the message type or version does not support this operation.

   547  */

   548 void CSmsReplyAddressOperations::ValidateOperationL() const

   549 	{

   550 	LOGGSMU1("CSmsReplyAddressOperations::ValidateOperationL()");

   551 

   552 	if (iMessage.Version() < CSmsMessage::ESmsMessageV1)

   553 	    {

   554 	    LOGGSMU2("CSmsReplyAddressOperations::AddReplyAddressL, Operation not supported, Msg Version %d", iMessage.Version());

   555 	    User::Leave(KErrNotSupported);

   556 	    }

   557 

   558 	if (!MessageTypeSupported())

   559 	    {

   560 	    LOGGSMU2("CSmsReplyAddressOperations::AddReplyAddressL, Operation not supported by this PDU type, type = %d", iMessage.Type());

   561 	    User::Leave(KErrNotSupported);

   562 	    }

   563 	} // CSmsReplyAddressOperations::ValidateOperationL

   564 

   565 

   566 /**

   567  *  @publishedAll

   568  *  

   569  *  Adds a reply address information element.

   570  *  

   571  *  @param aAddress

   572  *  The international number to be used in the reply address.

   573  *  @leave KErrNotSupported

   574  *  If the message version or type does not support a reply addresses.

   575  *  @leave KErrAlreadyExists

   576  *  If the message already contains a reply address.

   577  *  @capability None

   578  */

   579 EXPORT_C void  CSmsReplyAddressOperations::AddReplyAddressL(const TDesC& aAddress) const

   580 	{

   581 	LOGGSMU1("CSmsReplyAddressOperations::AddReplyAddressL()");

   582 

   583 	ValidateOperationL();

   584 

   585 	if (ContainsReplyAddressIEL())

   586 	    {

   587 	    LOGGSMU1("CSmsReplyAddressOperations::AddReplyAddressL, Already Exists");

   588 	    User::Leave(KErrAlreadyExists);

   589 	    }

   590 

   591 	CSmsMessageAdditionalAttributes& additionalAttributes = *((CSmsMessageAdditionalAttributes*) iMessage.AdditionalInfo());

   592 

   593 	CSmsAddress* address = CSmsAddress::NewL(iCharacterSetConverter,iFs); // needed for encoding the address into the IE.

   594 	CleanupStack::PushL(address);

   595 	address->SetAddressL(aAddress);

   596 	TBuf8<CSmsAddress::KSmsAddressMaxAddressLength> addressBuffer;

   597 	addressBuffer.SetLength(CSmsAddress::KSmsAddressMaxAddressLength);

   598 	TUint8* startPtr = &addressBuffer[0];

   599 	TUint8* endPtr = address->EncodeL(startPtr);

   600 	TInt length = 0;

   601 	(endPtr > startPtr) ? (length = endPtr - startPtr) : (length = startPtr - endPtr);

   602 	addressBuffer.SetLength(length);

   603 	CleanupStack::PopAndDestroy(address);

   604 

   605 	CSmsInformationElement* iE = CSmsInformationElement::NewL(CSmsInformationElement::ESmsReplyAddressFormat, addressBuffer);

   606 	CleanupStack::PushL(iE);

   607 	additionalAttributes.AddControlInformationElementL(iE);

   608 	CleanupStack::Pop(iE);

   609 	} // CSmsReplyAddressOperations::AddReplyAddressL

   610 

   611 

   612 /**

   613  *  @publishedAll

   614  *  

   615  *  Adds a reply address information element.

   616  *  

   617  *  @param aAddress

   618  *  Sets To and From addresses in ETSI format.

   619  *  @leave KErrNotSupported

   620  *  If the message version or type does not support a reply addresses.

   621  *  @leave KErrAlreadyExists

   622  *  If the message already contains a reply address.

   623  *  @capability None

   624  */

   625 EXPORT_C void  CSmsReplyAddressOperations::AddParsedReplyAddressL(const TGsmSmsTelNumber& aParsedAddress) const

   626 	{

   627 	LOGGSMU1("CSmsReplyAddressOperations::AddParsedReplyAddressL");

   628 

   629 	ValidateOperationL();

   630 

   631 	if (ContainsReplyAddressIEL())

   632 	    {

   633 	    LOGGSMU1("CSmsReplyAddressOperations::AddParsedReplyAddressL, Already Exists");

   634 	    User::Leave(KErrAlreadyExists);

   635 	    }

   636 

   637 	CSmsMessageAdditionalAttributes& additionalAttributes = *((CSmsMessageAdditionalAttributes*) iMessage.AdditionalInfo());

   638 

   639 	CSmsAddress* address = CSmsAddress::NewL(iCharacterSetConverter,iFs);

   640 	CleanupStack::PushL(address);

   641 	address->SetParsedAddressL(aParsedAddress);

   642 	TBuf8<CSmsAddress::KSmsAddressMaxAddressLength> addressBuffer;

   643 	addressBuffer.SetLength(CSmsAddress::KSmsAddressMaxAddressLength);

   644 	TUint8* startPtr = &addressBuffer[0];

   645 	TUint8* endPtr = address->EncodeL(startPtr);

   646 	TInt length = 0;

   647 	(endPtr > startPtr) ? (length = endPtr - startPtr) : (length = startPtr - endPtr);

   648 	addressBuffer.SetLength(length);

   649 	CleanupStack::PopAndDestroy(address);

   650 

   651 	CSmsInformationElement* iE = CSmsInformationElement::NewL(CSmsInformationElement::ESmsReplyAddressFormat, addressBuffer);

   652 	CleanupStack::PushL(iE);

   653 	additionalAttributes.AddControlInformationElementL(iE);

   654 	CleanupStack::Pop(iE);

   655 	} // CSmsReplyAddressOperations::AddParsedReplyAddressL

   656 

   657 

   658 /**

   659  *  @publishedAll

   660  *  

   661  *  Identifies whether a reply address has already been added to this

   662  *  CSmsMessage using the CSmsReplyAddressOperations interface.

   663  *  

   664  *  @return

   665  *  True if the reply address has already been added using this interface.

   666  *  @leave KErrNotSupported

   667  *  If the message version or type does not support this query.

   668  *  @capability None

   669  */

   670 EXPORT_C TBool CSmsReplyAddressOperations::ContainsReplyAddressIEL() const

   671 	{

   672 	LOGGSMU1("CSmsReplyAddressOperations::ContainsReplyAddressIEL()");

   673 

   674 	TBool rc = EFalse;

   675 

   676 	ValidateOperationL();

   677 

   678 	TSmsInformationElementCategories::TInformationElementCategory category;

   679 

   680 	if (TSmsInformationElementCategories::GetCategoryDefinition(CSmsInformationElement::ESmsReplyAddressFormat, category) == EFalse)

   681 		{

   682 		User::Leave(KErrArgument);

   683 		}

   684 

   685 	CSmsMessageAdditionalAttributes* additionalAttributes = (CSmsMessageAdditionalAttributes*) iMessage.AdditionalInfo();

   686 	TUint numberOfElements = additionalAttributes->NumberOfControlInformationElements(category);

   687 

   688 	for (TUint i = 0; i < numberOfElements; i++)

   689 	    {

   690 	    CSmsInformationElement::TSmsInformationElementIdentifier id = CSmsInformationElement::ESmsIEMaximum;

   691 	    

   692 	    // If function leaves, allow the error to propagate upwards

   693 	    id = additionalAttributes->GetControlInformationElementL(category, i).Identifier();

   694 

   695 	    if (id == CSmsInformationElement::ESmsReplyAddressFormat)

   696 	        {

   697 	        rc = ETrue;

   698 	        break;

   699 	        }

   700 	    }

   701 

   702 	return rc;

   703 	} // CSmsReplyAddressOperations::ContainsReplyAddressIEL

   704 

   705 

   706 /**

   707  *  @publishedAll

   708  *  

   709  *  Returns the reply address as an international number

   710  *  

   711  *  @return

   712  *  The reply address as an international number.

   713  *  @leave KErrNotSupported

   714  *  If the message version or type does not support this query.

   715  *  @leave KErrNotFound

   716  *  If the message does not contain a reply address information element.

   717  *  @leave KErrCorrupt

   718  *  If the reply address is corrupt

   719  *  @capability None

   720  */

   721 EXPORT_C HBufC* CSmsReplyAddressOperations::GetReplyAddressL() const

   722 	{

   723 	LOGGSMU1("CSmsReplyAddressOperations::GetReplyAddressL");

   724 

   725 	ValidateOperationL();

   726 

   727 	TBool found = EFalse;

   728 

   729 	CSmsAddress* address = CSmsAddress::NewL(iCharacterSetConverter,iFs);

   730 	CleanupStack::PushL(address);

   731 

   732 	TSmsInformationElementCategories::TInformationElementCategory category;

   733 

   734 	if (TSmsInformationElementCategories::GetCategoryDefinition(CSmsInformationElement::ESmsReplyAddressFormat, category) == EFalse)

   735 		{

   736 		User::Leave(KErrArgument);

   737 		}

   738 

   739 	CSmsMessageAdditionalAttributes* additionalAttributes = (CSmsMessageAdditionalAttributes*) iMessage.AdditionalInfo();

   740 	TUint numberOfElements = additionalAttributes->NumberOfControlInformationElements(category);

   741 

   742 	for (TUint i = 0; i < numberOfElements; i++)

   743 	    {

   744 	    CSmsInformationElement::TSmsInformationElementIdentifier id = CSmsInformationElement::ESmsIEMaximum;

   745 	    

   746 	    // If function leaves, allow the error to propagate upwards

   747 	    id = additionalAttributes->GetControlInformationElementL(category, i).Identifier();

   748 

   749 	    if (id == CSmsInformationElement::ESmsReplyAddressFormat)

   750 	        {

   751 	        TGsmuLex8 encodedAddress(additionalAttributes->GetControlInformationElementL(category, i).Data());

   752 	        TRAPD(err,address->DecodeL(encodedAddress));

   753 

   754 	        if (err == KErrNone)

   755 	            {

   756 	            found = ETrue;

   757 	            break;

   758 	            }

   759 	        else

   760 	            {

   761 	            User::Leave(KErrCorrupt);

   762 	            }

   763 	        }

   764 	    }

   765 

   766 	HBufC* buf = NULL;

   767 	if (found)

   768 	    {

   769 	    buf = HBufC::NewL(TGsmSmsTelNumberMaxLen); // 20 characters preceeded by '+'

   770 	    *buf = address->Address();

   771 	    }

   772 	else

   773 	    {

   774 	    User::Leave(KErrNotFound);

   775 	    }

   776 

   777 	CleanupStack::PopAndDestroy(address);

   778 

   779 	return buf;

   780 	} // CSmsReplyAddressOperations::GetReplyAddressL

   781 

   782 

   783 /**

   784  *  @publishedAll

   785  *  

   786  *  Returns the reply address in ETSI format.

   787  *  

   788  *  @return

   789  *  True, if the CSmsMessage contains a reply address.

   790  *  False, otherwise

   791  *  @leave KErrNotSupported

   792  *  If the message version or type does not support this query.

   793  *  @leave KErrCorrupt

   794  *  If the reply address is corrupt

   795  *  @capability None

   796  */

   797 EXPORT_C TInt  CSmsReplyAddressOperations::GetParsedReplyAddressL(TGsmSmsTelNumber& aParsedAddress) const

   798 	{

   799 	LOGGSMU1("CSmsReplyAddressOperations::GetParsedReplyAddressL");

   800 

   801 	ValidateOperationL();

   802 

   803 	TBool rc = EFalse;

   804 

   805 	CSmsAddress* address = CSmsAddress::NewL(iCharacterSetConverter,iFs);

   806 	CleanupStack::PushL(address);

   807 

   808 	TSmsInformationElementCategories::TInformationElementCategory category;

   809 

   810 	if (TSmsInformationElementCategories::GetCategoryDefinition(CSmsInformationElement::ESmsReplyAddressFormat, category) == EFalse)

   811 		{

   812 		User::Leave(KErrArgument);

   813 		}

   814 

   815 	CSmsMessageAdditionalAttributes* additionalAttributes = (CSmsMessageAdditionalAttributes*) iMessage.AdditionalInfo();

   816 	TUint numberOfElements = additionalAttributes->NumberOfControlInformationElements(category);

   817 

   818 	for (TUint i = 0; i < numberOfElements; i++)

   819 	    {

   820 	    CSmsInformationElement::TSmsInformationElementIdentifier id = CSmsInformationElement::ESmsIEMaximum;

   821 	    

   822 	    // If function leaves, allow the error to propagate upwards

   823 	    id = additionalAttributes->GetControlInformationElementL(category, i).Identifier();

   824 

   825 	    // CSmsAddress is used here for encoding the reply address into an IE.

   826 	    // It also used to encode the source / destination address in the CSmsMessage.

   827 	    // CSmsAddress::DecodeL expects internally that alphanumeric addresses will be size

   828 	    // CSmsAddress::KSmsAddressMaxAddressValueLength=10.

   829 	    // Need to add padding bytes to bring the address field up to the maximum size.

   830 	    if (id == CSmsInformationElement::ESmsReplyAddressFormat)

   831 	        {

   832 	        TBuf8<CSmsAddress::KSmsAddressMaxAddressLength> data;

   833 	        data = additionalAttributes->GetControlInformationElementL(category, i).Data();

   834 	        TUint8 actualDataLength = data.Length();

   835 	        data.SetLength(CSmsAddress::KSmsAddressMaxAddressLength);

   836 	        for (TUint8 j = actualDataLength; j < CSmsAddress::KSmsAddressMaxAddressLength; j++)

   837 	            {

   838 	            data[j] = 0;

   839 	            }

   840 

   841 	        TGsmuLex8 encodedAddress(data);

   842 	        TRAPD(err,address->DecodeL(encodedAddress));

   843 	        if (err==KErrNone)

   844 	            {

   845 	            address->ParsedAddress(aParsedAddress);

   846 	            rc = ETrue;

   847 	            break;

   848 	            }

   849 	        else

   850 	            {

   851 	            User::Leave(KErrCorrupt);

   852 	            }

   853 	        }

   854 	    }

   855 

   856 	CleanupStack::PopAndDestroy(address);

   857 

   858 	return rc;

   859 	} // CSmsReplyAddressOperations::GetParsedReplyAddressL

   860 

   861 

   862 /**

   863  *  @publishedAll

   864  *  

   865  *  Removes the reply address information element.

   866  *  

   867  *  @leave KErrNotSupported

   868  *  If the message version or type does not support this query.

   869  *  @capability None

   870  */

   871 EXPORT_C void  CSmsReplyAddressOperations::RemoveReplyAddressL() const

   872 	{

   873 	LOGGSMU1("CSmsReplyAddressOperations::RemoveReplyAddress");

   874 

   875 	ValidateOperationL();

   876 

   877 	TSmsInformationElementCategories::TInformationElementCategory category;

   878 

   879 	if (TSmsInformationElementCategories::GetCategoryDefinition(CSmsInformationElement::ESmsReplyAddressFormat, category) == EFalse)

   880 		{

   881 		User::Leave(KErrArgument);

   882 		}

   883 

   884 	CSmsMessageAdditionalAttributes* additionalAttributes = (CSmsMessageAdditionalAttributes*) iMessage.AdditionalInfo();

   885 	TUint numberOfElements = additionalAttributes->NumberOfControlInformationElements(category);

   886 

   887 	for (TInt i = 0; i < numberOfElements; i++)

   888 	    {

   889 	    CSmsInformationElement::TSmsInformationElementIdentifier id = CSmsInformationElement::ESmsIEMaximum;

   890 	    

   891 	    // If function leaves, allow the error to propagate upwards

   892 	    id = additionalAttributes->GetControlInformationElementL(category, i).Identifier();

   893 

   894 	    if (id == CSmsInformationElement::ESmsReplyAddressFormat)

   895 	        {

   896 	        additionalAttributes->DeleteControlInformationElement(category, i);

   897 	        break;

   898 	        }

   899 	    }

   900 	} // CSmsReplyAddressOperations::RemoveReplyAddressL

   901 

   902 

   903 CSmsReplyAddressOperations::CSmsReplyAddressOperations(CSmsInformationElement::TSmsInformationElementIdentifier aId,  CSmsMessage& aMessage,

   904                                                        CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs) : CSmsCtrlOperation(aId, aMessage),

   905                                                        iCharacterSetConverter(aCharacterSetConverter), iFs(aFs)

   906 	{

   907 	//NOP

   908 	} // CSmsReplyAddressOperations::CSmsReplyAddressOperations

   909 

   910 

   911 /**

   912  *  @internalComponent

   913  *  

   914  *  Identifies whether the message type or version supports this operation

   915  *  

   916  *  @leave

   917  *  If the message type or version does not support this operation.

   918  */

   919 void CSmsSpecialSMSMessageOperations::ValidateOperationL() const

   920 	{

   921 	LOGGSMU1("CSmsSpecialSMSMessageOperations::ValidateOperationL()");

   922 

   923 	if (iMessage.Version() < CSmsMessage::ESmsMessageV1)

   924 	    {

   925 	    LOGGSMU2("CSmsSpecialSMSMessageOperations::AddSpecialMessageIndicationL, Operation not supported, version %d", iMessage.Version());

   926 	    User::Leave(KErrNotSupported);

   927 	    }

   928 

   929 	if (!MessageTypeSupported())

   930 	    {

   931 	    LOGGSMU2("CSmsSpecialSMSMessageOperations::AddSpecialMessageIndicationL, Operation not supported by this PDU type, type = %d", iMessage.Type());

   932 	    User::Leave(KErrNotSupported);

   933 	    }

   934 	} // CSmsSpecialSMSMessageOperations::ValidateOperationL

   935 

   936 

   937 /**

   938  *  @internalComponent

   939  *  

   940  *  Prevent clients from using the assignment operator by including it in the class definition

   941  *  but making it protected and not exporting it.

   942  *  

   943  *  @capability None

   944  */

   945 void CSmsSpecialSMSMessageOperations::operator=(const CSmsSpecialSMSMessageOperations&)

   946     {

   947     // Ignore in code coverage - not intended to be used

   948     BULLSEYE_OFF    

   949     LOGGSMU1("CSmsSpecialSMSMessageOperations::operator=");

   950     Panic(KGsmuPanicMethodBodyNotImplemented1);

   951     BULLSEYE_RESTORE

   952     }

   953 

   954 /**

   955  *  @internalComponent

   956  *  

   957  *  Prevent clients from using the equality operator by including it in the class definition

   958  *  but making it protected and not exporting it.

   959  *  

   960  *  @capability None

   961  */

   962 TBool CSmsSpecialSMSMessageOperations::operator==(const CSmsSpecialSMSMessageOperations&)

   963 	{

   964 	LOGGSMU1("CSmsSpecialSMSMessageOperations::operator==");

   965 	Panic(KGsmuPanicMethodBodyNotImplemented1);

   966 	return EFalse;

   967 	} // CSmsSpecialSMSMessageOperations::operator

   968 

   969 

   970 /**

   971  *  @publishedAll

   972  *  

   973  *  Either adds a new or updates an existing special message indication information element.

   974  *  

   975  *  @param aStore

   976  *  Indicates whether or not the message shall be stored.

   977  *  @param aMessageIndicationType

   978  *  Indicates the basic message type

   979  *  @param aExtendedType

   980  *  Indicates the extended message type

   981  *  @param aProfile

   982  *  Indicates the profile ID of the Multiple Subscriber Profile

   983  *  @param aMessageCount

   984  *  Indicates the number of messages of the type specified in Octet 1 that are waiting

   985  *  @leave KErrNotSupported

   986  *  If the message version or type does not support this query.

   987  *  @capability None

   988  */

   989 EXPORT_C void CSmsSpecialSMSMessageOperations::AddSpecialMessageIndicationL(TBool aStore,

   990                                                                             TSmsMessageIndicationType aMessageIndicationType,

   991                                                                             TExtendedSmsIndicationType aExtendedType,

   992                                                                             TSmsMessageProfileType aProfile,

   993                                                                             TUint8 aMessageCount) const

   994 	{

   995 	LOGGSMU1("CSmsSpecialSMSMessageOperations::AddSpecialMessageIndicationL");

   996 

   997 	ValidateOperationL();

   998 

   999 	CSmsUserData& userData = iMessage.SmsPDU().UserData();

  1000 

  1001 	TBuf8<2> data;

  1002 	data.SetLength(2);

  1003 

  1004 	data[0] = ( ((TUint8) aMessageIndicationType) +

  1005 	            ((TUint8) (aExtendedType << 2))   +

  1006 	            ((TUint8) (aProfile      << 5))   +

  1007 	            ((TUint8) (aStore        << 7)) );

  1008 

  1009 	data[1] = aMessageCount;

  1010 

  1011 	CArrayFixFlat<TInt>* indices = new(ELeave) CArrayFixFlat<TInt>(4);

  1012 	CleanupStack::PushL(indices);

  1013 	userData.InformationElementIndicesL(CSmsInformationElement::ESmsIEISpecialSMSMessageIndication, *indices);

  1014 

  1015 	TBool found = EFalse;

  1016 	TInt count = indices->Count();

  1017 	for (TInt i=0; ((i<count) && (found==EFalse)); i++)

  1018 	    {

  1019 		TUint index = indices->operator[](i);

  1020 		CSmsInformationElement& ieAlreadyInWorkingPDU = userData.InformationElement(index);

  1021 

  1022 	    if (ieAlreadyInWorkingPDU.Data()[0] == data[0])

  1023 	        {

  1024 	        ieAlreadyInWorkingPDU.Data()[1] = data[1];

  1025 	        found = ETrue;

  1026 	        break;

  1027 	        }

  1028 	    }

  1029 	CleanupStack::PopAndDestroy(indices);

  1030 

  1031 	if (found == EFalse)

  1032 	    {

  1033 	    userData.AddInformationElementL(CSmsInformationElement::ESmsIEISpecialSMSMessageIndication,data);

  1034 	    }

  1035 	} // CSmsSpecialSMSMessageOperations::AddSpecialMessageIndicationL

  1036 

  1037 

  1038 /**

  1039  *  @publishedAll

  1040  *  

  1041  *  Gets a count of the number of special message indication information elements which

  1042  *  are stored inside the user data.

  1043  *  

  1044  *  @return The number of special message indication information elements which

  1045  *  are stored inside the user data.

  1046  *  @leave KErrNotSupported

  1047  *  If the message version or type does not support this query.

  1048  *  @capability None

  1049  */

  1050 EXPORT_C TUint CSmsSpecialSMSMessageOperations::GetCountOfSpecialMessageIndicationsL() const

  1051 	{

  1052 	LOGGSMU1("CSmsSpecialSMSMessageOperations::GetCountOfSpecialMessageIndicationsL()");

  1053 

  1054 	ValidateOperationL();

  1055 

  1056 	CSmsUserData& userData = iMessage.SmsPDU().UserData();

  1057 

  1058 	CArrayFixFlat<TInt>* indices = new (ELeave) CArrayFixFlat<TInt>(8);

  1059 	CleanupStack::PushL(indices);

  1060 	userData.InformationElementIndicesL(CSmsInformationElement::ESmsIEISpecialSMSMessageIndication,*indices);

  1061 	TUint  count = indices->Count();

  1062 	CleanupStack::PopAndDestroy(indices);

  1063 

  1064 	return count;

  1065 	} // CSmsSpecialSMSMessageOperations::GetCountOfSpecialMessageIndicationsL

  1066 

  1067 

  1068 /**

  1069  *  @publishedAll

  1070  *  

  1071  *  Gets the attributes of the Special Message Indication specified by aIndex.

  1072  *  

  1073  *  @param aIndex

  1074  *  aIndex is a value less than GetCountOfSpecialMessageIndications().

  1075  *  @param aStore

  1076  *  Indicates whether or not the message shall be stored.

  1077  *  @param aMessageIndicationType

  1078  *  Indicates the basic message type

  1079  *  @param aExtendedType

  1080  *  Indicates the extended message type

  1081  *  @param aProfile

  1082  *  Indicates the profile ID of the Multiple Subscriber Profile

  1083  *  @param aMessageCount

  1084  *  Indicates the number of messages of the type specified in Octet 1 that are waiting

  1085  *  @leave KErrNotSupported

  1086  *  If the message version or type does not support this query.

  1087  *  @leave KErrArgument

  1088  *  If aIndex is >= GetCountOfSpecialMessageIndications()

  1089  *  @capability None

  1090  */

  1091 EXPORT_C void CSmsSpecialSMSMessageOperations::GetMessageIndicationIEL(TUint aIndex,

  1092                                                                        TBool& aStore,

  1093                                                                        TSmsMessageIndicationType& aMessageIndicationType,

  1094                                                                        TExtendedSmsIndicationType& aExtendedType,

  1095                                                                        TSmsMessageProfileType&  aProfile,

  1096                                                                        TUint8& aMessageCount) const

  1097 	{

  1098 	LOGGSMU1("CSmsSpecialSMSMessageOperations::GetMessageIndicationIEL()");

  1099 

  1100 	ValidateOperationL();

  1101 

  1102 	CSmsUserData& userData = iMessage.SmsPDU().UserData();

  1103 

  1104 	CArrayFixFlat<TInt>* indices = new (ELeave) CArrayFixFlat<TInt>(8);

  1105 	CleanupStack::PushL(indices);

  1106 	userData.InformationElementIndicesL(CSmsInformationElement::ESmsIEISpecialSMSMessageIndication,*indices);

  1107 

  1108 	if (aIndex < indices->Count())

  1109 	    {

  1110 	    CSmsInformationElement& informationElement = userData.InformationElement((*indices)[aIndex]);

  1111 

  1112 	    aMessageIndicationType =  (TSmsMessageIndicationType)   (informationElement.Data()[0]       & 0x03);

  1113 	    aExtendedType          =  (TExtendedSmsIndicationType) ((informationElement.Data()[0] >> 2) & 0x07);

  1114 	    aProfile               =  (TSmsMessageProfileType)     ((informationElement.Data()[0] >> 5) & 0x03);

  1115 	    aStore                 =  (TBool)                      ((informationElement.Data()[0] >> 7) & 0x01);

  1116 	    aMessageCount          =  (TUint8)                      (informationElement.Data()[1]);

  1117 	    }

  1118 	else

  1119 	    {

  1120 	    User::Leave(KErrArgument);

  1121 	    }

  1122 

  1123 	CleanupStack::PopAndDestroy(indices);

  1124 	} // CSmsSpecialSMSMessageOperations::GetMessageIndicationIEL

  1125 

  1126 

  1127 /**

  1128  *  @publishedAll

  1129  *  

  1130  *  Removes the Special Message Indication specified by the input attributes, provided it exists.

  1131  *  

  1132  *  @param aMessageIndicationType

  1133  *  Indicates the basic message type

  1134  *  @param aExtendedType