--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/layouts/cdl/CdlServer/src/CdlSFiles.cpp Thu Dec 17 09:14:12 2009 +0200
@@ -0,0 +1,357 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+#include "CdlSFiles.h"
+#include "CdlServer.h"
+#include <e32uid.h>
+
+const TUid KCdlLibraryUid = { 0x101F8BD1 };
+
+_LIT(KCdlLibsPath,"*:\\sys\\bin");
+
+CCdlRefCollection* CCdlDllsWatcherBase::FileContentsLC(const TDesC& aFileName)
+ {
+ return CdlServerEngine::FileContentsLC(aFileName);
+ }
+
+//
+// CCdlDirs
+//
+
+const TInt KCCdlDirsGranularity = 4;
+
+CCdlDirs::CCdlDirs()
+: CArrayPtrFlat<CDir>(KCCdlDirsGranularity)
+ {
+ }
+
+CCdlDirs::~CCdlDirs()
+ {
+ ResetAndDestroy();
+ }
+
+
+//
+// CFsWatcher
+//
+
+CFsWatcher::CFsWatcher(RFs& aFs, MFsWatcherObserver& aObserver)
+: CActive(EPriorityStandard), iFs(aFs), iObserver(aObserver)
+ {
+ CActiveScheduler::Add(this);
+ Queue();
+ }
+
+CFsWatcher::~CFsWatcher()
+ {
+ Cancel();
+ }
+
+void CFsWatcher::ConstructL()
+ {
+ }
+
+CCdlDirs* CFsWatcher::CreateDirsListL() const
+ {
+ CCdlDirs* dirs = new(ELeave) CCdlDirs();
+ CleanupStack::PushL(dirs);
+
+ TDriveList drives;
+ User::LeaveIfError(iFs.DriveList(drives));
+ TFileName path(KCdlLibsPath);
+ path.Append('\\');
+ for (TInt drive = EDriveZ; drive >= EDriveA; drive--)
+ {
+ if (drives[drive])
+ {
+ path[0] = TText('A' + drive);
+ CDir* fileList=NULL;
+ const TUidType dllType(KDynamicLibraryUid, KCdlLibraryUid);
+ if (iFs.GetDir(path, dllType, ESortByName, fileList) == KErrNone)
+ {
+ CleanupStack::PushL(fileList);
+ dirs->AppendL(fileList);
+ CleanupStack::Pop(fileList);
+ }
+ }
+ }
+
+ CleanupStack::Pop(dirs);
+ return dirs;
+ }
+
+void CFsWatcher::DoCancel()
+ {
+ iFs.NotifyChangeCancel();
+ }
+
+void CFsWatcher::RunL()
+ {
+ // errors in the FS watcher can't be reported sensibly, so they are ignored.
+ TRAPD(ignore, DoRunL());
+ }
+
+void CFsWatcher::DoRunL()
+ {
+ // error from RFs::NotifyChange will stop the watcher
+ User::LeaveIfError(iStatus.Int());
+ Queue();
+ // error from CreateDirsListL, most likely OOM, will stop the change from being processed
+ // immediately, but further changes will make it catch up.
+ iObserver.NewDirsList(CreateDirsListL());
+ }
+
+void CFsWatcher::Queue()
+ {
+ iFs.NotifyChange(ENotifyAll, iStatus, KCdlLibsPath);
+ SetActive();
+ }
+
+
+//
+// CCdlDllsWatcher
+//
+
+void CCdlDllsWatcherBase::NewL(CCdlDllsWatcherBase*& iWatcher, RFs& aFs, MCdlDllsObserver* aObserver)
+ {
+ CCdlDllsWatcher* self = new(ELeave) CCdlDllsWatcher(aFs, aObserver);
+ iWatcher = self;
+ self->ConstructL();
+ }
+
+CCdlDllsWatcher::CCdlDllsWatcher(RFs& aFs, MCdlDllsObserver* aObserver)
+: CCdlDllsWatcherBase(aFs), iObserver(aObserver)
+ {
+ }
+
+CCdlDllsWatcher::~CCdlDllsWatcher()
+ {
+ delete iFsWatcher;
+ delete iCurrent.iDirs;
+ delete iNew.iDirs;
+ delete iNext;
+ Cancel();
+ }
+
+void CCdlDllsWatcher::ConstructL()
+ {
+ iFsWatcher = new(ELeave) CFsWatcher(iFs, *this);
+ iFsWatcher->ConstructL();
+ iNew.iDirs = iFsWatcher->CreateDirsListL();
+ iNew.Reset();
+ Queue();
+ }
+
+void CCdlDllsWatcher::DoCancel()
+ {
+ }
+
+void CCdlDllsWatcher::RunL()
+ {
+ // errors here will be caused by leaves in the observer. These should not stop
+ // processing of further DLLs. So, errors are ignored.
+ TRAPD(ignore, DoRunL());
+ }
+
+void CCdlDllsWatcher::DoRunL()
+ {
+ if (iCurrent.AtEnd() && iNew.AtEnd()) // At end of both queues, restart if there is a pending dirs list
+
+ {
+ delete iCurrent.iDirs;
+ iCurrent.iDirs = iNew.iDirs;
+ iCurrent.Reset();
+
+ iNew.iDirs = iNext;
+ iNext = NULL;
+ iNew.Reset();
+
+ if (iNew.iDirs)
+ Queue();
+
+ if (iTellingObserver)
+ {
+ iTellingObserver = EFalse;
+ iObserver->McdoChangesCompleteL();
+ }
+ }
+ else if (iCurrent.AtEnd()) // at end of current list, any DLLs left in new list should be added
+ {
+ AddNewToObserverL();
+ }
+ else if (iNew.AtEnd()) // at end of new list, any DLLs left in current list should be removed
+ {
+ RemoveCurrentFromObserverL();
+ }
+ else if (iCurrent == iNew) // DLLs are the same, skip to the next one
+ {
+ iCurrent.Next();
+ iNew.Next();
+ Queue();
+ }
+ else if (iCurrent < iNew) // current DLL does not appear in new list, remove it
+ {
+ // note: it is important to check for deletes before adds, because the
+ // two files may have the same name but different times.
+ RemoveCurrentFromObserverL();
+ }
+ else // new DLL does not appear in current list, add it
+ {
+ AddNewToObserverL();
+ }
+ }
+
+void CCdlDllsWatcher::AddNewToObserverL()
+ {
+ const TEntry& file = iNew.Current();
+ iNew.Next();
+ Queue();
+ StartTellingObserverIfNecessaryL();
+ iObserver->McdoFileAddedL(file.iName);
+ }
+
+void CCdlDllsWatcher::RemoveCurrentFromObserverL()
+ {
+ const TEntry& file = iCurrent.Current();
+ iCurrent.Next();
+ Queue();
+ StartTellingObserverIfNecessaryL();
+ iObserver->McdoFileRemovedL(file.iName);
+ }
+
+void CCdlDllsWatcher::StartTellingObserverIfNecessaryL()
+ {
+ if (!iTellingObserver)
+ iObserver->McdoPrepareForChangesL();
+ iTellingObserver = ETrue;
+ }
+
+void CCdlDllsWatcher::Queue()
+ {
+ iStatus = KRequestPending;
+ TRequestStatus* s = &iStatus;
+ User::RequestComplete(s, KErrNone);
+ SetActive();
+ }
+
+void CCdlDllsWatcher::NewDirsList(CCdlDirs* aNewDirs)
+ {
+ if (IsActive())
+ {
+ delete iNext;
+ iNext = aNewDirs;
+ }
+ else
+ {
+ iNew.iDirs = aNewDirs;
+ iNew.Reset();
+ Queue();
+ }
+ }
+
+
+//
+// CCdlDllsWatcher::TDllList
+//
+
+void CCdlDllsWatcher::TDllList::Reset()
+ {
+ Mem::FillZ(iIndices, sizeof(TInt)*KMaxDrives);
+ SetCurrent();
+ }
+
+TBool CCdlDllsWatcher::TDllList::operator==(const TDllList& aRhs) const
+ {
+ __ASSERT_ALWAYS(iCurrent, Panic(EPanicTDllListOpEqNullCurrent));
+
+ const TEntry& rhsEntry = aRhs.Current();
+ return iCurrent->iName.CompareF(rhsEntry.iName) == 0 &&
+ iCurrent->iModified == rhsEntry.iModified;
+ }
+
+TBool CCdlDllsWatcher::TDllList::operator<(const TDllList& aRhs) const
+ {
+ __ASSERT_ALWAYS(iCurrent, Panic(EPanicTDllListOpLtNullCurrent));
+
+ const TEntry& rhsEntry = aRhs.Current();
+ TInt cmp = iCurrent->iName.CompareF(rhsEntry.iName);
+ return cmp < 0 || (cmp == 0 && iCurrent->iModified < rhsEntry.iModified);
+ }
+
+const TEntry& CCdlDllsWatcher::TDllList::Current() const
+ {
+ __ASSERT_ALWAYS(iCurrent, Panic(EPanicTDllListCurrentNullCurrent));
+
+ return *iCurrent;
+ }
+
+TBool CCdlDllsWatcher::TDllList::AtEnd() const
+ {
+ if (!iDirs)
+ return ETrue;
+
+ return !iCurrent;
+ }
+
+void CCdlDllsWatcher::TDllList::Next()
+ {
+ __ASSERT_ALWAYS(iCurrent, Panic(EPanicTDllListNextNullCurrent));
+ __ASSERT_ALWAYS(iDirs, Panic(EPanicTDllListNextNullDirs));
+
+ TInt count = iDirs->Count();
+ for (TInt ii = 0; ii < count; ii++)
+ {
+ CDir& dir = *iDirs->At(ii);
+ if (iIndices[ii] < dir.Count())
+ {
+ const TEntry& entry = dir[iIndices[ii]];
+ if (entry.iName.CompareF(iCurrent->iName) == 0)
+ iIndices[ii]++;
+ }
+ }
+
+ SetCurrent();
+ }
+
+void CCdlDllsWatcher::TDllList::SetCurrent()
+ {
+ // This function implements the CDL drive priority rule,
+ // where DLLs on Z are higher priority than Y...
+ // nb. Z: is the first in iDirs, A: is last.
+
+ iCurrent = NULL;
+ if (!iDirs)
+ return;
+
+ TInt count = iDirs->Count();
+ for (TInt ii = 0; ii < count; ii++)
+ {
+ CDir& dir = *iDirs->At(ii);
+ if (iIndices[ii] < dir.Count())
+ {
+ const TEntry& entry = dir[iIndices[ii]];
+ if (!iCurrent || entry.iName.CompareF(iCurrent->iName) < 0)
+ iCurrent = &entry;
+ }
+ }
+ }
+
+TInt CCdlDllsWatcher::IsPluginInRom(const TDesC& /*aFileName*/, TBool& /*aIsInRom*/) const
+ {
+ return KErrNotSupported;
+ }
+
+