1 /*

     2 * Copyright (c) 2009 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 // INCLUDE FILES

    19 #include <QList>

    20 #include <logview.h>

    21 #include <logwraplimits.h>

    22 #include "logsreaderstates.h"

    23 #include "logsreaderstatecontext.h"

    24 #include "logsevent.h"

    25 #include "logseventdata.h"

    26 #include "logsengdefs.h"

    27 #include "logslogger.h"

    28 #include "logsreaderobserver.h"

    29 #include "logscommondata.h"

    30 

    31 // CONSTANTS

    32 

    33 // ----------------------------------------------------------------------------

    34 // LogsReaderStateBase::LogsReaderStateBase

    35 // ----------------------------------------------------------------------------

    36 //

    37 LogsReaderStateBase::LogsReaderStateBase(

    38     LogsReaderStateContext& context) 

    39  : mContext(context),

    40    mNextState(0)

    41 {

    42 }

    43 

    44 // ----------------------------------------------------------------------------

    45 // LogsReaderStateBase::~LogsReaderStateBase

    46 // ----------------------------------------------------------------------------

    47 //

    48 LogsReaderStateBase::~LogsReaderStateBase()

    49 {

    50 

    51 }

    52 

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

    54 // LogsReaderStateFiltering::setNextState

    55 // ----------------------------------------------------------------------------

    56 //

    57 void LogsReaderStateBase::setNextState(LogsReaderStateBase& nextState)

    58 {

    59     mNextState = &nextState;

    60 }

    61 

    62 // ----------------------------------------------------------------------------

    63 // LogsReaderStateFiltering::enterNextStateL

    64 // ----------------------------------------------------------------------------

    65 //

    66 bool LogsReaderStateBase::enterNextStateL()

    67 {

    68     if ( mNextState ){

    69         mContext.setCurrentState(*mNextState);

    70         return mNextState->enterL();

    71     }

    72     return false;

    73 }

    74 

    75 // ----------------------------------------------------------------------------

    76 // LogsReaderStateBase::enterL

    77 // ----------------------------------------------------------------------------

    78 //

    79 bool LogsReaderStateBase::enterL()

    80 {

    81     return false;

    82 }

    83 

    84 // ----------------------------------------------------------------------------

    85 // LogsReaderStateBase::continueL

    86 // ----------------------------------------------------------------------------

    87 //

    88 bool LogsReaderStateBase::continueL()

    89 {

    90     return false;

    91 }

    92 

    93 // ----------------------------------------------------------------------------

    94 // LogsReaderStateBase::viewCount

    95 // ----------------------------------------------------------------------------

    96 //

    97 int LogsReaderStateBase::viewCountL() const

    98     {

    99     return mContext.logView().CountL();

   100     }

   101 

   102 // ----------------------------------------------------------------------------

   103 // LogsReaderStateBase::event

   104 // ----------------------------------------------------------------------------

   105 //

   106 CLogEvent& LogsReaderStateBase::event() const

   107     {

   108     //The RVCT compiler provides warnings "type qualifier on return type is meaningless"

   109     //for functions that return const values. In order to avoid these numerous warnings and 

   110     //const cascading, the CLogEvent is const_casted here.

   111     return const_cast<CLogEvent&>( mContext.logView().Event() );

   112     }

   113 

   114 // ----------------------------------------------------------------------------

   115 // LogsReaderStateBase::updateAndInsertEventL

   116 // ----------------------------------------------------------------------------

   117 //

   118 bool LogsReaderStateBase::updateAndInsertEventL(

   119     const CLogEvent& source, LogsEvent* dest, int& eventIndex)

   120 {

   121     Q_ASSERT( dest );

   122     dest->initializeEventL( source, mContext.strings() );

   123     dest->setIndex(eventIndex);

   124     mContext.events().insert(eventIndex, dest);

   125     eventIndex++;

   126     return true;

   127 }

   128 

   129 // ----------------------------------------------------------------------------

   130 // LogsReaderStateBase::constructAndInsertEventL

   131 // ----------------------------------------------------------------------------

   132 //

   133 bool LogsReaderStateBase::constructAndInsertEventL(

   134     const CLogEvent& source, LogsEvent* dest, int& eventIndex, QList<LogsEvent*>& events)

   135 {

   136     Q_ASSERT( dest );

   137     dest->initializeEventL( source, mContext.strings() );

   138     if ( !dest->validate() ){

   139         LOGS_QDEBUG( "LogsReaderStateBase::constructAndInsertEventL, event discarded" )

   140         delete dest;

   141         return false;

   142     } 

   143     dest->setIndex(eventIndex);

   144     events.insert(eventIndex, dest);

   145     eventIndex++;

   146     return true;

   147 }

   148 

   149 // ----------------------------------------------------------------------------

   150 // LogsReaderStateBase::resetEvents

   151 // ----------------------------------------------------------------------------

   152 //

   153 void LogsReaderStateBase::resetEvents()

   154 {

   155     QList<LogsEvent*> &events = mContext.events();

   156     for ( int i = 0; i < events.count(); i++ ){

   157         events.at(i)->setIsInView(false);

   158     }

   159 }

   160 

   161 // ----------------------------------------------------------------------------

   162 // LogsReaderStateBase::takeMatchingEvent

   163 // ----------------------------------------------------------------------------

   164 //

   165 LogsEvent* LogsReaderStateBase::takeMatchingEvent(const CLogEvent& event)

   166 {

   167     QList<LogsEvent*> &events = mContext.events();

   168     for ( int i = 0; i < events.count(); i++ ){

   169         if ( events.at(i)->logId() == event.Id() ){

   170             return events.takeAt(i);

   171         }

   172     }

   173     return 0;

   174 }

   175 

   176 // ----------------------------------------------------------------------------

   177 // LogsReaderStateBase::eventById

   178 // ----------------------------------------------------------------------------

   179 //

   180 LogsEvent* LogsReaderStateBase::eventById(int eventId)

   181 {

   182     LogsEvent* event = 0;

   183     QList<LogsEvent*> &events = mContext.events();

   184     for ( int i = 0; i < events.count(); i++ ){

   185         if ( events.at(i)->logId() == eventId ){

   186             event = events.at(i);

   187             break;

   188         }

   189     }

   190     return event;

   191 }

   192 

   193 // ----------------------------------------------------------------------------

   194 // LogsReaderStateBase::duplicatesL

   195 // ----------------------------------------------------------------------------

   196 //

   197 bool LogsReaderStateBase::duplicatesL(const CLogFilter* aFilter){

   198     bool gettingDuplicates( false );

   199     if ( mContext.isRecentView() ){

   200         if ( aFilter ){

   201             gettingDuplicates = 

   202                 static_cast<CLogViewRecent&>( mContext.logView() ).DuplicatesL( 

   203                         mContext.duplicatesView(), *aFilter, mContext.reqStatus() ); 

   204         } else {

   205             gettingDuplicates = 

   206                 static_cast<CLogViewRecent&>( mContext.logView() ).DuplicatesL( 

   207                         mContext.duplicatesView(), mContext.reqStatus() ); 

   208         }

   209     }

   210     return gettingDuplicates;

   211 }

   212 

   213 // ----------------------------------------------------------------------------

   214 // LogsReaderStateInitReading::LogsReaderStateInitReading

   215 // ----------------------------------------------------------------------------

   216 //

   217 LogsReaderStateInitReading::LogsReaderStateInitReading(

   218     LogsReaderStateContext& context ) 

   219  : LogsReaderStateBase(context)

   220 {

   221 }

   222 

   223 // ----------------------------------------------------------------------------

   224 // LogsReaderInitReadingState::enterL

   225 // ----------------------------------------------------------------------------

   226 //

   227 bool LogsReaderStateInitReading::enterL()

   228 {

   229     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateInitReading::enterL" );

   230     resetEvents();

   231     return enterNextStateL();

   232 }

   233 

   234 // ----------------------------------------------------------------------------

   235 // LogsReaderStateFiltering::LogsReaderStateFiltering

   236 // ----------------------------------------------------------------------------

   237 //

   238 LogsReaderStateFiltering::LogsReaderStateFiltering(

   239     LogsReaderStateContext& context ) 

   240  : LogsReaderStateBase(context),

   241    mFilterList(0)

   242 {

   243 }

   244 

   245 // ----------------------------------------------------------------------------

   246 // LogsReaderStateFiltering::~LogsReaderStateFiltering

   247 // ----------------------------------------------------------------------------

   248 //

   249 LogsReaderStateFiltering::~LogsReaderStateFiltering()

   250 {

   251     if ( mFilterList ){

   252         mFilterList->ResetAndDestroy();

   253     }

   254     delete mFilterList;

   255 }

   256 

   257 // ----------------------------------------------------------------------------

   258 // LogsReaderStateFiltering::enterL

   259 // ----------------------------------------------------------------------------

   260 //

   261 bool LogsReaderStateFiltering::enterL()

   262 {

   263     // Filtering all recent calls (max number of recent events is configurable,

   264     // see TLogConfig in logcli.h

   265     //

   266     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateFiltering::enterL" );

   267     

   268     CLogFilterList* filterList = new ( ELeave ) CLogFilterList;

   269     CleanupStack::PushL(filterList);

   270     CLogFilter* filter = CLogFilter::NewL();

   271     CleanupStack::PushL( filter );

   272     filter->SetEventType( KLogCallEventTypeUid );

   273     filterList->AppendL( filter );

   274     CleanupStack::Pop( filter );

   275     

   276     if ( mFilterList ){

   277         mFilterList->ResetAndDestroy();

   278         delete mFilterList;

   279         mFilterList = 0;

   280     }

   281     mFilterList = filterList;

   282     CleanupStack::Pop(filterList);

   283     

   284     if ( setFilterL( *filterList ) ) {

   285         return true;

   286     }

   287     

   288     // Not possible to continue with filtering

   289     return enterNextStateL();

   290 }

   291 

   292 // ----------------------------------------------------------------------------

   293 // LogsReaderStateFiltering::continueL

   294 // ----------------------------------------------------------------------------

   295 //

   296 bool LogsReaderStateFiltering::continueL()

   297 {

   298     return enterNextStateL();

   299 }

   300 

   301 // ----------------------------------------------------------------------------

   302 // LogsReaderStateFiltering::setFilterL

   303 // ----------------------------------------------------------------------------

   304 //

   305 bool LogsReaderStateFiltering::setFilterL(CLogFilterList& filterList){

   306     __ASSERT_ALWAYS( mContext.isRecentView(), User::Leave( KErrNotFound ) );

   307     return static_cast<CLogViewRecent&>( mContext.logView() ).SetRecentListL( 

   308             KLogNullRecentList, filterList, mContext.reqStatus() );

   309 }

   310     

   311 // ----------------------------------------------------------------------------

   312 // LogsReaderStateFiltering::LogsReaderStateFiltering

   313 // ----------------------------------------------------------------------------

   314 //

   315 LogsReaderStateFilteringAll::LogsReaderStateFilteringAll(

   316     LogsReaderStateContext& context ) 

   317  : LogsReaderStateFiltering(context)

   318 {

   319 }

   320 

   321 // ----------------------------------------------------------------------------

   322 // LogsReaderStateFilteringAll::~LogsReaderStateFilteringAll

   323 // ----------------------------------------------------------------------------

   324 //

   325 LogsReaderStateFilteringAll::~LogsReaderStateFilteringAll()

   326 {

   327 }

   328 

   329 // ----------------------------------------------------------------------------

   330 // LogsReaderStateFilteringAll::setFilterL

   331 // ----------------------------------------------------------------------------

   332 //

   333 bool LogsReaderStateFilteringAll::setFilterL(CLogFilterList& filterList){

   334     __ASSERT_ALWAYS( !mContext.isRecentView(), User::Leave( KErrNotFound ) );

   335     return static_cast<CLogViewEvent&>( mContext.logView() ).SetFilterL( 

   336             filterList, mContext.reqStatus() );

   337 }

   338 

   339 // ----------------------------------------------------------------------------

   340 // LogsReaderStateReading::LogsReaderStateReading

   341 // ----------------------------------------------------------------------------

   342 //

   343 LogsReaderStateReading::LogsReaderStateReading(

   344     LogsReaderStateContext& context ) 

   345  : LogsReaderStateBase(context),

   346    mDuplicateMissedFilter(0),

   347    mCheckingMissed(false),

   348    mEventIndex(0),

   349    mReadSizeCounter(0)

   350 {

   351 }

   352 

   353 // ----------------------------------------------------------------------------

   354 // LogsReaderStateReading::~LogsReaderStateReading

   355 // ----------------------------------------------------------------------------

   356 //

   357 LogsReaderStateReading::~LogsReaderStateReading()

   358 {

   359     delete mDuplicateMissedFilter;

   360 }

   361 

   362 // ----------------------------------------------------------------------------

   363 // LogsReaderStateReading::enterL

   364 // ----------------------------------------------------------------------------

   365 //

   366 bool LogsReaderStateReading::enterL()

   367 {

   368     mCheckingMissed = false;

   369     mEventIndex = 0;

   370     mReadSizeCounter = 0;

   371     

   372     if ( !mDuplicateMissedFilter ){

   373         // Interested only about duplicates which are not marked as read

   374         mDuplicateMissedFilter = CLogFilter::NewL();

   375         mDuplicateMissedFilter->SetFlags(KLogEventRead);

   376         mDuplicateMissedFilter->SetNullFields(ELogFlagsField);

   377     }

   378     

   379     if ( viewCountL() > 0 && mContext.logView().FirstL( mContext.reqStatus() ) ){

   380         return true;

   381     }

   382     

   383     // Not possible to continue with reading

   384     return enterNextStateL();  

   385 }

   386 

   387 // ----------------------------------------------------------------------------

   388 // LogsReaderStateReading::continueL

   389 // ----------------------------------------------------------------------------

   390 //

   391 bool LogsReaderStateReading::continueL()

   392 {

   393     int& index = mContext.index();  

   394     QList<LogsEvent*> &events = mContext.events();

   395         

   396     if ( mCheckingMissed ) {

   397         events.at(mEventIndex-1)->setDuplicates( 

   398                 mContext.duplicatesView().CountL() );

   399         mCheckingMissed = false;

   400     } 

   401     else {

   402         const CLogEvent& sourceEvent = event();

   403         LogsEvent* event = takeMatchingEvent(sourceEvent);

   404         bool inserted = false;

   405         if ( event ){

   406             // Matching event is updated and put to new position

   407             inserted = updateAndInsertEventL( sourceEvent, event, mEventIndex );

   408         }

   409         else {

   410             // Create new entry

   411             event = new LogsEvent;

   412             inserted = constructAndInsertEventL( 

   413                     sourceEvent, event, mEventIndex, mContext.events() );

   414         }

   415         

   416         if ( inserted  ){

   417             updateReadSizeCounter(*event);

   418             if ( handleMissedL(*event) ){

   419                 mCheckingMissed = true;

   420                 return true;

   421             }

   422         }

   423     }

   424 

   425     index++;    

   426     if ( canContinueReadingL(index) ){

   427         return mContext.logView().NextL( mContext.reqStatus() );

   428     }           

   429     return enterNextStateL();

   430 }

   431 

   432 // ----------------------------------------------------------------------------

   433 // LogsReaderStateReading::handleMissedL

   434 // ----------------------------------------------------------------------------

   435 //

   436 bool LogsReaderStateReading::handleMissedL(LogsEvent& parsedEvent)

   437 {

   438     bool handled = false;

   439     if ( parsedEvent.direction() == LogsEvent::DirMissed ){

   440         handled = duplicatesL(mDuplicateMissedFilter); 

   441     }

   442     return handled;

   443 }

   444 

   445 // ----------------------------------------------------------------------------

   446 // LogsReaderStateReading::updateReadSizeCounter

   447 // ----------------------------------------------------------------------------

   448 //

   449 void LogsReaderStateReading::updateReadSizeCounter(LogsEvent& event)

   450 {

   451     if ( LogsCommonData::getInstance().maxReadSize() >= 0 ){

   452         LogsEvent::LogsDirection dir = 

   453             LogsCommonData::getInstance().maxReadSizeDirection();

   454         if ( dir == LogsEvent::DirUndefined || dir == event.direction() ){

   455             mReadSizeCounter++;

   456         }

   457     }

   458 }

   459 

   460 // ----------------------------------------------------------------------------

   461 // LogsReaderStateReading::canContinueReadingL

   462 // ----------------------------------------------------------------------------

   463 //

   464 bool LogsReaderStateReading::canContinueReadingL(int index) const

   465 {

   466     bool canContinue( index < viewCountL() );

   467     int maxReadSize = LogsCommonData::getInstance().maxReadSize();

   468     if ( canContinue && maxReadSize >= 0 ){

   469         canContinue = ( mReadSizeCounter < maxReadSize );

   470     }

   471     return canContinue;

   472 }

   473 

   474 // ----------------------------------------------------------------------------

   475 // LogsReaderStateFillDetails::LogsReaderStateFillDetails

   476 // ----------------------------------------------------------------------------

   477 //

   478 LogsReaderStateFillDetails::LogsReaderStateFillDetails(

   479     LogsReaderStateContext& context) 

   480  : LogsReaderStateBase(context)

   481 {

   482 }

   483 

   484 // ----------------------------------------------------------------------------

   485 // LogsReaderStateFillDetails::~LogsReaderStateFillDetails

   486 // ----------------------------------------------------------------------------

   487 //

   488 LogsReaderStateFillDetails::~LogsReaderStateFillDetails()

   489 {

   490 }

   491 

   492 // ----------------------------------------------------------------------------

   493 // LogsReaderStateFillDetails::enterL

   494 // ----------------------------------------------------------------------------

   495 //

   496 bool LogsReaderStateFillDetails::enterL()

   497 {

   498     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateFillDetails::enterL()" )

   499     fillDetails();

   500     LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateFillDetails::enterL()" )

   501     return enterNextStateL();

   502 }

   503 

   504 // ----------------------------------------------------------------------------

   505 // LogsReaderStateFillDetails::fillDetails

   506 // ----------------------------------------------------------------------------

   507 //

   508 void LogsReaderStateFillDetails::fillDetails()

   509 {

   510     QHash<QString, ContactCacheEntry>& contactMappings = mContext.contactCache();

   511     QList<LogsEvent*> &events = mContext.events();

   512     foreach ( LogsEvent* event, events ){

   513         const QString& num = event->getNumberForCalling();

   514         if ( !event->isInView() ){

   515             // Not interested about to be removed event

   516         } else if ( contactMappings.contains(num) ) {

   517             // Matching cached contact found, use that

   518             LOGS_QDEBUG_2( "logs [ENG]    Use existing contact for num:", num )

   519             ContactCacheEntry entry = contactMappings.value(num);

   520             event->setRemoteParty( entry.mRemoteParty );

   521             event->setContactLocalId( entry.mContactLocalId );

   522         } else if ( event->remoteParty().length() == 0 ) {

   523             // No remote party name, search for match from phonebook

   524             QString contactNameStr = event->updateRemotePartyFromContacts(

   525                     LogsCommonData::getInstance().contactManager());

   526             if (contactNameStr.length() > 0){

   527                 LOGS_QDEBUG_3( "LogsReaderStateFillDetails, (name, num):", 

   528                                contactNameStr, num );

   529                 // Cache the new contact name

   530                 ContactCacheEntry contactEntry(contactNameStr, event->contactLocalId());

   531                 contactMappings.insert( num, contactEntry );

   532             }

   533         }

   534     }    

   535 }

   536     

   537 // ----------------------------------------------------------------------------

   538 // LogsReaderStateDone::LogsReaderStateDone

   539 // ----------------------------------------------------------------------------

   540 //

   541 LogsReaderStateDone::LogsReaderStateDone(

   542     LogsReaderStateContext& context ) 

   543  : LogsReaderStateBase(context)

   544 {

   545 }

   546 

   547 // ----------------------------------------------------------------------------

   548 // LogsReaderStateDone::~LogsReaderStateDone

   549 // ----------------------------------------------------------------------------

   550 //

   551 LogsReaderStateDone::~LogsReaderStateDone()

   552 {

   553 }

   554 

   555 // ----------------------------------------------------------------------------

   556 // LogsReaderStateDone::enterL

   557 // ----------------------------------------------------------------------------

   558 //

   559 bool LogsReaderStateDone::enterL()

   560 {

   561     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateDone::enterL" );

   562     

   563     int numRead = qMin(mContext.index(),viewCountL());

   564     mContext.observer().readCompleted(numRead);

   565 

   566     LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateDone::enterL" );

   567     

   568     return false;

   569 }

   570 

   571 

   572 // ----------------------------------------------------------------------------

   573 // LogsReaderStateSearchingEvent::LogsReaderStateSearchingEvent

   574 // ----------------------------------------------------------------------------

   575 //

   576 LogsReaderStateSearchingEvent::LogsReaderStateSearchingEvent(

   577     LogsReaderStateContext& context ) 

   578   : LogsReaderStateBase(context)

   579 {

   580 }

   581 

   582 

   583 // ----------------------------------------------------------------------------

   584 // LogsReaderStateSearchingEvent::enterL

   585 // ----------------------------------------------------------------------------

   586 //

   587 bool LogsReaderStateSearchingEvent::enterL()

   588 {

   589     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateSearchingEvent::enterL" );

   590     if ( viewCountL() > 0 && mContext.logView().FirstL( mContext.reqStatus() ) ){

   591         return true;

   592     }    

   593     return enterNextStateL();    

   594 }

   595 

   596 

   597 // ----------------------------------------------------------------------------

   598 // LogsReaderStateSearchingEvent::continueL

   599 // ----------------------------------------------------------------------------

   600 //

   601 bool LogsReaderStateSearchingEvent::continueL()

   602 {

   603     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateSearchingEvent::continueL" );

   604     int& index = mContext.index();

   605     if ( event().Id() != mContext.currentEventId() ) {

   606         index++;            

   607         if ( index < viewCountL() ){

   608             return mContext.logView().NextL( mContext.reqStatus() );

   609         }

   610     }

   611     

   612     return enterNextStateL();

   613 }    

   614 

   615 // ----------------------------------------------------------------------------

   616 // LogsReaderStateFindingDuplicates::LogsReaderStateFindingDuplicates

   617 // ----------------------------------------------------------------------------

   618 //

   619 LogsReaderStateFindingDuplicates::LogsReaderStateFindingDuplicates(

   620     LogsReaderStateContext& context ) 

   621  : LogsReaderStateBase(context),

   622    mDuplicateFilter(0)

   623 {

   624 }

   625 

   626 // ----------------------------------------------------------------------------

   627 // LogsReaderStateFindingDuplicates::~LogsReaderStateFindingDuplicates

   628 // ----------------------------------------------------------------------------

   629 //

   630 LogsReaderStateFindingDuplicates::~LogsReaderStateFindingDuplicates()

   631 {

   632     delete mDuplicateFilter;

   633 }

   634 

   635 // ----------------------------------------------------------------------------

   636 // LogsReaderStateFindingDuplicates::enterL

   637 // ----------------------------------------------------------------------------

   638 //

   639 bool LogsReaderStateFindingDuplicates::enterL()

   640 {

   641     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateFindingDuplicates::enterL" );

   642     

   643     if ( !mDuplicateFilter ){

   644         // Interested only about duplicates which are not marked as read

   645         mDuplicateFilter = CLogFilter::NewL();

   646         mDuplicateFilter->SetFlags(KLogEventRead);

   647         mDuplicateFilter->SetNullFields(ELogFlagsField);

   648     }

   649     

   650     if ( duplicatesL(mDuplicateFilter) ) {

   651         LOGS_QDEBUG( "logs [ENG] duplicates exist!");

   652         return true;

   653     }

   654     

   655     // Not possible to continue with finding

   656     return enterNextStateL();

   657 }

   658 

   659 // ----------------------------------------------------------------------------

   660 // LogsReaderStateFindingDuplicates::continueL

   661 // ----------------------------------------------------------------------------

   662 //

   663 bool LogsReaderStateFindingDuplicates::continueL()

   664 {

   665     LOGS_QDEBUG( "logs [ENG] <-> LogsReaderStateFindingDuplicates::continueL" );

   666     

   667     return enterNextStateL();

   668 }

   669 

   670 

   671 // ----------------------------------------------------------------------------

   672 // LogsReaderStateMarkingDuplicates::LogsReaderStateMarkingDuplicates

   673 // ----------------------------------------------------------------------------

   674 //

   675 LogsReaderStateMarkingDuplicates::LogsReaderStateMarkingDuplicates(

   676     LogsReaderStateContext& context ) 

   677  : LogsReaderStateBase(context)

   678 {

   679 }

   680     

   681 // ----------------------------------------------------------------------------

   682 // LogsReaderStateMarkingDuplicates::enterL

   683 // ----------------------------------------------------------------------------

   684 //

   685 bool LogsReaderStateMarkingDuplicates::enterL()

   686 {

   687     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateMarkingDuplicates::enterL" );

   688     

   689     mGettingDuplicates = false;

   690     if ( event().Id() == mContext.currentEventId() ) {

   691         // Mark event read

   692         event().SetFlags( event().Flags() | KLogEventRead ); 

   693         mContext.logClient().ChangeEvent(event(), mContext.reqStatus());

   694         return true;

   695     }

   696     

   697     // Not possible to continue with marking

   698     return enterNextStateL();

   699 }

   700 

   701 // ----------------------------------------------------------------------------

   702 // LogsReaderStateMarkingDuplicates::continueL

   703 // ----------------------------------------------------------------------------

   704 //

   705 bool LogsReaderStateMarkingDuplicates::continueL()

   706 {

   707     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateMarkingDuplicates::continueL" );

   708 

   709     if ( !mGettingDuplicates ){

   710         if ( duplicatesL() ) {

   711             LOGS_QDEBUG( "logs [ENG] duplicates exist!");

   712             mGettingDuplicates = true;

   713             return true;

   714         }

   715     } else {

   716         // Mark duplicate events read

   717         mContext.duplicatesView().SetFlagsL(

   718                 mContext.duplicatesView().Event().Flags() | KLogEventRead ); 

   719     }

   720 

   721     LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateMarkingDuplicates::continueL" );

   722     

   723     return enterNextStateL();

   724 }

   725 

   726 // ----------------------------------------------------------------------------

   727 // LogsReaderStateReadingDuplicates::LogsReaderStateReadingDuplicates

   728 // ----------------------------------------------------------------------------

   729 //

   730 LogsReaderStateReadingDuplicates::LogsReaderStateReadingDuplicates(

   731     LogsReaderStateContext& context ) 

   732  : LogsReaderStateBase(context)

   733 {

   734 }

   735 

   736 // ----------------------------------------------------------------------------

   737 // LogsReaderStateReadingDuplicates::enterL

   738 // ----------------------------------------------------------------------------

   739 //

   740 bool LogsReaderStateReadingDuplicates::enterL()

   741 {

   742     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateReadingDuplicates::enterL" );

   743     if ( mContext.duplicatesView().CountL() > 0 && 

   744          mContext.duplicatesView().FirstL(mContext.reqStatus()) ){

   745          LOGS_QDEBUG( "logs [ENG] duplicates exist!");

   746          return true;

   747     }

   748     

   749     // Not possible to continue with deletion

   750     return enterNextStateL();

   751 }

   752 

   753 // ----------------------------------------------------------------------------

   754 // LogsReaderStateReadingDuplicates::continueL

   755 // ----------------------------------------------------------------------------

   756 //

   757 bool LogsReaderStateReadingDuplicates::continueL()

   758 {

   759     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateReadingDuplicates::continueL" );

   760 

   761     int nextIndex = mContext.duplicatedEvents().count();

   762     const CLogEvent& sourceEvent = mContext.duplicatesView().Event();

   763     LogsEvent* event = new LogsEvent;

   764     constructAndInsertEventL( 

   765             sourceEvent, event, nextIndex, mContext.duplicatedEvents() );

   766     if ( mContext.duplicatesView().NextL(mContext.reqStatus()) ) {

   767         return true;

   768     } 

   769 

   770     LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateReadingDuplicates::continueL" );

   771     

   772     return enterNextStateL();

   773 }

   774 

   775 // ----------------------------------------------------------------------------

   776 // LogsReaderStateModifyingDone::LogsReaderStateModifyingDone

   777 // ----------------------------------------------------------------------------

   778 //

   779 LogsReaderStateModifyingDone::LogsReaderStateModifyingDone(

   780     LogsReaderStateContext& context) : LogsReaderStateBase(context)

   781 {

   782 

   783 }

   784     

   785 // ----------------------------------------------------------------------------

   786 // LogsReaderStateModifyingDone::enterL

   787 // ----------------------------------------------------------------------------

   788 //

   789 bool LogsReaderStateModifyingDone::enterL()

   790 {

   791     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateModifyingDone::enterL" );

   792     

   793     LogsEvent* modifiedEvent = eventById(mContext.currentEventId());

   794     if ( modifiedEvent ){

   795         // Update modified event to know that it has been marked. Real

   796         // update of the event happens soon when db notifies the change.

   797         modifiedEvent->markedAsSeenLocally(true);

   798     }

   799     mContext.observer().eventModifyingCompleted();

   800 

   801     LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateModifyingDone::enterL" );

   802     

   803     return false;

   804 }

   805 

   806 // ----------------------------------------------------------------------------

   807 // LogsReaderStateReadingDuplicatesDone::LogsReaderStateReadingDuplicatesDone

   808 // ----------------------------------------------------------------------------

   809 //

   810 LogsReaderStateReadingDuplicatesDone::LogsReaderStateReadingDuplicatesDone(

   811     LogsReaderStateContext& context) : LogsReaderStateBase(context)

   812 {

   813 

   814 }

   815     

   816 // ----------------------------------------------------------------------------

   817 // LogsReaderStateReadingDuplicatesDone::enterL

   818 // ----------------------------------------------------------------------------

   819 //

   820 bool LogsReaderStateReadingDuplicatesDone::enterL()

   821 {

   822     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateReadingDuplicatesDone::enterL" );

   823     

   824     QList<LogsEvent*> duplicates = mContext.duplicatedEvents();

   825     mContext.duplicatedEvents().clear();

   826     mContext.observer().duplicatesReadingCompleted(duplicates);

   827 

   828     LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateReadingDuplicatesDone::enterL" );

   829     

   830     return false;

   831 }