/*
* 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:  Implementation of storage manager
*
*/



// INCLUDE FILES
#include "cvimpststorageserviceview.h"

#include <e32std.h>

#include "cvimpststoragemanager.h"
#include "tvimpststoragepanics.h"
#include "vimpstdebugtrace.h"


// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CVIMPSTStorageManager::InitialiseLibraryL
// Factory method that create the singleton instance of the storage manager
// -----------------------------------------------------------------------------
//
void CVIMPSTStorageManager::InitialiseLibraryL()
    {
    TRACE( T_LIT("CVIMPSTStorageManager::InitialiseLibraryL() begin") );
    //see whether there is an instance in the TLS
    //if not create the instance and set the same in TLS
    CVIMPSTStorageManager *sm = static_cast<CVIMPSTStorageManager*>( Dll::Tls() );
    if ( ! sm )
        {
        // no existing instance, create a new one
        CVIMPSTStorageManager *manager = CVIMPSTStorageManager::NewL();
        sm = manager;
        CleanupStack::PushL( manager );
        User::LeaveIfError( Dll::SetTls( static_cast<TAny*>( sm ) ) );
        CleanupStack::Pop( manager );
        }
    TRACE( T_LIT("CVIMPSTStorageManager::InitialiseLibraryL() end") );
    }

// -----------------------------------------------------------------------------
// CVIMPSTStorageManager::Release
// Factory method to release the singleton instance of the storage manager
// -----------------------------------------------------------------------------
//
TInt CVIMPSTStorageManager::Release()
    {
    TRACE( T_LIT("CVIMPSTStorageManager::Release() begin") );
    //if any instance in TLS get the same and delete it    
    CVIMPSTStorageManager *storage = static_cast<CVIMPSTStorageManager*>( Dll::Tls() );
    if ( storage )
        {
        delete storage;
        Dll::SetTls( NULL );
        }
    TRACE( T_LIT("CVIMPSTStorageManager::Release() end") );
    return KErrNone;
    }



// -----------------------------------------------------------------------------
// CVIMPSTStorageManager::Instance()
// -----------------------------------------------------------------------------
//
CVIMPSTStorageManager& CVIMPSTStorageManager::Instance()
    {
    //get the instance frm TLS and return the same
    TRACE( T_LIT("CVIMPSTStorageManager::Instance() begin") );
    CVIMPSTStorageManager *storage = static_cast<CVIMPSTStorageManager*>( Dll::Tls() );
    
    __ASSERT_ALWAYS( storage,
        User::Panic( KPanicCategory, KLIBNOTINITIALIZED ) );
	TRACE( T_LIT("CVIMPSTStorageManager::Instance() end") );
    return *storage;
    }    
    
    

// -----------------------------------------------------------------------------
// CVIMPSTStorageManager::NewL
// -----------------------------------------------------------------------------
//
 CVIMPSTStorageManager* CVIMPSTStorageManager::NewL()
    {
    TRACE( T_LIT("CVIMPSTStorageManager::NewL() begin") );
    //creates the instance
    CVIMPSTStorageManager* self = new( ELeave ) CVIMPSTStorageManager;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    TRACE( T_LIT("CVIMPSTStorageManager::NewL() end") );
    return self;
    }
    
// -----------------------------------------------------------------------------
// CVIMPSTStorageManager::ConstructL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
void CVIMPSTStorageManager::ConstructL()
	{
    TRACE( T_LIT("CVIMPSTStorageManager::ConstructL() begin") );
    TRACE( T_LIT("CVIMPSTStorageManager::ConstructL() end") );
    }
    
    
// -----------------------------------------------------------------------------
// CVIMPSTStorageManager::~CVIMPSTStorageManager
// -----------------------------------------------------------------------------
// 
 CVIMPSTStorageManager::~CVIMPSTStorageManager()
    {
    TRACE( T_LIT("CVIMPSTStorageManager::~CVIMPSTStorageManager() begin") );
    //release  all the existing views
	iServiceViewList.ResetAndDestroy();	
    TRACE( T_LIT("CVIMPSTStorageManager::~CVIMPSTStorageManager() end") );
    }
    
