1 /*

     2 * Copyright (c) 2005-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:  Phonebook 2 MMC UI extension copy to MMC command.

    15 *

    16 */

    17 

    18 

    19 #include "CPmuCopyToMmcCmd.h"

    20 

    21 // Phonebook 2

    22 #include <MPbk2ContactUiControl.h>

    23 #include <MPbk2ApplicationServices.h>

    24 #include <MPbk2AppUi.h>

    25 #include <MPbk2ContactNameFormatter.h>

    26 #include <MPbk2CommandObserver.h>

    27 #include <Pbk2ProcessDecoratorFactory.h>

    28 #include <MPbk2ProcessDecorator.h>

    29 #include <TPbk2CopyContactsResults.h>

    30 #include <Pbk2MmcUIRes.rsg>

    31 #include <CPbk2DriveSpaceCheck.h>

    32 

    33 // Virtual Phonebook

    34 #include <MVPbkContactOperationBase.h>

    35 #include <MVPbkStoreContact.h>

    36 #include <CVPbkVCardEng.h>

    37 #include <CVPbkContactManager.h>

    38 #include <CVPbkContactLinkArray.h>

    39 

    40 // System includes

    41 #include <pathinfo.h>

    42 #include <StringLoader.h>

    43 #include <aknnotewrappers.h>

    44 

    45 #include <AknCommonDialogsDynMem.h>

    46 #include <CAknMemorySelectionDialogMultiDrive.h>

    47 #include <driveinfo.h>

    48 

    49 // Debug Header

    50 #include <Pbk2Debug.h>

    51 

    52 /// Unnamed namespace for local definitions

    53 namespace {

    54 

    55 _LIT( KPbk2VCardFileExtension, ".vcf" );

    56 _LIT( KInvalidFileNameChars, "?*<>/\"|\\:" );

    57 _LIT( KNumberFormat, "%d" );

    58 _LIT( KOpeningParenthesis, "(" );

    59 _LIT( KClosingParenthesis, ")" );

    60 _LIT( KZero, "0" );

    61 const TInt KOneContact = 1;

    62 

    63 /**

    64  * Removes invalid characters from given descriptor.

    65  *

    66  * @param aPtr  The descriptor to inspect.

    67  */

    68 void RemoveInvalidCharacters( TPtr& aPtr )

    69     {

    70     for ( TInt i = aPtr.Length() - 1; i >= 0; --i )

    71         {

    72         TChar ch = aPtr[i];

    73         if ( KInvalidFileNameChars().Locate( ch ) != KErrNotFound )

    74             {

    75             aPtr.Delete( i, 1 ); // ch is not a valid character

    76             }

    77         }

    78     }

    79     

    80 enum TPmuCopyToMmcCmdState

    81     {

    82     EPmuCopyToMmcCmdStartProcess,

    83     EPmuCopyToMmcCmdDeleteOldEntries,

    84     EPmuCopyToMmcCmdRun,

    85     EPmuCopyToMmcCmdComplete,

    86     EPmuCopyToMmcCmdCancel

    87     };    

    88 

    89 #ifdef _DEBUG

    90 

    91 enum TPanicCode

    92     {

    93     EPanic_CopyNextL_OOB = 1,

    94     EPanic_OperationComplete_PreCond,

    95     EPanic_ShowResultsL_PreCond

    96     };

    97 

    98 void Panic( TPanicCode aPanic )

    99     {

   100     _LIT( KPanicCat, "CPmuCopyToMmcCmd" );

   101     User::Panic( KPanicCat(), aPanic );

   102     }

   103 

   104 #endif // _DEBUG

   105 

   106 } /// namespace

   107 

   108 // --------------------------------------------------------------------------

   109 // CPmuCopyToMmcCmd::CPmuCopyToMmcCmd

   110 // --------------------------------------------------------------------------

   111 //

   112 CPmuCopyToMmcCmd::CPmuCopyToMmcCmd( MPbk2ContactUiControl& aUiControl ) :

   113         CActive( EPriorityStandard ),

   114         iUiControl( &aUiControl )

   115     {

   116     CActiveScheduler::Add( this );

   117     }

   118 

   119 // --------------------------------------------------------------------------

   120 // CPmuCopyToMmcCmd::~CPmuCopyToMmcCmd

   121 // --------------------------------------------------------------------------

   122 //

   123 CPmuCopyToMmcCmd::~CPmuCopyToMmcCmd()

   124     {

   125     Cancel();

   126     

   127     if ( iUiControl )

   128         {

   129         iUiControl->RegisterCommand( NULL );

   130         }

   131 

   132     iWriteStream.Close();

   133     delete iFileMan;

   134     delete iDecorator;

   135     delete iStoreContact;

   136     delete iPreviousContact;

   137     delete iContactLinks;

   138     delete iVCardEngine;

   139     delete iDriveSpaceCheck;

   140     }

   141 

   142 // --------------------------------------------------------------------------

   143 // CPmuCopyToMmcCmd::NewL

   144 // --------------------------------------------------------------------------

   145 //

   146 CPmuCopyToMmcCmd* CPmuCopyToMmcCmd::NewL( MPbk2ContactUiControl& aUiControl )

   147     {

   148     CPmuCopyToMmcCmd* self = new ( ELeave ) CPmuCopyToMmcCmd( aUiControl );

   149     CleanupStack::PushL( self );

   150     self->ConstructL();

   151     CleanupStack::Pop( self );

   152     return self;

   153     }

   154 

   155 // --------------------------------------------------------------------------

   156 // CPmuCopyToMmcCmd::ConstructL

   157 // --------------------------------------------------------------------------

   158 //

   159 inline void CPmuCopyToMmcCmd::ConstructL()

   160     {

   161     PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING("CPmuCopyToDriveCmd::ConstructL"));

   162     

   163     iVCardEngine = CVPbkVCardEng::NewL

   164         ( Phonebook2::Pbk2AppUi()->ApplicationServices().ContactManager() );

   165 

   166     iContactLinks = iUiControl->SelectedContactsOrFocusedContactL();

   167 

   168     iDecorator = Pbk2ProcessDecoratorFactory::CreateProgressDialogDecoratorL

   169         ( R_PMU_COPY_PROGRESS_NOTE, ETrue );

   170     iDecorator->SetObserver( *this );

   171     

   172     iUiControl->RegisterCommand( this );

   173     

   174     // set the default contacts path

   175     iContactsPath = PathInfo::MemoryCardContactsPath();

   176     

   177     iDriveSpaceCheck = CPbk2DriveSpaceCheck::NewL

   178             ( CCoeEnv::Static()->FsSession() );

   179     }

   180 

   181 // --------------------------------------------------------------------------

   182 // CPmuCopyToMmcCmd::RunL

   183 // --------------------------------------------------------------------------

   184 //

   185 void CPmuCopyToMmcCmd::RunL()

   186     {

   187     switch( iState )

   188         {

   189         case EPmuCopyToMmcCmdStartProcess:

   190             {

   191             iDecorator->ProcessStartedL(iContactLinks->Count());                        

   192             

   193             if ( iDeleteOldEntries )

   194                 {

   195                 iState = EPmuCopyToMmcCmdDeleteOldEntries;

   196                 IssueRequest();

   197                 }

   198             else

   199                 {

   200                 Phonebook2::Pbk2AppUi()->ApplicationServices().

   201                     ContactManager().FsSession().MkDirAll

   202                         ( iContactsPath );

   203                 

   204                 iState = EPmuCopyToMmcCmdRun;

   205                 IssueRequest();

   206                 }

   207             break;

   208             }

   209         case EPmuCopyToMmcCmdDeleteOldEntries:

   210             {

   211             DeleteOldEntriesL();

   212             Phonebook2::Pbk2AppUi()->ApplicationServices().ContactManager().

   213                 FsSession().MkDirAll( iContactsPath );

   214             break;

   215             }        

   216         case EPmuCopyToMmcCmdRun:

   217             {                        

   218             if (iFileMan)

   219                 {

   220                 delete iFileMan;

   221                 iFileMan = NULL;

   222                 }

   223 

   224             if (iStoreContact)

   225                 {

   226                 HBufC* fileName = CreateFileNameLC(*iStoreContact);

   227                 iWriteStream.Create( Phonebook2::Pbk2AppUi()->

   228                     ApplicationServices().ContactManager().FsSession(),

   229                         *fileName, EFileWrite );

   230                 iExportOperation = iVCardEngine->ExportVCardForSyncL(

   231                     iWriteStream, *iStoreContact, *this );

   232                 CleanupStack::PopAndDestroy(fileName);

   233                 }

   234             else if (iCurrentIndex < iContactLinks->Count())

   235                 {

   236                 TRAPD( err, CopyNextL() );

   237                 if( err != KErrNone )

   238                     User::LeaveIfError( HandleError( err ) );

   239                 }

   240             else

   241                 {

   242                 iState = EPmuCopyToMmcCmdComplete;

   243                 IssueRequest();

   244                 }

   245             break;

   246             }

   247         case EPmuCopyToMmcCmdComplete:

   248             {

   249             // Copy complete, decorator calls processdismissed

   250             iDecorator->ProcessStopped();

   251             break;

   252             }

   253         default:

   254             {            

   255             }

   256         }    

   257     }

   258 

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

   260 // CPmuCopyToMmcCmd::DoCancel

   261 // --------------------------------------------------------------------------

   262 //

   263 void CPmuCopyToMmcCmd::DoCancel()

   264     {

   265     iState = EPmuCopyToMmcCmdCancel;

   266     

   267     delete iRetrieveOperation;

   268     iRetrieveOperation = NULL;

   269     delete iExportOperation;

   270     iExportOperation = NULL;

   271     }

   272 

   273 // --------------------------------------------------------------------------

   274 // CPmuCopyToMmcCmd::RunError

   275 // --------------------------------------------------------------------------

   276 //

   277 TInt CPmuCopyToMmcCmd::RunError( TInt aError )

   278     {

   279     return HandleError( aError );

   280     }

   281 

   282 // --------------------------------------------------------------------------

   283 // CPmuCopyToMmcCmd::ExecuteLD

   284 // --------------------------------------------------------------------------

   285 //

   286 void CPmuCopyToMmcCmd::ExecuteLD()

   287     {

   288     CleanupStack::PushL( this );

   289 

   290     // Show memory selection dialog if multiple drives available.

   291     if ( ShowMemorySelectionDialogL() )

   292         {

   293         // User selected a drive

   294         ShowConfirmationQueryL();

   295         }

   296     else // If user cancelled the selection

   297         {

   298         iCommandObserver->CommandFinished( *this );

   299         }

   300     CleanupStack::Pop( this );

   301     }

   302 

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

   304 // CPmuCopyToMmcCmd::AddObserver

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

   306 //

   307 void CPmuCopyToMmcCmd::AddObserver( MPbk2CommandObserver& aObserver )

   308     {

   309     iCommandObserver = &aObserver;

   310     }

   311 

   312 // --------------------------------------------------------------------------

   313 // CPmuCopyToMmcCmd::ResetUiControl

   314 // --------------------------------------------------------------------------

   315 //

   316 void CPmuCopyToMmcCmd::ResetUiControl( MPbk2ContactUiControl& aUiControl )

   317     {

   318     if ( iUiControl == &aUiControl )

   319         {

   320         iUiControl = NULL;

   321         }

   322     }

   323 

   324 // --------------------------------------------------------------------------

   325 // CPmuCopyToMmcCmd::ProcessDismissed

   326 // --------------------------------------------------------------------------

   327 //

   328 void CPmuCopyToMmcCmd::ProcessDismissed( TInt /*aCancelCode*/ )

   329     {

   330     Cancel();

   331     delete iRetrieveOperation;

   332     iRetrieveOperation = NULL;

   333     delete iExportOperation;

   334     iExportOperation = NULL;

   335 

   336     // It is a not big deal if result note is not shown to user

   337     TRAP_IGNORE( ShowResultsL() );

   338     if ( iUiControl )

   339         {

   340         iUiControl->UpdateAfterCommandExecution();

   341         } 

   342     iCommandObserver->CommandFinished( *this );

   343     }

   344 

   345 // --------------------------------------------------------------------------

   346 // CPmuCopyToMmcCmd::VPbkSingleContactOperationComplete

   347 // --------------------------------------------------------------------------

   348 //

   349 void CPmuCopyToMmcCmd::VPbkSingleContactOperationComplete

   350         ( MVPbkContactOperationBase& aOperation,

   351           MVPbkStoreContact* aContact )

   352     {

   353     __ASSERT_DEBUG( iDecorator, Panic( EPanic_OperationComplete_PreCond ));

   354     

   355     if ( &aOperation == iRetrieveOperation )

   356         {

   357         delete iRetrieveOperation;

   358         iRetrieveOperation = NULL;

   359 

   360         iStoreContact = aContact;

   361         }

   362     else if ( &aOperation == iExportOperation )

   363         {

   364         delete iExportOperation;

   365         iExportOperation = NULL;

   366 

   367         // After the copying take the contact pointer,

   368         // because if this was last contact we need it in result note

   369         delete iPreviousContact;

   370         iPreviousContact = iStoreContact; // iPreviousContact takes ownership

   371         iStoreContact = NULL;

   372 

   373         iWriteStream.Close();

   374         

   375         // Copy next and update progressbar

   376         ++iCurrentIndex;

   377         ++iCountOfContacts;

   378         iDecorator->ProcessAdvance( 1 );

   379         }

   380     IssueRequest();        

   381     }

   382 

   383 // --------------------------------------------------------------------------

   384 // CPmuCopyToMmcCmd::VPbkSingleContactOperationFailed

   385 // --------------------------------------------------------------------------

   386 //

   387 void CPmuCopyToMmcCmd::VPbkSingleContactOperationFailed

   388         ( MVPbkContactOperationBase& aOperation, TInt /*aError*/ )

   389     {

   390     if (&aOperation == iRetrieveOperation)

   391         {

   392         delete iRetrieveOperation;

   393         iRetrieveOperation = NULL;

   394         }

   395     else if (&aOperation == iExportOperation)

   396         {

   397         delete iExportOperation;

   398         iExportOperation = NULL;

   399         delete iStoreContact;

   400         iStoreContact = NULL;

   401         }

   402     

   403     // Copy next    

   404     ++iCurrentIndex;

   405     IssueRequest();        

   406     }

   407     

   408 // --------------------------------------------------------------------------

   409 // CPmuCopyToMmcCmd::NotifyFileManStarted

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

   411 //    

   412 MFileManObserver::TControl CPmuCopyToMmcCmd::NotifyFileManStarted()

   413     {

   414     if ( iState == EPmuCopyToMmcCmdCancel )

   415         {

   416         return MFileManObserver::EAbort;

   417         }

   418     return MFileManObserver::EContinue;

   419     }

   420     

   421 // --------------------------------------------------------------------------

   422 // CPmuCopyToMmcCmd::NotifyFileManOperation

   423 // --------------------------------------------------------------------------

   424 //

   425 MFileManObserver::TControl CPmuCopyToMmcCmd::NotifyFileManOperation()

   426     {

   427     if ( iState == EPmuCopyToMmcCmdCancel )

   428         {

   429         return MFileManObserver::EAbort;

   430         }

   431     return MFileManObserver::EContinue;

   432     }    

   433 

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

   435 // CPmuCopyToMmcCmd::CopyNextL

   436 // --------------------------------------------------------------------------

   437 //

   438 void CPmuCopyToMmcCmd::CopyNextL()

   439     {

   440     __ASSERT_DEBUG( iContactLinks->Count() > iCurrentIndex,

   441          Panic( EPanic_CopyNextL_OOB ) );

   442     

   443     //Check free storage space

   444     iDriveSpaceCheck->SetStore( iContactsPath );

   445     iDriveSpaceCheck->DriveSpaceCheckL();

   446     

   447     iRetrieveOperation = Phonebook2::Pbk2AppUi()->ApplicationServices().

   448         ContactManager().RetrieveContactL

   449             ( iContactLinks->At( iCurrentIndex ), *this );

   450     }

   451 

   452 // --------------------------------------------------------------------------

   453 // CPmuCopyToMmcCmd::IssueRequest

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

   455 //

   456 void CPmuCopyToMmcCmd::IssueRequest()

   457     {

   458     if ( !IsActive() )

   459         {

   460         TRequestStatus* status = &iStatus;

   461         User::RequestComplete( status, KErrNone );

   462         SetActive();        

   463         }

   464     }

   465 

   466 // --------------------------------------------------------------------------

   467 // CPmuCopyToMmcCmd::CreateFileNameLC

   468 // --------------------------------------------------------------------------

   469 //

   470 HBufC* CPmuCopyToMmcCmd::CreateFileNameLC

   471         ( const MVPbkStoreContact& aContact ) const

   472     {

   473     HBufC* title = Phonebook2::Pbk2AppUi()->ApplicationServices().

   474         NameFormatter().GetContactTitleL( aContact.Fields(), 0 );

   475 

   476     CleanupStack::PushL(title);

   477     TPtr titlePtr = title->Des();

   478 

   479     RemoveInvalidCharacters(titlePtr);

   480 

   481     TBool fileNameFound = EFalse;

   482     TInt number = 0;

   483     TFileName fileName;

   484     while (!fileNameFound)

   485         {

   486         fileName.Zero();

   487         fileName.Append( iContactsPath );

   488         fileName.Append(titlePtr);

   489 

   490         if (number > 0)

   491             {

   492             fileName.Append(KOpeningParenthesis);

   493             if (number < 10)

   494                 {

   495                 fileName.Append(KZero);

   496                 }

   497             fileName.AppendFormat(KNumberFormat, number);

   498             fileName.Append(KClosingParenthesis);

   499             }

   500 

   501         fileName.Append(KPbk2VCardFileExtension);

   502 

   503         TEntry entry;

   504         TInt err = Phonebook2::Pbk2AppUi()->ApplicationServices().

   505             ContactManager().FsSession().Entry(fileName, entry);

   506         if (err == KErrNotFound)

   507             {

   508             fileNameFound = ETrue;

   509             }

   510         else

   511             {

   512             User::LeaveIfError( err );

   513             ++number;

   514             }

   515         }

   516     CleanupStack::PopAndDestroy(title);

   517 

   518     return fileName.AllocLC();

   519     }

   520 

   521 // --------------------------------------------------------------------------

   522 // CPmuCopyToMmcCmd::DeleteOldEntriesL

   523 // --------------------------------------------------------------------------

   524 //

   525 void CPmuCopyToMmcCmd::DeleteOldEntriesL()

   526     {        

   527     iFileMan = CFileMan::NewL( Phonebook2::Pbk2AppUi()->

   528         ApplicationServices().ContactManager().FsSession(), this );

   529     User::LeaveIfError( iFileMan->Delete( 

   530             iContactsPath,

   531             CFileMan::ERecurse, iStatus ) );

   532     iState = EPmuCopyToMmcCmdRun;            

   533     SetActive();    

   534     }

   535 

   536 // --------------------------------------------------------------------------

   537 // CPmuCopyToMmcCmd::ShowConfirmationQueryL

   538 // --------------------------------------------------------------------------

   539 //

   540 void CPmuCopyToMmcCmd::ShowConfirmationQueryL()

   541     {

   542     HBufC* prompt = StringLoader::LoadLC(R_QTN_PHOB_QUERY_REMOVE_ALL_CONTACTS);

   543     CAknQueryDialog* dlg = CAknQueryDialog::NewL();

   544 

   545     TInt result = dlg->ExecuteLD

   546         (R_PHONEBOOK2_CONFIRM_DELETE_EXISTING_CONTACTS, *prompt);

   547     CleanupStack::PopAndDestroy(prompt);

   548     iDeleteOldEntries = (result != 0);

   549         

   550     iState = EPmuCopyToMmcCmdStartProcess;

   551     IssueRequest();

   552     }

   553 

   554 // --------------------------------------------------------------------------

   555 // CPmuCopyToMmcCmd::ShowMemorySelectionDialogL

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

   557 //

   558 TBool CPmuCopyToMmcCmd::ShowMemorySelectionDialogL()

   559     {

   560     TBool driveSelected( EFalse );

   561 

   562     TDriveNumber selectedMem;

   563     CAknMemorySelectionDialogMultiDrive* dlg =

   564             CAknMemorySelectionDialogMultiDrive::NewL(

   565                     ECFDDialogTypeSelect,

   566                     R_PHONEBOOK2_MEMORY_SELECTION_DIALOG,

   567                     EFalse,

   568                     AknCommonDialogsDynMem::EMemoryTypeMMCExternal |

   569                     AknCommonDialogsDynMem::EMemoryTypeInternalMassStorage );

   570     CleanupStack::PushL( dlg );

   571     driveSelected = dlg->ExecuteL( selectedMem );

   572     CleanupStack::PopAndDestroy(); // dlg

   573 

   574     // If user selected a drive

   575     if ( driveSelected )

   576         {

   577         TInt err = PathInfo::GetFullPath( iContactsPath, 

   578                                            selectedMem,

   579                                            PathInfo::EMemoryCardContactsPath );

   580         User::LeaveIfError( err );

   581         }

   582 

   583     return driveSelected;

   584     }

   585 

   586 // --------------------------------------------------------------------------

   587 // CPmuCopyToMmcCmd::ShowResultsL

   588 // --------------------------------------------------------------------------

   589 //

   590 void CPmuCopyToMmcCmd::ShowResultsL()

   591     {        

   592     const TInt contactCount = iContactLinks->Count();

   593     if (contactCount == KOneContact)

   594         {

   595         HBufC* title = NULL;

   596 

   597         // If we do not have iPreviousContact, then probably coping is failed

   598         if ( iPreviousContact )

   599             {

   600             title = Phonebook2::Pbk2AppUi()->ApplicationServices().

   601                 NameFormatter().GetContactTitleL( iPreviousContact->Fields(),

   602                     MPbk2ContactNameFormatter::EPreserveLeadingSpaces);

   603             CleanupStack::PushL(title);

   604             }

   605         else if ( iStoreContact )

   606             {

   607             // If we still have iStoreContact, then retrieve is atleast 

   608             // completed and we can show note.

   609             title = Phonebook2::Pbk2AppUi()->ApplicationServices().

   610                 NameFormatter().GetContactTitleL( iStoreContact->Fields(),

   611                     MPbk2ContactNameFormatter::EPreserveLeadingSpaces );

   612             CleanupStack::PushL(title);

   613             }

   614             

   615         if ( title )

   616             {

   617             TPbk2CopyContactsResults results( iCountOfContacts, *title );

   618             results.SetOneContactCopiedTextRes

   619                 ( R_QTN_PBCOP_NOTE_CONTACT_COPIED_PB2 );

   620             results.SetOneContactNotCopiedTextRes

   621                 ( R_QTN_PBCOP_NOTE_ENTRY_NOT_COPIED );

   622             results.ShowNoteL();

   623 

   624             CleanupStack::PopAndDestroy( title );

   625             }                            

   626         }

   627     else

   628         {

   629         TPbk2CopyContactsResults results( 

   630             iCountOfContacts, iContactLinks->Count());

   631         results.ShowNoteL();

   632         }

   633     }

   634 

   635 TInt CPmuCopyToMmcCmd::HandleError( TInt aError )

   636     {

   637     TInt err = aError;

   638     

   639     delete iRetrieveOperation;

   640     iRetrieveOperation = NULL;

   641     delete iExportOperation;

   642     iExportOperation = NULL;

   643        

   644     // if there are already copied contacts, dont show error

   645     if( iCountOfContacts )

   646         err = KErrNone;

   647     

   648     if ( iDecorator )

   649         {

   650         iDecorator->ProcessStopped();

   651         }

   652     

   653     return err;

   654     }

   655 

   656 // End of File