1 /*

     2 * Copyright (c) 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:  Progressive Download Utility  Implementation of ContentFile Classes.

    15 *

    16 */

    17 

    18 #include <f32file.h>

    19 #include <e32std.h>

    20 #include <caf/attribute.h>

    21 #include <caf/bitset.h>

    22 

    23 using namespace ContentAccess;

    24 

    25 #include "ContentFile.h"

    26 

    27 

    28 CContentFile::~CContentFile()

    29     {

    30     delete iData;

    31 

    32     if (iLegacyFileOpen)

    33         iLegacyFile.Close();

    34     delete iFilePath;

    35     }

    36 

    37 

    38 CContentFile* CContentFile::NewL(RFs& aSession, const TDesC& aFilePath, const TDesC& aUniqueId, TUint aMode, TBool aEnableUI)

    39     {

    40     CContentFile* self = new (ELeave) CContentFile;

    41     CleanupStack::PushL(self);

    42     self->ConstructL(aSession, aFilePath, aUniqueId, aMode, aEnableUI);

    43     CleanupStack::Pop(self);

    44     return self;

    45     }

    46 

    47 void CContentFile::ConstructL(RFs& aSession, const TDesC& aPath, const TDesC& aUniqueId, TUint /*aMode*/, TBool aEnableUI)

    48     {

    49     iSession = &aSession;

    50     iFilePath = aPath.AllocL();

    51 

    52     // Assume that we want the content to be shared and read-only.

    53     if (aUniqueId.Length() > 0)

    54         {

    55         iData = CData::NewL(TVirtualPathPtr(*iFilePath, aUniqueId), EContentShareReadWrite);

    56         }

    57     else

    58         {

    59         iData = CData::NewL(TVirtualPathPtr(*iFilePath), EContentShareReadWrite);

    60         }

    61 

    62     TInt err = iData->SetProperty(EAgentPropertyAgentUI, aEnableUI);

    63     if (err != KErrNone && err != KErrCANotSupported)

    64         {

    65         User::Leave(err);

    66         }

    67     User::LeaveIfError(iData->EvaluateIntent(EPeek));

    68     }

    69 

    70 

    71 

    72 TInt CContentFile::EvaluateIntent(TIntent aIntent) const

    73     {

    74     ASSERT(iData);

    75     return iData->EvaluateIntent(aIntent);

    76     }

    77 

    78 

    79 TInt CContentFile::ExecuteIntent(TIntent aIntent)

    80     {

    81     ASSERT(iData);

    82     return iData->ExecuteIntent(aIntent);

    83     }

    84 

    85 TBool CContentFile::IsProtected() const

    86     {

    87     ASSERT(iData);

    88     TInt value = 0;

    89     TInt err =iData->GetAttribute(EIsProtected, value);

    90     return (err == KErrNone && value);

    91     }

    92 

    93 TInt CContentFile::SetAgentProperty(ContentAccess::TAgentProperty aProperty, TInt aValue)

    94     {

    95     ASSERT(iData);

    96     return iData->SetProperty(aProperty, aValue);

    97     }

    98 

    99 TInt CContentFile::Seek(TSeek aSeekMode, TInt& aPos)

   100     {

   101     ASSERT(iData);

   102     return iData->Seek(aSeekMode, aPos);

   103     }

   104 

   105 TInt CContentFile::Read(TDes8& aDes,TInt aLength)

   106     {

   107     ASSERT(iData);

   108     return iData->Read(aDes,aLength);

   109     }

   110 

   111 void CContentFile::Read(TDes8& aDes, TInt aLength, TRequestStatus& aStatus)

   112     {

   113     ASSERT(iData);

   114     iData->Read(aDes, aLength, aStatus);

   115     }

   116 

   117 TInt CContentFile::Write(const TDesC8& /*aDes*/,TInt /*aLength*/)

   118     {

   119     return KErrAccessDenied;

   120     }

   121 void CContentFile::Write(const TDesC8& /*aDes*/, TInt /*aLength*/, TRequestStatus& aStatus)

   122     {

   123     TRequestStatus* status = &aStatus;

   124     User::RequestComplete(status, KErrAccessDenied);

   125     }

   126 

   127 TInt CContentFile::SetSize(TInt /*aSize*/)

   128     {

   129     // Only a source is implemented, hence this cannot be allowed

   130     return KErrAccessDenied;

   131     }

   132 

   133 

   134 // Get the size of file

   135 // this method opens a new, read-only, RFile the first time this method is called

   136 

   137 TInt CContentFile::Size(TInt& aSize)

   138     {

   139     ASSERT(iData);

   140     TRAPD(err, iData->DataSizeL(aSize));

   141     return err;

   142     }

   143 

   144     /**

   145     * return a RFile for the legacy RFile method

   146     * this method opens a new, read-only, RFile the first time this method is called

   147     * @internalTechnology

   148     * @return Reference to RFile handle to current file

   149 */

   150 RFile& CContentFile::FileL()

   151     {

   152     if (!iLegacyFileOpen)

   153         {

   154         User::LeaveIfError(iLegacyFile.Open(*iSession, *iFilePath, EFileRead | EFileStream | EFileShareReadersOnly));

   155         iLegacyFileOpen = ETrue;

   156         }

   157     return iLegacyFile;

   158     }

   159 

   160 CContentFile* CContentFile::NewL(RFile& aFile, const TDesC& aUniqueId, TBool aEnableUI)

   161     {

   162     CContentFile* self = new (ELeave) CContentFile;

   163     CleanupStack::PushL(self);

   164     self->ConstructL(aFile, aUniqueId, aEnableUI);

   165     CleanupStack::Pop(self);

   166     return self;

   167     }

   168 

   169 void CContentFile::ConstructL(RFile& aFile, const TDesC& aUniqueId, TBool aEnableUI)

   170     {

   171     iData = CData::NewL(aFile, aUniqueId);

   172     TInt err = iData->SetProperty(EAgentPropertyAgentUI, aEnableUI);

   173     if (err != KErrNone && err != KErrCANotSupported)

   174         {

   175         User::Leave(err);

   176         }

   177     User::LeaveIfError(iData->EvaluateIntent(EPeek));

   178     }