diff -r 000000000000 -r 8e480a14352b messagingfw/wappushfw/pushwatcher/src/pushwatcher.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingfw/wappushfw/pushwatcher/src/pushwatcher.cpp Mon Jan 18 20:36:02 2010 +0200 @@ -0,0 +1,273 @@ +// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include +#include + +#include "pushwatcher.h" +#include +#include +#include "flogger.h" + +#ifdef __WATCHER_API_V2__ + +#include + +const TImplementationProxy ImplementationTable[] = + { + IMPLEMENTATION_PROXY_ENTRY(0x10009145, CPushWatcher::NewL) + }; + +EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount) + { + aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy); + + return ImplementationTable; + } +#endif // __WATCHER_API_V2__ + +#ifdef __WATCHER_API_V2__ +CPushWatcher* CPushWatcher::NewL(TAny* aWatcherParams) +#else +/** single exported constructor to allow creation of push watcher + which in turn creates Connection Manager and waits for a push + message to arrive. + @param RF + @param CWatcherLog + @return pointer to created object +*/ +EXPORT_C CPushWatcher* CPushWatcher::NewL(RFs&, CWatcherLog& aLog) +#endif // __WATCHER_API_V2__ + { +#ifdef __WATCHER_API_V2__ + TWatcherParams* params = reinterpret_cast(aWatcherParams); + CPushWatcher* self= new (ELeave) CPushWatcher(CActive::EPriorityStandard, params->iLog); +#else + CPushWatcher* self = new(ELeave) CPushWatcher(CActive::EPriorityStandard, aLog); +#endif // __WATCHER_API_V2__ + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +/** private constructor */ +CPushWatcher::CPushWatcher(TInt aPriority, CWatcherLog& aLog) +: CActive(aPriority), iLog(aLog) + { + } + +/** destructor to cancel any outstanding requests */ +CPushWatcher::~CPushWatcher() + { + Cancel(); + } + +/** start scheduler and create connection manager, then wait */ +void CPushWatcher::ConstructL() + { + CActiveScheduler::Add(this); + iLog.Printf(_L("PushWatcher: Constructing...")); + iConnMan = CConnectionManager::NewL(*this); + } + +/** watcher starts connection manager and just idles, no other states or + activities so RunL is empty. + + The Connection Manager processes any push messages. */ +void CPushWatcher::RunL() + { + // nothing to do + } + +/** no active RunL so no Cancel required */ +void CPushWatcher::DoCancel() + { + // nothing to do + } + + + + + + +/** log debug information tp c:\logs\watcher directory if present + after formatting message to print. + @param list of args + @return void +*/ +void CPushWatcher::WPLPrintf(const TDesC& aDescription) + { + _LIT(KPushLogFmt,"Push:%S"); + + // 7 is the length of "Push:" from above + '\n' tagged on in the Printf() + TPtrC buf = aDescription.Left(Min(KWatcherLogBuffer-7, aDescription.Length())); + iLog.Printf(KPushLogFmt, &buf); + } + + +/** + * Takes the data in a Push Message and prints it to console and the logs it to file. + * Uses the accessor functions of the CPushMessage class and this classes Printf function + * to perform this. Currently 4 headers and the message body are displayed and + * logged. The headers are: + * PushID, Content-Type, X-Application-ID, Expiry Date, + * + * @param CPushMessage& aMessage + * in: a reference to a Push Message. + */ +void CPushWatcher::WPLPrintf(CPushMessage& aMessage) + { + TRAPD(error, WPLPrintfL(aMessage)); + if (error != KErrNone) + { + _LIT(KErrMessage, "Wap Push Watcher logging failed"); + WPLPrintf(KErrMessage); + } + } + +/** + * Private WPLPrint leaving method + */ +void CPushWatcher::WPLPrintfL(CPushMessage& aMessage) + { + TBuf buf; + + // Content type + _LIT(KLogContentFmt,"Content Type : \t%S"); + TPtrC contentPointer; + aMessage.GetContentType(contentPointer); + // max length, including the post-append '\n' + TInt maxSize(KWatcherLogBuffer - (KLogContentFmt().Length()+1)); + TPtrC tmp(contentPointer.Left(maxSize)); + buf.Format(KLogContentFmt,&tmp); + buf.Append('\n'); + WPLPrintf(buf); + + // Date Field + _LIT(KLogDateTimeFmt," %-B%:0%J%:1%T%:2%S%+B %D %N %Y %4 %5 %3"); + _LIT(KLogDateFmt,"Date :\tS"); + TBool foundField; + TTime timeValue; + foundField = aMessage.GetHeaderField(EHttpDate, timeValue); + if (foundField) + { + timeValue.FormatL(buf, KLogDateTimeFmt); + buf.Format(KLogDateFmt, &buf); + WPLPrintf(buf); + } + + //Expires Field + foundField = aMessage.GetHeaderField(EHttpExpires, timeValue); + if (foundField) + { + timeValue.FormatL(buf, KLogDateTimeFmt); + buf.Format(KLogDateFmt, &buf); + WPLPrintf(buf); + } + + // X-Wap-Application-ID + TBool isInt; + TInt ID; + TPtrC8 generalPtr; + _LIT(KLogAppIdIntFmt,"App ID :\t%X"); + _LIT(KLogAppIdStringFmt,"App ID :\t%S"); + foundField = aMessage.GetAppIdL(generalPtr, ID, isInt); + if (foundField) // App ID is present + { + if (isInt) // Field in integer format + { + buf.Format(KLogAppIdIntFmt,ID); + } + else // should be descriptor format + { + buf.Format(KLogAppIdStringFmt,&generalPtr); + } + WPLPrintf(buf); + } + + //Message Header Binary + _LIT(KLogMsgHdr,"Header Binary:"); + WPLPrintf(KLogMsgHdr); + aMessage.GetHeader(generalPtr); + + HBufC* tempHdr = HBufC::NewLC(generalPtr.Length()); + tempHdr->Des().Copy(generalPtr); + WPLLogBinaryAsHex(*tempHdr); + CleanupStack::PopAndDestroy(); //tempHdr + + //Message Body + aMessage.GetMessageBody(generalPtr); + + // Dump Body As Text + _LIT(KLogMsgBody,"Body Text:"); + WPLPrintf(KLogMsgBody); + HBufC* tempBody = HBufC::NewLC(generalPtr.Length()); + tempBody->Des().Copy(generalPtr); + WPLPrintf(*tempBody); + + // Dump Body As Hex + _LIT(KBodyBinary,"Body Binary:"); + WPLPrintf(KBodyBinary); + WPLLogBinaryAsHex(*tempBody); + + CleanupStack::PopAndDestroy(); //tempBody + } + + /** + * Prints out Buffer data in the format: + * %X %X %X %X %X %X %X\n etc + * For example + * AB CD 01 12 34 A2 + * + * @param aDescription + * in: the descriptor to be dumped into the log + */ +void CPushWatcher::WPLLogBinaryAsHex(const TDesC& aDescription) + { + _LIT(KHexSpace,"%02X "); + TBuf hexBuf; + TBuf buf; + + TInt i = 0, bodyLen = aDescription.Length(); + + for (; i < bodyLen; i++) + { + hexBuf.Format(KHexSpace,aDescription[i]); + buf.Append(hexBuf); + if ( i && ((i+1) % 8) == 0 ) + { + WPLPrintf(buf); + buf.Zero(); + } + } + + if (buf.Length()) + WPLPrintf(buf); + } + + + +/** log error description to debug file */ +void CPushWatcher::WPLLogError(const TDesC& aDescription,TInt aError) + { + _LIT(KErrorLogFmt,"Push:%S, Error\t%d"); + const TInt KWatcherLogBuffer=256; + TBuf buf; + buf.Format(KErrorLogFmt,&aDescription,aError); + buf.Append('\n'); + WPLPrintf(buf); + } +