--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/installationservices/swcomponentregistry/test/tscraccessor/source/tscraccessor_server_session.cpp Tue Aug 31 15:21:33 2010 +0300
@@ -0,0 +1,470 @@
+/*
+* Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+* Scr Accessor - server and implementation
+*
+*/
+
+
+/**
+ @file
+ @test
+ @internalComponent
+*/
+
+#include "tscraccessor_server_session.h"
+#include "tscraccessor_common.h"
+#include "tscraccessor_client.h"
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include "screntries_internal.h"
+#endif //SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <scs/cleanuputils.h>
+#include <usif/usiferror.h>
+#include <usif/scr/screntries_platform.h>
+using namespace Usif;
+
+/////////////////////// Utility functions //////////////////////////////
+void StartTimer(TTime& aTimer)
+ {
+ aTimer.HomeTime();
+ }
+
+TInt StopTimer(TTime aStartTimer)
+ {
+ TTime endTime;
+ endTime.HomeTime();
+
+ TTimeIntervalMicroSeconds duration = endTime.MicroSecondsFrom(aStartTimer);
+ TInt actualDuration = I64INT(duration.Int64())/1000; // in millisecond
+ return actualDuration;
+ }
+
+//////////////////////// Server implementation /////////////////////////
+
+CServer2* CScrAccessServer::NewLC()
+ {
+ CScrAccessServer* self=new(ELeave) CScrAccessServer;
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+ }
+
+CScrAccessServer::CScrAccessServer()
+ :CServer2(0, ESharableSessions)
+ {
+ }
+
+CScrAccessServer::~CScrAccessServer()
+ {
+ iScrSession.Close();
+ }
+
+void CScrAccessServer::ConstructL()
+ {
+ StartL(KScrAccessServerName);
+ }
+
+CSession2* CScrAccessServer::NewSessionL(const TVersion&, const RMessage2&) const
+ {
+ return new(ELeave) CScrAccessSession();
+ }
+
+void CScrAccessServer::AddSession()
+ {
+ ++iSessionCount;
+ }
+
+void CScrAccessServer::DropSession()
+ {
+ --iSessionCount;
+ if(!iSessionCount)
+ CActiveScheduler::Stop();
+ }
+
+
+//////////////////////// Session implementation /////////////////////////
+CScrAccessSession::CScrAccessSession()
+ {
+ }
+
+void CScrAccessSession::CreateL()
+ {
+ Server().AddSession();
+ }
+
+CScrAccessSession::~CScrAccessSession()
+ {
+ Server().DropSession();
+ }
+
+HBufC* ReadDescFromMessageLC(const RMessage2& aMessage, TInt aSlot)
+ {
+ TInt len = aMessage.GetDesLengthL(aSlot);
+ HBufC* desc = HBufC::NewLC(len);
+ TPtr ptrDesc(desc->Des());
+ aMessage.ReadL(aSlot, ptrDesc);
+ return desc;
+ }
+
+void VerifySoftwareTypeAdditionL(TInt& aError, RScrAccessor::TAccessorOperationResult& aOpResult, RSoftwareComponentRegistry& aScrSession, const TDesC& aMimeType, TUid aExpectedPluginUid)
+ {
+ // Do verification, there is no error until this step
+ if(KErrNone == aError)
+ { // if adding software type operation is successful, check if the software type has really been added to teh sCR.
+ // Get the plugin uid of the newly added MIME type
+ TUid retrievedPluginUid;
+ TRAP(aError, retrievedPluginUid = aScrSession.GetPluginUidL(aMimeType));
+ if(KErrNone == aError)
+ { // if the plugin uid is found, then compare it with the expected one.
+ if(retrievedPluginUid != aExpectedPluginUid)
+ aOpResult = RScrAccessor::EOpFailUnexpectedPluginUid;
+ }
+ else if(KErrNotFound == aError)
+ aOpResult = RScrAccessor::EOpFailSwTypeNotFound;
+ // if the returned error is different from KErrNone and KErrNotFound, pass it to the client.
+ }
+ }
+
+void GenerateTestDataL(RPointerArray<HBufC>& aMimeTypes, const TDesC& aBaseMimeTypeName, TInt aMimeTypeNum, RPointerArray<CLocalizedSoftwareTypeName>& aLocalizedSwTypeNames, const TDesC& aBaseSwTypeName, TInt aSwTypesNum)
+ {
+ RBuf buf;
+ buf.CreateL(aBaseMimeTypeName.Length() + 3); // 3 is extra bytes to append number to the buffer
+ buf.CleanupClosePushL();
+ buf.Copy(aBaseMimeTypeName);
+
+ for(TInt i=0; i<aMimeTypeNum; ++i)
+ {
+ buf.AppendNum(i);
+ HBufC *name = buf.AllocLC();
+ aMimeTypes.AppendL(name);
+ CleanupStack::Pop(name);
+ buf.SetLength(buf.Length()-1);
+ }
+ buf.Close();
+
+ buf.CreateL(aBaseSwTypeName.Length() + 3);
+ buf.Copy(aBaseSwTypeName);
+
+ for(TInt i=0; i<aSwTypesNum; ++i)
+ {
+ buf.AppendNum(i);
+ CLocalizedSoftwareTypeName *localizedName = CLocalizedSoftwareTypeName::NewL(buf, TLanguage(i+1));
+ CleanupStack::PushL(localizedName); // Use NewL for coverage
+ aLocalizedSwTypeNames.AppendL(localizedName);
+ CleanupStack::Pop(localizedName); // ownership is transferred
+ }
+ CleanupStack::PopAndDestroy(&buf);
+ }
+
+TInt AddSoftwareTypeL(RSoftwareComponentRegistry& aScrSession, const TDesC& aUniqueSwTypeName, TUid aSifPluginUid, RArray<TCustomAccessInfo> aInstallerSids, const TDesC& aBaseMimeTypeName, TInt aMimeTypeNum, const TDesC& aBaseSwTypeName, TInt aSwTypesNum, const TDesC& aLauncherExecutable, RScrAccessor::TAccessorOperationResult& aOpResult)
+ {
+ RPointerArray<HBufC> mimeTypesArray;
+ CleanupResetAndDestroyPushL(mimeTypesArray);
+ RPointerArray<CLocalizedSoftwareTypeName> localizedSwNames;
+ CleanupResetAndDestroyPushL(localizedSwNames);
+
+ GenerateTestDataL(mimeTypesArray, aBaseMimeTypeName, aMimeTypeNum, localizedSwNames, aBaseSwTypeName, aSwTypesNum);
+
+ RPointerArray<CLocalizedSoftwareTypeName> *plocalizedSwNames = &localizedSwNames;
+ if(!aSwTypesNum)
+ plocalizedSwNames = NULL;
+
+ HBufC *mimeType2BChecked (0);
+ if(mimeTypesArray.Count() > 0)
+ mimeType2BChecked = mimeTypesArray[0]->AllocLC();
+ else
+ mimeType2BChecked = KNullDesC().AllocLC();
+
+ Usif::CSoftwareTypeRegInfo* swType = Usif::CSoftwareTypeRegInfo::NewL(aUniqueSwTypeName);
+ CleanupStack::PushL(swType);
+ swType->SetSifPluginUid(aSifPluginUid);
+ for(TInt i=0;i<aInstallerSids.Count(); ++i)
+ {
+ swType->SetCustomAccessL(aInstallerSids[i]);
+ }
+ if(aMimeTypeNum)
+ {
+ for(TInt i=0;i<mimeTypesArray.Count(); ++i)
+ {
+ swType->SetMimeTypeL(mimeTypesArray[i]->Des());
+ }
+ }
+
+ swType->SetLauncherExecutableL(aLauncherExecutable);
+ if(plocalizedSwNames)
+ {
+ for(TInt i=0;i<plocalizedSwNames->Count(); ++i)
+ {
+ swType->SetLocalizedSoftwareTypeNameL(plocalizedSwNames->operator [](i)->Locale(), plocalizedSwNames->operator [](i)->NameL());
+ }
+ }
+
+ TRAPD(err, aScrSession.AddSoftwareTypeL(*swType));
+ VerifySoftwareTypeAdditionL(err, aOpResult, aScrSession, *mimeType2BChecked, aSifPluginUid);
+ CleanupStack::PopAndDestroy(4, &mimeTypesArray); // mimeTypesArray, localizedSwNames, mimeType2BChecked
+ return err;
+ }
+
+void CScrAccessSession::ServiceL(const RMessage2& aMessage)
+ {
+ TInt err(0);
+ TTime timer;
+ StartTimer(timer);
+ TInt actualTestDuration(0);
+
+ RScrAccessor::TAccessorOperationResult opResult = RScrAccessor::EOpSucessful;
+
+ TScrAccessMessages f = static_cast<TScrAccessMessages>(aMessage.Function());
+
+ if(EAddSoftwareType == f || EDeleteSoftwareType == f)
+ {
+ User::LeaveIfError(Server().ScrSession().Connect());
+ // create transaction on SCR for mutable operations
+ Server().ScrSession().CreateTransactionL();
+ }
+
+ switch (f)
+ {
+ case EAddSoftwareType:
+ {
+ RScrAccessor::TAccessorOperationType opType = static_cast<RScrAccessor::TAccessorOperationType>(aMessage.Int0());
+
+ TUid localizedSifPluginUid = {0xA01B7222};
+ RArray<TCustomAccessInfo> locSidArray;
+ CleanupClosePushL(locSidArray);
+
+ TCustomAccessInfo id1(TSecureId(0x10285BC9), static_cast<TAccessMode>(1));
+ locSidArray.AppendL(id1);
+
+ _LIT(KMimeTypeBaseNameLocalized, "test_mimetype_localizedinstaller");
+ _LIT(KSwTypeBaseLocalizableName, "test_localizedinstaller_name");
+ _LIT(KSwTypeUniqueNameLocalized, "test_localizedinstaller_uniquename");
+
+ switch(opType)
+ {
+ case RScrAccessor::EAddNonLocalizedSoftwareType:
+ {
+ TUid sifPluginUid = {0xA01B7211};
+
+ RArray<TCustomAccessInfo> sidArray;
+ CleanupClosePushL(sidArray);
+
+ TCustomAccessInfo id1(TSecureId(0x10285BC9), static_cast<TAccessMode>(1));
+ TCustomAccessInfo id2(TSecureId(0xAAEEDD11), static_cast<TAccessMode>(1));
+ sidArray.AppendL(id1);
+ sidArray.AppendL(id2);
+
+ _LIT(KMimeTypeBaseName, "test_mimetype_nonlocalizedinstaller");
+ _LIT(KSwTypeUniqueName, "test_nonlocalizedinstaller_uniquename");
+
+ err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueName, sifPluginUid, sidArray, KMimeTypeBaseName, 2, KNullDesC, 0, KNullDesC, opResult);
+ CleanupStack::PopAndDestroy(&sidArray);
+ break;
+ }
+ case RScrAccessor::EAddLocalizedSoftwareType:
+ {
+ err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, locSidArray, KMimeTypeBaseNameLocalized, 2, KSwTypeBaseLocalizableName, 2, KNullDesC, opResult);
+ break;
+ }
+ case RScrAccessor::EAddSofwtareTypeWithoutMimeTypes:
+ {
+ TUid sifPluginUid = {0xA01B7333};
+ RArray<TCustomAccessInfo> sidArray;
+ CleanupClosePushL(sidArray);
+
+ TCustomAccessInfo id1(TSecureId(0x10285BC9), static_cast<TAccessMode>(1));
+ sidArray.AppendL(id1);
+ _LIT(KSwTypeUniqueName, "test_nomimeinstaller_uniquename");
+
+ err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueName, sifPluginUid, sidArray, KNullDesC, 0, KNullDesC, 0, KNullDesC, opResult);
+ CleanupStack::PopAndDestroy(&sidArray);
+ break;
+ }
+ case RScrAccessor::EAddLocalizedSoftwareTypeWithDifferentPluginUid:
+ {
+ TUid localizedDifferentSifPluginUid = {0xCC1B7333};
+ err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedDifferentSifPluginUid, locSidArray, KMimeTypeBaseNameLocalized, 2, KSwTypeBaseLocalizableName, 2, KNullDesC, opResult);
+ if(KErrAlreadyExists == err)
+ err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.
+ break;
+ }
+ case RScrAccessor::EAddLocalizedSoftwareTypeWithExtraName:
+ {
+ err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, locSidArray, KMimeTypeBaseNameLocalized, 2, KSwTypeBaseLocalizableName, 3, KNullDesC, opResult);
+ if(KErrAlreadyExists == err)
+ err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.
+ break;
+ }
+ case RScrAccessor::EAddLocalizedSoftwareTypeWithMissingName:
+ {
+ err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, locSidArray, KMimeTypeBaseNameLocalized, 2, KSwTypeBaseLocalizableName, 1, KNullDesC, opResult);
+ if(KErrAlreadyExists == err)
+ err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.
+ break;
+ }
+ case RScrAccessor::EAddLocalizedSoftwareTypeWithExtraMime:
+ {
+ err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, locSidArray, KMimeTypeBaseNameLocalized, 3, KSwTypeBaseLocalizableName, 2, KNullDesC, opResult);
+ if(KErrAlreadyExists == err)
+ err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.
+ break;
+ }
+ case RScrAccessor::EAddLocalizedSoftwareTypeWithMissingMime:
+ {
+ err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, locSidArray, KMimeTypeBaseNameLocalized, 1, KSwTypeBaseLocalizableName, 2, KNullDesC, opResult);
+ if(KErrAlreadyExists == err)
+ err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.
+ break;
+ }
+ case RScrAccessor::EAddMultipleSidWithLauncherExecutable:
+ {
+ TUid sifPluginUid = {0xA01B7212};
+ _LIT(KSwTypeUniqueName, "test_uniquename");
+ _LIT(KMimeTypeBaseName, "test_mimetype");
+ _LIT(KLauncherExecutable, "LauncherExecutable");
+ RArray<TCustomAccessInfo> sidArray;
+ CleanupClosePushL(sidArray);
+
+ TCustomAccessInfo id1(TSecureId(0x10285BC9), static_cast<TAccessMode>(1));
+ TCustomAccessInfo id2(TSecureId(0xAAEEDD11), static_cast<TAccessMode>(1));
+ TCustomAccessInfo id3(TSecureId(0xAAEEEE11), static_cast<TAccessMode>(1));
+
+ sidArray.AppendL(id1);
+ sidArray.AppendL(id2);
+ sidArray.AppendL(id3);
+
+ err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueName, sifPluginUid, sidArray, KMimeTypeBaseName, 1, KNullDesC, 0, KLauncherExecutable, opResult);
+ CleanupStack::PopAndDestroy(&sidArray);
+ break;
+ }
+ } // switch(opType)
+ CleanupStack::PopAndDestroy(&locSidArray);
+ actualTestDuration = StopTimer(timer);
+ break;
+ }
+ case EDeleteSoftwareType:
+ {
+ _LIT(KSwTypeUniqueName, "test_nonlocalizedinstaller_uniquename");
+ _LIT(KMimeTypeBaseName, "test_mimetype_nonlocalizedinstaller");
+ RPointerArray<HBufC> deletedMimeTypes;
+ CleanupResetAndDestroyPushL(deletedMimeTypes);
+ TRAP(err, Server().ScrSession().DeleteSoftwareTypeL(KSwTypeUniqueName,deletedMimeTypes));
+ actualTestDuration = StopTimer(timer);
+
+ // If the delete operation is successfull, check the returned MIME types deleted are as expected.
+ // If the delete operation fails, just return the error code to teh client.
+ if(KErrNone == err)
+ {
+ RPointerArray<HBufC> mimeTypesArray;
+ CleanupResetAndDestroyPushL(mimeTypesArray);
+ RPointerArray<CLocalizedSoftwareTypeName> localizedSwNames;
+ GenerateTestDataL(mimeTypesArray, KMimeTypeBaseName, 2, localizedSwNames, KNullDesC, 0);
+
+ TInt expectedMimeTypesCount = mimeTypesArray.Count();
+ TInt retrievedMimeTypesCount = deletedMimeTypes.Count();
+ if(retrievedMimeTypesCount != expectedMimeTypesCount)
+ opResult = RScrAccessor::EOpFailUnexpectedMimeTypeNum;
+ else
+ {
+ for(TInt i=0; i<retrievedMimeTypesCount; ++i)
+ {
+ if(*(deletedMimeTypes[i]) != *(mimeTypesArray[i]))
+ opResult = RScrAccessor::EOpFailUnexpectedMimeTypeNum;;
+ } // for
+ } // if-else
+
+ TRAP(err, Server().ScrSession().GetPluginUidL(KSwTypeUniqueName));
+ if(KErrNone == err)
+ {
+ // The plugin UID has been retrieved successfully. This is unexpected result.
+ opResult = RScrAccessor::EOpFailSwTypeStillExists;
+ }
+ else if(KErrSifUnsupportedSoftwareType == err)
+ {
+ // The plugin UID couldn't be found as expected. As the operation is successfull,
+ // return KErrNone to the client
+ err = KErrNone;
+ }
+ CleanupStack::PopAndDestroy(&mimeTypesArray);
+ }
+ CleanupStack::PopAndDestroy(&deletedMimeTypes);
+ break;
+ }
+ case EDeleteFile:
+ {
+ HBufC *file = ReadDescFromMessageLC(aMessage, 0);
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+ err = fs.Delete(*file);
+ CleanupStack::PopAndDestroy(2, file); // file, fs
+ break;
+ }
+ case ECopyFile:
+ {
+ HBufC *sourceFile = ReadDescFromMessageLC(aMessage, 0);
+ HBufC *targetFile = ReadDescFromMessageLC(aMessage, 1);
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+
+ CFileMan* fileManager = CFileMan::NewL(fs);
+ CleanupStack::PushL(fileManager);
+ err = fileManager->Copy(*sourceFile, *targetFile, 0);
+
+ // Reset the read-only attribute on the copied file
+ TTime time;
+ User::LeaveIfError(fileManager->Attribs(*targetFile, 0, KEntryAttReadOnly, time));
+ CleanupStack::PopAndDestroy(4, sourceFile); // sourceFile, targetFile, fs, fileManager
+ break;
+ }
+ default:
+ {
+ PanicClient(aMessage, EPanicIllegalFunction);
+ break;
+ }
+ }
+
+ if(EAddSoftwareType == f || EDeleteSoftwareType == f)
+ {
+ // create transaction on SCR for mutable operations
+ Server().ScrSession().CommitTransactionL();
+
+ TPckg<TInt> timePckg(actualTestDuration);
+ TPckg<RScrAccessor::TAccessorOperationResult> opResultPckg(opResult);
+
+ if(EDeleteSoftwareType == f)
+ {
+ aMessage.WriteL(0, opResultPckg);
+ aMessage.WriteL(1, timePckg);
+ }
+ else if (EAddSoftwareType == f)
+ {
+ aMessage.WriteL(1, opResultPckg);
+ aMessage.WriteL(2, timePckg);
+ }
+ }
+
+ aMessage.Complete(err);
+ }
+
+void CScrAccessSession::ServiceError(const RMessage2& aMessage, TInt aError)
+ {
+ if (aError == KErrBadDescriptor)
+ PanicClient(aMessage, EPanicBadDescriptor);
+ CSession2::ServiceError(aMessage,aError);
+ }
+
+
+