// Copyright (c) 2006-2009 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:
// 

/**
@file
@internalComponent
*/ 
#include <e32cmn.h>

#include "mtpservicecommon.h"
#include "cmtpserviceconfig.h"
#include "cmtpservicemgr.h"
#include <mtp/mtpprotocolconstants.h>

__FLOG_STMT(_LIT8(KComponent,"ServiceMgr");)


/**

*/
CMTPServiceMgr* CMTPServiceMgr::NewL()
    {
    CMTPServiceMgr* self = new (ELeave) CMTPServiceMgr();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

CMTPServiceMgr::CMTPServiceMgr()
    {
    
    }

void CMTPServiceMgr::ConstructL()
	{
	__FLOG_OPEN(KMTPSubsystem, KComponent);
	__FLOG(_L8("ConstructL - Entry"));
	
    iSingletons.OpenL();
	iServiceCfg = CMTPServiceConfig::NewL( iSingletons.Fs() );
	   
	__FLOG(_L8("ConstructL - Exit"));
	}
/**
Destructor
*/    
CMTPServiceMgr::~CMTPServiceMgr()
    {
    __FLOG(_L8("~CMTPServiceMgr - Entry"));
    
    delete iServiceCfg;
    
    iSingletons.Close();
    
    iServiceIDs.Close();
    
    __FLOG(_L8("~CMTPServiceMgr - Exit"));
    __FLOG_CLOSE;
    }

EXPORT_C TBool CMTPServiceMgr::IsSupportedService( const TUint aServiceID ) const
    {
    return ( ServiceInfo( aServiceID ) != NULL );
    }

EXPORT_C TBool CMTPServiceMgr::IsSupportedService( const TMTPTypeGuid& aPGUID ) const
    {
    return iServiceCfg->IsSupportedService( aPGUID );
    }

TInt CMTPServiceMgr::EnableService(const TMTPTypeGuid& aPGUID, const TUint aServiceID )
    {
    __FLOG(_L8("CMTPServiceMgr::EnableService : "));
    
    if( NULL == iServiceCfg->ServiceInfo(aPGUID)  )
        {
        TRAPD(err,LoadServiceL( aPGUID ));
        if( KErrNone == err)
            {
            iServiceCfg->ServiceInfo(aPGUID)->SetServiceID( aServiceID );
            }
        
        __FLOG_1(_L8("CMTPServiceMgr::EnableService - Fail to Load service! error = %d "), err );
        return err;
        }
    
    __FLOG(_L8("CMTPServiceMgr::EnableService - Has been loaded!"));
    
    return KErrNone;
    }

TInt CMTPServiceMgr::ServiceTypeOfSupportedService( const TMTPTypeGuid& aPGUID ) const
    {
    return iServiceCfg->ServiceTypeOfSupportedService( aPGUID );
    }

EXPORT_C CMTPServiceInfo* CMTPServiceMgr::ServiceInfo(const TMTPTypeGuid& aServiceGUID )const
    {
    return iServiceCfg->ServiceInfo( aServiceGUID );
    }

EXPORT_C CMTPServiceInfo* CMTPServiceMgr::ServiceInfo(const TUint aServiceID) const
    {
    return iServiceCfg->ServiceInfo( aServiceID );
    }

EXPORT_C TBool CMTPServiceMgr::IsServiceFormatCode(const TUint32 aDatacode ) const
    {
    return ( (EMTPFormatCodeVendorExtDynamicStart <= aDatacode) && ( aDatacode <= EMTPFormatCodeVendorExtDynamicEnd ) );
    }

EXPORT_C const RArray<TUint>& CMTPServiceMgr::GetServiceIDs() const
	{
	return iServiceIDs;
	}

TInt CMTPServiceMgr::InsertServiceId(const TUint aServiceId)
    {
    return iServiceIDs.InsertInOrder( aServiceId );
    }

void CMTPServiceMgr::LoadServiceL( const TMTPTypeGuid& aPGUID )
	{
	__FLOG(_L8("CMTPServiceMgr::LoadServiceL - Entry"));

	iServiceCfg->LoadServiceDataL(aPGUID);
	
    __FLOG(_L8("CMTPServiceMgr::LoadServiceL - Exit"));
	}

TInt CMTPServiceMgr::GetServiceProperty( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aPKNamespace, const TUint aPKID, CServiceProperty** aServicePropertye) const
    {
    __FLOG(_L8("CMTPServiceMgr::GetServiceProperty :"));
        
    CMTPServiceInfo* svcinfo = iServiceCfg->ServiceInfo( aServicePGUID );
    if( NULL == svcinfo )
       return KErrNotSupported;
    
    CServiceProperty* prop = svcinfo->ServiceProperty( aPKNamespace, aPKID );
    if( NULL == prop)
       return KErrNotSupported;
    
    *aServicePropertye = prop;
    
    __FLOG(_L8("CMTPServiceMgr::GetServiceProperty Exit"));
    return KErrNone;
    }

TInt CMTPServiceMgr::GetServiceFormat( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, CServiceFormat** aServiceFormat ) const
   {
    __FLOG(_L8("CMTPServiceMgr::GetServiceFormat :"));
    
    CMTPServiceInfo* svcinfo = iServiceCfg->ServiceInfo( aServicePGUID );
    if( NULL == svcinfo )
       return KErrNotSupported;
    
    CServiceFormat* format = svcinfo->ServiceFormat( aGUID );
    if( NULL == format)
       return KErrNotSupported;
    
    *aServiceFormat = format;
   
    __FLOG(_L8("CMTPServiceMgr::GetServiceFormat Exit"));
    return KErrNone;
   }

TInt CMTPServiceMgr::GetServiceMethod( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, CServiceMethod** aServiceMethod ) const
   {
    __FLOG(_L8("CMTPServiceMgr::GetServiceMethod :"));
    
    CMTPServiceInfo* svcinfo = iServiceCfg->ServiceInfo( aServicePGUID );
    if( NULL == svcinfo )
       return KErrNotSupported;
    
    CServiceMethod* method = svcinfo->ServiceMethod( aGUID );
    if( NULL == method)
       return KErrNotSupported;
    
    *aServiceMethod = method ;
    
    __FLOG(_L8("CMTPServiceMgr::GetServiceMethod - Exit"));
    return KErrNone;
   }

TInt CMTPServiceMgr::GetServiceId( const TMTPTypeGuid& aServiceGUID, TUint& aServiceID) const
	{
	__FLOG(_L8("CMTPServiceMgr::FindServiceId :"));
	
	CMTPServiceInfo* svcinfo = ServiceInfo( aServiceGUID );
	
	if( NULL ==  svcinfo )
	    {
	    __FLOG(_L8("CMTPServiceMgr::GetServiceId - Invalid serviceID"));
	    
	    return KErrNotFound;
	    }
	else
	    {
	    aServiceID = svcinfo->ServiceID();
	    
	    __FLOG_1(_L8("CMTPServiceMgr::GetServiceId = %d"),aServiceID );
	    
	    return KErrNone;
	    }
	}

TInt CMTPServiceMgr::GetServicePropertyCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aPKNamespace, const TUint aPKID, TUint& aServicePropertyCode ) const
    {
    __FLOG(_L8("CMTPServiceMgr::GetServicePropertyCode :"));
    
    CServiceProperty* prop = NULL;
    TInt err =  GetServiceProperty( aServicePGUID, aPKNamespace, aPKID, &prop );
    if( KErrNone != err)
        return err;
    
    aServicePropertyCode = prop->Code();
 
    __FLOG(_L8("CMTPServiceMgr::GetServicePropertyCode - Exit"));
    return KErrNone;
    }