// -----------------------------------------------------------------------------
// CVIMPSTStorageManager::CreateServiceViewL
// -----------------------------------------------------------------------------
//
CVIMPSTStorageServiceView* CVIMPSTStorageManager::CreateServiceViewL( TUint32 aServiceId,
											const TDesC& aStoreName,
											const TDesC& aServiceName )
	{
	TRACE( T_LIT("CVIMPSTStorageManager::CreateServiceViewL() begin") );
	//creates a new view based on the service id.
	TInt index = KErrNotFound;
	CVIMPSTStorageServiceView* serviceView = NULL;
	
	//check if the view already exists in the viewlist
	index = FindServiceView(aServiceId);
	if( KErrNotFound == index )
		{
		TRACE( T_LIT("CVIMPSTStorageManager::CreateServiceViewL() service does not exit") );
		// service view is not found 
		// check if store name is valid create a service view for aServiceId
		if( aStoreName.Length() )
			{
			TRACE( T_LIT("CVIMPSTStorageManager::CreateServiceViewL() store name is valid") );
			serviceView = CVIMPSTStorageServiceView::NewL(aServiceId,
	    										aStoreName, aServiceName);	
			iServiceViewList.Append(serviceView); 
			TRACE( T_LIT("CVIMPSTStorageManager::CreateServiceViewL() new view created for serviceId = %d"),aServiceId );
			}
		// if store name is not valid ,return NULL
		}
    else
	    {
	    TRACE( T_LIT("CVIMPSTStorageManager::CreateServiceViewL() service already exist = %d"),aServiceId );
	    serviceView = iServiceViewList[ FindServiceView(aServiceId)];
	    }
    //return the extisting view from the viewlist
    TRACE( T_LIT("CVIMPSTStorageManager::CreateServiceViewL() end") );
	return serviceView;
	}
// -----------------------------------------------------------------------------
// CVIMPSTStorageManager::FindServiceView
// -----------------------------------------------------------------------------
//
TInt CVIMPSTStorageManager::FindServiceView( TUint32 aServiceId)
	{
	TRACE( T_LIT("CVIMPSTStorageManager::FindServiceView() begin") );
	//search whether the view exists in the view list.
	TInt index = KErrNotFound;
    TInt count = iServiceViewList.Count();
    for(TInt i = 0; i < count; i++ )
	    {
    	if( aServiceId == iServiceViewList[ i ]->GetServiceId() )
			{
			TRACE( T_LIT("CVIMPSTStorageManager::FindServiceView() aServiceId found = %d") ,aServiceId ); 
			index = i;
			break;
			}
		}
	TRACE( T_LIT("CVIMPSTStorageManager::FindServiceView() end") );	
	return index;
	}
	
	
// -----------------------------------------------------------------------------
// CVIMPSTStorageManager::RemoveServiceView
// -----------------------------------------------------------------------------
//
void  CVIMPSTStorageManager::RemoveServiceView( TUint32 aServiceId)
	{
	TRACE( T_LIT("CVIMPSTStorageManager::RemoveServiceView() begin") );
	//searches and removes the view from the view list.
    TInt index = FindServiceView(aServiceId);
	if( index >= 0 )
		{
		TRACE( T_LIT("CVIMPSTStorageManager::RemoveServiceView() aServiceId found = %d") ,aServiceId ); 
		//view exists, so delete and remove the same
		CVIMPSTStorageServiceView* serviceView = iServiceViewList[ index ];
		iServiceViewList.Remove( index ); 
		delete serviceView;
		iServiceViewList.Compress();     
		}
	TRACE( T_LIT("CVIMPSTStorageManager::RemoveServiceView() end") );   
	}

//  End of File