1 /*

     2 * Copyright (c) 2008 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:   Recognizes files to get corresponding MIME types

    15 *

    16 */

    17 

    18 

    19 #include "appmngr2filerecognizer.h"     // CAppMngr2FileRecognizer

    20 #include <appmngr2recognizedfile.h>     // CAppMngr2RecognizedFile

    21 #include <f32file.h>                    // RFs, CDir

    22 #include <apmstd.h>                     // TDataType

    23 #include <caf/caf.h>                    // ContentAccess

    24 

    25 

    26 // ======== MEMBER FUNCTIONS ========

    27 

    28 // ---------------------------------------------------------------------------

    29 // CAppMngr2FileRecognizer::NewL()

    30 // ---------------------------------------------------------------------------

    31 //

    32 CAppMngr2FileRecognizer* CAppMngr2FileRecognizer::NewL( RFs& aFs )

    33     {

    34     CAppMngr2FileRecognizer* self = new (ELeave) CAppMngr2FileRecognizer( aFs );

    35     return self;

    36     }

    37 

    38 // ---------------------------------------------------------------------------

    39 // CAppMngr2FileRecognizer::~CAppMngr2FileRecognizer()

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

    41 //

    42 CAppMngr2FileRecognizer::~CAppMngr2FileRecognizer()

    43     {

    44     Cancel();

    45     iDirStatus = NULL;

    46     delete iDirPath;

    47     delete iDirEntries;

    48     iResultArray.ResetAndDestroy();

    49     }

    50 

    51 // ---------------------------------------------------------------------------

    52 // CAppMngr2FileRecognizer::RecognizeFilesL()

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

    54 //

    55 void CAppMngr2FileRecognizer::RecognizeFilesL( const TDesC& aPath,

    56         TRequestStatus& aStatus )

    57     {

    58     if( IsActive() )

    59         {

    60         User::Leave( KErrInUse );

    61         }

    62 

    63     if( iDirPath )

    64         {

    65         delete iDirPath;

    66         iDirPath = NULL;

    67         }

    68     iDirPath = aPath.AllocL();

    69 

    70     if( iDirEntries )

    71         {

    72         delete iDirEntries;

    73         iDirEntries = NULL;

    74         }

    75     

    76     TInt err = iFs.GetDir( *iDirPath, KEntryAttNormal, ESortNone, iDirEntries );

    77     User::LeaveIfError( err );

    78 

    79     aStatus = KRequestPending;  // for recognizing all files in the directory

    80     iDirStatus = &aStatus;

    81 

    82     iResultArray.ResetAndDestroy();

    83     iIndex = 0;

    84     iState = ERecognizing;

    85     

    86     // start recognizing the first file asynchronously

    87     SetActive();

    88     TRequestStatus* fileStatus = &iStatus;

    89     User::RequestComplete( fileStatus, KErrNone );

    90     }

    91 

    92 // ---------------------------------------------------------------------------

    93 // CAppMngr2FileRecognizer::CancelRecognizeFiles()

    94 // ---------------------------------------------------------------------------

    95 //

    96 void CAppMngr2FileRecognizer::CancelRecognizeFiles()

    97     {

    98     Cancel();

    99     }

   100 

   101 // ---------------------------------------------------------------------------

   102 // CAppMngr2FileRecognizer::Results()

   103 // ---------------------------------------------------------------------------

   104 //

   105 RPointerArray<CAppMngr2RecognizedFile>& CAppMngr2FileRecognizer::Results()

   106     {

   107     return iResultArray;

   108     }

   109 

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

   111 // CAppMngr2FileRecognizer::DoCancel()

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

   113 //

   114 void CAppMngr2FileRecognizer::DoCancel()

   115     {

   116     switch( iState )

   117         {

   118         case EIdle:

   119             break;

   120         case ERecognizing:

   121             iState = EIdle;

   122             if( iDirStatus )

   123                 {

   124                 User::RequestComplete( iDirStatus, KErrCancel );

   125                 iDirStatus = NULL;

   126                 }

   127             break;

   128         default:

   129             break;

   130         }

   131     }

   132 

   133 // ---------------------------------------------------------------------------

   134 // CAppMngr2FileRecognizer::RunL()

   135 // ---------------------------------------------------------------------------

   136 //

   137 void CAppMngr2FileRecognizer::RunL()

   138     {

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

   140     

   141     switch( iState )

   142         {

   143         case EIdle:

   144             break;

   145         case ERecognizing:

   146             RecognizeNextFileL();

   147             break;

   148         default:

   149             break;

   150         }

   151     }

   152 

   153 // ---------------------------------------------------------------------------

   154 // CAppMngr2FileRecognizer::RunError()

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

   156 //

   157 TInt CAppMngr2FileRecognizer::RunError( TInt aError )

   158     {

   159     // RunL() leaved, pass the error code to caller

   160     if( iDirStatus )

   161         {

   162         User::RequestComplete( iDirStatus, aError );

   163         iDirStatus = NULL;

   164         }

   165     return KErrNone;

   166     }

   167 

   168 // ---------------------------------------------------------------------------

   169 // CAppMngr2FileRecognizer::CAppMngr2FileRecognizer()

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

   171 //

   172 CAppMngr2FileRecognizer::CAppMngr2FileRecognizer( RFs& aFs ) :

   173         CActive( CActive::EPriorityLow ), iFs( aFs )

   174     {

   175     // EPriorityLow used for smooth operation. Low priority allows UI refreshes

   176     // to proceed when some files have been recognized (even if there are still

   177     // more files to be recognized and recognizer is waiting for the next file

   178     // to be recognized).

   179     CActiveScheduler::Add( this );

   180     }

   181 

   182 // ---------------------------------------------------------------------------

   183 // CAppMngr2FileRecognizer::RecognizeNextFileL()

   184 // ---------------------------------------------------------------------------

   185 //

   186 void CAppMngr2FileRecognizer::RecognizeNextFileL()

   187     {

   188     if( iIndex < iDirEntries->Count() )

   189         {

   190         // recognize the file which index is iIndex

   191         const TEntry& file = ( *iDirEntries )[ iIndex ];

   192         

   193         HBufC* fullName = HBufC::NewLC( iDirPath->Length() + file.iName.Length() );

   194         TPtr namePtr( fullName->Des() );

   195         namePtr.Copy( *iDirPath );

   196         namePtr.Append( file.iName );

   197         

   198         ContentAccess::CContent* content = ContentAccess::CContent::NewLC(

   199                 *fullName, ContentAccess::EContentShareReadWrite );

   200         

   201         HBufC* mimeType = HBufC::NewLC( KMaxDataTypeLength );

   202         TPtr mimePtr( mimeType->Des() );

   203         content->GetStringAttribute( ContentAccess::EMimeType, mimePtr );

   204         

   205         CAppMngr2RecognizedFile* recFile = CAppMngr2RecognizedFile::NewL( fullName, mimeType );

   206         CleanupStack::Pop( mimeType );

   207         CleanupStack::PopAndDestroy( content );

   208         CleanupStack::Pop( fullName );

   209         

   210         CleanupStack::PushL( recFile );

   211         iResultArray.AppendL( recFile );

   212         CleanupStack::Pop( recFile );

   213 

   214         // and then recognize the next file

   215         iIndex++;

   216         SetActive();

   217         TRequestStatus* fileStatus = &iStatus;

   218         User::RequestComplete( fileStatus, KErrNone );

   219         }

   220     else

   221         {

   222         // all done, directory has been processed

   223         User::RequestComplete( iDirStatus, KErrNone );

   224         iDirStatus = NULL;

   225         }

   226     }

   227