/*
* Copyright (c) 2006-2007 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: ?Description
*
*/
#include <coemain.h>
#include <ezgzip.h>
#include <sysutil.h>
#include <utf.h>
#include <etel3rdparty.h>
#include <imcvcodc.h>
#include "irdebug.h"
#include "irreportsettings.h"
#include "irsessiondb.h"
#include "irsessionlogger.h"
#include "irsessionloggerutility.h"
#include "irsettings.h"
#include "irnmslogdb.h"
#include "irnmslogger.h"
#include "irdbstatusobserver.h"
#include "irphoneinfo.h"
const TUint KFieldPosition = 5;
const TInt KAmpMaxLength = 5;
const TInt KFormatBuffMaxLength = 6;
const TInt KMaxUrlSize = 256;
const TUint KSessionLogGranularity = 4;
const TUint KNmsLogGranularity = 5;
const TUint KSessionLogThreshold = 5; // Session Log Maximum 15
const TUint KNmsLogThreshold = 5; // Nms Log Maximum 15
// ---------------------------------------------------------------------------
// Function: OpenL
// Two phase constructor returns the instance of CIRReportGenerator
// this is a single ton implementation
// ---------------------------------------------------------------------------
//
EXPORT_C CIRReportGenerator* CIRReportGenerator::OpenL()
{
IRLOG_DEBUG( "CIRReportGenerator::OpenL" );
CIRReportGenerator* reportGenerator = reinterpret_cast<CIRReportGenerator*>(Dll::Tls());
if (reportGenerator)
{
User::LeaveIfError(reportGenerator->Open());
IRLOG_INFO( "CIRReportGenerator::OpenL - Opened singleton for new user." );
}
else
{
reportGenerator = new (ELeave) CIRReportGenerator;
CleanupClosePushL(*reportGenerator);
reportGenerator->ConstructL();
User::LeaveIfError(Dll::SetTls(reportGenerator));
CleanupStack::Pop(reportGenerator);
IRLOG_INFO( "CIRSessionLogger::OpenL - Created the CIRReportGenerator singleton." );
}
IRLOG_DEBUG( "CIRReportGenerator::OpenL - Exiting." );
return reportGenerator;
}
// ---------------------------------------------------------------------------
// Function: ~CIRReportGenerator
// default destructor
// ---------------------------------------------------------------------------
//
CIRReportGenerator::~CIRReportGenerator()
{
IRLOG_DEBUG( "CIRReportGenerator::~CIRReportGenerator" );
delete iImeiBase64;
iImeiBase64 = NULL;
delete iPhoneInfo;
iPhoneInfo = NULL;
//operation settings instance is removed
if( iSettingsData )
{
iSettingsData->Close(); // delete is handled like this.
}
delete iSessionLog;
delete iNmsLog;
delete iLogSessionDb;
delete iNmsLogDb;
//session data is also removed
if (iSessionData)
{
iSessionData->ResetAndDestroy();
}
delete iSessionData;
//NmsLog data is also removed
if (iNmsLogData)
{
iNmsLogData->ResetAndDestroy();
}
delete iNmsLogData;
iBrowseLog.Close(); //browse log array is closed
iLogFile.Close();
//file session is closed
iFsSession.Close();
delete iPreviousSessionLog;
delete iPreviousNmsLog;
Dll::FreeTls();
IRLOG_DEBUG( "CIRReportGenerator::~CIRReportGenerator - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: ConstructL
// Two phase constructor
// ---------------------------------------------------------------------------
//
void CIRReportGenerator::ConstructL()
{
IRLOG_DEBUG( "CIRReportGenerator::ConstructL" );
iSessionEndCalled = 0;
//file session is connected
//Create the IROperation Settings Instance
iSettingsData = CIRSettings::OpenL();
User::LeaveIfError(iFsSession.Connect());
//session logger is created
iSessionLog = CIRSessionLogger::NewL();
//session logger is created
iNmsLog = CIRNmsLogger::NewL();
//session db is created
iLogSessionDb = CIRSessionDb::NewL();
//NmsLog db is created
iNmsLogDb = CIRNmsLogDb::NewL();
iSessFile =iSettingsData->PrivatePath();
iSessFile.Append(KSession);
TInt error = iLogSessionDb->CreateDbConditional(iSessFile);
if ( error )
{
iSessionDbCreationFailed = ETrue;
}
else
{
iSessionDbCreationFailed = EFalse;
}
iNmsLogFile =iSettingsData->PrivatePath();
iNmsLogFile.Append(KNmsLog);
TInt nmsError = iNmsLogDb->CreateDbConditional(iNmsLogFile);
if ( nmsError )
{
iNmsDbCreationFailed = ETrue;
}
else
{
iNmsDbCreationFailed = EFalse;
}
//session log for five session are to be stored
//and is stored in session data
iSessionData = new (ELeave) CArrayPtrFlat<CIRSessionLogger>(KSessionLogGranularity);
iNmsLogData = new (ELeave) CArrayPtrFlat<CIRNmsLogger>(KNmsLogGranularity);
iPhoneInfo = CPhoneInfo::NewL(this);
iPhoneInfo->StartUpdating();
IRLOG_DEBUG( "CIRReportGenerator::ConstructL - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: CIRReportGenerator
// default constructor
// ---------------------------------------------------------------------------
//
CIRReportGenerator::CIRReportGenerator():iPhoneInfo(NULL),
iDbStatusObserver(NULL),
iNmsLogDbUpdated(EFalse),
iSessionLogDbUpdated(EFalse),
iUnComfirmedReportSent(EFalse),
iSessionLogUpdationFailed(EFalse),
iNmsLogUpdationFailed(EFalse),
iSessionDbCreationFailed(EFalse),
iNmsDbCreationFailed(EFalse),
iImeiBase64(NULL)
{
//No Implementation
}
// ---------------------------------------------------------------------------
// Function: LogServerResult
// logs server connection result
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::LogServerResult(const TDesC& aUrl,TResponse aResult)
{
iSessionLog->LogServerResult(aUrl,aResult);
}
// ---------------------------------------------------------------------------
// Function: LogSongRecog
// logs song recog
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::LogSongRecog()
{
//taking the session start time in GMT
iSongRecogTimestamp.UniversalTime();
TTimeIntervalSeconds offset(iSettingsData->TimeCorrection());
iSongRecogTimestamp -= offset;
iDate = iSongRecogTimestamp.DateTime();
TBuf<64> songRecogTimestamp;
FormatDateTime(songRecogTimestamp,iDate);
iSessionLog->LogSongRecog(songRecogTimestamp);
}
// ---------------------------------------------------------------------------
// Function: UpdateCurrentBrowseNetwork
// logs network browsing
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::UpdateCurrentBrowseNetwork(TInt aNetwork)
{
iCurrentBrowseNetwork = aNetwork;
}
// ---------------------------------------------------------------------------
// Function: LogBrowse
// logs browse url and status information
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::LogBrowse(const TDesC8& aUrl,TInt aStatus)
{
IRLOG_DEBUG( "CIRReportGenerator::LogBrowse" );
//browse url is copied
iRBrowseLog.iBrowseUrl.Copy(aUrl);
//time stamp in GMT is onbtained
iBrowseLogTimeStamp.UniversalTime();
TInt time_val = 0;
time_val = iSettingsData->TimeCorrection();
TTimeIntervalSeconds offset(time_val);
iBrowseLogTimeStamp -= offset;
iDate = iBrowseLogTimeStamp.DateTime();
//formated
FormatDateTime(iRBrowseLog.iTimeStamp,iDate);
_LIT(KFormat,"%d");
(iRBrowseLog.iCurrentNetwork).Format(KFormat,
iCurrentBrowseNetwork);
//status is stored
iRBrowseLog.iStatus = aStatus;
TRAP_IGNORE(iBrowseLog.AppendL(iRBrowseLog))
IRLOG_DEBUG( "CIRReportGenerator::LogBrowse - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: SessionStartedL
// starts a new session
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::SessionStartedL()
{
IRLOG_DEBUG( "CIRReportGenerator::SessionStartedL" );
//gets the session id for new session
iSessionLog->ResetResource();
iSessionLog->UpdateSessionId(iSettingsData->GetLogRunningNo());
iSettingsData->SetLogRunningNoL();
iFileWritePos = 0;
iLogFilePath = iSettingsData->PrivatePath();
iLogFilePath.Append(KLogFileName);
//taking the session start time in GMT
iSessionStartTime.UniversalTime();
iSessionLog->UpdateSessionStartGMTTime();
TTimeIntervalSeconds offset(iSettingsData->TimeCorrection());
iSessionStartTime -= offset;
iDate = iSessionStartTime.DateTime();
FormatDateTime(iSessionLog->StartTime(),iDate);
iSessionLog->UnMarkSession();
//collect the neccessary information
CollectSettingsData();
iSessionLogUpdationFailed = EFalse;
//start adding the intial information in db
IRLOG_DEBUG( "CIRReportGenerator::SessionStartedL - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: NmsLogStartedL
// starts a new nmslog
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::NmsLogStartedL()
{
IRLOG_DEBUG( "CIRReportGenerator::SessionStartedL" );
iNmsTimestamp.UniversalTime();
TInt time_val = 0;
time_val = iSettingsData->TimeCorrection();
TTimeIntervalSeconds offset(time_val);
iNmsTimestamp -= offset;
iDate = iNmsTimestamp.DateTime();
//formated
FormatDateTime(iNmsLog->StartTime(),iDate);
iNmsLogUpdationFailed = EFalse;
//start adding the intial information in db
IRLOG_DEBUG( "CIRReportGenerator::SessionStartedL - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: SessionEnd
// marks the a session
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::SessionEndL( TBool aForcedTermination )
{
IRLOG_DEBUG( "CIRReportGenerator::SessionEndL" );
iSessionEndCalled++;
//session end
if( aForcedTermination )
{
//forced ending of session log
ForcedSessionEndedL();
}
else
{
//unforced ending of session log
iSessionLog->EndLogging();
UnForceSessionEndedL(iSessionLog);
}
IRLOG_DEBUG( "CIRReportGenerator::SessionEndL - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: UpdateTerminatedBy
// updates the termination status
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::UpdateTerminatedBy(TTerminationStatus
aTerminatedBy)
{
IRLOG_DEBUG( "CIRReportGenerator::UpdateTerminatedBy" );
iSessionLog->UpdateTerminationStatus(aTerminatedBy);
}
// ---------------------------------------------------------------------------
// Function: GetConnectedFrom
// connected information is stored
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::UpdateConnectedFrom(TConnectedFrom aConnectedFrom)
{
IRLOG_DEBUG( "CIRReportGenerator::UpdateConnectedFrom" );
iSessionLog->GetConnectedFrom(aConnectedFrom);
}
// ---------------------------------------------------------------------------
// Function: BrowseUrl
// logs browse url and result
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::BrowseUrl(const TDesC& aBrowseUrl,
TInt aStatus)
{
IRLOG_DEBUG( "CIRReportGenerator::BrowseUrl" );
_LIT(KAmp,"&");
TBuf8<KAmpMaxLength> amp;
amp.Copy(KAmp);
TBuf8<KMaxUrlSize> url;
url.Copy(aBrowseUrl);
_LIT8(KAmpnd,"&");
TInt pos = url.Find(KAmpnd);
if(pos > 0)
{
url.Replace(pos,1,amp);
}
LogBrowse(url,aStatus);
IRLOG_DEBUG( "CIRReportGenerator::BrowseUrl - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: UpdateChannelID
// updates the channel id
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::UpdateChannelID(TInt aChanneldID)
{
IRLOG_DEBUG( "CIRReportGenerator::UpdateChannelID" );
iSessionLog->UpdateChannelID(aChanneldID);
}
// ---------------------------------------------------------------------------
// Function: UpdateCurrentNetwork
// updates the current network
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::UpdateCurrentNetwork(TInt aCurrentNetwork)
{
IRLOG_DEBUG( "CIRReportGenerator::UpdateCurrentNetwork" );
iSessionLog->UpdateCurrentNetwork(aCurrentNetwork);
}
// ---------------------------------------------------------------------------
// Function: UpdateHomeOperator
// updates the home network
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::UpdateHomeOperator(TInt aHomeOperator)
{
IRLOG_DEBUG( "CIRReportGenerator::UpdateHomeOperator" );
iSessionLog->UpdateHomeOperator(aHomeOperator);
}
// ---------------------------------------------------------------------------
// Function: MarkSessionStart
// updates the termination status
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::MarkSessionStart()
{
iSessionStartTime.UniversalTime();
TInt time_val = 0;
time_val = iSettingsData->TimeCorrection();
TTimeIntervalSeconds offset(time_val);
iSessionStartTime -= offset;
iDate = iSessionStartTime.DateTime();
FormatDateTime(iSessionLog->StartTime(),iDate);
//setting session start time
iSessionLog->UpdateSessionStartGMTTime();
iSessionLog->MarkSession();
if( iPreviousSessionLog )
{
//if previous session exist it added to the log
TRAP_IGNORE( UnForceSessionEndedL(iPreviousSessionLog) )
delete iPreviousSessionLog;
iPreviousSessionLog = NULL;
}
}
// ---------------------------------------------------------------------------
// Function: HandleStopEvents
// function handles session state changes
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::HandleStopEvents(TBool aIsSessionProgressing )
{
IRLOG_DEBUG( "CIRReportGenerator::HandleStopEvents" );
if( !aIsSessionProgressing )
{
iSessionLog->HandleStopEvents();
}
else
{
iSessionLog->HandleStartEvents();
}
IRLOG_DEBUG( "CIRReportGenerator::HandleStopEvents - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: ReStorePreviousSession
// restore the previous session
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CIRReportGenerator::ReStorePreviousSession()
{
if( iPreviousSessionLog )
{
//if previous session exist that is restored
//ETrue is returned.
iSessionLog->GetBackedUp(*iPreviousSessionLog);
delete iPreviousSessionLog;
iPreviousSessionLog = NULL;
return ETrue;
}
else
{
//if previous session doesn't exist EFalse is returned
return EFalse;
}
}
// ---------------------------------------------------------------------------
// Function: UpdateConnectionType
// updates the connection type
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::UpdateConnectionType(const TDesC&
aConnectionType)
{
IRLOG_DEBUG( "CIRReportGenerator::UpdateConnectionType" );
iSessionLog->UpdateConnectionType(aConnectionType);
}
// ---------------------------------------------------------------------------
// Function: UpdateNmsType
// updates the connection type
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::UpdateNmsType(const TDesC& aNmsType)
{
IRLOG_DEBUG( "CIRReportGenerator::UpdateNmsType" );
iNmsLog->UpdateNmsType(aNmsType);
}
// ---------------------------------------------------------------------------
// Function: SetDbStatusObserser
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::SetDbStatusObserser(MIRLogDbStatusObserver *aDbStatusObserver)
{
iDbStatusObserver = aDbStatusObserver;
}
// ---------------------------------------------------------------------------
// Function: reportSent
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::ReportSent()
{
iUnComfirmedReportSent = ETrue;
}
// ---------------------------------------------------------------------------
// Function : ReponseFromISDSObtained
// This function is called when session log is successfully sent
// removes all session log entries from sessiondb
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::ReponseFromISDSObtained()
{
IRLOG_DEBUG( "CIRReportGenerator::ReponseFromISDSObtained" );
iUnComfirmedReportSent = EFalse;
TRAP_IGNORE(iLogSessionDb->DeleteAllSessionL())
TRAP_IGNORE(iNmsLogDb->DeleteAllNmsLogL())
for(TInt i = 0; i < iBrowseLogsCntToXml; i++)
{
if(iBrowseLog.Count() > 0)
iBrowseLog.Remove(0);
}
}
// ---------------------------------------------------------------------------
// Function: CollectSettingsData
// collect information during starting of session
// like irid, version information.
// ---------------------------------------------------------------------------
//
void CIRReportGenerator::CollectSettingsData()
{
IRLOG_DEBUG( "CIRReportGenerator::CollectSettingsData" );
_LIT(KData,"1.0");
_LIT(KIRID,"NO IRID");
//gets irid from opsetting
TRAP_IGNORE( iIRId.Copy(iSettingsData->GetIRIDL()) );
//if length of irid is zero "no irid" is assigned
if((iIRId).Length() == 0)
{
iIRId.Copy(KIRID);
}
//version copied
iReportVersion.Copy(KData);
IRLOG_DEBUG( "CIRReportGenerator::CollectSettingsData - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: WriteToXmlL
// gathers the information and generates sesion log file and zip file
// file will be stored in private path
// ---------------------------------------------------------------------------
//
void CIRReportGenerator::WriteToXmlL()
{
IRLOG_DEBUG( "CIRReportGenerator::WriteToXmlL" );
//1. log file is created
User::LeaveIfError(iLogFile.Replace(iFsSession,iLogFilePath,EFileWrite));
iLogFile.Seek(ESeekStart,iFileWritePos);
//2. Write file header.
iUniCodeBuf.Copy(KXmlHeader);
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
WriteBufferToLogFile();
//3. Write Version + IRID + IMEI
iUniCodeBuf.Copy(KRPSTARTTAG);
iFileWritePos = iUniCodeBuf.Find(KField);
//3.1 Write Version
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,iReportVersion);
iFileWritePos = iUniCodeBuf.Find(KField);
//3.2 Write IRID
RBuf tempIRID;
TRAP_IGNORE( tempIRID.Create(iSettingsData->GetIRIDL()) );
if((tempIRID).Length() != 0)
{
iIRId.Copy(tempIRID);
}
tempIRID.Close();
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,iIRId);
//3.3 Write IMEI
iFileWritePos = iUniCodeBuf.Find(KField);
if(NULL == iImeiBase64)
{
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,KNullDesC);
}
else
{
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,*iImeiBase64);
}
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
WriteBufferToLogFile();
//4. Write session log
if(!iSessionLogUpdationFailed)
{
for(TInt count = 0; count<(iSessionData->Count()); count++)
{
WriteSessionData(count);
}
}
//5. Write browse log
WriteBrowseLog();
//6. Write nms log
if(!iNmsLogUpdationFailed)
{
iUniCodeBuf.Copy(KNMSLOGSTARTTAG);
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
WriteBufferToLogFile();
for(TInt count = 0; count<(iNmsLogData->Count()); count++)
{
WriteNmsLogData(count);
}
iUniCodeBuf.Copy(KNMSLOGENDTAG);
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
WriteBufferToLogFile();
}
//7. Write file ending
iUniCodeBuf.Copy(KRPENDTAG);
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
WriteBufferToLogFile();
iLogFile.Close();
ZipFileL();
iBrowseLogsCntToXml = iBrowseLog.Count();
IRLOG_DEBUG( "CIRReportGenerator::WriteToXmlL - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: WriteNmsLogtoXmlL
// logs nmsEvents to Xml file
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::WriteNmsLogtoXmlL()
{
IRLOG_DEBUG( "CIRReportGenerator::WriteNmsLogtoXmlL" );
if(iSessionEndCalled == 0)
{
ForcedSessionEndedL();
iSessionEndCalled++;
}
iNmsEventFlag = ETrue;
UnForceSessionEndedL(iSessionLog);
iNmsEventFlag = EFalse;
IRLOG_DEBUG( "CIRReportGenerator::WriteNmsLogtoXmlL - Leaving" );
}
// ---------------------------------------------------------------------------
// Function: WriteSessionData
// gathers session log data and writes to XML file
// ---------------------------------------------------------------------------
//
void CIRReportGenerator::WriteSessionData(TInt aIndex)
{
IRLOG_DEBUG( "CIRReportGenerator::WriteSessionData" );
ASSERT( aIndex >= 0 && aIndex < iSessionData->Count() );
TBuf<KFormatBuffMaxLength> FormatBuff;
_LIT(KConvert,"%d");
// 1. session start time is copied
iUniCodeBuf.Copy(KSESSIONSTARTTAG);
iFileWritePos = iUniCodeBuf.Find(KField);
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,(iSessionData->
At(aIndex))->StartTime());
// 2. session duration is copied
iFileWritePos = iUniCodeBuf.Find(KField);
TInt duration = (iSessionData->At(aIndex))->SessionDuration();
FormatBuff.Format(KConvert,duration);
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,FormatBuff);
// 3. termination status is copied
iFileWritePos = iUniCodeBuf.Find(KField);
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,(iSessionData->
At(aIndex))->TerminationStatus());
// 4. connected from information is copied
iFileWritePos = iUniCodeBuf.Find(KField);
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,(iSessionData->
At(aIndex))->ConnectedFrom());
// 5. session id is copied
iFileWritePos = iUniCodeBuf.Find(KField);
FormatBuff.Format(KConvert,(iSessionData->At(aIndex))->SessionId());
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,FormatBuff);
// 6. channel id is copied
iFileWritePos = iUniCodeBuf.Find(KField);
FormatBuff.Format(KConvert,(iSessionData->At(aIndex))->ChannelID());
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,FormatBuff);
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
WriteBufferToLogFile();
// 8. Write ServerResult
TInt ServerResultCount = (iSessionData->At(aIndex))->
SessionData().Count();
for(TInt count=0; count < ServerResultCount;count++)
{
//channel server urls are copied for the session
iUniCodeBuf.Copy(KSERVERRESULTTAG);
iFileWritePos = iUniCodeBuf.Find(KField);
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,(iSessionData->
At(aIndex)->SessionData()[count].iServerUrl));
//status is copied
iFileWritePos = iUniCodeBuf.Find(KField);
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,(iSessionData->
At(aIndex)->SessionData()[count].iServerResult));
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
//writting the information to the xml file
WriteBufferToLogFile();
}
// 9. connection type is copied
iUniCodeBuf.Copy(KCONNECTIONTAG);
iFileWritePos = iUniCodeBuf.Find(KField);
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,(iSessionData->
At(aIndex))->ConnectionType());
// 10. current network is copied
iFileWritePos = iUniCodeBuf.Find(KField);
FormatBuff.Format(KConvert,(iSessionData->At(aIndex))->
CurrentNetwork());
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,FormatBuff);
// 11. home operator is copied
iFileWritePos = iUniCodeBuf.Find(KField);
FormatBuff.Format(KConvert,(iSessionData->At(aIndex))->HomeOperator());
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,FormatBuff);
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
WriteBufferToLogFile();
// 12. Write Song Recog Log
iUniCodeBuf.Copy(KSONGRECOGLOGSTARTTAG);
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
WriteBufferToLogFile();
TInt songRecogLogCount = (iSessionData->At(aIndex))->
SongRecogLog().Count();
for(TInt count=0; count < songRecogLogCount; count++)
{
iUniCodeBuf.Copy(KSONGRECOGEVENTTAG);
iFileWritePos = iUniCodeBuf.Find(KField);
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,(iSessionData->
At(aIndex)->SongRecogLog()[count].iTimeStamp));
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
WriteBufferToLogFile();
}
iUniCodeBuf.Copy(KSONGRECOGLOGENDTAG);
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
WriteBufferToLogFile();
// write ending tag </session>
iUniCodeBuf.Copy(KSESSIONENDTAG);
//tags are also written into xml file
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
WriteBufferToLogFile();
IRLOG_DEBUG( "CIRReportGenerator::WriteSessionData - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: WriteBrowseLog
// gathers browse log data and writes to XML file
// ---------------------------------------------------------------------------
//
void CIRReportGenerator::WriteBrowseLog()
{
IRLOG_DEBUG( "CIRReportGenerator::WriteBrowseLog" );
//browse log
//browse log tag is written
iUniCodeBuf.Copy(KBROWSESTARTTAG);
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
WriteBufferToLogFile();
for(TInt count = 0; count < (iBrowseLog.Count());count++)
{
//browse log url is copied
iUniCodeBuf.Copy(KBROWSETAG);
iFileWritePos = iUniCodeBuf.Find(KField);
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,
(iBrowseLog).operator[](count).iBrowseUrl);
iFileWritePos = iUniCodeBuf.Find(KField);
//browse log time stamp is copied
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,
(iBrowseLog).operator[](count).iTimeStamp);
iFileWritePos = iUniCodeBuf.Find(KField);
//browse log current network is copied
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,
(iBrowseLog).operator[](count).iCurrentNetwork);
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
//browse log is written to xml
WriteBufferToLogFile();
}
//browse log end tag is copied
iUniCodeBuf.Copy(KBROWSEENDTAG);
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
WriteBufferToLogFile();
IRLOG_DEBUG( "CIRReportGenerator::WriteBrowseLog - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: ZipFileL
// generates the zip file from the input xml file
// output file is in gzip format and is stored in private path
// ---------------------------------------------------------------------------
//
void CIRReportGenerator::ZipFileL()
{
IRLOG_DEBUG( "CIRReportGenerator::ZipFileL" );
//input file is the xml file in private path and output is a gzip file stored
//private path
//xml file
RFile iplogfile;
//getting path of zip file
TFileName gzipfilepath = iSessionLog->FileName();
gzipfilepath.Append(KGZipLogFileName);
iLogFilePath = iSettingsData->PrivatePath();
iLogFilePath.Append(KLogFileName);
//input file is opened
TInt error = iplogfile.Open(iFsSession,iLogFilePath,EFileStream | EFileRead);
CleanupClosePushL( iplogfile );
if( KErrNone != error )
{
User::LeaveIfError(error);
}
//generating zip file
TInt fileSize(0);
TInt err = iplogfile.Size( fileSize );
if(!err)
{
TParse zipParse;
zipParse.Set( iLogFilePath, NULL, NULL );
TPtrC zipDrive = zipParse.Drive();
TChar driveChar = zipDrive[0];
TInt driveNum(0);
RFs::CharToDrive( driveChar, driveNum );
TDriveInfo driveInfo;
TInt driveErr = iplogfile.Drive( driveNum, driveInfo );
if( !driveErr
&& driveNum != EDriveZ
&& !SysUtil::DiskSpaceBelowCriticalLevelL(
&CCoeEnv::Static()->FsSession(), iUTF8Buffer.Size(), driveNum ) )
{
// disk space is not below critical level
// Next generate the zip file
CEZFileToGZip* zip = CEZFileToGZip::NewLC(iFsSession,gzipfilepath, iplogfile);
while(zip->DeflateL())
{
}
CleanupStack::PopAndDestroy(zip);
}
else
{
// disk space is below critical level
// Do not generate the zip file
}
}
//file is closed
CleanupStack::PopAndDestroy(); // iplogfile
IRLOG_DEBUG( "CIRReportGenerator::ZipFileL - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: FormatDateTime
// formats the date time given in "%d-%d-%d %d:%d:%d GMT\n" format
// copies the result to a descriptor
// ---------------------------------------------------------------------------
//
void CIRReportGenerator::FormatDateTime(TDes& aBuffer,TDateTime aDateTime)
{
IRLOG_DEBUG( "CIRReportGenerator::FormatDateTime" );
_LIT(KFormatTxt,"%d-%d-%d %d:%d:%d GMT\n");
aBuffer.Format(KFormatTxt,aDateTime.Year(),TInt(aDateTime.Month()+1),
//Format the month as a TInt to preserve locale independence
//aDateTime.Day()+1,
aDateTime.Day()+1,
// Day and month ranges begin at zero (0-30 and 0-11),
// so add one when formatting
aDateTime.Hour(), aDateTime.Minute(), aDateTime.Second()
//aDateTime.MicroSecond()
);
IRLOG_DEBUG( "CIRReportGenerator::FormatDateTime - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: WriteBufferToLogFile
// Writes the content of iUTF8Buffer to iLogFile
// ---------------------------------------------------------------------------
//
void CIRReportGenerator::WriteBufferToLogFile()
{
IRLOG_DEBUG( "CIRReportGenerator::WriteBufferToLogFile" );
// Get the drive where iLogFile is located.
TInt driveNumber(0);
TDriveInfo driveInfo;
TInt err = iLogFile.Drive( driveNumber, driveInfo );
// Write the log file only if:
// Drive was fetched successflly,
// the drive is not Z
// and free disk space is not below critical level (128kB)
if( !err && driveNumber!=EDriveZ )
{
TBool ret = ETrue;
TRAP_IGNORE( ret = SysUtil::DiskSpaceBelowCriticalLevelL(
&CCoeEnv::Static()->FsSession(),iUTF8Buffer.Size(), driveNumber ))
if( !ret )
{
iLogFile.Write( iUTF8Buffer );
}
else
{
// Do not write the session log.
}
}
else
{
// Do not write the session log.
}
IRLOG_DEBUG( "CIRReportGenerator::WriteBufferToLogFile - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: UnForceSessionEndedL
// Handles Unforced end of the session
// ---------------------------------------------------------------------------
//
void CIRReportGenerator::UnForceSessionEndedL( CIRSessionLogger* aSession )
{
// 1. retrieve session log from db
if(iSessionDbCreationFailed)
{
iSessionLogUpdationFailed = ETrue;
}
else
{
if(iNmsEventFlag)
{
TRAPD(error,
//count is stored
iLogSessionDb->GetAllSessionL(*iSessionData);
);
if(error)
{
iSessionLogUpdationFailed = ETrue;
}
}
else
{
TRAPD( error,
//loads the information into the db at the end of the session
iLogSessionDb->AddSessionStartL(*aSession);
//count is stored
iLogSessionDb->GetAllSessionL(*iSessionData);
);
if(error)
{
iSessionLogUpdationFailed = ETrue;
}
else
{
TInt count = iSessionData->Count();
if((count>0) && (count%KSessionLogThreshold == 0))
{
iSessionLogDbUpdated = ETrue;
}
}
}
}
// 2. retrieve nms log from db
if(iNmsDbCreationFailed)
{
iNmsLogUpdationFailed = ETrue;
}
else
{
if(!iNmsEventFlag)
{
TRAPD( error, iNmsLogDb->GetAllNmsLogL(*iNmsLogData) );
if(error)
{
iNmsLogUpdationFailed = ETrue;
}
}
else
{
TRAPD( error,
//loads the information into the db at the end of the session
iNmsLogDb->AddNmsLogStartL(*iNmsLog);
//count is stored
iNmsLogDb->GetAllNmsLogL(*iNmsLogData);
);
if(error)
{
iNmsLogUpdationFailed = ETrue;
}
else
{
TInt count = iNmsLogData->Count();
if((count>0) && (count%KNmsLogThreshold == 0))
{
iNmsLogDbUpdated = ETrue;
}
}
}
}
//xml file is created and is zipped
WriteToXmlL();
if( iDbStatusObserver &&
( iNmsLogDbUpdated ||
iSessionLogDbUpdated ||
iUnComfirmedReportSent
)
)
{
iDbStatusObserver->LogDbNeedFlush();
iNmsLogDbUpdated = EFalse;
iSessionLogDbUpdated = EFalse;
}
}
// ---------------------------------------------------------------------------
// Function: ForcedSessionEndedL
// Handles forced end of the session
// ---------------------------------------------------------------------------
//
void CIRReportGenerator::ForcedSessionEndedL()
{
iSessionLog->EndLogging();
iPreviousSessionLog = CIRSessionLogger::NewL();
iPreviousSessionLog->GetBackedUp(*iSessionLog);
iPreviousNmsLog = CIRNmsLogger::NewL();
iPreviousNmsLog->GetBackedUp(*iNmsLog);
}
/**
* The following methods are for Nms Event Usage Logging
*/
// ---------------------------------------------------------------------------
// Function: UpdateNmsCurrentNetwork
// logs network during Music Store launching
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::UpdateNmsCurrentNetwork(TInt aNetwork)
{
iNmsLog->UpdateCurrentNetwork(aNetwork);
}
// ---------------------------------------------------------------------------
// Function: UpdateNmsHomeOperator
// logs network during Music Store Launching
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::UpdateNmsHomeOperator(TInt aNetwork)
{
iNmsLog->UpdateHomeOperator(aNetwork);
}
// ---------------------------------------------------------------------------
// Function: UpdateNmsChannelID
// updates the channel id
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRReportGenerator::UpdateNmsChannelID(TInt aChanneldID)
{
IRLOG_DEBUG( "CIRReportGenerator::UpdateNmsChannelID" );
iNmsLog->UpdateChannelID(aChanneldID);
}
// ---------------------------------------------------------------------------
// Function: WriteNmsLogData
// gathers Nmslog data and writes to XML file
// ---------------------------------------------------------------------------
//
void CIRReportGenerator::WriteNmsLogData(TInt aIndex)
{
IRLOG_DEBUG( "CIRReportGenerator::WriteNmsLogData" );
TBuf<KFormatBuffMaxLength> FormatBuff;
_LIT(KConvert,"%d");
//NmsEvent Tag is written
iUniCodeBuf.Copy(KNMSEVENTTAG);
iFileWritePos = iUniCodeBuf.Find(KField);
//Nms Event timestamp is copied
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,(iNmsLogData->
At(aIndex))->StartTime());
//channel id is copied
iFileWritePos = iUniCodeBuf.Find(KField);
ASSERT( aIndex >= 0 && aIndex < iNmsLogData->Count() );
FormatBuff.Format(KConvert,(iNmsLogData->At(aIndex))->ChannelID());
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,FormatBuff);
//type is copied
iFileWritePos = iUniCodeBuf.Find(KField);
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,(iNmsLogData->
At(aIndex))->NmsType());
iFileWritePos = iUniCodeBuf.Find(KField);
//current network is copied
ASSERT( aIndex >= 0 && aIndex < iNmsLogData->Count() );
FormatBuff.Format(KConvert,(iNmsLogData->At(aIndex))->
CurrentNetwork());
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,FormatBuff);
iFileWritePos = iUniCodeBuf.Find(KField);
//home operator is copied
ASSERT( aIndex >= 0 && aIndex < iNmsLogData->Count() );
FormatBuff.Format(KConvert,(iNmsLogData->At(aIndex))->HomeOperator());
iUniCodeBuf.Replace(iFileWritePos,KFieldPosition,FormatBuff);
CnvUtfConverter::ConvertFromUnicodeToUtf8(iUTF8Buffer,iUniCodeBuf);
//writting the information to the xml file
WriteBufferToLogFile();
IRLOG_DEBUG( "CIRReportGenerator::WriteNmsLogData - Exiting." );
}
// ---------------------------------------------------------------------------
// Function: ImeiUpdated
// From MIRPhoneInfoObserver
// ---------------------------------------------------------------------------
//
void CIRReportGenerator::ImeiUpdatedL(const TDesC& aImei)
{
if(0 == aImei.Length())
{
iPhoneInfo->StartUpdating();
return;
}
// prepare base64 codec input
HBufC8 *imei = HBufC8::NewLC( aImei.Length() );
TPtr8 imeiPtr = imei->Des();
imeiPtr.Copy(aImei);
// prepare base64 codec output
HBufC8 *buffer = HBufC8::NewLC( aImei.Length() * 2 );
TPtr8 bufferPtr = buffer->Des();
// Encoding
TImCodecB64 base64Codec;
base64Codec.Initialise();
base64Codec.Encode(*imei, bufferPtr);
// store to data member
if(NULL == iImeiBase64)
{
iImeiBase64 = HBufC16::NewL( aImei.Length() * 2 );
}
TPtr imeiBase64Ptr = iImeiBase64->Des();
imeiBase64Ptr.Copy(bufferPtr);
CleanupStack::PopAndDestroy(buffer);
CleanupStack::PopAndDestroy(imei);
}