logsui/logsengine/logssymbianos/src/logsreaderstates.cpp
changeset 15 76d2cf7a585e
parent 9 68f3171a5819
child 17 90fe74753f71
equal deleted inserted replaced
13:52d644758b05 15:76d2cf7a585e
    58 bool LogsReaderStateBase::updateAndInsertEventL(
    58 bool LogsReaderStateBase::updateAndInsertEventL(
    59     const CLogEvent& source, LogsEvent* dest, int& eventIndex)
    59     const CLogEvent& source, LogsEvent* dest, int& eventIndex)
    60 {
    60 {
    61     Q_ASSERT( dest );
    61     Q_ASSERT( dest );
    62     dest->initializeEventL( source, mContext.strings() );
    62     dest->initializeEventL( source, mContext.strings() );
    63     dest->setIndex(eventIndex);
       
    64     mContext.events().insert(eventIndex, dest);
    63     mContext.events().insert(eventIndex, dest);
    65     eventIndex++;
    64     eventIndex++;
    66     return true;
    65     return true;
    67 }
    66 }
    68 
    67 
    78     if ( !dest->validate() ){
    77     if ( !dest->validate() ){
    79         LOGS_QDEBUG( "LogsReaderStateBase::constructAndInsertEventL, event discarded" )
    78         LOGS_QDEBUG( "LogsReaderStateBase::constructAndInsertEventL, event discarded" )
    80         delete dest;
    79         delete dest;
    81         return false;
    80         return false;
    82     } 
    81     } 
    83     dest->setIndex(eventIndex);
       
    84     events.insert(eventIndex, dest);
    82     events.insert(eventIndex, dest);
    85     eventIndex++;
    83     eventIndex++;
    86     return true;
    84     return true;
    87 }
    85 }
    88 
    86 
   119 //
   117 //
   120 LogsEvent* LogsReaderStateBase::eventById(int eventId)
   118 LogsEvent* LogsReaderStateBase::eventById(int eventId)
   121 {
   119 {
   122     LogsEvent* event = 0;
   120     LogsEvent* event = 0;
   123     QList<LogsEvent*> &events = mContext.events();
   121     QList<LogsEvent*> &events = mContext.events();
   124     for ( int i = 0; i < events.count(); i++ ){
   122     for ( int i = 0; i < events.count() && !event; i++ ){
   125         if ( events.at(i)->logId() == eventId ){
   123         if ( events.at(i)->logId() == eventId ){
   126             event = events.at(i);
   124             event = events.at(i);
   127             break;
       
   128         }
   125         }
   129     }
   126     }
   130     return event;
   127     return event;
   131 }
   128 }
   132 
   129 
   425 // LogsReaderStateFillDetails::fillDetails
   422 // LogsReaderStateFillDetails::fillDetails
   426 // ----------------------------------------------------------------------------
   423 // ----------------------------------------------------------------------------
   427 //
   424 //
   428 void LogsReaderStateFillDetails::fillDetails()
   425 void LogsReaderStateFillDetails::fillDetails()
   429 {
   426 {
       
   427     mDuplicateLookup.invalidate();
       
   428     
   430     QHash<QString, ContactCacheEntry>& contactMappings = mContext.contactCache();
   429     QHash<QString, ContactCacheEntry>& contactMappings = mContext.contactCache();
   431     QList<LogsEvent*> &events = mContext.events();
   430     QList<LogsEvent*> &events = mContext.events();
   432     foreach ( LogsEvent* event, events ){
   431     foreach ( LogsEvent* event, events ){  
   433         const QString& num = event->getNumberForCalling();
   432         if ( event->isInView() ){
   434         if ( !event->isInView() ){
   433             const QString& num = event->getNumberForCalling();
   435             // Not interested about to be removed event
   434             if ( contactMappings.contains(num) ) {
   436         } else if ( contactMappings.contains(num) ) {
   435                 // Matching cached contact found, use that
   437             // Matching cached contact found, use that
   436                 LOGS_QDEBUG_2( "logs [ENG]    Use existing contact for num:", num )
   438             LOGS_QDEBUG_2( "logs [ENG]    Use existing contact for num:", num )
   437                 ContactCacheEntry entry = contactMappings.value(num);
   439             ContactCacheEntry entry = contactMappings.value(num);
   438                 event->setContactMatched( true );
   440             event->setRemoteParty( entry.mRemoteParty );
   439                 event->setRemoteParty( entry.mRemoteParty );
   441             event->setContactLocalId( entry.mContactLocalId );
   440                 event->setContactLocalId( entry.mContactLocalId );
   442         } else if ( event->remoteParty().length() == 0 ) {
   441             } else if ( event->remoteParty().length() == 0 ) {
   443             // No remote party name, search for match from phonebook
   442                 // No remote party name, search for match from phonebook
   444             QString contactNameStr = event->updateRemotePartyFromContacts(
   443                 QString contactNameStr = event->updateRemotePartyFromContacts(
   445                     LogsCommonData::getInstance().contactManager());
   444                         LogsCommonData::getInstance().contactManager());
   446             if (contactNameStr.length() > 0){
   445                 if (contactNameStr.length() > 0){
   447                 LOGS_QDEBUG_3( "LogsReaderStateFillDetails, (name, num):", 
   446                     LOGS_QDEBUG_3( "LogsReaderStateFillDetails, (name, num):", 
   448                                contactNameStr, num );
   447                                    contactNameStr, num );
   449                 // Cache the new contact name
   448                     // Cache the new contact name
   450                 ContactCacheEntry contactEntry(contactNameStr, event->contactLocalId());
   449                     event->setContactMatched( true );
   451                 contactMappings.insert( num, contactEntry );
   450                     ContactCacheEntry contactEntry(contactNameStr, event->contactLocalId());
       
   451                     contactMappings.insert( num, contactEntry );
       
   452                 }
   452             }
   453             }
   453         }
   454             if ( mBaseContext.isRecentView() ){
   454     }    
   455                 LogsEvent* duplicateEvent = mDuplicateLookup.findDuplicate(*event);
   455 }
   456                 if ( duplicateEvent ){
   456     
   457                     mergeDuplicates( *duplicateEvent, *event ); 
       
   458                 } else {
       
   459                     mDuplicateLookup.addLookupEntry(*event);
       
   460                 }
       
   461             }
       
   462         }
       
   463     } 
       
   464     
       
   465     mDuplicateLookup.cleanup();
       
   466 }
       
   467  
       
   468 // ----------------------------------------------------------------------------
       
   469 // LogsReaderStateFillDetails::mergeDuplicates
       
   470 // ----------------------------------------------------------------------------
       
   471 //
       
   472 void LogsReaderStateFillDetails::mergeDuplicates( 
       
   473     LogsEvent& usedEvent, LogsEvent& discardedEvent ) const
       
   474 {
       
   475     usedEvent.merge(discardedEvent);
       
   476     discardedEvent.setIsInView(false);
       
   477 }
       
   478 
   457 // ----------------------------------------------------------------------------
   479 // ----------------------------------------------------------------------------
   458 // LogsReaderStateDone::LogsReaderStateDone
   480 // LogsReaderStateDone::LogsReaderStateDone
   459 // ----------------------------------------------------------------------------
   481 // ----------------------------------------------------------------------------
   460 //
   482 //
   461 LogsReaderStateDone::LogsReaderStateDone(
   483 LogsReaderStateDone::LogsReaderStateDone(
   478 //
   500 //
   479 bool LogsReaderStateDone::enterL()
   501 bool LogsReaderStateDone::enterL()
   480 {
   502 {
   481     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateDone::enterL" );
   503     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateDone::enterL" );
   482     
   504     
   483     int numRead = qMin(mBaseContext.index(),viewCountL());
   505     mContext.observer().readCompleted();
   484     mContext.observer().readCompleted(numRead);
       
   485 
   506 
   486     LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateDone::enterL" );
   507     LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateDone::enterL" );
   487     
   508     
   488     return false;
   509     return false;
   489 } 
   510 } 
   647     
   668     
   648     return enterNextStateL();
   669     return enterNextStateL();
   649 }
   670 }
   650 
   671 
   651 // ----------------------------------------------------------------------------
   672 // ----------------------------------------------------------------------------
       
   673 // LogsReaderStateMergingDuplicates::LogsReaderStateMergingDuplicates
       
   674 // ----------------------------------------------------------------------------
       
   675 //
       
   676 LogsReaderStateMergingDuplicates::LogsReaderStateMergingDuplicates(
       
   677     LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) 
       
   678  : LogsReaderStateBase(context, readerContext)
       
   679 {
       
   680 }
       
   681 
       
   682 // ----------------------------------------------------------------------------
       
   683 // LogsReaderStateMergingDuplicates::enterL
       
   684 // ----------------------------------------------------------------------------
       
   685 //
       
   686 bool LogsReaderStateMergingDuplicates::enterL()
       
   687 {
       
   688     LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateMergingDuplicates::enterL" );
       
   689 
       
   690     QList<LogsEvent*>& duplicates = mContext.duplicatedEvents();
       
   691     
       
   692     LogsEvent* event = eventById( mBaseContext.currentEventId() );
       
   693     if ( event ){
       
   694         for ( int i = 0; i < event->mergedDuplicates().count(); i++ ){
       
   695             const LogsEvent& mergedDupl = event->mergedDuplicates().at(i);
       
   696             if ( !mergedDupl.isSeenLocally() ){
       
   697                 // Search backwards duplicates list until later occured event is
       
   698                 // found and insert the merged duplicate after that.
       
   699                 // Event is added to beginning of the list if there's no
       
   700                 // later events.
       
   701                 int insertIndex = 0;
       
   702                 int lastIndex = duplicates.count() - 1;
       
   703                 for ( int j = lastIndex; j >= 0 && insertIndex == 0; j-- ) {
       
   704                     if ( duplicates.at(j)->time() >= mergedDupl.time() ){
       
   705                         insertIndex = j + 1; // break the loop
       
   706                     }
       
   707                 }
       
   708                 duplicates.insert(insertIndex, new LogsEvent(mergedDupl) );
       
   709             }
       
   710         }
       
   711     }
       
   712     LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateMergingDuplicates::enterL" );   
       
   713     return enterNextStateL();
       
   714 }
       
   715 
       
   716 // ----------------------------------------------------------------------------
   652 // LogsReaderStateModifyingDone::LogsReaderStateModifyingDone
   717 // LogsReaderStateModifyingDone::LogsReaderStateModifyingDone
   653 // ----------------------------------------------------------------------------
   718 // ----------------------------------------------------------------------------
   654 //
   719 //
   655 LogsReaderStateModifyingDone::LogsReaderStateModifyingDone(
   720 LogsReaderStateModifyingDone::LogsReaderStateModifyingDone(
   656     LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) 
   721     LogsStateBaseContext& context, LogsReaderStateContext& readerContext )