1 /*

     2 * Copyright (c) 2003-2007 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:  CNssTagMgr implements the MNssTagMgr interface. In addition, it also provides

    15 *               methods for internal use by VAS components.

    16 *

    17 */

    18 

    19 

    20 // includes

    21 #include "nssvasctagmgr.h"

    22 #include "nssvasccontextmgr.h"

    23 #include "nssvascvasdatabase.h"

    24 #include "nssvascspeechitembuilder.h"

    25 #include "rubydebug.h"

    26 

    27 _LIT( KTagMgrPanic, "tagmgr.cpp" );

    28 

    29 // -----------------------------------------------------------------------------

    30 // CNssTagMgr::CNssTagMgr

    31 // C++ default constructor can NOT contain any code, that

    32 // might leave.

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

    34 //

    35 CNssTagMgr::CNssTagMgr()

    36 : CActive( CActive::EPriorityStandard )

    37     {

    38     }

    39 

    40 // -----------------------------------------------------------------------------

    41 // CNssTagMgr::CNssTagMgr

    42 // C++ overloaded constructor can NOT contain any code, that

    43 // might leave.

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

    45 //

    46 CNssTagMgr::CNssTagMgr(CNssVASDatabase* aVasDatabase, CNssContextMgr *aContextManager)

    47 : CActive( CActive::EPriorityStandard ), iTagList( 0 ), iTagRefList( 0 )

    48     {

    49     iVasDatabase = aVasDatabase;

    50     iContextManager = aContextManager;

    51     iState = ENone;

    52     }

    53 

    54 // destructor

    55 CNssTagMgr::~CNssTagMgr()

    56     {

    57     Cancel();

    58 

    59     if( iTagList ) 

    60         {

    61         iTagList->ResetAndDestroy();

    62         delete iTagList;

    63         }

    64     if ( iSpeechItemBuilder )

    65         {

    66         delete iSpeechItemBuilder;

    67         iSpeechItemBuilder = NULL;

    68         }

    69     

    70     }

    71 

    72 // -----------------------------------------------------------------------------

    73 // CNssTagMgr::NewL

    74 // Two-phased constructor.

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

    76 //

    77 CNssTagMgr* CNssTagMgr::NewL( CNssVASDatabase* aVasDatabase, CNssContextMgr *aContextManager )

    78     {

    79     CNssTagMgr* self = NewLC(aVasDatabase, aContextManager);

    80     CleanupStack::Pop( self );

    81     return self;

    82     }

    83 

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

    85 // CNssTagMgr::NewLC

    86 // Two-phased constructor.

    87 // -----------------------------------------------------------------------------

    88 //

    89 CNssTagMgr* CNssTagMgr::NewLC( CNssVASDatabase* aVasDatabase, CNssContextMgr *aContextManager )

    90     {

    91     CNssTagMgr* self = new(ELeave) CNssTagMgr(aVasDatabase, aContextManager);

    92     CleanupStack::PushL( self );

    93     self->ConstructL();

    94     return ( self );

    95     }

    96 

    97 // -----------------------------------------------------------------------------

    98 // CNssTagMgr::ConstructL

    99 // EPOC constructor.

   100 // -----------------------------------------------------------------------------

   101 //

   102 void CNssTagMgr::ConstructL()

   103     {

   104     iSpeechItemBuilder = CNssSpeechItemBuilder::NewL( iVasDatabase );

   105     

   106     CActiveScheduler::Add( this );

   107     }

   108 

   109 // -----------------------------------------------------------------------------

   110 // CNssTagMgr::CreateTagL

   111 // creates a new tag, taking in the context for the tag

   112 // -----------------------------------------------------------------------------

   113 //

   114 MNssTag* CNssTagMgr::CreateTagL( MNssContext* aContext )

   115     {

   116     if ( !aContext )

   117         {

   118         User::Leave( KErrArgument );

   119         }

   120     

   121     CNssContext *context = ((CNssContext*)(aContext))->CopyL();

   122     CleanupStack::PushL(context);

   123     CNssSpeechItem *speechItem = iSpeechItemBuilder->CreateEmptySpeechItemL(*context);

   124     CleanupStack::PushL(speechItem);

   125     CNssRRD* rrd = CNssRRD::NewL(); 

   126     CleanupStack::PushL(rrd);

   127     CNssTag *tag = new (ELeave) CNssTag(context, rrd, speechItem);

   128     CleanupStack::Pop(rrd);

   129     CleanupStack::Pop(speechItem);

   130     CleanupStack::Pop(context);

   131     return tag;

   132     }

   133 

   134 // -----------------------------------------------------------------------------

   135 // CNssTagMgr::CreateTagL

   136 // gets a tag list from VAS DB for a given context

   137 // -----------------------------------------------------------------------------

   138 //

   139 TInt CNssTagMgr::GetTagList( MNssGetTagClient* aTagClient,MNssContext* aContext )

   140     {

   141     if ( IsActive() || !aTagClient || !aContext )

   142         {

   143         return KErrGeneral;

   144         }

   145     

   146     iState = EGetTagClient;

   147     iGetTagClient = aTagClient;

   148     

   149     if( iTagList ) 

   150         {

   151         iTagList->ResetAndDestroy();

   152         delete iTagList;

   153         iTagList = NULL;

   154         }

   155     

   156     iTagList = iVasDatabase->GetTag((CNssContext*)(aContext));

   157     

   158     if ( !iTagList || iTagList->Count() == 0 )

   159         {

   160         return KErrGeneral;

   161         }

   162     

   163     TRequestStatus* pRS = &iStatus;

   164     User::RequestComplete(pRS, KErrNone);

   165     SetActive();

   166     

   167     return KErrNone;

   168     }

   169 

   170 // -----------------------------------------------------------------------------

   171 // CNssTagMgr::GetTagList

   172 // gets a tag list from VAS DB for a given name

   173 // -----------------------------------------------------------------------------

   174 //

   175 TInt CNssTagMgr::GetTagList( MNssGetTagClient* aTagClient, 

   176                              MNssContext* aContext, const TDesC& aName )

   177     {

   178     if ( IsActive() || !aTagClient || 

   179          !aContext || aName.Length() == 0 )

   180         {

   181         return KErrGeneral;

   182         }

   183     

   184     iState = EGetTagClient;

   185     iGetTagClient = aTagClient;

   186     

   187     if( iTagList ) 

   188         {

   189         iTagList->ResetAndDestroy();

   190         delete iTagList;

   191         iTagList = NULL;

   192         }

   193     

   194     iTagList = iVasDatabase->GetTag((CNssContext*)(aContext), aName);

   195     

   196     if ( !iTagList || iTagList->Count() == 0 )

   197         {

   198         return KErrGeneral;

   199         }

   200     

   201     TRequestStatus* pRS = &iStatus;

   202     User::RequestComplete(pRS, KErrNone);

   203     SetActive();

   204     

   205     return KErrNone;

   206     }

   207 

   208 // -----------------------------------------------------------------------------

   209 // CNssTagMgr::DeleteTag

   210 // deletes a tag from VAS 

   211 // -----------------------------------------------------------------------------

   212 //

   213 TInt CNssTagMgr::DeleteTag( MNssDeleteTagClient* aTagClient, MNssTag* aTag )

   214     {

   215     if ( IsActive() || !aTagClient || !aTag )

   216         {

   217         return KErrGeneral;

   218         }

   219 

   220     iState = EDeleteTagClient;

   221 	iDeleteTagClient = aTagClient;

   222 	iLocalTag = (CNssTag*) (aTag);

   223 	iLocalSpeechItem = (CNssSpeechItem*) (iLocalTag->SpeechItem());

   224 

   225     TInt ret( KErrNone );

   226 

   227    	MNssCoreSrsDBEventHandler::TNssSrsDBResult srsDBResult = 

   228    	                    MNssCoreSrsDBEventHandler::EVasSuccess;

   229     TRAPD( err, (srsDBResult = 

   230            iLocalSpeechItem->NSSBeginDeleteFromSrs( iDeleteTagClient, iLocalTag )) );

   231 

   232 	if(err != KErrNone || srsDBResult != MNssCoreSrsDBEventHandler::EVasSuccess)

   233         {

   234 		ret = KErrGeneral;

   235         }

   236     

   237     return ret;

   238     }

   239 

   240 // -----------------------------------------------------------------------------

   241 // CNssTagMgr::SaveTag

   242 // saves a tag to VAS 

   243 // -----------------------------------------------------------------------------

   244 //

   245 TInt CNssTagMgr::SaveTag( MNssSaveTagClient* aTagClient, MNssTag* aTag )

   246     {

   247     if ( IsActive() || !aTagClient || !aTag )

   248         {

   249         return KErrGeneral;

   250         }

   251     

   252     // Client can save only trained tags.

   253     if ( aTag->SpeechItem()->TrainedType() == TNssVasCoreConstant::EVasNotTrained )

   254         {

   255         return KErrNotReady;

   256         }

   257     

   258     iSaveTagClient = aTagClient;

   259     

   260     iState = ESaveTagClient;

   261     

   262     /********************* Debug rule ID and grammar ID ***********************/

   263     /*

   264     RFs session;

   265     RFile file;

   266     _LIT( aFileName, "c:\\documents\\savetag.txt" );

   267     

   268       session.Connect();

   269       if ( file.Open( session, aFileName, EFileWrite ) != KErrNone )

   270       {

   271       if ( file.Create( session, aFileName, EFileWrite ) != KErrNone )

   272       {

   273       User::Panic( _L("SDContrlDebug"), __LINE__ );

   274       }

   275       }

   276       

   277         TInt size = 0;

   278         file.Seek( ESeekEnd, size );

   279         

   280           TBuf8<100> debugBuf;

   281           debugBuf.AppendFormat( _L8("Saving tag with RID:%d, GID:%d\n"), ((CNssSpeechItem*)aTag->SpeechItem())->RuleID(),((CNssContext*)aTag->Context())->GrammarId() );

   282           file.Write( debugBuf );

   283           

   284             file.Close();

   285             session.Close();

   286     */

   287     /**************************************************************************/

   288     TInt ret( KErrNone );

   289     CNssTag* tag = (CNssTag*)aTag;

   290     TInt err;

   291     

   292     iLocalSpeechItem = (CNssSpeechItem*)tag->SpeechItem();

   293     err = iLocalSpeechItem->NSSBeginSaveToSrs( aTagClient, tag );

   294     

   295     if ( err != KErrNone )

   296         {

   297         ret = KErrGeneral;

   298         }

   299     

   300     return ret;

   301     }

   302 

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

   304 // CNssTagMgr::GetTag

   305 // get tag from VAS DB based on grammar id and rule id

   306 // -----------------------------------------------------------------------------

   307 //

   308 CNssTag* CNssTagMgr::GetTag( TUint32 aGrammarId, TUint32 aRuleId )

   309     {

   310     MNssTag* result = 0;

   311     

   312     if( iTagList ) 

   313         {

   314         iTagList->ResetAndDestroy();

   315         delete iTagList;

   316         iTagList = NULL;

   317         }

   318     

   319     iTagList = iVasDatabase->GetTag( aGrammarId, aRuleId );

   320     

   321     // If there are tags in the list, return the first one.

   322     if ( iTagList != 0 )

   323         {

   324         if ( iTagList->Count() > 0 )

   325             {

   326             result = (*iTagList)[0];

   327             

   328             iTagList->Delete( 0 );

   329             

   330             __ASSERT_DEBUG( iTagList->Count() == 0, User::Panic( KTagMgrPanic, __LINE__ ) );

   331             }

   332         

   333         // Release the memory

   334         iTagList->ResetAndDestroy();

   335         delete iTagList;

   336         iTagList = 0;

   337         }

   338     

   339     // Cast is safe, since only CNssTag implements MNssTag.

   340     return( STATIC_CAST( CNssTag*, result ) );

   341     }

   342 

   343 // -----------------------------------------------------------------------------

   344 // CNssTagMgr::GetTags

   345 // get tags from VAS DB based on theirgrammar id and rule id

   346 // -----------------------------------------------------------------------------

   347 MNssTagListArray* CNssTagMgr::GetTags( TNssGrammarIdRuleIdListArray&  aGrammarIdRuleIds)

   348     {

   349     MNssTagListArray* result = iVasDatabase->GetTags( aGrammarIdRuleIds );

   350     return result;

   351     }

   352 

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

   354 // CNssTagMgr::VASDatabaseComplete

   355 // call back from CNssVASDatabase 

   356 // -----------------------------------------------------------------------------

   357 //

   358 void CNssTagMgr::VASDatabaseComplete( CArrayPtrFlat<CNssContext>* /*aContextList*/, 

   359                                       CArrayPtrFlat<CNssTag>* /*aTagList*/, 

   360                                       CArrayPtrFlat<CNssTagReference>* /*aTagRefList*/,

   361                                       MNssVASDatabaseClient::TNssVASDBClientReturnCode /*aCode*/ )

   362     {

   363     User::Panic( KTagMgrPanic, __LINE__ );

   364     }

   365  

   366 // -----------------------------------------------------------------------------

   367 // CNssTagMgr::HandleSaveSrsDBCompleted

   368 //  call back from SRS DB 

   369 // -----------------------------------------------------------------------------

   370 //

   371 void CNssTagMgr::HandleSaveSrsDBCompleted()

   372     {

   373     TInt newTagId;

   374     

   375     CNssSpeechItem* item = (CNssSpeechItem*)iLocalTag->SpeechItem();

   376     

   377     // Save tag to VAS.

   378     TInt ret = iVasDatabase->SaveTag( iLocalTag, newTagId );

   379     

   380     // If VAS DB saving failed, roll back Plugin DB changes.

   381     if ( ret != KErrNone )

   382         {

   383         CNssSpeechItem* item = (CNssSpeechItem*)iLocalTag->SpeechItem();

   384         item->RollbackSrsChanges();

   385         

   386         if(iSaveTagClient)

   387             {

   388             iSaveTagClient->SaveTagCompleted( ret );

   389             }

   390         return;

   391         }

   392     

   393     MNssCoreSrsDBEventHandler::TNssSrsDBResult srsret = item->CommitSrsChanges();

   394     

   395     if ( srsret == EVasSuccess )

   396         {

   397         if(iSaveTagClient)

   398             {

   399             iSaveTagClient->SaveTagCompleted( KErrNone );

   400             }

   401         }

   402     else{

   403         if(iSaveTagClient)

   404             {

   405             iSaveTagClient->SaveTagCompleted( KErrGeneral );

   406             }

   407         }

   408     }

   409 

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

   411 // CNssTagMgr::HandleDeleteSrsDBCompleted

   412 //  call back from SRS DB 

   413 // -----------------------------------------------------------------------------

   414 //

   415 void CNssTagMgr::HandleDeleteSrsDBCompleted()

   416     {

   417     iState = ENone;

   418 

   419     TInt ret = iVasDatabase->DeleteTag( iLocalTag );

   420 

   421     //                      trained, not saved -case

   422     if ( ret != KErrNone && ret != KErrNotFound )

   423         {

   424         iLocalSpeechItem->RollbackSrsChanges();

   425 

   426         iDeleteTagClient->DeleteTagCompleted( ret );

   427         return;

   428         }

   429 

   430     if ( iLocalSpeechItem->CommitSrsChanges() != MNssCoreSrsDBEventHandler::EVasSuccess )

   431         {

   432         iDeleteTagClient->DeleteTagCompleted( KErrGeneral );

   433         return;

   434         }

   435 

   436     iDeleteTagClient->DeleteTagCompleted( KErrNone );

   437     return;

   438     }

   439 

   440 // -----------------------------------------------------------------------------

   441 // CNssTagMgr::HandleResetSrsDBCompleted

   442 //  call back from SRS DB 

   443 // -----------------------------------------------------------------------------

   444 //

   445 void CNssTagMgr::HandleResetSrsDBCompleted()

   446     {

   447     // Should never be called

   448     RUBY_DEBUG0( "CNssTagMgr::HandleResetSrsDBCompleted - ERROR" );

   449     }

   450 

   451 // -----------------------------------------------------------------------------

   452 // CNssTagMgr::HandleSrsDBError

   453 //  call back from SRS DB 

   454 // -----------------------------------------------------------------------------

   455 //

   456 void CNssTagMgr::HandleSrsDBError( MNssCoreSrsDBEventHandler::TNssSrsDBResult /*aResult*/ )

   457     {

   458     

   459     switch(iState)

   460         {

   461         case EDeleteTagClient:

   462             iState = ENone;

   463             iDeleteTagClient->DeleteTagCompleted( KErrGeneral );

   464             break;

   465         case ESaveTagClient:

   466             iState = ENone;

   467             iSaveTagClient->SaveTagCompleted( KErrGeneral );

   468             break;

   469         default:

   470             break;

   471         }

   472     }

   473 

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

   475 // CNssTagMgr::CNssTagListToMNssTagListConvertorL

   476 //  utility function for CNssTag list to MNssTag list conversion, and call back to client

   477 // -----------------------------------------------------------------------------

   478 //

   479 void CNssTagMgr::CNssTagListToMNssTagListConvertorL(CArrayPtrFlat<CNssTag>* aSourceList)

   480     {

   481     CArrayPtrFlat<MNssTag> *destinationList = new (ELeave) CArrayPtrFlat<MNssTag>(1);

   482     CleanupStack::PushL(destinationList);

   483     for(TInt i = 0; i < aSourceList->Count(); i++)

   484         {

   485         destinationList->AppendL( (MNssTag*) ((*aSourceList)[i]) );

   486         }

   487     aSourceList->Reset();

   488     delete aSourceList; 

   489     CleanupStack::Pop(destinationList);

   490     iGetTagClient->GetTagListCompleted(destinationList, KErrNone);

   491 #ifndef __SIND_RD_BREAK_PHONEBOOK_COMPATIBILITY    

   492     iGetTagClient->GetTagListCompleted( destinationList );

   493 #endif // __SIND_RD_BREAK_PHONEBOOK_COMPATIBILITY  

   494     }

   495 

   496 // -----------------------------------------------------------------------------

   497 // CNssTagMgr::CancelGetTag

   498 // cancel get tag for inter-comp clients

   499 // -----------------------------------------------------------------------------

   500 //

   501 void CNssTagMgr::CancelGetTag()

   502     {

   503     iInterCompTagMgrClient = NULL;

   504     }

   505 

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

   507 // CNssTagMgr::TagCount

   508 // gets a tag count from VAS DB for a given context

   509 // -----------------------------------------------------------------------------

   510 //

   511 TInt CNssTagMgr::TagCount( MNssContext* aContext )

   512     {

   513     return iVasDatabase->TagCount( (CNssContext*)aContext );

   514     }

   515 

   516 // -----------------------------------------------------------------------------

   517 // CNssTagMgr::Tag

   518 // gets a tag from VAS DB based on rrd int value and position

   519 // -----------------------------------------------------------------------------

   520 //

   521 TInt CNssTagMgr::GetTagList(MNssGetTagClient* aTagClient,MNssContext* aContext,

   522                             TInt aNum,TInt aPosition)

   523     {

   524     if ( IsActive() || !aTagClient || !aContext

   525          || aPosition < 0 )

   526         {

   527         return KErrGeneral;

   528         }

   529     iState = EGetTagClient;

   530     iGetTagClient = aTagClient;

   531     

   532     if( iTagList ) 

   533         {

   534         iTagList->ResetAndDestroy();

   535         delete iTagList;

   536         iTagList = NULL;

   537         }

   538     

   539     iTagList = iVasDatabase->GetTagList( (CNssContext*)aContext, aNum, aPosition );

   540     

   541     if ( !iTagList || iTagList->Count() == 0 )

   542         {

   543         return KErrGeneral;

   544         }

   545     

   546     TRequestStatus* pRS = &iStatus;

   547     User::RequestComplete(pRS, KErrNone);

   548     SetActive();

   549     

   550     return KErrNone;

   551     }

   552 

   553 // -----------------------------------------------------------------------------

   554 // CNssTagMgr::GetTagList

   555 // gets a tag from VAS DB based on rrd text value and position

   556 // -----------------------------------------------------------------------------

   557 //

   558 TInt CNssTagMgr::GetTagList( MNssGetTagClient* aTagClient,MNssContext* aContext,

   559                              TDesC& aText,TInt aPosition )

   560     {

   561     if ( IsActive() || !aTagClient || !aContext ||

   562         aText.Length() == 0 || aPosition < 0 )

   563         {

   564         return KErrGeneral;

   565         }

   566     

   567     iState = EGetTagClient;

   568     iGetTagClient = aTagClient;

   569     

   570     if( iTagList ) 

   571         {

   572         iTagList->ResetAndDestroy();

   573         delete iTagList;

   574         iTagList = NULL;

   575         }

   576     

   577     iTagList = iVasDatabase->GetTagList( (CNssContext*)aContext, aText, aPosition );

   578     

   579     if ( !iTagList || iTagList->Count() == 0 )

   580         {

   581         return KErrGeneral;

   582         }

   583     

   584     TRequestStatus* pRS = &iStatus;

   585     User::RequestComplete(pRS, KErrNone);

   586     SetActive();

   587     

   588     return KErrNone;

   589     }

   590 

   591 // -----------------------------------------------------------------------------

   592 // CNssTagMgr::GetTagReferenceList

   593 // get a list of tag references from VAS DB based on a context

   594 // -----------------------------------------------------------------------------

   595 //

   596 TInt CNssTagMgr::GetTagReferenceList( MNssGetTagReferenceClient* aTagRefClient,

   597                                       MNssContext* aContext)

   598     {

   599     if ( IsActive() || !aTagRefClient || !aContext )

   600         {

   601         return KErrGeneral;

   602         }

   603     

   604     iState = EGetTagReferenceClient;

   605     iGetTagReferenceClient = aTagRefClient;

   606     

   607     if ( iTagRefList )

   608         {

   609         iTagRefList->ResetAndDestroy();

   610         delete iTagRefList;

   611         iTagRefList = NULL;

   612         }

   613     

   614     iTagRefList = iVasDatabase->GetTagReferenceList( (CNssContext*)aContext );

   615     

   616     if ( !iTagRefList || iTagRefList->Count() == 0 )

   617         {

   618         return KErrGeneral;

   619         }

   620     

   621     TRequestStatus* pRS = &iStatus;

   622     User::RequestComplete(pRS, KErrNone);

   623     SetActive();

   624     

   625     return KErrNone;

   626     }

   627 

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

   629 // CNssTagMgr::GetTag

   630 // get a tag from VAS DB based on tagreference (using the TagId of the tagreference)

   631 // -----------------------------------------------------------------------------

   632 //

   633 TInt CNssTagMgr::GetTag(MNssGetTagClient* aTagClient,MNssTagReference* aTagReference)

   634     {

   635     CNssTagReference* ctagRef = (CNssTagReference*) aTagReference;

   636     

   637     if ( IsActive() || !aTagClient || !aTagReference )

   638         {

   639         return KErrGeneral;

   640         }

   641     

   642     iState = EGetTagClient;

   643     iGetTagClient = aTagClient;

   644     

   645     if( iTagList ) 

   646         {

   647         iTagList->ResetAndDestroy();

   648         delete iTagList;

   649         iTagList = NULL;

   650         }

   651     

   652     iTagList = iVasDatabase->GetTag( ctagRef->TagId() );

   653     

   654     if ( !iTagList || iTagList->Count() == 0 )

   655         {

   656         return KErrGeneral;

   657         }

   658     

   659     TRequestStatus* pRS = &iStatus;

   660     User::RequestComplete(pRS, KErrNone);

   661     SetActive();

   662     

   663     return KErrNone;

   664     }

   665 

   666 // -----------------------------------------------------------------------------

   667 // CNssTagMgr::CNssTagRefListToMNssTagRefListConvertorL

   668 // utility function for CNssTagReference list to MNssTagReference list conversion, 

   669 // and call back to client

   670 // -----------------------------------------------------------------------------

   671 //

   672 void CNssTagMgr::CNssTagRefListToMNssTagRefListConvertorL(

   673                     CArrayPtrFlat<CNssTagReference>* aSourceList )

   674     {

   675     

   676     CArrayPtrFlat<MNssTagReference> *destinationList = 

   677                             new (ELeave) CArrayPtrFlat<MNssTagReference>(1);

   678     CleanupStack::PushL(destinationList);

   679     for(TInt i = 0; i < aSourceList->Count(); i++)

   680         {

   681         destinationList->AppendL( (MNssTagReference*) ((*aSourceList)[i]) );

   682         }

   683     aSourceList->Reset();

   684     delete aSourceList; 

   685     CleanupStack::Pop(destinationList);

   686     iGetTagReferenceClient->GetTagReferenceListCompleted( destinationList,

   687                                                           KErrNone );

   688     }

   689 

   690 

   691 /************ ACTIVE OBJECT *************/

   692 

   693 // -----------------------------------------------------------------------------

   694 // CNssTagMgr::DoCancel

   695 //

   696 // -----------------------------------------------------------------------------

   697 //

   698 void CNssTagMgr::DoCancel()

   699     {

   700     }

   701 

   702 // -----------------------------------------------------------------------------

   703 // CNssTagMgr::RunL

   704 //

   705 // -----------------------------------------------------------------------------

   706 //

   707 void CNssTagMgr::RunL()

   708     {

   709 	switch (iState)

   710 	    {

   711         case ESaveTagClient:

   712             iSaveTagClient->SaveTagCompleted( KErrNone );

   713             break;

   714 

   715         case EGetTagClient:

   716             {

   717             MNssTagListArray* ret = iTagList;

   718             iTagList = 0;

   719 

   720             iGetTagClient->GetTagListCompleted( ret, KErrNone );

   721 #ifndef __SIND_RD_BREAK_PHONEBOOK_COMPATIBILITY    

   722             iGetTagClient->GetTagListCompleted( ret );

   723 #endif // __SIND_RD_BREAK_PHONEBOOK_COMPATIBILITY              

   724             }

   725             break;

   726 

   727         case EGetTagReferenceClient:

   728             {

   729             CArrayPtrFlat<MNssTagReference>* ret = iTagRefList;

   730             iTagRefList = 0;

   731 

   732             iGetTagReferenceClient->GetTagReferenceListCompleted( ret, KErrNone );

   733             }

   734             break;

   735 

   736         default:

   737             User::Panic( KTagMgrPanic, __LINE__ );

   738         }

   739     }

   740 

   741 // -----------------------------------------------------------------------------

   742 // CNssTagMgr::RunError

   743 //

   744 // -----------------------------------------------------------------------------

   745 //

   746 TInt CNssTagMgr::RunError(TInt /*aError*/)

   747 {

   748 	Cancel();

   749 

   750     return KErrNone;

   751 }