1 /*

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 

    20 #include <cntdef.h>

    21 

    22 #include "engine.h"

    23 #include "enginewrapper.h"

    24 #include "creator_log.h" 

    25 #include "creator_traces.h"

    26 

    27 static const TInt KLogsFieldLength = 256;

    28 

    29 //_LIT(KCreatorLogsPrefixName, "CR_");

    30 

    31 //----------------------------------------------------------------------------

    32 

    33 CLogsParameters::CLogsParameters()

    34     {

    35     LOGSTRING("Creator: CLogsParameters::CLogsParameters");

    36 

    37     iPhoneNumber = HBufC::New(KLogsFieldLength);

    38     /*iMissedCallPhoneNumber = HBufC::New(KLogsFieldLength);

    39     iReceivedCallPhoneNumber = HBufC::New(KLogsFieldLength);

    40     iDialledNumberPhoneNumber = HBufC::New(KLogsFieldLength);*/

    41     }

    42 

    43 CLogsParameters::~CLogsParameters()

    44     {

    45     LOGSTRING("Creator: CLogsParameters::~CLogsParameters");

    46 

    47     delete iPhoneNumber;

    48     /*delete iDialledNumberPhoneNumber;

    49     delete iReceivedCallPhoneNumber;

    50     delete iMissedCallPhoneNumber;*/

    51     }

    52 

    53 //----------------------------------------------------------------------------

    54 

    55 CCreatorLogs* CCreatorLogs::NewL(CCreatorEngine* aEngine)

    56     {

    57     CCreatorLogs* self = CCreatorLogs::NewLC(aEngine);

    58     CleanupStack::Pop(self);

    59     return self;

    60     }

    61 

    62 CCreatorLogs* CCreatorLogs::NewLC(CCreatorEngine* aEngine)

    63     {

    64     CCreatorLogs* self = new (ELeave) CCreatorLogs;

    65     CleanupStack::PushL(self);

    66     self->ConstructL(aEngine);

    67     return self;

    68     }

    69 

    70 CCreatorLogs::CCreatorLogs() : CActive(0)

    71     {

    72     }

    73 

    74 void CCreatorLogs::ConstructL(CCreatorEngine* aEngine)

    75     {

    76     LOGSTRING("Creator: CCreatorLogs::ConstructL");

    77 

    78     iEngine = aEngine;

    79 

    80     iLogClient = CLogClient::NewL(CEikonEnv::Static()->FsSession());

    81     iLogEvent = CLogEvent::NewL();

    82 

    83 	CActiveScheduler::Add(this); // needed by CActive

    84     }

    85 

    86 CCreatorLogs::~CCreatorLogs()

    87     {

    88     LOGSTRING("Creator: CCreatorLogs::~CCreatorLogs");

    89 

    90     Cancel(); //from CActive

    91 

    92     if ( iEngine && iEntryIds.Count() )

    93         {

    94         TRAP_IGNORE( iEngine->WriteEntryIdsToStoreL( iEntryIds, KUidDictionaryUidLogs ) );

    95         }

    96     iEntryIds.Reset();

    97     iEntryIds.Close();

    98     

    99     delete iLogEvent;

   100     delete iLogClient;

   101 

   102     if (iParameters)

   103         delete iParameters;

   104     }

   105 

   106 //----------------------------------------------------------------------------

   107 

   108 TBool CCreatorLogs::AskDataFromUserL(TInt aCommand, TInt& aNumberOfEntries)

   109     {

   110     LOGSTRING("Creator: CCreatorLogs::AskDataFromUserL");

   111     if ( aCommand == ECmdDeleteLogs )

   112         {

   113         return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all log entries?") );

   114         }

   115     else if ( aCommand ==  ECmdDeleteCreatorLogs )

   116         {

   117         return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all log entries created with Creator?") );

   118         }

   119     return iEngine->GetEngineWrapper()->EntriesQueryDialog( aNumberOfEntries, _L("How many entries to create?") );

   120     }

   121 

   122 //----------------------------------------------------------------------------

   123 

   124 void CCreatorLogs::RunL()

   125 	{

   126     LOGSTRING("Creator: CCreatorLogs::RunL");

   127 

   128     // log writing finished, stop the async waiting

   129     iLogWriteWait.AsyncStop();

   130     }

   131 

   132 //----------------------------------------------------------------------------

   133 

   134 void CCreatorLogs::DoCancel()

   135 	{

   136     }

   137 

   138 //----------------------------------------------------------------------------

   139 

   140 TInt CCreatorLogs::CreateMissedCallEntryL(CLogsParameters *aParameters)

   141     {

   142     LOGSTRING("Creator: CCreatorLogs::CreateMissedCallEntryL");

   143 

   144     // clear any existing parameter definations

   145     delete iParameters;

   146     iParameters = NULL;

   147     

   148     CLogsParameters* parameters = aParameters;

   149     

   150     // random data needed if no predefined data available

   151     if (!parameters)

   152         {

   153         iParameters = new(ELeave) CLogsParameters;

   154         parameters = iParameters;

   155 

   156         /*iParameters->iMissedCallPhoneNumber->Des().Zero();

   157         iParameters->iMissedCallPhoneNumber->Des().AppendNum( iEngine->RandomNumber(1000000, 9999999) );

   158 

   159         iParameters->iMissedCallEventTime.UniversalTime();

   160         iParameters->iMissedCallEventTime -= TTimeIntervalMinutes( iEngine->RandomNumber(12000) );*/

   161         parameters->iPhoneNumber->Des().Zero();

   162         parameters->iPhoneNumber->Des().AppendNum( iEngine->RandomNumber(1000000, 9999999) );

   163         

   164         parameters->iEventTime.UniversalTime();

   165         parameters->iEventTime -= TTimeIntervalMinutes( iEngine->RandomNumber(12000) );

   166 

   167         }

   168     

   169     // defaults

   170     iLogEvent->SetId( KLogNullId );

   171     iLogEvent->SetEventType( KNullUid );

   172     iLogEvent->SetRemoteParty( KNullDesC );

   173     iLogEvent->SetDirection( KNullDesC );

   174     iLogEvent->SetTime( Time::NullTTime() );

   175     iLogEvent->SetDurationType( KLogNullDurationType );

   176     iLogEvent->SetDuration( KLogNullDuration );

   177     iLogEvent->SetStatus( KNullDesC );

   178     iLogEvent->SetSubject( KNullDesC );

   179     iLogEvent->SetNumber( KNullDesC );

   180     iLogEvent->SetContact( KNullContactId );

   181     iLogEvent->SetLink( KLogNullLink );

   182     iLogEvent->SetDescription( KNullDesC );

   183     iLogEvent->SetFlags( KLogNullFlags );

   184     iLogEvent->SetEventType(KLogCallEventTypeUid);

   185     iLogEvent->SetSubject(_L("A"));

   186 

   187     // set direction

   188     TLogString missed;

   189     iLogClient->GetString(missed, R_LOG_DIR_MISSED);

   190     iLogEvent->SetDirection(missed);

   191 

   192     // set duration

   193     iLogEvent->SetDurationType( KLogDurationNone );

   194     TLogDuration duration = 0;

   195     iLogEvent->SetDuration(duration);

   196 

   197     // set the phone number

   198     //iLogEvent->SetNumber( iParameters->iMissedCallPhoneNumber->Des() );

   199     iLogEvent->SetNumber( parameters->iPhoneNumber->Des() );

   200 

   201     // set event time

   202     //iLogEvent->SetTime( iParameters->iMissedCallEventTime );

   203     iLogEvent->SetTime( parameters->iEventTime );

   204 

   205     // start writing

   206     __ASSERT_ALWAYS(!IsActive(), User::Panic(_L("LogWriter"), 150));

   207 	iLogClient->AddEvent(*iLogEvent, iStatus);

   208 	SetActive();

   209 

   210     // wait till adding has finished

   211     iLogWriteWait.Start();

   212 

   213     // id has been generated, store it for being able to delete

   214     // entries created only with Creator

   215     iEntryIds.Append( iLogEvent->Id() );

   216 

   217     return iStatus.Int();  // should be KErrNone if writing was succesful

   218     }

   219 

   220 //----------------------------------------------------------------------------

   221 

   222 TInt CCreatorLogs::CreateReceivedCallEntryL(CLogsParameters *aParameters)

   223     {

   224     LOGSTRING("Creator: CCreatorLogs::CreateReceivedCallEntryL");

   225 

   226     // clear any existing parameter definations

   227     delete iParameters;

   228     iParameters = NULL;

   229     

   230     CLogsParameters* parameters = aParameters;

   231         

   232     // random data needed if no predefined data available

   233     if (!parameters)

   234         {

   235         iParameters = new(ELeave) CLogsParameters;

   236         parameters = iParameters;

   237 

   238         /*iParameters->iReceivedCallPhoneNumber->Des().Zero();

   239         iParameters->iReceivedCallPhoneNumber->Des().AppendNum( iEngine->RandomNumber(1000000, 9999999) );

   240 

   241         iParameters->iReceivedCallEventTime.UniversalTime();

   242         iParameters->iReceivedCallEventTime -= TTimeIntervalMinutes( iEngine->RandomNumber(12000) );

   243 

   244         iParameters->iReceivedCallDuration = iEngine->RandomNumber(7200);*/

   245         parameters->iPhoneNumber->Des().Zero();

   246         parameters->iPhoneNumber->Des().AppendNum( iEngine->RandomNumber(1000000, 9999999) );

   247         

   248         parameters->iEventTime.UniversalTime();

   249         parameters->iEventTime -= TTimeIntervalMinutes( iEngine->RandomNumber(12000) );

   250         

   251         parameters->iDuration = iEngine->RandomNumber(7200);

   252         }

   253    

   254     // defaults

   255     iLogEvent->SetId( KLogNullId );

   256     iLogEvent->SetEventType( KNullUid );

   257     iLogEvent->SetRemoteParty( KNullDesC );

   258     iLogEvent->SetDirection( KNullDesC );

   259     iLogEvent->SetTime( Time::NullTTime() );

   260     iLogEvent->SetDurationType( KLogNullDurationType );

   261     iLogEvent->SetDuration( KLogNullDuration );

   262     iLogEvent->SetStatus( KNullDesC );

   263     iLogEvent->SetSubject( KNullDesC );

   264     iLogEvent->SetNumber( KNullDesC );

   265     iLogEvent->SetContact( KNullContactId );

   266     iLogEvent->SetLink( KLogNullLink );

   267     iLogEvent->SetDescription( KNullDesC );

   268     iLogEvent->SetFlags( KLogNullFlags );

   269     iLogEvent->SetEventType(KLogCallEventTypeUid);

   270     iLogEvent->SetSubject(_L("A"));

   271 

   272     // set direction

   273     TLogString incoming;

   274     iLogClient->GetString(incoming, R_LOG_DIR_IN);

   275     iLogEvent->SetDirection(incoming);

   276 

   277     // set duration

   278     iLogEvent->SetDurationType( KLogDurationValid );

   279     //iLogEvent->SetDuration( iParameters->iReceivedCallDuration );

   280     iLogEvent->SetDuration( parameters->iDuration );

   281 

   282     // set the phone number

   283     //iLogEvent->SetNumber( iParameters->iReceivedCallPhoneNumber->Des() );

   284     iLogEvent->SetNumber( parameters->iPhoneNumber->Des() );

   285 

   286     // set event time

   287     //iLogEvent->SetTime( iParameters->iReceivedCallEventTime );

   288     iLogEvent->SetTime( parameters->iEventTime );

   289 

   290     // start writing

   291     __ASSERT_ALWAYS(!IsActive(), User::Panic(_L("LogWriter"), 151));

   292 	iLogClient->AddEvent(*iLogEvent, iStatus);

   293 	SetActive();

   294 

   295     // wait till adding has finished

   296     iLogWriteWait.Start();

   297 

   298     // id has been generated, store it for being able to delete

   299     // entries created only with Creator

   300     iEntryIds.Append( iLogEvent->Id() );

   301 

   302     return iStatus.Int();  // should be KErrNone if writing was succesful

   303     }

   304 

   305 //----------------------------------------------------------------------------

   306 

   307 

   308 TInt CCreatorLogs::CreateDialledNumberEntryL(CLogsParameters *aParameters)

   309     {

   310     LOGSTRING("Creator: CCreatorLogs::CreateDialledNumberEntryL");

   311 

   312     // clear any existing parameter definations

   313     delete iParameters;

   314     iParameters = NULL;

   315     

   316     CLogsParameters* parameters = aParameters; 

   317         

   318     // random data needed if no predefined data available

   319     if (!parameters)

   320         {

   321         iParameters = new(ELeave) CLogsParameters;

   322         parameters = iParameters;

   323 

   324         /*iParameters->iDialledNumberPhoneNumber->Des().Zero();

   325         iParameters->iDialledNumberPhoneNumber->Des().AppendNum( iEngine->RandomNumber(1000000, 9999999) );

   326 

   327         iParameters->iDialledNumberEventTime.UniversalTime();

   328         iParameters->iDialledNumberEventTime -= TTimeIntervalMinutes( iEngine->RandomNumber(12000) );

   329 

   330         iParameters->iDialledNumberDuration = iEngine->RandomNumber(7200);*/

   331         parameters->iPhoneNumber->Des().Zero();

   332         parameters->iPhoneNumber->Des().AppendNum( iEngine->RandomNumber(1000000, 9999999) );

   333 

   334         parameters->iEventTime.UniversalTime();

   335         parameters->iEventTime -= TTimeIntervalMinutes( iEngine->RandomNumber(12000) );

   336 

   337         parameters->iDuration = iEngine->RandomNumber(7200);

   338 

   339         }

   340    

   341     // defaults

   342     iLogEvent->SetId( KLogNullId );

   343     iLogEvent->SetEventType( KNullUid );

   344     iLogEvent->SetRemoteParty( KNullDesC );

   345     iLogEvent->SetDirection( KNullDesC );

   346     iLogEvent->SetTime( Time::NullTTime() );

   347     iLogEvent->SetDurationType( KLogNullDurationType );

   348     iLogEvent->SetDuration( KLogNullDuration );

   349     iLogEvent->SetStatus( KNullDesC );

   350     iLogEvent->SetSubject( KNullDesC );

   351     iLogEvent->SetNumber( KNullDesC );

   352     iLogEvent->SetContact( KNullContactId );

   353     iLogEvent->SetLink( KLogNullLink );

   354     iLogEvent->SetDescription( KNullDesC );

   355     iLogEvent->SetFlags( KLogNullFlags );

   356     iLogEvent->SetEventType(KLogCallEventTypeUid);

   357     iLogEvent->SetSubject(_L("A"));

   358 

   359     // set direction

   360     TLogString outgoing;

   361     iLogClient->GetString(outgoing, R_LOG_DIR_OUT);

   362     iLogEvent->SetDirection(outgoing);

   363 

   364     // set duration

   365     iLogEvent->SetDurationType( KLogDurationValid );

   366     //iLogEvent->SetDuration( iParameters->iDialledNumberDuration );

   367     iLogEvent->SetDuration( parameters->iDuration );

   368 

   369     // set the phone number

   370     //iLogEvent->SetNumber( iParameters->iDialledNumberPhoneNumber->Des() );

   371     iLogEvent->SetNumber( parameters->iPhoneNumber->Des() );

   372 

   373     // set event time

   374     //iLogEvent->SetTime( iParameters->iDialledNumberEventTime );

   375     iLogEvent->SetTime( parameters->iEventTime );

   376 

   377     // start writing

   378     __ASSERT_ALWAYS(!IsActive(), User::Panic(_L("LogWriter"), 152));

   379 	iLogClient->AddEvent(*iLogEvent, iStatus);

   380 	SetActive();

   381 

   382     // wait till adding has finished

   383     iLogWriteWait.Start();

   384 

   385     // id has been generated, store it for being able to delete

   386     // only entries created with Creator

   387     iEntryIds.Append( iLogEvent->Id() );

   388     

   389     return iStatus.Int();  // should be KErrNone if writing was succesful

   390     }

   391 

   392 //----------------------------------------------------------------------------

   393 void CCreatorLogs::DeleteAllL()

   394     {

   395     LOGSTRING("Creator: CCreatorLogs::DeleteAllL");

   396     iLogClient->ClearLog( TTime( Time::MaxTTime() ), iStatus ); 

   397     SetActive();

   398     

   399     // wait till delete has finished

   400     iLogWriteWait.Start();

   401     User::LeaveIfError( iStatus.Int() );

   402 

   403     // reset must be done here, because iEntryIds is stored in destructor

   404     iEntryIds.Reset();

   405     

   406     // all entries deleted, remove the Logs related registry

   407     iEngine->RemoveStoreL( KUidDictionaryUidLogs );

   408     }

   409 

   410 //----------------------------------------------------------------------------

   411 void CCreatorLogs::DeleteAllCreatedByCreatorL()

   412     {

   413     LOGSTRING("Creator: CCreatorLogs::DeleteAllCreatedByCreatorL");

   414     iEntryIds.Reset();

   415     

   416     // fetch ids of entries created by Creator

   417     iEngine->ReadEntryIdsFromStoreL( iEntryIds, KUidDictionaryUidLogs );

   418     

   419     // delete entries

   420     for ( TInt i = 0; i < iEntryIds.Count(); i++ )

   421         {

   422         // This could be implemented with while loop

   423         // with additional cancel flag. That would enable 

   424         // using CancelOp() and cancelling would be bit smoother.

   425         // With this for loop implementation all entries will be

   426         // deleted whether or not user cancels during logs operation.

   427 

   428         iLogClient->DeleteEvent( iEntryIds[i], iStatus );

   429         SetActive();        

   430         // wait till delete has finished

   431         iLogWriteWait.Start();

   432         }

   433     

   434     // reset must be done here, because iEntryIds is stored in destructor

   435     iEntryIds.Reset();

   436     

   437     // all entries deleted, remove the Logs related registry

   438     iEngine->RemoveStoreL( KUidDictionaryUidLogs );

   439     }