/*

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

*

*/

/**

 @file

 @publishedAll

 @released

*/

#ifndef __MCTTOKEN_H__

#define __MCTTOKEN_H__

#include <ct/tcttokenobjecthandle.h>

#include <ct/mcttokenobject.h>

#include <ct/tcttokenhandle.h>

#include <ct/mcttokentype.h>

class MCTTokenInterface;

/** 

 * The base class for a token.

 * 

 * Token types must implement this class. It is created from a MCTTokenType using 

 * MCTTokenType::OpenToken().

 * 

 * A token represents one instance of a particular kind of cryptographic module; 

 * for instance, on a device with two WIMs, each WIM is a token. The token contains 

 * several interfaces, representing particular kinds of functions supported by 

 * the token (e.g. certificate management, key management, etc.) 

 * 

 * @since v7.0 

 */

class MCTToken

	{

 public:

  //Functions for opening an interface. 

  //The base class implements the reference counting then calls the corresponding pure virtual Do... methods	

	/** 

	 * Gets a token interface, or NULL if it's not supported by this token.

	 *

	 * This is an asynchronous request.

	 *

	 * @param aRequiredInterface	The UID of the interface that should be returned.

	 * @param aReturnedInterface	On success, this will be set to a pointer to the 

	 * 								returned interface.

	 * @param aStatus				The request status object; contains the result of the 

	 * 								GetInterface() request when complete. Set to KErrCancel 

	 * 								if an outstanding request is cancelled. 

	 */

	IMPORT_C void GetInterface(TUid aRequiredInterface,

							  MCTTokenInterface*& aReturnedInterface, 

							  TRequestStatus& aStatus);

	/** 

	 * Cancels an asynchronous GetInterface() operation.

	 *

	 * The operation completes with KErrCancel. 

	 */

	IMPORT_C void CancelGetInterface();

	/**

	 * Allows the client to add a reference to the token (for

	 * example, when a reference to a token is copied elsewhere).  

	 * 

	 * Does not need to be called if token is referenced through OpenToken().

	 */

	inline void AddRef();

	/** 

	 * Destroys the object.

	 *	

	 * The interface should be destroyed via this method as the destructor is protected.

	 *

	 * The token implements reference counting, with one count

	 * for itself and one for every opened interface. Once the count

	 * reaches 0, it releases its count with the token type.

	 */

	IMPORT_C void Release();

	// Notification of token removal. The base class assumes the token is not removable, and so does nothing. Removable tokens must implement these functions.

	/** 

	 * Notifies the client when the token has been removed.

	 *	

	 * The base class assumes the token is not removable, and so does nothing. Removable 

	 * tokens must implement these functions.

	 *

	 * This is an asynchronous request.	

	 *

	 * @param aStatus	The request status object; contains the result of the 

	 * 					NotifyOnRemoval() request when complete. Set to KErrCancel 

	 * 					if an outstanding request is cancelled. 

	 */

	IMPORT_C virtual void NotifyOnRemoval(TRequestStatus& aStatus);

	/** 

	 * Cancels an asynchronous NotifyOnRemoval() operation.

	 *

	 * The operation completes with KErrCancel. 

	 */

	IMPORT_C virtual void CancelNotify();

	/** 

	 * Gets the associated token type.	

	 *

	 * @return	The associated token type. 

	 */

	virtual MCTTokenType& TokenType() = 0;

	/** 

	 * Gets a label for the token.

	 *

	 * This should be the same as the descriptor returned by MCTTokenType::List().

	 *

	 * @return	The label to the token type. 

	 */

	virtual const TDesC& Label() = 0;

	/** Available information strings for the token. */

	enum TTokenInformation

		{

		/** Version */

		EVersion,

		/** Serial number */

		ESerialNo,

		/** Manufacturer */

		EManufacturer

		};

	/** 

	 * Gets the token's handle.

	 *

	 * This can be used to identify a token to another process.

	 *

	 * See the documentation of TCTTokenHandle for an explanation of the use of token 

	 * handles.

	 *

	 * @return	The handle of the token. 

	 */

	virtual TCTTokenHandle Handle() = 0;

 protected:

 	 /** 

 	  * The destructor is protected so that users of the interface

	  * have to use the Release() function. 

	  */

	inline virtual ~MCTToken() = 0;

	// Helper functions for the reference counting

	/** 

	 * Destroys the token object.

	 *

	 * This function is called when Release() has determined that the object is ready 

	 * to be destroyed.

	 *

	 * The default implementation just does a 'delete this', but classes can override 

	 * that if they want different behaviour.

	 *

	 * It should destroy the token; it MUST NOT release the token type, as Release() 

	 * will do that. 

	 */

	IMPORT_C virtual void DoRelease();

	/** 

	 * Gets a reference to the variable used as a reference counter.

	 *

	 * The implementer should initialise this to 0. The value of the reference count 

	 * should be treated as opaque by the implementer.

	 *

	 * @return	A reference to the variable used as a reference counter. 

	 */

	virtual TInt& ReferenceCount() = 0;

	// Implementation of GetInterface functionality */

	/** 

	 * Implementation for getting a token interface.

	 *

	 * This is called by GetInterface().

	 *

	 * This is an asynchronous request.

	 *

	 * @see GetInterface

	 * @param aRequiredInterface	The UID of the interface that should be returned.

	 * @param aReturnedInterface	On success, this will be set to a pointer to the 

	 * 								returned interface.

	 * @param aStatus				The request status object; contains the result of 

	 * 								the GetInterface() request when complete. Set to 

	 * 								KErrCancel if an outstanding request is cancelled. 

	 */

	virtual void DoGetInterface(TUid aRequiredInterface,

							  MCTTokenInterface*& aReturnedInterface, 

							  TRequestStatus& aStatus) = 0;

	/** 

	 * Implements an asynchronous CancelGetInterface() request.

	 * 

	 * @see	CancelGetInterface

	 * @return	ETrue if there is an token interface running; EFalse, otherwise. 

	 */

	virtual TBool DoCancelGetInterface() = 0;

 private:

	// Used by the token object to increment the reference count

	void ObjectCreated();

	// Needed to allow MCTTokenObject to increment the reference count

	// of the token

	friend class MCTTokenObject;

 public:

	/**

	 * Gets the specified information string about the token.

	 * The default implementation returns an empty descriptor.

	 */

	virtual const TDesC& Information(TTokenInformation aRequiredInformation) = 0;

	};

/** 

 * Destructor.

 *

 * Frees all resources owned by the object, prior to its destruction. 

 */

inline MCTToken::~MCTToken()

	{

	}

inline void MCTToken::AddRef()

	{

	++ReferenceCount();

	}

#endif //__MCTTOKEN_H__