/*

* Copyright (c) 2004-2009 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: 

*

*/

#include <swicertstore.h>

#include "CSWICertStoreImpl.h"

#include "CSWICertStoreToken.h"

#include "CSWICertStoreTokenType.h"

_LIT(KSWICertStorePanic, "CSWICertStore");

EXPORT_C CCTTokenType* CSWICertStore::CreateTokenTypeL()

	{

	// This method is just here so we don't have to declare

	// CSWICertStoreTokenType in the exported header

	return CSWICertStoreTokenType::NewL();

	}

EXPORT_C CSWICertStore* CSWICertStore::NewL(RFs& aFs)

	{

	// This method relies on the fact that we know the implementation of the swi

	// cert store token type is synchronous

	// Create token type

	MCTTokenType* tokenType = CSWICertStoreTokenType::NewL(aFs);

	CleanupReleasePushL(*tokenType);

	// Open token

	TRequestStatus stat;

	MCTToken* token = NULL;

	TUid tokenTypeUid = { KSWICertStoreTokenTypeUid };

	TCTTokenHandle tokenHandle(tokenTypeUid, CSWICertStoreTokenType::ESWICertStore);

	tokenType->OpenToken(tokenHandle, token, stat);

	User::WaitForRequest(stat);

	User::LeaveIfError(stat.Int());

	CleanupReleasePushL(*token);

	// Get interface

	MCTTokenInterface* tokenIf = NULL;

	token->GetInterface(TUid::Uid(KInterfaceCertStore), tokenIf, stat);

	User::WaitForRequest(stat);

	User::LeaveIfError(stat.Int());

	__ASSERT_ALWAYS(tokenIf, User::Panic(KSWICertStorePanic, 1));

	// Release token and token type

	CleanupStack::PopAndDestroy(2, tokenType);

	return static_cast<CSWICertStore*>(tokenIf);

	}

CSWICertStore* CSWICertStore::NewL(CSWICertStoreToken& aToken, RFs& aFs)

	{

	CSWICertStore* self = new (ELeave) CSWICertStore(aToken);

	CleanupStack::PushL(self);

	self->ConstructL(aFs);

	CleanupStack::Pop(self);

	return self;

	}

CSWICertStore::CSWICertStore(CSWICertStoreToken& aToken) :

	iToken(aToken)

	{

	}

void CSWICertStore::ConstructL(RFs& aFs)

	{

	iImpl = CSWICertStoreImpl::NewL(iToken, aFs);

	}

void CSWICertStore::DoRelease()

	{

	if (iToken.ReleaseInterface())

		{

		delete this;

		}

	}

CSWICertStore::~CSWICertStore()

	{

	delete iImpl;

	}

MCTToken& CSWICertStore::Token()

	{

	return iToken;

	}

void CSWICertStore::List(RMPointerArray<CCTCertInfo>& aCerts,

						 const CCertAttributeFilter& aFilter,

						 TRequestStatus& aStatus)

	{

	TRAPD(err, iImpl->ListL(aCerts, aFilter));

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CSWICertStore::CancelList()

	{

	}

void CSWICertStore::GetCert(CCTCertInfo*& aCertInfo,

							const TCTTokenObjectHandle& aHandle, 

							TRequestStatus& aStatus)

	{

	TRAPD(err, aCertInfo = iImpl->GetCertL(aHandle));

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CSWICertStore::CancelGetCert()

	{

	}

void CSWICertStore::Applications(const CCTCertInfo& aCertInfo,

								 RArray<TUid>& aApplications,

								 TRequestStatus& aStatus)

	{

	TRAPD(err, iImpl->ApplicationsL(aCertInfo.Handle(), aApplications));

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CSWICertStore::CancelApplications()

	{

	}

void CSWICertStore::IsApplicable(const CCTCertInfo& aCertInfo,

								 TUid aApplication, 

								 TBool& aIsApplicable,

								 TRequestStatus& aStatus)

	{

	TRAPD(err, aIsApplicable = iImpl->IsApplicableL(aCertInfo.Handle(), aApplication));

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CSWICertStore::CancelIsApplicable()

	{

	}

void CSWICertStore::Trusted(const CCTCertInfo& aCertInfo,

							TBool& aTrusted, 

							TRequestStatus& aStatus)

	{

	TRAPD(err, aTrusted = iImpl->TrustedL(aCertInfo.Handle()));

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CSWICertStore::CancelTrusted()

	{

	}

void CSWICertStore::Retrieve(const CCTCertInfo& aCertInfo,

							 TDes8& aEncodedCert, 

							 TRequestStatus& aStatus)

	{

	TRAPD(err, iImpl->RetrieveL(aCertInfo.Handle(), aEncodedCert));

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CSWICertStore::CancelRetrieve()

	{

	}

EXPORT_C const TCertMetaInfo& CSWICertStore::CertMetaInfoL(const CCTCertInfo& aCertInfo)

	{

	return iImpl->CertMetaInfoL(aCertInfo.Handle());

	}