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:  Implementation of FileAccess Classes.

    15 *

    16 */

    17 

    18 #include <f32file.h>

    19 #include <e32std.h>

    20 #include <caf/attribute.h>

    21 #include <caf/bitset.h>

    22 #include <caf/content.h>

    23 #include <caf/data.h>

    24 using namespace ContentAccess;

    25 #include <f32file.h>

    26 

    27 #include "FileAccess.h"

    28 

    29 CF32File::~CF32File()

    30     {

    31     if (!iFileHandle)

    32         iFile.Close();

    33     delete iFilePath;

    34     }

    35 

    36 CF32File* CF32File::NewL(RFs& aSession, TDesC& aFilePath, TUint aMode) 

    37     {

    38     CF32File* self = new (ELeave) CF32File;

    39     CleanupStack::PushL(self);

    40     self->ConstructL(aSession, aFilePath, aMode);

    41     CleanupStack::Pop(self);

    42     return self;

    43     }

    44 

    45 

    46 void CF32File::ConstructL(RFs& aSession, TDesC& aPath, TUint aFileMode)

    47     {

    48     iSession = &aSession;

    49     iFilePath = aPath.AllocL();

    50     TUint attributes = 0;

    51     TInt err = iSession->Att(*iFilePath, attributes);

    52     if (err == KErrNone)

    53         {

    54         if ( attributes & KEntryAttReadOnly )

    55             User::LeaveIfError(iFile.Open(*iSession, *iFilePath, EFileShareReadersOnly )) ;

    56         else //if ( !( attributes & KEntryAttReadOnly ) )

    57             User::LeaveIfError(iFile.Open(*iSession, *iFilePath, aFileMode)) ;

    58         }

    59     else if ((err == KErrNotFound) && (aFileMode & EFileWrite))

    60         {

    61         User::LeaveIfError(iFile.Create(*iSession, *iFilePath, aFileMode )) ;

    62         }

    63     else

    64         {

    65         User::Leave(err);

    66         }

    67     }

    68 

    69 

    70 RFile& CF32File::FileL() 

    71     {

    72     return iFile;

    73     }

    74 

    75 TInt CF32File::Seek(TSeek aSeekMode, TInt aPos)

    76     {

    77     return iFile.Seek(aSeekMode, aPos);

    78     }

    79 

    80 TInt CF32File::Read(TDes8& aDes,TInt aLength)

    81     {

    82     return iFile.Read(aDes, aLength);

    83     }

    84 

    85 void CF32File::Read(TDes8& aDes, TInt aLength, TRequestStatus& aStatus)

    86     {

    87     iFile.Read(aDes, aLength, aStatus);

    88     }

    89 

    90 TInt CF32File::Write(const TDesC8& aDes,TInt aLength)

    91     {

    92     return iFile.Write(aDes, aLength);

    93     }

    94 

    95 void CF32File::Write(const TDesC8& aDes, TInt aLength, TRequestStatus& aStatus)

    96     {

    97     iFile.Write(aDes, aLength, aStatus);

    98     }

    99 

   100 TInt CF32File::Size(TInt& aSize)

   101     {

   102     return iFile.Size(aSize);

   103     }

   104 

   105 TInt CF32File::SetSize(TInt aSize)	

   106     {

   107     TInt err =  iFile.SetSize(aSize);

   108     if(err == KErrNone)

   109         iFileSize = aSize;

   110     else

   111         iFileSize = -1;

   112     

   113     return err;

   114     }

   115 

   116 TInt CF32File::EvaluateIntent(TIntent /*aIntent*/) const

   117     {

   118     return KErrNone;

   119     }

   120 

   121 

   122 TInt CF32File::ExecuteIntent(TIntent /*aIntent*/)

   123     {

   124     return KErrNone;

   125     }

   126 

   127 TBool CF32File::IsProtected() const

   128     {

   129     return EFalse;

   130     }

   131 

   132 TInt CF32File::SetAgentProperty(TAgentProperty /*aProperty*/, TInt /*aValue*/)

   133     {

   134     // not an error to set this if not supported, just wont do anything

   135     return KErrNone;

   136     }

   137 

   138 CContentFile::~CContentFile()

   139     {

   140     delete iData;

   141     

   142     if (iLegacyFileOpen)

   143         iLegacyFile.Close();

   144     delete iFilePath;

   145     }

   146 

   147 

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

   149     {

   150     CContentFile* self = new (ELeave) CContentFile;

   151     CleanupStack::PushL(self);

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

   153     CleanupStack::Pop(self);

   154     return self;

   155     }

   156 

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

   158     {

   159     iSession = &aSession;

   160     iFilePath = aPath.AllocL();

   161     

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

   163     if (aUniqueId.Length() > 0)

   164         {

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

   166         }

   167     else

   168         {

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

   170         }

   171     

   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     }

   179 

   180 

   181 

   182 TInt CContentFile::EvaluateIntent(TIntent aIntent) const

   183     {

   184     ASSERT(iData);

   185     return iData->EvaluateIntent(aIntent);

   186     }

   187 

   188 

   189 TInt CContentFile::ExecuteIntent(TIntent aIntent)

   190     {

   191     ASSERT(iData);

   192     return iData->ExecuteIntent(aIntent);

   193     }

   194 

   195 TBool CContentFile::IsProtected() const

   196     {

   197     ASSERT(iData);

   198     TInt value = 0;

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

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

   201     }

   202 

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

   204     {

   205     ASSERT(iData);

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

   207     }

   208 

   209 TInt CContentFile::Seek(TSeek aSeekMode, TInt aPos)

   210     {

   211     ASSERT(iData);

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

   213     }

   214 

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

   216     {

   217     ASSERT(iData);

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

   219     }

   220 

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

   222     {

   223     ASSERT(iData);

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

   225     }

   226 

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

   228     {

   229     return KErrAccessDenied;

   230     }

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

   232     {

   233     TRequestStatus* status = &aStatus;

   234     User::RequestComplete(status, KErrAccessDenied);

   235     }

   236 

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

   238     {

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

   240     return KErrAccessDenied;

   241     }

   242 

   243 

   244 // Get the size of file

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

   246 

   247 TInt CContentFile::Size(TInt& aSize)

   248     {

   249     ASSERT(iData);

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

   251     return err;

   252     }

   253 

   254     /**

   255     * return a RFile for the legacy RFile method

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

   257     * @internalTechnology

   258     * @return Reference to RFile handle to current file

   259 */

   260 RFile& CContentFile::FileL() 

   261     {

   262     if (!iLegacyFileOpen)

   263         {

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

   265         iLegacyFileOpen = ETrue;

   266         }

   267     return iLegacyFile;

   268     }

   269 

   270 CF32File* CF32File::NewL(RFile& aFile) 

   271     {

   272     CF32File* self = new (ELeave) CF32File;

   273     CleanupStack::PushL(self);

   274     self->ConstructL(aFile);

   275     CleanupStack::Pop(self);

   276     return self;

   277     }

   278 

   279 void CF32File::ConstructL(RFile& aFile)

   280     {

   281     iFile = aFile;

   282     iFileHandle = ETrue;

   283     }

   284 

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

   286     {

   287     CContentFile* self = new (ELeave) CContentFile;

   288     CleanupStack::PushL(self);

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

   290     CleanupStack::Pop(self);

   291     return self;

   292     }

   293 

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

   295     {

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

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

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

   299         {

   300         User::Leave(err);

   301         }

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

   303     }