--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsidentitymanager/src/senmultiuseridentitymanager.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,303 @@
+/*
+* Copyright (c) 2008 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 <s32mem.h>
+#include <s32file.h>
+#include <sysutil.h>
+
+#include "senmultiuseridentitymanager.h"
+
+#include "senlogger.h"
+#include "SenXmlUtils.h"
+
+namespace
+ {
+ _LIT8(KUser, "User");
+ _LIT8(KUsers, "Users");
+ _LIT8(KUserName, "username");
+ _LIT8(KPIN, "PIN");
+ _LIT8(KActive, "active");
+ _LIT8(KTrue, "1");
+ _LIT8(KFalse, "0");
+ _LIT8(KUsersStart, "<Users>");
+ _LIT8(KUsersEnd, "</Users>");
+ _LIT8(KUserStartFmt, "<User username=\"%S\" PIN=\"%S\" active=\"%d\">");
+ _LIT8(KUserEnd, "</User>");
+ const TInt KFLATBUF_SIZE = 128;
+ const TInt KActiveValueSize = 1;
+
+ const TInt KStateParsingIdentity = 100;
+ }
+
+
+EXPORT_C CSenMultiUserIdentityManager* CSenMultiUserIdentityManager::NewL(
+ MSenCoreServiceManager& aManager)
+ {
+ CSenMultiUserIdentityManager* pNew = NewLC(aManager);
+ CleanupStack::Pop();
+ return(pNew) ;
+ }
+
+EXPORT_C CSenMultiUserIdentityManager* CSenMultiUserIdentityManager::NewLC(
+ MSenCoreServiceManager& aManager)
+ {
+ CSenMultiUserIdentityManager* pNew =
+ new (ELeave) CSenMultiUserIdentityManager(aManager);
+ CleanupStack::PushL(pNew);
+ pNew->ConstructL();
+ return pNew;
+ }
+
+CSenMultiUserIdentityManager::CSenMultiUserIdentityManager(
+ MSenCoreServiceManager& aManager)
+ : CSenBaseIdentityManager(aManager)
+ {
+ }
+
+EXPORT_C CSenMultiUserIdentityManager::~CSenMultiUserIdentityManager()
+ {
+ iUsers.ResetAndDestroy();
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CSenMultiUserIdentityManager::~CSenMultiUserIdentityManager");
+ }
+
+void CSenMultiUserIdentityManager::ConstructL()
+ {
+ CSenBaseIdentityManager::ConstructL();
+ //db was empty, take default one from Base class(loaded during Base::Contructl)
+ if (!iActiveIdentity)
+ {
+ iActiveIdentity = iIdentity;
+ iActiveUser = CSenUser::NewL(KNullDesC8, KNullDesC8, ETrue);
+ iActiveUser->Identites().Append(iActiveIdentity);
+ iUsers.Append(iActiveUser);
+ }
+ else
+ {
+ //parsing from CSenBaseIdentityManager::ConstructL()
+ // caused, that iActiveIdentity is already set (because has been set by below "StartElement" method).
+ // So, orginal iIdentity should be replaced by iActiveIdentity (used by UpdateTouch functionality)
+ delete iIdentity;
+ iIdentity = NULL;
+ iIdentity = iActiveIdentity;
+ };
+
+ }
+
+void CSenMultiUserIdentityManager::StartElementL(
+ const TDesC8& /*aNsUri*/,
+ const TDesC8& aLocalName,
+ const TDesC8& /*aQName*/,
+ const RAttributeArray& aAttributes
+ )
+ {
+ switch (iState)
+ {
+ case KStateIgnore:
+ {
+ if (aLocalName == KUser)
+ {
+ TPtrC8 userName = SenXmlUtils::AttrValue(aAttributes, KUserName);
+ TPtrC8 pin = SenXmlUtils::AttrValue(aAttributes, KPIN);
+ TPtrC8 active = SenXmlUtils::AttrValue(aAttributes, KActive);
+ if (active == KTrue)
+ {
+ iParsedUser = CSenUser::NewL(userName, pin, ETrue);
+ }
+ else
+ {
+ iParsedUser = CSenUser::NewL(userName, pin);
+ }
+
+ if (active == KTrue)
+ {
+ //2nd time active user?? within db
+ __ASSERT_ALWAYS(!iActiveUser, User::Panic(KSenUser, KErrAlreadyExists));
+ iActiveUser = iParsedUser;
+ }
+ iUsers.Append(iParsedUser);
+ iState = KStateParsingIdentity;
+ }
+ }
+ break;
+
+ case KStateParsingIdentity:
+ {
+ if (aLocalName == KIdentityElementLocalName)
+ {
+ CSenBaseIdentity* identity = CSenBaseIdentity::NewLC(ipDeviceID->Des());
+ identity->SetAttributesL(aAttributes);
+ identity->SetReader(*Reader());
+ DelegateParsingL(*identity);
+ __ASSERT_ALWAYS(iParsedUser, User::Panic(KSenUser, KErrAlreadyExists));
+ iParsedUser->Identites().Append(identity);
+
+ //current parsed user is active
+ if (iParsedUser == iActiveUser)
+ {
+ iActiveIdentity = identity;
+ }
+ CleanupStack::Pop(identity);
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+void CSenMultiUserIdentityManager::EndElementL(
+ const TDesC8& /*aNsUri*/,
+ const TDesC8& aLocalName,
+ const TDesC8& /*aQName*/)
+ {
+ switch (iState)
+ {
+ case KStateIgnore:
+ {
+ if (aLocalName == KUsers)//end parsing
+ {
+ if (iUsers.Count() == 1)
+ {
+ CSenUser* user = iUsers[0];
+ iActiveUser = user;
+ iActiveIdentity = iActiveUser->Identites()[0];
+ }
+ }
+ break;
+ }
+ case KStateParsingIdentity:
+ {
+ if (aLocalName == KUser)
+ {
+ iState = KStateIgnore;
+ }
+ }
+ break;
+ }
+ }
+
+
+MSenIdentity& CSenMultiUserIdentityManager::IdentityL()
+ {
+ return (MSenIdentity&)*iActiveIdentity;
+ }
+
+TInt CSenMultiUserIdentityManager::UserNameL(HBufC8*& aUserName)
+ {
+ delete aUserName;
+ aUserName = NULL;
+ aUserName = iActiveUser->UserName().AllocL();
+ return KErrNone;
+ }
+
+
+
+
+
+TInt CSenMultiUserIdentityManager::WriteConfigurationToL( const TDesC& aFile )
+ {
+ // First, collect everything into MEMORY
+ CBufFlat *pBuf = CBufFlat::NewL(KFLATBUF_SIZE);
+ CleanupStack::PushL(pBuf);
+
+ RBufWriteStream bufWs(*pBuf);
+ CleanupClosePushL(bufWs);
+ bufWs.WriteL(KUsersStart);
+
+
+//############# main loop #########
+ TInt count = iUsers.Count();
+ for (TInt i=0; i<count; i++)
+ {
+ RBuf8 userTag;
+ CSenUser* user = iUsers[i];
+ userTag.CreateL(KUserStartFmt().Length() +
+ user->PIN().Length() +
+ user->UserName().Length() +
+ KActiveValueSize //1
+ );
+
+ if (user->Active())
+ {
+ userTag.Format(KUserStartFmt, &(user->UserName()), &(user->PIN()), KTrue);
+ }
+ else
+ {
+ userTag.Format(KUserStartFmt, &(user->UserName()), &(user->PIN()), KFalse);
+ }
+
+
+ bufWs.WriteL(userTag);
+ TInt count2 = iUsers[i]->Identites().Count();
+ for (TInt j=0; j<count2; j++)
+ {
+ CSenBaseIdentity* identity = iUsers[i]->Identites()[j];
+ identity->WriteAsXMLToL(bufWs);
+ }
+ bufWs.WriteL(KUserEnd);
+ userTag.Close();
+ }
+
+//#############
+ bufWs.WriteL(KUsersEnd);
+
+ TPtrC8 p8 = pBuf->Ptr(0);
+
+ CleanupStack::PopAndDestroy(1); // bufWs
+
+ // Everything in MEMORY ok, prepare to write into file
+ RFs fss;
+ User::LeaveIfError(fss.Connect());
+ CleanupClosePushL(fss);
+
+ RFileWriteStream fileOutStream;
+ CleanupClosePushL(fileOutStream);
+
+
+ if(!SysUtil::FFSSpaceBelowCriticalLevelL(&fss, p8.Length()) )
+ {
+ // note, this will zero-length the file(!)
+ // it is better to require that 2xfilesize is available and not to
+ // dangerously zero the old file and find out
+ // that there is no space left..
+
+ //Data caging 2 implementation
+#if defined( EKA2 ) || defined( RD_SECURE_PRIV_DATA )
+ TBuf<KMaxPath> file;
+ fss.CreatePrivatePath(EDriveC);
+ fss.PrivatePath(file);
+ file.Append(aFile);
+ fileOutStream.Replace(fss, file, EFileWrite);
+#else
+ fileOutStream.Replace(fss, aFile, EFileWrite);
+#endif
+ // finally write the UTF-8 into the file.
+ fileOutStream.WriteL(p8);
+ }
+ CleanupStack::PopAndDestroy(3);
+ return KErrNone;
+ }
+
+
+
+// End of file