1 /*

     2 * Copyright (c) 2002-2006 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:  Implementation of CDocumentHandler class.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 

    21 #include "DocumentHandler.h"        // Class Declaration

    22 #include "DocConstants.h"

    23 

    24 // All special handlers and the default handler

    25 #include "DocDefaultHandler.h"

    26 #include "DocImageHandler.h"

    27 #include "DocGameHandler.h"

    28 #include "DocAppInstHandler.h"

    29 //#include "DocMidletHandler.h"

    30 

    31 #ifdef ENABLE_DRM

    32 #include "DocDCFHandler.h"

    33 #include <Oma2Agent.h>

    34 #endif // ENABLE_DRM

    35 

    36 #include <AiwGenericParam.h>

    37 

    38 #include <featmgr.h>

    39 

    40 #include <centralrepository.h>

    41 #include <CommonUiInternalCRKeys.h>

    42 

    43 #define LEAVEONERROR( error ) if( error != KUserCancel && error != KErrNone )\

    44                                    User::Leave( error )

    45 

    46 const TInt KDocMaxCenRepBufLen = 1024;

    47 const TInt KDocPDMaxMimeLen = 64;

    48 const TInt KDocPDMaxUids = 24;

    49 const TInt KDocPDMaxUidLen = 12;

    50 const TInt KDocMaxDigitsInHexString = 8; // 32 bits.

    51 

    52 // ================= MEMBER FUNCTIONS =======================

    53 

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

    55 // might leave.

    56 // @since Series60 3.0

    57 //

    58 CDocumentHandler::CDocumentHandler()

    59     {

    60     }

    61 

    62 // Two-phased constructor.

    63 // @since Series60 3.0

    64 EXPORT_C CDocumentHandler* CDocumentHandler::NewL( )

    65     {

    66     CDocumentHandler* self = NewLC( );

    67     CleanupStack::Pop();

    68     return self;

    69     }

    70 

    71 // Two-phased constructor.

    72 // @since Series60 3.0

    73 EXPORT_C CDocumentHandler* CDocumentHandler::NewLC( )

    74     {

    75     CDocumentHandler* self = new( ELeave ) CDocumentHandler ( );

    76     CleanupStack::PushL( self );

    77     self->ConstructL();

    78     return self;

    79     }

    80 

    81 // EPOC default constructor can leave.

    82 void CDocumentHandler::ConstructL()

    83     {

    84     iApaLs = new ( ELeave ) RApaLsSession;

    85     User::LeaveIfError(iApaLs->Connect());

    86 

    87     FeatureManager::InitializeLibL();

    88 

    89     iTempFileName.Zero();

    90     }

    91 

    92 // Two-phased constructor.

    93 EXPORT_C CDocumentHandler* CDocumentHandler::NewL( CEikProcess* /*aProcess*/ )

    94     {

    95     CDocumentHandler* self = NewLC( );

    96     CleanupStack::Pop();

    97     return self;

    98     }

    99 

   100 // Two-phased constructor.

   101 EXPORT_C CDocumentHandler* CDocumentHandler::NewLC( CEikProcess* /*aProcess*/ )

   102     {

   103     CDocumentHandler* self = new( ELeave ) CDocumentHandler (  );

   104     CleanupStack::PushL( self );

   105     self->ConstructL();

   106     return self;

   107     }

   108 

   109 // Destructor

   110 EXPORT_C CDocumentHandler::~CDocumentHandler()

   111     {

   112     FeatureManager::UnInitializeLib();

   113 

   114     if ( iApaLs )

   115         {

   116         iApaLs->Close();

   117         delete iApaLs;

   118         }

   119 

   120     CloseSharableFS();

   121 

   122     // If we have temp file, we use iHandler services to delete this file

   123     if ( iTempFileName.Length() != 0 && iHandler )

   124         {

   125         iHandler->DeleteFile(iTempFileName);

   126         }

   127 

   128     delete iHandler;

   129 

   130     if ( iInParams )

   131         {

   132         delete iInParams;

   133         }

   134 

   135     #ifdef _DEBUG

   136     RDebug::Print( _L("DocumentHandler: CDocumentHandler instance destructed succesfully!"));

   137     #endif

   138     }

   139 

   140 

   141 // ---------------------------------------------------------

   142 // RApaLsSession* CDocumentHandler::ApaLs()

   143 // Returns Application list server object

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

   145 RApaLsSession* CDocumentHandler::ApaLs()

   146     {

   147     return iApaLs;

   148     }

   149 

   150 // ---------------------------------------------------------

   151 // CDocumentHandler::DocOperation()

   152 // Returns CDocumentHandler::iOperation.

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

   154 TDocOperation CDocumentHandler::DocOperation() const

   155     {

   156     return iOperation;

   157     }

   158 

   159 // ---------------------------------------------------------

   160 // MApaEmbeddedDocObserver* CDocumentHandler::ExitObserver()

   161 // Returns ExitObserver

   162 // @since Series60 3.0

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

   164 MAknServerAppExitObserver* CDocumentHandler::ServerAppExitObserver() const

   165     {

   166     return iServerAppExitObserver;

   167     }

   168 

   169 // ---------------------------------------------------------

   170 // CDocumentHandler::SaveL

   171 // Save content to the correct directory based on aDataType

   172 // with a generated filename and attributes.

   173 //

   174 // This functions calls other SaveL version.

   175 //

   176 // Returns: KErrNone:           Everything went ok

   177 //          KUserCancel:      The user cancelled the operation

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

   179 //

   180 EXPORT_C TInt CDocumentHandler::SaveL(

   181     const TDesC8& aContent,     // Content buffer

   182     TDataType& aDataType,       // Mime type of the content

   183     const TUint aAttr )         // Save with these attributes

   184     {

   185     #ifdef _DEBUG

   186     RDebug::Print( _L("DocumentHandler: CDocumentHandler::SaveL(aContent, aDataType, aAttr) Called"));

   187     TPtrC mimetype = aDataType.Des();

   188     RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S "), &mimetype);

   189     #endif

   190 

   191     TFileName nullFileName;

   192 

   193     return SaveL(aContent, aDataType, nullFileName, aAttr);

   194     }

   195 

   196 // ---------------------------------------------------------

   197 // CDocumentHandler::SaveL

   198 // Save content to the correct directory based on aDataType

   199 // with aFileName and attributes.

   200 //

   201 // We first save wile with SaveTempFileL command.

   202 // After that we use MoveL command.

   203 //

   204 // Returns: KErrNone:           Everything went ok

   205 //          KUserCancel:      The user cancelled the operation

   206 // ---------------------------------------------------------

   207 //

   208 EXPORT_C TInt CDocumentHandler::SaveL(

   209     const TDesC8& aContent,     // Content buffer

   210     TDataType& aDataType,       // Mime type of the content

   211     const TDesC& aName,         // Save with this name

   212     const TUint aAttr )         // Save with these attributes

   213     {

   214     #ifdef _DEBUG

   215     RDebug::Print( _L("DocumentHandler: CDocumentHandler::SaveL(aContent, aDataType, aFileName, aAttr) Called"));

   216     TPtrC mimetype = aDataType.Des();

   217     RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S -- aFileName: %S  "), &mimetype, &aName);

   218     #endif

   219 

   220     TUid uid = { 0 };

   221     TInt error;

   222 

   223     if (aDataType.Des8().FindF( KDummyMimeType ) != KErrNotFound)

   224         {

   225         return KErrNone;

   226         }

   227 

   228     TFileName tempFileName;

   229 

   230     iOperation = EDocSaveTemp; // First save temp file

   231 

   232     // Use Default Handler for saving whatever mimetype actually is

   233     delete iHandler;            // delete the old handler

   234     iHandler = NULL;

   235     iHandler = CDocDefaultHandler::NewL( aDataType,

   236                                              uid, this, EDocSaveOnly );

   237 

   238     error = iHandler->SetDestName( aName );     // Save with this file name

   239 

   240     // Close if existing sharable RFs and create new for sharing purposes.

   241     if ( error == KErrNone )

   242         {

   243         CloseSharableFS();

   244         User::LeaveIfError(iSharableFS.Connect());

   245         iSharableFS.ShareProtected();

   246         }

   247 

   248     if ( error == KErrNone )

   249         {

   250         error = iHandler->SaveTempFileL( aContent, KEntryAttNormal, tempFileName);

   251         }

   252 

   253     iOperation = EDocMove; // Move temp file to correct folder

   254 

   255     if ( error == KErrNone )

   256         {

   257         RecognizeAndCheckFileL( tempFileName, aDataType, uid );

   258 

   259         TRAP( error, FindHandlerL( aDataType, uid ) ); // allow unsupported.

   260         if ( error == KMimeNotSupported )

   261             {

   262             iHandler = CDocDefaultHandler::NewL( aDataType, uid, this, EDocSaveOnly );

   263             error = KErrNone;

   264             }

   265         else

   266             {

   267             User::LeaveIfError( error );

   268             }

   269         }

   270 

   271     if ( !iHandler->CanSave() )

   272         {

   273         User::Leave( KErrNotSupported );

   274         }

   275 

   276     if ( error == KErrNone )

   277         {

   278         error = iHandler->SetSrcFileName( tempFileName );

   279         }

   280 

   281     if ( error == KErrNone )

   282         {

   283         error = iHandler->SetDestName( aName );

   284         }

   285 

   286     // We use CopyOrMoveL-function, iOperation is checked there

   287     if ( error == KErrNone )

   288         {

   289         error = iHandler->CopyOrMoveL( aAttr );

   290         }

   291 

   292     #ifdef _DEBUG

   293     RDebug::Print( _L("DocumentHandler: CDocumentHandler::SaveL: finished with error=%d."), error);

   294     #endif

   295 

   296     LEAVEONERROR( error );

   297 

   298 // Because DCF files are not tried to be recognized we return empty

   299 // type here. Normally the return value has the type which was used

   300 // when handler was selected.

   301 #ifdef ENABLE_DRM

   302 #ifdef __DRM_OMA2

   303     if ( aDataType.Des8().FindF( KOma1DcfContentType ) != KErrNotFound ||

   304          aDataType.Des8().FindF( KOma2DcfContentType ) != KErrNotFound )

   305 #else // __DRM_OMA2

   306     if ( aDataType.Des8().FindF( KOma1DcfContentType ) != KErrNotFound )

   307 #endif // __DRM_OMA2

   308         {

   309         TDataType emptyDataType;

   310         aDataType = emptyDataType;

   311         }

   312 #endif // ENABLE_DRM

   313 

   314     return error;

   315     }

   316 

   317 // ---------------------------------------------------------

   318 // CDocumentHandler::CopyL

   319 // Copy file to the correct directory based on it's mime type.

   320 //

   321 // Returns: KErrNone:           Everything went ok

   322 //          KUserCancel:      The user cancelled the operation

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

   324 //

   325 EXPORT_C TInt CDocumentHandler::CopyL(

   326     const TDesC& aFileNameOld,  // copy data from this file

   327     const TDesC& aFileNameNew,  // using this filename

   328     TDataType& aDataType,       // Mime type of data

   329     const TUint aAttr )         // use these attributes

   330     {

   331     #ifdef _DEBUG

   332     RDebug::Print( _L("DocumentHandler: CDocumentHandler::CopyL(aFileNameOld, aFileNameNew, aDataType, aAttr) Called"));

   333     TPtrC mimetype = aDataType.Des();

   334     RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S -- aFileNameOld: %S -- aFileNameNew: %S"), &mimetype, &aFileNameOld, &aFileNameNew);

   335     #endif

   336 

   337     TInt error = KErrNone;

   338     TUid uid = { 0 };

   339 

   340     if (aDataType.Des8().FindF( KDummyMimeType ) != KErrNotFound)

   341         {

   342         return KErrNone;

   343         }

   344 

   345     iOperation = EDocCopy;

   346 

   347     RecognizeAndCheckFileL( aFileNameOld, aDataType, uid );

   348 

   349     TRAP( error, FindHandlerL( aDataType, uid ) ); // allow unsupported.

   350     if ( error == KMimeNotSupported )

   351         {

   352         iHandler = CDocDefaultHandler::NewL( aDataType, uid, this, EDocSaveOnly );

   353         error = KErrNone;

   354         }

   355     else

   356         {

   357         User::LeaveIfError( error );

   358         }

   359 

   360     if ( !iHandler->CanSave() )

   361         {

   362         User::Leave( KErrNotSupported );

   363         }

   364 

   365     error = iHandler->SetSrcFileName( aFileNameOld );

   366     if ( error == KErrNone )

   367         {

   368         // If aFileNameNew is not set, use source file name

   369         if (aFileNameNew.Length() != 0)

   370             {

   371             error = iHandler->SetDestName( aFileNameNew );

   372             }

   373         else

   374             {

   375             error = iHandler->SetDestName( aFileNameOld );

   376             }

   377         }

   378 

   379     // We use CopyOrMoveL-function, iOperation is checked there

   380     if ( error == KErrNone )

   381         {

   382         error = iHandler->CopyOrMoveL( aAttr );

   383         }

   384 

   385     #ifdef _DEBUG

   386     RDebug::Print( _L("DocumentHandler: CDocumentHandler::CopyL: finished with error=%d."), error);

   387     #endif

   388 

   389     LEAVEONERROR( error );

   390 

   391     return error;

   392     }

   393 

   394 

   395 // ---------------------------------------------------------

   396 // CDocumentHandler::CopyL

   397 // Copy file to the correct directory based on it's mime type.

   398 //

   399 // Returns: KErrNone:           Everything went ok

   400 //          KUserCancel:      The user cancelled the operation

   401 // ---------------------------------------------------------

   402 //

   403 EXPORT_C TInt CDocumentHandler::CopyL(

   404     const RFile& aFileOld,      // copy data from this file

   405     const TDesC& aFileNameNew,  // using this filename

   406     TDataType& aDataType,       // Mime type of data

   407     const TUint aAttr )         // use these attributes

   408     {

   409     #ifdef _DEBUG

   410     RDebug::Print( _L("DocumentHandler: CDocumentHandler::CopyL(aFileOld, aFileNameNew, aDataType, aAttr) Called"));

   411     TPtrC mimetype = aDataType.Des();

   412     TFileName fileNameOld;

   413     aFileOld.FullName(fileNameOld);

   414     RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S -- aFileOld (name): %S -- aFileNameNew: %S"), &mimetype, &fileNameOld, &aFileNameNew);

   415     #endif

   416 

   417     TInt error = KErrNone;

   418     TUid uid = { 0 };

   419 

   420     if (aDataType.Des8().FindF( KDummyMimeType ) != KErrNotFound)

   421         {

   422         return KErrNone;

   423         }

   424 

   425     iOperation = EDocCopy;

   426 

   427     RecognizeAndCheckFileL( const_cast<RFile&>(aFileOld), aDataType, uid );

   428 

   429     TRAP( error, FindHandlerL( aDataType, uid ) ); // allow unsupported.

   430     if ( error == KMimeNotSupported )

   431         {

   432         iHandler = CDocDefaultHandler::NewL( aDataType, uid, this, EDocSaveOnly );

   433         error = KErrNone;

   434         }

   435     else

   436         {

   437         User::LeaveIfError( error );

   438         }

   439 

   440     if ( !iHandler->CanSave() )

   441         {

   442         User::Leave( KErrNotSupported );

   443         }

   444 	

   445 	TFileName filenameold;

   446     aFileOld.FullName( filenameold );

   447     iHandler->SetSrcFileName( filenameold );

   448 

   449     // If aFileNameNew is not set, use source file name

   450     if (aFileNameNew.Length() != 0)

   451         {

   452         error = iHandler->SetDestName( aFileNameNew );

   453         }

   454     else

   455         {

   456         aFileOld.Name( filenameold );

   457         error = iHandler->SetDestName( filenameold );

   458         }

   459 

   460     // Let's do actual copying using CopyHandleL method

   461     if ( error == KErrNone )

   462         {

   463         error = iHandler->CopyHandleL( aFileOld, aAttr );

   464         }

   465 

   466     #ifdef _DEBUG

   467     RDebug::Print( _L("DocumentHandler: CDocumentHandler::CopyL: finished with error=%d."), error);

   468     #endif

   469 

   470     LEAVEONERROR( error );

   471 

   472     return error;

   473     }

   474 

   475 // ---------------------------------------------------------

   476 // CDocumentHandler::MoveL

   477 // Move file to the correct directory based on it's mime type.

   478 //

   479 // Returns: KErrNone:           Everything went ok

   480 //          KUserCancel:      The user cancelled the operation

   481 // ---------------------------------------------------------

   482 //

   483 EXPORT_C TInt CDocumentHandler::MoveL(

   484     const TDesC& aFileNameOld,  // Move this file ...

   485     const TDesC& aFileNameNew,  // ...to this filename

   486     TDataType& aDataType,       // Mime type of data

   487     const TUint aAttr )         // use these attributes to new file

   488     {

   489     #ifdef _DEBUG

   490     RDebug::Print( _L("DocumentHandler: CDocumentHandler::MoveL(aFileNameOld, aFileNameNew, aDataType, aAttr) Called"));

   491     TPtrC mimetype = aDataType.Des();

   492     RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S -- aFileNameOld: %S -- aFileNameNew: %S"), &mimetype, &aFileNameOld, &aFileNameNew);

   493     #endif

   494 

   495     TInt error = KErrNone;

   496     TUid uid = { 0 };

   497 

   498     if (aDataType.Des8().FindF( KDummyMimeType ) != KErrNotFound)

   499         {

   500         return KErrNone;

   501         }

   502 

   503     iOperation = EDocMove;

   504 

   505     RecognizeAndCheckFileL( aFileNameOld, aDataType, uid );

   506 

   507     TRAP( error, FindHandlerL( aDataType, uid ) ); // allow unsupported.

   508     if ( error == KMimeNotSupported )

   509         {

   510         iHandler = CDocDefaultHandler::NewL( aDataType, uid, this, EDocSaveOnly );

   511         error = KErrNone;

   512         }

   513     else

   514         {

   515         User::LeaveIfError( error );

   516         }

   517 

   518     if ( !iHandler->CanSave() )

   519         {

   520         User::Leave( KErrNotSupported );

   521         }

   522 

   523     error = iHandler->SetSrcFileName( aFileNameOld );

   524     if ( error == KErrNone )

   525         {

   526         error = iHandler->SetDestName( aFileNameNew );

   527         }

   528 

   529     // We use CopyOrMoveL-function, iOperation is checked there

   530     if ( error == KErrNone )

   531         {

   532         error = iHandler->CopyOrMoveL( aAttr );

   533         }

   534 

   535     #ifdef _DEBUG

   536     RDebug::Print( _L("DocumentHandler: CDocumentHandler::MoveL: finished with error=%d."), error);

   537     #endif

   538 

   539     LEAVEONERROR( error );

   540 

   541     return error;

   542     }

   543 

   544 // ---------------------------------------------------------

   545 // CDocumentHandler::SilentMoveL

   546 // Move file to the correct directory based on it's mime type.

   547 // Not any user interaction.

   548 //

   549 // Returns: KErrNone:           Everything went ok

   550 //          KUserCancel:      The user cancelled the operation

   551 // ---------------------------------------------------------

   552 //

   553 EXPORT_C TInt CDocumentHandler::SilentMoveL(

   554     const TDesC& aFileNameOld,

   555     const TDesC& aNameNew,

   556     const TDesC& aRootPath,

   557     TDataType& aDataType,

   558     const TUint aAttr )

   559     {

   560     #ifdef _DEBUG

   561     RDebug::Print( _L("DocumentHandler: CDocumentHandler::SilentMoveL(aFileNameOld, aFileNameNew, aDataType, aAttr) Called"));

   562     TPtrC mimetype = aDataType.Des();

   563     RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S -- aFileNameOld: %S -- aFileNameNew: %S"), &mimetype, &aFileNameOld, &aNameNew);

   564     #endif

   565 

   566     TInt error = KErrNone;

   567     TUid uid = { 0 };

   568 

   569     if (aDataType.Des8().FindF( KDummyMimeType ) != KErrNotFound)

   570         {

   571         return KErrNone;

   572         }

   573 

   574     iOperation = EDocSilentMove;

   575 

   576     RecognizeAndCheckFileL( aFileNameOld, aDataType, uid );

   577 

   578     TRAP( error, FindHandlerL( aDataType, uid ) ); // allow unsupported.

   579     if ( error == KMimeNotSupported )

   580         {

   581         iHandler = CDocDefaultHandler::NewL( aDataType, uid, this, EDocSaveOnly );

   582         error = KErrNone; 

   583         }

   584     else

   585         {

   586         User::LeaveIfError( error );

   587         }

   588 

   589     if ( !iHandler->CanSave() )

   590         {

   591         User::Leave( KErrNotSupported );

   592         }

   593 

   594     error = iHandler->SetRootPath( aRootPath );

   595 

   596     if ( error == KErrNone )

   597         {

   598         error = iHandler->SetSrcFileName( aFileNameOld );

   599         }

   600     if ( error == KErrNone )

   601         {

   602         error = iHandler->SetDestName( aNameNew );

   603         }

   604 

   605     // We use CopyOrMoveL-function, iOperation is checked there

   606     if ( error == KErrNone )

   607         {

   608         error = iHandler->CopyOrMoveL( aAttr );

   609         }

   610 

   611     #ifdef _DEBUG

   612     RDebug::Print( _L("DocumentHandler: CDocumentHandler::SilentMoveL: finished with error=%d."), error);

   613     #endif

   614 

   615     LEAVEONERROR( error );

   616 

   617     return error;

   618     }

   619 

   620 // ---------------------------------------------------------

   621 // CDocumentHandler::OpenFileL

   622 //

   623 // Open a file with a given data type standalone.

   624 // Calls other version of OpenFileL.

   625 //

   626 // Returns: KErrNone:           Everything went ok

   627 //          KUserCancel:      The user cancelled the operation

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

   629 //

   630 EXPORT_C TInt CDocumentHandler::OpenFileL(

   631     const TDesC& aFileName,     // Read data from here

   632     TDataType& aDataType )      // mime type of the data

   633     {

   634     #ifdef _DEBUG

   635     RDebug::Print( _L("DocumentHandler: CDocumentHandler::OpenFileL(aFileName, aDataType) Called"));

   636     TPtrC mimetype = aDataType.Des();

   637     RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S -- aFileName: %S  "), &mimetype, &aFileName);

   638     #endif

   639 

   640     RFile fileHandle;

   641     OpenTempFileL(aFileName, fileHandle);

   642     TInt error = OpenFileL(fileHandle, aDataType);

   643     fileHandle.Close();

   644     return error;

   645     }

   646 

   647 // ---------------------------------------------------------

   648 // CDocumentHandler::OpenFileL

   649 //

   650 // Open a file with a given data type standalone. First

   651 // check that the content is supported and get the handler

   652 // application's UID. Based on that UID find the correct

   653 // handler for the content. File data is not copied over.

   654 //

   655 // Returns: KErrNone:           Everything went ok

   656 //          KUserCancel:      The user cancelled the operation

   657 // ---------------------------------------------------------

   658 //

   659 EXPORT_C TInt CDocumentHandler::OpenFileL(

   660           RFile& aSharableFile,

   661           TDataType& aDataType)

   662     {

   663     #ifdef _DEBUG

   664     RDebug::Print( _L("DocumentHandler: CDocumentHandler::OpenFileL(aSharableFile, aDataType) Called"));

   665     TPtrC mimetype = aDataType.Des();

   666     TFileName filename;

   667     aSharableFile.FullName(filename);

   668     RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S -- fullname of filehandle: %S  "), &mimetype, &filename);

   669     #endif

   670 

   671     TUid uid = { 0 };

   672     TInt error;

   673 

   674     if (aDataType.Des8().FindF( KDummyMimeType ) != KErrNotFound)

   675         {

   676         return KErrNone;

   677         }

   678 

   679     iOperation = EDocOpenFile;

   680 

   681     RecognizeAndCheckFileL( aSharableFile, aDataType, uid );

   682 

   683     FindHandlerL( aDataType, uid );

   684 

   685     if ( !iHandler->CanOpen() )

   686         {

   687         User::Leave( KErrNotSupported );

   688         }

   689 

   690     error = iHandler->OpenFileL(aSharableFile);            // Do open file

   691 

   692     #ifdef _DEBUG

   693     RDebug::Print( _L("DocumentHandler: CDocumentHandler::OpenFileL: finished with error=%d."), error);

   694     #endif

   695 

   696     LEAVEONERROR( error );

   697 

   698     return error;

   699     }

   700 

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

   702 // CDocumentHandler::OpenFileEmbeddedL

   703 // Open a file with a given data type embedded.

   704 // Calls other version of OpenFileEmbeddedL.

   705 //

   706 // Returns: KErrNone:           Everything went ok

   707 //          KUserCancel:      The user cancelled the operation

   708 // ---------------------------------------------------------

   709 //

   710 EXPORT_C TInt CDocumentHandler::OpenFileEmbeddedL(

   711     const TDesC& aFileName,     // Read data from here

   712     TDataType& aDataType )      // mime type of the data

   713     {

   714     #ifdef _DEBUG

   715     RDebug::Print( _L("DocumentHandler: CDocumentHandler::OpenFileEmbeddedL(aFileName, aDataType) Called"));

   716     TPtrC mimetype = aDataType.Des();

   717     RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S -- aFileName: %S  "), &mimetype, &aFileName);

   718     #endif

   719 

   720     RFile fileHandle;

   721     OpenTempFileL(aFileName, fileHandle);

   722     TInt error = OpenFileEmbeddedL(fileHandle, aDataType, InParamListL());

   723     fileHandle.Close();

   724     return error;

   725     }

   726 

   727 // ---------------------------------------------------------

   728 // CDocumentHandler::OpenFileEmbeddedL

   729 // Calls other version of OpenFileEmbeddedL.

   730 //

   731 // Returns: KErrNone:           Everything went ok

   732 //          KUserCancel:      The user cancelled the operation

   733 // ---------------------------------------------------------

   734 //

   735 EXPORT_C TInt CDocumentHandler::OpenFileEmbeddedL(

   736           RFile& aSharableFile,

   737           TDataType& aDataType)

   738     {

   739     #ifdef _DEBUG

   740     RDebug::Print( _L("DocumentHandler: CDocumentHandler::OpenFileEmbeddedL(aSharableFile, aDataType) Called"));

   741     #endif

   742 

   743     return OpenFileEmbeddedL(aSharableFile, aDataType, InParamListL());

   744     }

   745 

   746 // ---------------------------------------------------------

   747 // CDocumentHandler::OpenFileEmbeddedL

   748 // Open a file with a given data type embedded. First

   749 // check that the content is supported and get the handler

   750 // application's UID. Based on that UID find the correct

   751 // handler for the content. File data is not copied over.

   752 //

   753 // Returns: KErrNone:           Everything went ok

   754 //          KUserCancel:      The user cancelled the operation

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

   756 //

   757 EXPORT_C TInt CDocumentHandler::OpenFileEmbeddedL(

   758           RFile& aSharableFile,

   759           TDataType& aDataType,

   760           const CAiwGenericParamList& aParamList)

   761     {

   762     #ifdef _DEBUG

   763     RDebug::Print( _L("DocumentHandler: CDocumentHandler::OpenFileEmbeddedL(aSharableFile, aDataType, aParamList) Called"));

   764     TPtrC mimetype = aDataType.Des();

   765     TFileName filename;

   766     aSharableFile.FullName(filename);

   767     RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S -- fullname of filehandle: %S  "), &mimetype, &filename);

   768     #endif

   769 

   770     TUid uid = { 0 };

   771     TInt error;

   772 

   773     if (aDataType.Des8().FindF( KDummyMimeType ) != KErrNotFound)

   774         {

   775         return KErrNone;

   776         }

   777 

   778     iOperation = EDocOpenFileEmb;

   779 

   780     error = RecognizeAndCheckFileL( aSharableFile, aDataType, uid );

   781 

   782     if ( error != KErrNone )

   783         {

   784         User::Leave( KErrNotSupported );

   785         }

   786 

   787     FindHandlerL( aDataType, uid );

   788 

   789     if ( !iHandler->CanOpen() )

   790         {

   791         User::Leave( KErrNotSupported );

   792         }

   793 

   794     iHandler->AddToParamListL( aParamList );

   795 

   796 

   797      // Default to true.

   798     TBool supportsEmbeddability = ETrue;

   799 

   800     // Check from AppArc whether the handler app. supports embeddability.

   801     TUid handlerUid;

   802     iHandler->HandlerAppUid( handlerUid );

   803 

   804     TApaAppCapability caps;

   805     TPckg<TApaAppCapability> pack( caps );

   806     TInt err = iApaLs->GetAppCapability( pack, handlerUid );

   807 

   808     if ( err == KErrNone && caps.iEmbeddability == TApaAppCapability::ENotEmbeddable )

   809         {

   810         supportsEmbeddability = EFalse;

   811         }

   812 

   813     if ( supportsEmbeddability )

   814         {

   815         error = iHandler->OpenFileEmbeddedL(aSharableFile); // Open embedded

   816         }

   817     else

   818         {

   819         error = iHandler->OpenFileL(aSharableFile); // Open stand-alone

   820         }

   821 

   822     #ifdef _DEBUG

   823     RDebug::Print( _L("DocumentHandler: CDocumentHandler::OpenFileEmbeddedL: finished with error=%d."), error);

   824     #endif

   825 

   826     LEAVEONERROR( error );

   827 

   828     return error;

   829     }

   830 

   831 // ---------------------------------------------------------

   832 // CDocumentHandler::CanHandleL

   833 // Check if there is a handler application for aDataType.

   834 //

   835 // Returns: ETrue:  The system is capable of handling aDataType

   836 //          EFalse: The system is not capable of handling aDataType

   837 // ---------------------------------------------------------

   838 //

   839 EXPORT_C TBool CDocumentHandler::CanHandleL( const TDataType& aDataType )

   840     {

   841     TUid appUid;

   842     TInt error;

   843     TBool response = EFalse;

   844 

   845     #ifdef _DEBUG

   846     TPtrC mimetype = aDataType.Des();

   847     RDebug::Print( _L("DocumentHandler: CDocumentHandler::CanHandleL called with aDataType: %S "), &mimetype );

   848     #endif

   849 

   850     error = iApaLs->AppForDataType( aDataType, appUid );

   851     if ( error == KErrNone )

   852         {

   853         TRAP( error, FindHandlerL( aDataType, appUid ) ); // allow unsupported.

   854         if ( error == KMimeNotSupported )

   855             {

   856             iHandler = CDocDefaultHandler::NewL( aDataType, appUid, this, EDocSaveOnly );

   857             error = KErrNone;

   858             }

   859         else

   860             {

   861             User::LeaveIfError( error );

   862             }

   863 

   864         if ( iHandler )

   865             {

   866             response = ( iHandler->CanOpen() ||

   867                          iHandler->CanSave() );

   868             }

   869         }

   870     return response;

   871     }

   872 

   873 // ---------------------------------------------------------

   874 // CDocumentHandler::CanOpenL

   875 // Check if there is a handler application for aDataType and

   876 // open is possible.

   877 //

   878 // Returns: ETrue:  The system is capable of handling aDataType

   879 //          EFalse: The system is not capable of handling aDataType

   880 // ---------------------------------------------------------

   881 //

   882 EXPORT_C TBool CDocumentHandler::CanOpenL( const TDataType& aDataType )

   883     {

   884     TUid appUid;

   885     TInt error;

   886     TBool response = EFalse;

   887 

   888     #ifdef _DEBUG

   889     TPtrC mimetype = aDataType.Des();

   890     RDebug::Print( _L("DocumentHandler: CDocumentHandler::CanOpenL called with aDataType: %S "), &mimetype );

   891     #endif

   892 

   893     error = iApaLs->AppForDataType( aDataType, appUid );

   894     if ( error == KErrNone )

   895         {

   896         FindHandlerL( aDataType, appUid ); // do not allow unsupported

   897         if ( iHandler )

   898             {

   899             response = iHandler->CanOpen();

   900             }

   901         }

   902     return response;

   903     }

   904 

   905 

   906 // ---------------------------------------------------------

   907 // CDocumentHandler::CanSaveL

   908 // Check if there is a handler application for aDataType and

   909 // saving is possible.

   910 //

   911 // Returns: ETrue:  The system is capable of handling aDataType

   912 //          EFalse: The system is not capable of handling aDataType

   913 // ---------------------------------------------------------

   914 //

   915 EXPORT_C TBool CDocumentHandler::CanSaveL( const TDataType& aDataType )

   916     {

   917     TUid appUid;

   918     TInt error;

   919     TBool response = EFalse;

   920 

   921     #ifdef _DEBUG

   922     TPtrC mimetype = aDataType.Des();

   923     RDebug::Print( _L("DocumentHandler: CDocumentHandler::CanSaveL called with aDataType: %S "), &mimetype );

   924     #endif

   925 

   926     error = iApaLs->AppForDataType( aDataType, appUid );

   927     if ( error == KErrNone )

   928         {

   929         TRAP( error, FindHandlerL( aDataType, appUid ) ); // allow unsupported.

   930         if ( error == KMimeNotSupported )

   931             {

   932             iHandler = CDocDefaultHandler::NewL( aDataType, appUid, this, EDocSaveOnly );

   933             error = KErrNone;

   934             }

   935         else

   936             {

   937             User::LeaveIfError( error );

   938             }

   939 

   940         if ( iHandler )

   941             {

   942             response = iHandler->CanSave();

   943             }

   944         }

   945     return response;

   946     }

   947 

   948 

   949 // ---------------------------------------------------------

   950 // CDocumentHandler::CheckFileNameExtension

   951 // Add correct file extension to aFileName with aDatatype.

   952 // Calls CDocDefaultHandler::CheckFileNameExtensionL()

   953 // ---------------------------------------------------------

   954 //

   955 EXPORT_C void CDocumentHandler::CheckFileNameExtension( TDes& aFileName, const TDataType& aDatatype )

   956     {

   957     #ifdef _DEBUG

   958     TPtrC mimetype = aDatatype.Des();

   959     RDebug::Print( _L("DocumentHandler: CDocumentHandler::CheckFileNameExtension called with: aFileName: %S -- aDataType: %S "), &aFileName, &mimetype );

   960     #endif

   961 

   962     TUid appUid;

   963     TInt error;

   964 

   965     // Try to find uid

   966     error = iApaLs->AppForDataType( aDatatype, appUid );

   967     if ( error == KErrNone )

   968         {

   969         // Try to find handler.

   970         TRAPD(err, FindHandlerL(aDatatype, appUid));

   971 

   972         if (err == KErrNone && iHandler)

   973             {

   974             // Check finally extension

   975             TRAP_IGNORE( iHandler->CheckFileNameExtensionL( aFileName, aDatatype ) );

   976             }

   977         }

   978 

   979     #ifdef _DEBUG

   980     RDebug::Print( _L("DocumentHandler: CDocumentHandler::CheckFileNameExtension finished : aFileName: %S"), &aFileName );

   981     #endif

   982     }

   983 

   984 // ---------------------------------------------------------

   985 // CDocumentHandler::SetExitObserver(..)

   986 // Delegate exit signals to aObserver too.

   987 // ---------------------------------------------------------

   988 //

   989 EXPORT_C void CDocumentHandler::SetExitObserver(

   990     MAknServerAppExitObserver* aObserver )

   991     {

   992     #ifdef _DEBUG

   993     RDebug::Print( _L("DocumentHandler: CDocumentHandler::SetExitObserver called.") );

   994     #endif

   995 

   996     __ASSERT_DEBUG (

   997         aObserver,

   998         User::Panic ( _L ( "DocumentHandler" ), KErrUnknown ) );

   999     iServerAppExitObserver = aObserver;

  1000     }

  1001 

  1002 // ---------------------------------------------------------

  1003 // CDocumentHandler::FindHandlerByUidL(..)

  1004 // Try to find a handler for aUid.

  1005 // ---------------------------------------------------------

  1006 //

  1007 void CDocumentHandler::FindHandlerByUidL( const TUid& aUid, const TDataType& aDataType )

  1008     {

  1009     switch ( aUid.iUid )

  1010         {

  1011         case KTextHandler:        // Notepad viewer

  1012             iHandler = CDocDefaultHandler::NewL(

  1013                            aDataType, 

  1014                            aUid, this, EDocOpenAndSave );

  1015             break;

  1016         case KCertSaveAppHandler: // Cert save app

  1017             iHandler = CDocDefaultHandler::NewL(

  1018                            aDataType,

  1019                            aUid, this, EDocOpenOnly );

  1020             break;

  1021         case KLandmarkHandler: // Landmark UI app

  1022             iHandler = CDocDefaultHandler::NewL(

  1023                            aDataType,

  1024                            aUid, this, EDocOpenOnly );

  1025             break;

  1026         case KImageViewerHandler: // Image Viewer

  1027             iHandler = CDocImageHandler::NewL(

  1028                            aDataType, aUid, this);

  1029             break;

  1030         case KAppInstHandler:   // Application Installer

  1031             iHandler = CDocAppInstHandler::NewL(

  1032                            aDataType,

  1033                            aUid, this, EDocOpenAndSave );

  1034             break;

  1035         case KWmlcHandler: // Browser

  1036             iHandler = CDocDefaultHandler::NewL(

  1037                            aDataType,

  1038                            aUid, this, EDocOpenAndSave );

  1039             break;

  1040         default:

  1041 /*          TODO: Do we need midlet handler anymore?

  1042             if (FeatureManager::FeatureSupported( KFeatureIdCdmaExtendedAms ) )

  1043                 {

  1044                 // Check if given UID belongs to a Java Midlet

  1045                 if ( CDocMidletHandler::IsMidlet( aUid ) )

  1046                     {

  1047                     iHandler = CDocMidletHandler::NewL(

  1048                         aDataType,

  1049                         aUid, this);

  1050                     }

  1051                 }

  1052 */

  1053             break; // We will use default handler

  1054         }

  1055     }

  1056 

  1057 // ---------------------------------------------------------

  1058 // void CDocumentHandler::FindHandlerByMimeTypeL(..)

  1059 // Try to find a handler for aDataType

  1060 // ---------------------------------------------------------

  1061 //

  1062 void CDocumentHandler::FindHandlerByMimeTypeL( const TUid& aUid, const TDataType& aDataType )

  1063     {

  1064     // All games are handler by the game handler

  1065     if ( aDataType.Des8().FindF( KGameMimeType ) != KErrNotFound )

  1066         {

  1067         iHandler = CDocGameHandler::NewL(

  1068                            aDataType, aUid, this, EDocSaveOnly );

  1069         return;

  1070         }

  1071 

  1072     if (( aDataType.Des8().FindF( KDocMimeCard ) != KErrNotFound) ||

  1073         ( aDataType.Des8().FindF( KDocMimeCalendar) != KErrNotFound) ||

  1074         ( aDataType.Des8().FindF( KDocMimeCalendar2) != KErrNotFound))

  1075         {

  1076         //

  1077         // vCal and vCard types are handled as 'read only' types

  1078         // (must be saved from application, not through doc handler).

  1079         //

  1080         iHandler = CDocDefaultHandler::NewL(

  1081                            aDataType,

  1082                            aUid, this, EDocOpenOnly );

  1083         return;

  1084         }

  1085     #ifdef ENABLE_DRM

  1086     #ifdef __DRM_OMA2

  1087     if ( aDataType.Des8().FindF( KOma1DcfContentType ) != KErrNotFound ||

  1088          aDataType.Des8().FindF( KOma2DcfContentType ) != KErrNotFound )

  1089     #else // __DRM_OMA2

  1090     if ( aDataType.Des8().FindF( KOma1DcfContentType ) != KErrNotFound )

  1091     #endif // __DRM_OMA2

  1092         {

  1093         iHandler = CDocDCFHandler::NewL( aDataType, iOperation, aUid, this );

  1094         return;

  1095         }

  1096     #endif // ENABLE_DRM

  1097 

  1098     }

  1099 

  1100 // ---------------------------------------------------------

  1101 // CDocumentHandler::FindHandlerL

  1102 // Based on app uid and mime type decide which handler

  1103 // implementation to use.

  1104 //

  1105 //

  1106 // Returns: KErrNone:           The handler was constructed ok

  1107 // ---------------------------------------------------------

  1108 //

  1109 TInt CDocumentHandler::FindHandlerL(

  1110     const TDataType& aDataType,

  1111     const TUid& aUid)

  1112     {

  1113     delete iHandler;            // delete the old handler

  1114     iHandler = NULL;

  1115 

  1116     // First check by the application uid

  1117     FindHandlerByUidL( aUid, aDataType );

  1118 

  1119     // Then check by the mime type

  1120     if ( !iHandler )

  1121         {

  1122         FindHandlerByMimeTypeL( aUid, aDataType );

  1123         }

  1124 

  1125     // Default handler if everything else has failed

  1126     if ( !iHandler )

  1127         {

  1128         TApaAppInfo info;

  1129         if ( iApaLs->GetAppInfo( info, aUid ) == KErrNone ) // Check the uid is real.

  1130             {

  1131             iHandler = CDocDefaultHandler::NewL( aDataType,

  1132                                              aUid, this, EDocOpenAndSave );

  1133             }

  1134         else