FCL/sf/app/webuis: comparison pushmtm/Plugins/PushContentHandler/CSIContentHandler.cpp

equal deleted inserted replaced

-:868cceedabd3
+:92a061761a7b
 #include "PushMtmUiDef.h"
 #include "StringResourceReader.h"
 #include "PushContentHandlerPanic.h"
 #include "si_dict.h"
 #include "PushContentHandlerUtils.h"
-#include <CSIPushMsgEntry.h>
+#include <push/CSIPushMsgEntry.h>
 #include <msvids.h>
 #include <PushMtmUi.rsg>
 #include <nw_dom_node.h>
 #include <nw_dom_document.h>
 #include <nw_dom_element.h>
 // ---------------------------------------------------------
 // CSIContentHandler::CSIContentHandler
 // ---------------------------------------------------------
 //
 CSIContentHandler::CSIContentHandler()
 :   CPushContentHandlerBase(),
 iSavedMsgId( KMsvNullIndexEntryId ),
 iPushMsgAction( KErrNotFound ),
 iExpiresTime( Time::NullTTime() ),
 iCreatedTime( Time::NullTTime() )
 	{
 	}
 // ---------------------------------------------------------
 {
 PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: Empty body")
 User::Leave( KErrCorrupt );
 }
 // Get content type. It will tell us wheather the msg body is encoded or
 // textual.
 TPtrC contentType;
 	iMessage->GetContentType( contentType );
 PUSHLOG_WRITE_FORMAT("CSIContentHandler::ParsePushMsgL: HTTP header - Content type <%S>",&contentType);
 PUSHLOG_WRITE_FORMAT(" HTTP header - Content encoding <%S>",&encodingBuf);
 #endif // __TEST_LOG__
 */
 // Add SI dictionary.
 NW_WBXML_Dictionary_t* dictArray[ KNoOfDictArrays ] =
 { (NW_WBXML_Dictionary_t*)&NW_SI_WBXMLDictionary };
 NW_Status_t stat = NW_STAT_SUCCESS;
 RWbxmlDictionary wbxmlDict;
 NW_TinyDom_Handle_t domHandle;
 NW_Byte* buffer = (NW_Byte*)bodyPtr.Ptr();
 NW_Int32 length = (NW_Int32)bodyPtr.Size();
 // Let's use the content type now.
 NW_Bool encoded = ( contentType.CompareF( KSiTextContentType ) == 0 ) ?
 NW_FALSE : NW_TRUE;
 // SI public identifier.
 NW_Uint32 publicID = NW_SI_PublicId;
 NW_Bool extTNotStringTable = NW_FALSE;
 NW_DOM_NodeType_t type = 0;
 *   Root of DOM
 ***********************************/
 CDocumentTreeOwner* docTreeOwner = new (ELeave) CDocumentTreeOwner;
 CleanupStack::PushL( docTreeOwner );
 NW_DOM_DocumentNode_t* domNode = NW_DOM_DocumentNode_BuildTree
 (
 &domHandle,
 buffer,
 length,
 encoded,
 publicID,
 extTNotStringTable
 );
 	if (!domNode)
 		{
 		PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: domNode is Null")
 		}
 PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: No SI element present in the dom tree. Message corrupted.")
 User::Leave( KErrCorrupt );
 }
 	PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: before calling getDocumentElement")
 NW_DOM_ElementNode_t* siElement =
 NW_DOM_DocumentNode_getDocumentElement( domNode );
 	PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: after calling getDocumentElement")
 	if (!siElement)
 		{
 		PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: siElement is Null")
 stringOwner->SetString( name );
 stat = NW_DOM_Node_getNodeName( node, name );
 			PUSHLOG_WRITE_FORMAT("CSIContentHandler::ParsePushMsgL: getNodeName ErrCode: %d", NwxStatusToErrCode( stat ))
 User::LeaveIfError( NwxStatusToErrCode( stat ) );
 NW_Byte*  nameBuf = NW_String_getStorage( name );
 NW_Uint16 nameLen = NW_String_getCharCount( name,
 iCharEncoding );
 TPtrC8 namePtr( nameBuf, nameLen );
 if ( type == NW_DOM_ELEMENT_NODE &&
 namePtr.CompareF( KIndication ) == 0 )
 {
 // We found the indication element. Parse it.
 PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: indication under si found.")
 indicationFound = ETrue;
 NW_DOM_ElementNode_t* indicationElement =
 REINTERPRET_CAST( NW_DOM_ElementNode_t*, node );
 ParseIndicationL( *indicationElement );
 }
 CleanupStack::PopAndDestroy( stringOwner ); // stringOwner
 /**********************************
 *   PCDATA of ELEMENT indication
 ***********************************/
 if ( NW_DOM_Node_hasChildNodes( &aIndication ) )
 {
 NW_DOM_TextNode_t* textNode =
 NW_DOM_Node_getFirstChild( &aIndication );
 User::LeaveIfNull( textNode );
 type = NW_DOM_Node_getNodeType( textNode );
 if ( type != NW_DOM_TEXT_NODE )
 // ---------------------------------------------------------
 // CSIContentHandler::ParseIndAttributeL
 // ---------------------------------------------------------
 //
 void CSIContentHandler::ParseIndAttributeL( NW_DOM_AttributeHandle_t&
 aAttrHandle )
 	{
 PUSHLOG_ENTERFN("CSIContentHandler::ParseIndAttributeL")
 NW_Status_t stat = NW_STAT_SUCCESS;
 stat = NW_DOM_AttributeHandle_getValue( &aAttrHandle, val );
 if ( stat != NW_STAT_DOM_NO_STRING_RETURNED )
 {
 User::LeaveIfError( NwxStatusToErrCode( stat ) );
 NW_Byte* storage = NW_String_getStorage( val );
 NW_Uint16 length = NW_String_getCharCount( val,
 iCharEncoding );
 if ( length == 0 )
 {
 // Zero length href attribute is considered as missing.
 PUSHLOG_WRITE(" Zero length HrefFlag");
 CleanupStack::PushL( stringOwner );
 NW_String_t* val = NW_String_new();
 User::LeaveIfNull( val );
 stringOwner->SetString( val );
 stat = NW_DOM_AttributeHandle_getValue( &aAttrHandle, val );
 User::LeaveIfError( NwxStatusToErrCode( stat ) );
 NW_Byte* storage = NW_String_getStorage( val );
 NW_Uint16 length = NW_String_getCharCount( val, iCharEncoding );
 TPtrC8 actionPtr( storage, length );
 CleanupStack::PopAndDestroy( stringOwner ); // stringOwner
 }
 }
 else
 {
 __ASSERT_DEBUG( EFalse,
 ContHandPanic( EPushContHandPanUnexpSiToken ) );
 }
 CleanupStack::PopAndDestroy( stringOwner ); // stringOwner
 ucs2buffer = HBufC::NewLC( ptr.Length() );
 resultOnStack = ETrue;
 }
 else
 {
 __ASSERT_DEBUG( resultOnStack,
 ContHandPanic( EPushContHandPanSiResNotOnStack ) );
 // This may change the address of ucs2buffer so we need to put
 // it on the cleanup stack again!!
 ucs2buffer = ucs2buffer->ReAllocL
 ( ucs2buffer->Length() + ptr.Length() );
 // Source
 PUSHLOG_WRITE_FORMAT(" Storage: 0x%x",NW_String_getStorage(&aString));
 PUSHLOG_WRITE_FORMAT(" Byte count: %d",NW_String_getByteCount(&aString)-1);
 // We will use NW_String_getByteCount(&aString)-1 as size, because
 // NW_String_getByteCount(&aString) includes NULL terminator.
 const TPtrC8 src( NW_String_getStorage(&aString),
 NW_String_getByteCount(&aString)-1 );
 HBufC16* ucs2buffer = ConvertToUnicodeL( src, id );
 PUSHLOG_LEAVEFN("CSIContentHandler::ConvertToUnicodeL");
 return ucs2buffer;
 PUSHLOG_ENTERFN("CSIContentHandler::InitialiseCharacterSetConverterL")
 iCharacterSetConverter = CCnvCharacterSetConverter::NewL();
 RFs& fs = iMsvSession->FileSession();
 iCharacterSetsAvailable =
 CCnvCharacterSetConverter::CreateArrayOfCharacterSetsAvailableL( fs );
 PUSHLOG_LEAVEFN("CSIContentHandler::InitialiseCharacterSetConverterL")
 }
 // ---------------------------------------------------------
 // CSIContentHandler::SetSIPushMsgEntryFieldsL
 // ---------------------------------------------------------
 //
 void CSIContentHandler::SetSIPushMsgEntryFieldsL( CSIPushMsgEntry&
 aSIPushMsgEntry )
 	{
 PUSHLOG_ENTERFN("CSIContentHandler::SetSIPushMsgEntryFieldsL")
 	if ( SiIdFlag() || HrefFlag() )
 aSIPushMsgEntry.SetIdL( *iSiIdBuf );
 aSIPushMsgEntry.SetUrlL( *iHrefBuf );
 }
 		}
 __ASSERT_DEBUG( ActionFlag(),
 ContHandPanic( EPushContHandPanUnspecSiAction ) );
 	if ( ActionFlag() )
 {
 		aSIPushMsgEntry.SetAction( iPushMsgAction );
 }
 // First line in Inbox: TMsvEntry::iDetails.
 if ( srvAddress.Length() == 0 )
 {
 // Read from resource.
 HBufC* details =
 iStrRscReader->AllocReadResourceLC( R_PUSHMISC_UNK_SENDER );
 aSIPushMsgEntry.SetMsgDetailsL( *details );
 CleanupStack::PopAndDestroy( details );
 }
 else
 {
 // Convert the "From" information to the format required by the UI
 // spec and then decode it.
 HBufC* details = iWapPushUtils->ConvertDetailsL( srvAddress );
 CleanupStack::PushL( details );
 HBufC* convertedFrom =
 CPushMtmUtil::ConvertUriToDisplayFormL( *details );
 CleanupStack::PushL( convertedFrom );
 //
 aSIPushMsgEntry.SetMsgDetailsL( *convertedFrom );
 //
 		aSIPushMsgEntry.SetMsgDescriptionL( *iData );
 }
 else
 {
 // Display URL.
 __ASSERT_DEBUG( HrefFlag(),
 ContHandPanic( EPushContHandPanUnspecSiHref ) );
 const TPtrC url = aSIPushMsgEntry.Url();
 HBufC* convertedUrl = CPushMtmUtil::ConvertUriToDisplayFormL( url );
 CleanupStack::PushL( convertedUrl );
 //
 }
 // ******** Push MTM specific processing *********
 /*
 * Unfortunately in CPushMsgEntryBase there is no such functionality
 * with which we can reach TMsvEntry as non-const, but we have to
 * modify the entry's iMtmData2 member somehow. We can do it
 * with either casting or with modifying and saving the entry
 * manually after it has been saved by CSIPushMsgEntry. The latter
 * solution is more expensive so we choose the first.
 */
 TMsvEntry& tEntry = CONST_CAST( TMsvEntry&, aSIPushMsgEntry.Entry() );
 if ( HrefFlag() )
 {
 	{
 PUSHLOG_ENTERFN("CSIContentHandler::ProcessingPushMsgEntryL")
 	TBool deletePushMsg( EFalse );
 __ASSERT_DEBUG( ActionFlag(),
 ContHandPanic( EPushContHandPanUnspecSiAction ) );
 // S60 requirement: if both the href and the message is empty then
 // delete the msg.
 if ( HrefFlag() == EFalse && DataFlag() == EFalse )
 {
 deletePushMsg = ETrue;
 }
 PUSHLOG_WRITE("CSIContentHandler already expired")
 		    deletePushMsg = ETrue;
 		    }
 }
 	// An SI with the action attribute set to “delete” MUST have an
 // explicitly assigned value for si-id.
 	if ( !deletePushMsg && ActionFlag() )
 		{
 		if ( iPushMsgAction == CSIPushMsgEntry::ESIPushMsgDelete )
 {
 }
 if ( !deletePushMsg && ActionFlag() )
 {
 // SI with action=signal-none must not be presented to the end-user.
 // Note. In S60 signal-none behaves the same as delete: the
 // message is discarded after processing it!
 if ( iPushMsgAction == CSIPushMsgEntry::ESIPushMsgSignalNone )
 {
 deletePushMsg = ETrue;
 }
 {
 		StoreSIMessageL( matchingEntryId );
 }
 else
 {
 // The new entry must be discarded.
 // Delete the corresponding matching entry, too.
 if ( matchingEntryId != KMsvNullIndexEntryId )
 {
 iWapPushUtils->DeleteEntryL( matchingEntryId );
 }
 {
 PUSHLOG_WRITE("Matching SI found");
 //Delete this old entry
 iWapPushUtils->DeleteEntryL( aMatchingEntryId );
 }
 SetSIPushMsgEntryFieldsL( *siEntry );
 iSavedMsgId = siEntry->SaveL( *iMsvSession, KMsvGlobalInBoxIndexEntryId );
 #ifdef __TEST_LOG__
 _LIT( KDateFormat, "%E%D%X%N%Y %1 %2 %3" );
 //
 TBool CSIContentHandler::HandleMsgOrderReceptionL( TMsvId& aMatchingEntryId )
 	{
 PUSHLOG_ENTERFN("CSIContentHandler::HandleMsgOrderReceptionL")
 __ASSERT_DEBUG( ( SiIdFlag() || HrefFlag() ),
 ContHandPanic( EPushContHandPanNoSiIdOrHrefAttr ) );
 __ASSERT_DEBUG( CreatedFlag(),
 ContHandPanic( EPushContHandPanNoCreatedAttr ) );
 CMsvEntrySelection* matchingIdList = NULL;
 	TBool discardPushMsg( EFalse );
 	if ( 0 < matchingListCount && CreatedFlag() )
 		{
 		CSIPushMsgEntry* siEntry = CSIPushMsgEntry::NewL();
 		CleanupStack::PushL( siEntry );
 		// Delete older stored messages and/or mark current message for
 // deletion if same date or older than stored messages
 TBool foundOneToBeReplaced = EFalse;
 		for ( TInt count = 0; count < matchingListCount; ++count )
 			{
 			TMsvId matchingSiMsgEntryId( matchingIdList->At(count) );
 siEntry->RetrieveL( *iMsvSession, matchingSiMsgEntryId );
 			// Skip date comparisons if creation date not valid -
 // SI without created attribute never gets replaced.
 			TTime existingSiCreatedTime( siEntry->Created() );
 			if ( existingSiCreatedTime == Time::NullTTime() )
 {
 				// continue;
 }
 else
 {
 __ASSERT_DEBUG( !foundOneToBeReplaced,
 ContHandPanic( EPushContHandPanTooManySi ) );
 if ( foundOneToBeReplaced )
 {
 PUSHLOG_WRITE(" Already found one")
 // Only one SI has to be found.
 // If the program runs into it, then make a
 // garbage collection to ensure consistency and
 // remove other messages found.
 iWapPushUtils->DeleteEntryL( matchingSiMsgEntryId );
 // After the 'for' only one SI is allowed that has created
 // attribute.
 }
 else
 {
 foundOneToBeReplaced = ETrue; // A match was found.
 // Check if received SI is newer than existing stored Si
 // (out of order).
 if ( iCreatedTime > existingSiCreatedTime )
 	                    {
 PUSHLOG_WRITE(" Replacing...")
 // The new SI replaces the existing.
 aMatchingEntryId = matchingSiMsgEntryId;
 discardPushMsg = EFalse;
 }
 			}
 		CleanupStack::PopAndDestroy( siEntry ); // siEntry
 		}
 	CleanupStack::PopAndDestroy( matchingIdList ); // matchingIdList
 PUSHLOG_LEAVEFN("CSIContentHandler::HandleMsgOrderReceptionL")
 return discardPushMsg;
 	}
 // ---------------------------------------------------------
 // CSIContentHandler::ConvertDateTimeL
 // ---------------------------------------------------------
 //
 TBool CSIContentHandler::ConvertDateTimeL( const TDesC& aDateTime,
 TTime& aConvertedDate ) const
 	{
 PUSHLOG_ENTERFN("CSIContentHandler::ConvertDateTimeL")
 	TTime convertedTime = Time::NullTTime();
 User::Leave( KErrCorrupt );
 }
 else
 			{
 // Now 'str' is in format YYYYMMDD:HHMMSS
 			// Adjust UTC time to zero offset TTime. Only month and day
 // is effected.
 			const TInt KFirstMonthChar = KValidTTimeMonthStart;
 			const TInt KSecondMonthChar = KFirstMonthChar + 1;
 			const TInt KFirstDayChar = KValidTTimeDayStart;
 			const TInt KSecondDayChar = KFirstDayChar + 1;
 				// day value is between 1 and 9 so reduce day by one
 				// eg 29 becomes 28, 11 bcomes 10, 31 becomes 30
 				str[KSecondDayChar]--;
 }
 			// string is now syntaxically correct, but Set() will return an
 // error if it's semantically incorrect.
 User::LeaveIfError( convertedTime.Set( str ) );
 			convertedOK = ETrue;
 			}
 		}
 }
 convertedPtr.Append( TChar(KAsciiZeroCharCode + high) );
 convertedPtr.Append( TChar(KAsciiZeroCharCode + low) );
 }
 // A valid UTC %Datetime contains 14 numerical characters and 6
 // non-numerical: “1999-04-30T06:40:00Z”.
 // So fill the remaining bytes with zeros.
 for ( i = convertedPtr.Length(); i < KValidUTCNumericals; ++i )
 {
 convertedPtr.Append( TChar('0') );
 }
 else
 {
 	    // strip out formatting characters
 	    TInt formatCharPos = 4;
 	    aDateTime.Delete( formatCharPos, 1 );
 	    // now move through two characters at a time and remove other chars
 	    // to just leave digits
 	    const TInt KRemainingFormatChars = 5;
 TInt i( 0 );
 	    for ( i = 0; i < KRemainingFormatChars; ++i )
 		    {
 		    aDateTime.Delete( formatCharPos, 1 );
 		    }
 // Now aDateTime has to be in format YYYYMMDDHHMMSS
 __ASSERT_DEBUG( aDateTime.Length() == KValidTTimeLength,
 ContHandPanic( EPushContHandPanBadTTimeLength ) );
 // now have UTC string stripped of format characters - check remaining
 // characters are all digits - YYYYMMDDHHMMSS
 TChar ch;
 for ( i = 0; i < KValidTTimeLength; ++i )
 		    {
 		    ch = aDateTime[i];
 }
 		    }
 if ( isValid )
 {
 /*
 In YYYYMMDDHHMMSS
 YYYY = 4 digit year ("0000" ... "9999")
 MM = 2 digit month ("01"=January, "02"=February ... "12"=December)
 DD = 2 digit day ("01", "02" ... "31")
 HH = 2 digit hour, 24-hour timekeeping system ("00" ... "23")
 */
 TInt err;
 TUint val;
 // Do not check year. There are no restrictions.
 // Check month.
 TLex parser( aDateTime.Mid( KValidTTimeMonthStart,
 KValidTTimeBlockLength ) );
 err = parser.Val( val, EDecimal );
 if ( err )
 {
 isValid = EFalse;
 }
 }
 // Check day.
 if ( isValid )
 {
 parser = aDateTime.Mid( KValidTTimeDayStart,
 KValidTTimeBlockLength );
 err = parser.Val( val, EDecimal );
 if ( err )
 {
 isValid = EFalse;
 }
 }
 // Check hour.
 if ( isValid )
 {
 parser = aDateTime.Mid( KValidTTimeHourStart,
 KValidTTimeBlockLength );
 err = parser.Val( val, EDecimal );
 if ( err )
 {
 isValid = EFalse;
 }
 }
 // Check minute.
 if ( isValid )
 {
 parser = aDateTime.Mid( KValidTTimeMinuteStart,
 KValidTTimeBlockLength );
 err = parser.Val( val, EDecimal );
 if ( err )
 {
 isValid = EFalse;
 }
 }
 // Check second.
 if ( isValid )
 {
 parser = aDateTime.Mid( KValidTTimeSecondStart,
 KValidTTimeBlockLength );
 err = parser.Val( val, EDecimal );
 if ( err )
 {
 isValid = EFalse;
 // ---------------------------------------------------------
 // CSIContentHandler::AttributeToTTimeL
 // ---------------------------------------------------------
 //
 TBool CSIContentHandler::AttributeToTTimeL
 ( NW_DOM_AttributeHandle_t& aAttrHandle,
 TTime& aConvertedDate ) const
 {
 PUSHLOG_ENTERFN("CSIContentHandler::AttributeToTTimeL")
 TBool gotDate = EFalse;
 TPtrC8 dataPtr( storage, length );
 HBufC* dataBuf = HBufC::NewMaxLC( dataPtr.Length() );
 dataBuf->Des().Copy( dataPtr );
 gotDate = ConvertDateTimeL( *dataBuf, aConvertedDate );
 CleanupStack::PopAndDestroy( 2, stringOwner ); // dataBuf,
 // stringOwner
 }
 else if ( valType == NW_DOM_ATTR_VAL_OPAQUE )
 {
 NW_Uint32 len = 0;
 // ---------------------------------------------------------
 // CSIContentHandler::HandleMessageL
 // ---------------------------------------------------------
 //
 void CSIContentHandler::HandleMessageL( CPushMessage* aPushMsg,
 TRequestStatus& aStatus )
 	{
 PUSHLOG_ENTERFN("CSIContentHandler::HandleMessageL")
 __ASSERT_DEBUG( aPushMsg != NULL,
 ContHandPanic( EPushContHandPanMsgNull ) );
 #ifdef __TEST_LOG__
 TPtrC8 bodyPtr;
 aPushMsg->GetMessageBody( bodyPtr );
 //
 void CSIContentHandler::HandleMessageL( CPushMessage* aPushMsg )
 	{
 PUSHLOG_ENTERFN("CSIContentHandler::HandleMessageL")
 __ASSERT_DEBUG( aPushMsg != NULL,
 ContHandPanic( EPushContHandPanMsgNull ) );
 #ifdef __TEST_LOG__
 TPtrC8 bodyPtr;
 aPushMsg->GetMessageBody( bodyPtr );

changeset 32	92a061761a7b
parent 0	84ad3b177aa3