# examples/ForumNokia/S60_3rd_Edition_TextMTM_Example/modules/Util/src/txut.cpp

    00001 // TXUT.CPP
    00002 //
    00003 // © 2004 Nokia Corporation.  All rights reserved.
    00004 //
    00005
    00006 #include <msvstd.h>             // TMsvEntry
    00007 #include <msvstore.h>   // CMsvStore
    00008 #include <MSVUIDS.H>    //KUidMsvFolderEntry
    00009 #include <centralrepository.h>
    00010 #include "txut.h"
    00011
    00012 // system includes
    00013 #include <msvuids.h>    //KUidMsvFolderEntry
    00014 const TUint32 KNullId = 0x00000000;
    00015 const TUint32 KIncrementAccount = 0x00100000;
    00016 const TInt KMaxAccount = 2048;
    00017 const TUint32 KDefaultServiceId = 0x80000000; // set top bit
    00018 const TUint32 EAccountMask = 0x800FFFFF;
    00019
    00020 // Key IDs for particular text mtm settings in repository
    00021 enum
    00022         {
    00023         EServiceId = 0,
    00024         EFolderSettingId = 1
    00025         };
    00026 // user includes
    00027 // standard NewL
    00028 EXPORT_C CMTMTxtSettings* CMTMTxtSettings::NewL()
    00029         {
    00030         CMTMTxtSettings* self = new (ELeave) CMTMTxtSettings();
    00031         CleanupStack::PushL(self);
    00032         self->ConstructL();
    00033         CleanupStack::Pop();
    00034         return self;
    00035         }
    00036
    00037 // destructor
    00038 CMTMTxtSettings::~CMTMTxtSettings()
    00039         {
    00040         delete iRepository;
    00041         }
    00042
    00043 // delete all settings for specified service
    00044 EXPORT_C void CMTMTxtSettings::DeleteSettingsL(TMsvId aServiceId)
    00045         {
    00046         TUint32 serviceKey = FindAccountL(aServiceId);
    00047         DeleteSettingL(serviceKey);
    00048         DeleteSettingL(serviceKey + EFolderSettingId);
    00049         }
    00050
    00058 EXPORT_C void CMTMTxtSettings::LoadSettingsL(TMsvId aServiceId, TMTMTxtSettings& aSettings) const
    00059         {
    00060         TUint32 serviceKey = FindAccountL(aServiceId);
    00061         TFileName rootFolder;
    00062         User::LeaveIfError(iRepository->Get(serviceKey + EFolderSettingId, rootFolder));
    00063         aSettings.SetRootFolder(rootFolder);
    00064         }
    00065
    00073 EXPORT_C void CMTMTxtSettings::SaveSettingsL(TMsvId aServiceId, const TMTMTxtSettings& aSettings)
    00074         {
    00075         TUint32 accountId = 0;
    00076         TInt error = 0;
    00077         // see if account already exists
    00078         TRAP(error, accountId = FindAccountL(aServiceId));
    00079         if (error != KErrUnknown) User::LeaveIfError(error);
    00080         // doesn't already exist, so get id of new account
    00081         if (error == KErrUnknown) accountId = GetNextAccountSlotL();
    00082
    00083         TRAP( error,
    00084                 // Save settings to CenRep
    00085                 CreateOrSetL(accountId, static_cast<TInt>(aServiceId));
    00086                 CreateOrSetL(accountId + EFolderSettingId, aSettings.RootFolder());
    00087                 );
    00088         if (error != KErrNone)
    00089                 {
    00090                 // saving settings to CenRep failed, so cleanup account and leave
    00091                 DeleteSettingsL(aServiceId);
    00092                 User::Leave(error);
    00093                 }
    00094         }
    00095
    00101 EXPORT_C void CMTMTxtSettings::SetDefaultServiceL(TMsvId aService)
    00102         {
    00103         CreateOrSetL(KDefaultServiceId, static_cast<TInt>(aService));
    00104         }
    00105
    00113 EXPORT_C TMsvId CMTMTxtSettings::DefaultServiceL() const
    00114         {
    00115         // Get the service Id from CenRep
    00116         TInt temp = 0;
    00117         User::LeaveIfError(iRepository->Get(KDefaultServiceId, temp));
    00118         return static_cast<TMsvId>(temp);
    00119         }
    00120
    00124 EXPORT_C void CMTMTxtSettings::DeleteDefaultServiceSettingL()
    00125         {
    00126         DeleteSettingL(KDefaultServiceId);
    00127         }
    00128
    00129 // create cenrep repository in which to store textmtm settings
    00130 void CMTMTxtSettings::ConstructL()
    00131         {
    00132
    00133 //#ifdef __WINS__
    00134 //      const TUid KUidMtm = { KUidMsgTypeText };
    00135
    00136 //#else
    00137         const TInt KUidDefaultMtmRepositoryFileValue = 0x10274556;
    00138         const TUid KUidMtm = { KUidDefaultMtmRepositoryFileValue };
    00139 //#endif
    00140
    00141         iRepository = CRepository::NewL(KUidMtm);
    00142
    00143         }
    00144
    00145 // sets (or creates if it does not already exist) a string key
    00146 void CMTMTxtSettings::CreateOrSetL(TUint aKey, const TDesC& aValue)
    00147         {
    00148         TInt error = iRepository->Set(aKey, aValue);
    00149         if (error == KErrNotFound)
    00150                 {
    00151                 // setting does not exist, so create it
    00152                 User::LeaveIfError(iRepository->Create(aKey, aValue));
    00153                 }
    00154         else
    00155                 {
    00156                 User::LeaveIfError(error);
    00157                 }
    00158         }
    00159
    00160 // sets (or creates if it does not already exist) an integer key
    00161 void CMTMTxtSettings::CreateOrSetL(TUint aKey, TInt aValue)
    00162         {
    00163         TInt error = iRepository->Set(aKey, aValue);
    00164         if (error == KErrNotFound)
    00165                 {
    00166                 // setting does not exist, so create it
    00167                 User::LeaveIfError(iRepository->Create(aKey, aValue));
    00168                 }
    00169         else
    00170                 {
    00171                 User::LeaveIfError(error);
    00172                 }
    00173         }
    00174
    00175 // Leaves with KErrUnknown if account does not exist
    00176 TUint32 CMTMTxtSettings::FindAccountL(TMsvId aService) const
    00177         {
    00178         RArray<TUint32> accounts;
    00179         CleanupClosePushL(accounts);
    00180         TInt error = iRepository->FindEqL(KNullId, static_cast<TUint32>(EAccountMask), static_cast<TInt>(aService), accounts);
    00181         if (error == KErrNotFound)
    00182                 {
    00183                 // account does not exist
    00184                 User::Leave(KErrUnknown);
    00185                 }
    00186         else
    00187                 {
    00188                 User::LeaveIfError(error);
    00189                 }
    00190
    00191         if (accounts.Count()>1)
    00192                 {
    00193                 // There should be only one account for the service
    00194                 User::Leave(KErrOverflow);
    00195                 }
    00196
    00197         TUint32 account = accounts[0];
    00198         CleanupStack::PopAndDestroy(&accounts);
    00199         return account;
    00200         }
    00201 //      TMTMTxtSettings: service settings storage
    00202 //
    00203
    00204 EXPORT_C void TMTMTxtSettings::ExternalizeL( RMsvWriteStream& aWriteStream ) const
    00205         {
    00206         // store iRootFolder
    00207         aWriteStream << iRootFolder;
    00208         return;
    00209         }
    00210
    00211 EXPORT_C void TMTMTxtSettings::InternalizeL( RMsvReadStream& aReadStream )
    00212         {
    00213         aReadStream >> iRootFolder;
    00214         return;
    00215         }
    00216
    00217 EXPORT_C void TMTMTxtSettings::StoreL(CMsvStore& aMsvStore) const
    00218         {
    00219         RMsvWriteStream out;
    00220         out.AssignLC( aMsvStore, KUidTxtMTMSettings ); // pushes 'out' to the stack
    00221         ExternalizeL(out);
    00222         out.CommitL();
    00223         CleanupStack::PopAndDestroy();
    00224         }
    00225
    00226 // get a base (account) id to identify all keys for a particular service
    00227 TUint CMTMTxtSettings::GetNextAccountSlotL()
    00228         {
    00229         TUint32 accountId = KNullId;
    00230         TInt serviceId = 0;
    00231         TInt error = 0;
    00232         TBool found = EFalse;
    00233
    00234         for (TInt count = 0; count < KMaxAccount; ++count)
    00235                 {
    00236                 accountId = accountId + KIncrementAccount;
    00237                 error = iRepository->Get(accountId, serviceId);
    00238                 if (error == KErrNotFound)
    00239                         {
    00240                         found = ETrue;
    00241                         break;
    00242                         }
    00243                 else
    00244                         {
    00245                         User::LeaveIfError(error);
    00246                         }
    00247                 }
    00248
    00249         if (found == EFalse)
    00250                 {
    00251                 // No empty slot available
    00252                 User::Leave(KErrNotFound);
    00253                 }
    00254
    00255         return accountId;
    00256         }
    00257
    00258 // delete a setting, and don't give an error if it doesn't exist
    00259 void CMTMTxtSettings::DeleteSettingL(TUint32 settingId)
    00260         {
    00261         TInt error = iRepository->Delete(settingId);
    00262         if (error != KErrNotFound)
    00263                 {
    00264                 User::LeaveIfError(error);
    00265                 }
    00266         }
    00267 EXPORT_C void TMTMTxtSettings::RestoreL(const CMsvStore& aMessageStore )
    00268
    00269         {
    00270         if (aMessageStore.IsPresentL(KUidTxtMTMSettings))
    00271                 {
    00272                 RMsvReadStream in;
    00273                 in.OpenLC( aMessageStore, KUidTxtMTMSettings ); // pushes 'in' to the stack
    00274                 InternalizeL(in);
    00275                 CleanupStack::PopAndDestroy();
    00276                 }
    00277         }
    00278
    00279 //
    00280 // TxtUtils: Generic static utility functions
    00281 //
    00282
    00283 EXPORT_C void TxtUtils::GetEntryFileNameL(TFileName& aFileName, TMsvEntry& aEntry)
    00284 // Create absolute file name: default path + aEntry.iDetails + aEntry.iDescription
    00285         {
    00286         CMTMTxtSettings* settings = CMTMTxtSettings::NewL();
    00287         CleanupStack::PushL(settings);
    00288         TMTMTxtSettings root;
    00289         settings->LoadSettingsL(aEntry.iServiceId, root);
    00290         CleanupStack::PopAndDestroy(); //settings
    00291         aFileName = root.RootFolder();
    00292         aFileName.Append(aEntry.iDetails);
    00293         aFileName.Append(aEntry.iDescription);
    00294         if (aEntry.iType == KUidMsvFolderEntry)
    00295                 aFileName.Append(KPathDelimiter);
    00296         }
    00297
    00298 EXPORT_C void TxtUtils::FindFileL(const TDesC& aFileName, const TDesC& aLocation, TFileName& aRetVal)
    00299     {
    00300     RFs fs;
    00301     User::LeaveIfError(fs.Connect());
    00302     CleanupClosePushL(fs);
    00303     TFindFile finder(fs);
    00304     User::LeaveIfError(finder.FindByDir(aFileName, aLocation));
    00305     aRetVal = finder.File();
    00306     CleanupStack::PopAndDestroy();
    00307     }
    00308
    00309 //
    00310 // CMsvOpWait
    00311 //      Allows a synchronous wait on a operation
    00312 //
    00313 EXPORT_C CMsvOpWait* CMsvOpWait::NewLC(TInt aPriority)
    00314         {
    00315         CMsvOpWait* self = new (ELeave) CMsvOpWait(aPriority);
    00316         CleanupStack::PushL(self);
    00317         return self;
    00318         }
    00319
    00320 CMsvOpWait::CMsvOpWait(TInt aPriority)
    00321 : CActive(aPriority)
    00322         {
    00323         CActiveScheduler::Add(this);
    00324         }
    00325
    00326 EXPORT_C CMsvOpWait::~CMsvOpWait()
    00327         {
    00328         Cancel();
    00329         }
    00330
    00331 EXPORT_C void CMsvOpWait::Start()
    00332         {
    00333         SetActive();
    00334         }
    00335
    00336 void CMsvOpWait::RunL()
    00337         {
    00338         CActiveScheduler::Stop();
    00339         }
    00340
    00341 void CMsvOpWait::DoCancel()
    00342         {
    00343         TRequestStatus* s=&iStatus;
    00344         User::RequestComplete(s, KErrCancel);
    00345         }
    00346 //
    00347 // CMsvCompOperation
    00348 //      An operation which is already completed on construction
    00349 //
    00350 EXPORT_C CMsvCompOperation* CMsvCompOperation::NewL(CMsvSession& aSession, TUid aMtm,
    00351         const TDesC8& aProgress, TMsvId aService, TRequestStatus& aObserverRequestStatus, TInt aError)
    00352 // aMtm and aService set CMsvOperation protected data members
    00353 // aProgress is progress information
    00354 // aObserverRequestStatus is the active object to signal on completion
    00355 // aError is the error code from the relevant operation
    00356         {
    00357         CMsvCompOperation* self = new (ELeave) CMsvCompOperation(aSession, aObserverRequestStatus);
    00358         CleanupStack::PushL(self);
    00359         self->ConstructL(aMtm, aError, aProgress, aService);
    00360         CleanupStack::Pop(self);
    00361         return self;
    00362         }
    00363
    00364 CMsvCompOperation::CMsvCompOperation(CMsvSession& aSession, TRequestStatus& aObserverRequestStatus)
    00365 : CMsvOperation(aSession, EPriorityStandard, aObserverRequestStatus)
    00366         {
    00367         }
    00368
    00369 EXPORT_C CMsvCompOperation::~CMsvCompOperation()
    00370         {
    00371         Cancel();
    00372         delete iProgress;
    00373         }
    00374
    00375 void CMsvCompOperation::ConstructL(TUid aMtm, TInt aError, const TDesC8& aProgress, TMsvId aService)
    00376         {
    00377         iProgress = HBufC8::NewL(aProgress.Length());
    00378         *iProgress = aProgress;
    00379         iMtm=aMtm;
    00380         iService=aService;
    00381         //
    00382         CActiveScheduler::Add(this);
    00383         iStatus = KRequestPending;
    00384         SetActive();
    00385         //
    00386         TRequestStatus* pstat=&iStatus;
    00387         User::RequestComplete(pstat, aError);
    00388         iObserverRequestStatus = KRequestPending;
    00389         }
    00390
    00391 const TDesC8& CMsvCompOperation::ProgressL()
    00392         {
    00393         return *iProgress;
    00394         }
    00395
    00396 void CMsvCompOperation::DoCancel()
    00397         {
    00398         // does nothing as iStatus has already been completed in in ConstructL()
    00399         }
    00400
    00401 void CMsvCompOperation::RunL()
    00402         {
    00403         TRequestStatus* pstat=&iObserverRequestStatus;
    00404         User::RequestComplete(pstat, iStatus.Int());
    00405         }