TInt CMTPServiceMgr::SetServicePropertyCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aPKNamespace, const TUint aPKID, const TUint aCurrPropertyCode )
    {
    __FLOG(_L8("CMTPServiceMgr::SetServicePropertyCode :"));
    
    CServiceProperty* prop = NULL;
    TInt err =  GetServiceProperty( aServicePGUID, aPKNamespace, aPKID, &prop );
    if( KErrNone != err)
        return err;
    
    prop->SetCode( aCurrPropertyCode );
    
    __FLOG(_L8("CMTPServiceMgr::SetServicePropertyCode - Exit"));
    return KErrNone;
    }

TInt CMTPServiceMgr::GetServiceFormatCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, TUint& aServiceFormatCode ) const
    {
    __FLOG(_L8("CMTPServiceMgr::GetServiceFormatCode :"));
    
    CServiceFormat* format = NULL;
    TInt err = GetServiceFormat( aServicePGUID, aGUID, &format );
    if( KErrNone != err )
        return err;
    
    aServiceFormatCode = format->Code();
    
    __FLOG(_L8("CMTPServiceMgr::GetServiceFormatCode - Exit"));
    return KErrNone;
    }

TInt CMTPServiceMgr::SetServiceFormatCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, const TUint aCurrFormatCode )
    {
    __FLOG(_L8("CMTPServiceMgr::SetServiceFormatCode :"));
    
    CServiceFormat* format = NULL;
    TInt err = GetServiceFormat( aServicePGUID, aGUID, &format );
    if( KErrNone != err )
       return err;
    
    format->SetCode( aCurrFormatCode );
    
    __FLOG(_L8("CMTPServiceMgr::SetServiceFormatCode - Exit"));
    return KErrNone;
    }

TInt CMTPServiceMgr::GetServiceMethodCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, TUint& aServiceMethodCode ) const
    {
    __FLOG(_L8("CMTPServiceMgr::GetServiceMethodCode :"));
    
    CServiceMethod* method = NULL;
    TInt err = GetServiceMethod( aServicePGUID, aGUID, &method );
    if ( KErrNone != err )
        return err;
    
    aServiceMethodCode = method->Code();
    
    __FLOG(_L8("CMTPServiceMgr::GetServiceMethodCode - Exit"));
    return KErrNone;
    }

TInt CMTPServiceMgr::SetServiceMethodCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, const TUint aCurrMethodCode )
    {
    __FLOG(_L8("CMTPServiceMgr::SetServiceMethodCode :"));
    
    CServiceMethod* method = NULL;
    TInt err = GetServiceMethod( aServicePGUID, aGUID, &method );
    if ( KErrNone != err )
        return err;
    
    method->SetCode( aCurrMethodCode );
    
    __FLOG(_L8("CMTPServiceMgr::SetServiceMethodCode - Exit"));
    return KErrNone;
    }