// 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>
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "cmtpservicemgrTraces.h"
#endif



/**

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

CMTPServiceMgr::CMTPServiceMgr()
    {
    
    }

void CMTPServiceMgr::ConstructL()
	{
	OstTraceFunctionEntry0( CMTPSERVICEMGR_CONSTRUCTL_ENTRY );
	
    iSingletons.OpenL();
	iServiceCfg = CMTPServiceConfig::NewL( iSingletons.Fs() );

	OstTraceFunctionExit0( CMTPSERVICEMGR_CONSTRUCTL_EXIT );
	}
/**
Destructor
*/    
CMTPServiceMgr::~CMTPServiceMgr()
    {
    OstTraceFunctionEntry0( CMTPSERVICEMGR_CMTPSERVICEMGR_DES_ENTRY );
    
    delete iServiceCfg;
    
    iSingletons.Close();
    
    iServiceIDs.Close();

    OstTraceFunctionExit0( CMTPSERVICEMGR_CMTPSERVICEMGR_DES_EXIT );
    }

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 )
    {
    OstTraceFunctionEntry0( CMTPSERVICEMGR_ENABLESERVICE_ENTRY );
    
    if( NULL == iServiceCfg->ServiceInfo(aPGUID)  )
        {
        TRAPD(err,LoadServiceL( aPGUID ));
        if( KErrNone == err)
            {
            iServiceCfg->ServiceInfo(aPGUID)->SetServiceID( aServiceID );
            }
        else
            OstTraceDef1(OST_TRACE_CATEGORY_PRODUCTION, TRACE_IMPORTANT, CMTPSERVICEMGR_ENABLESERVICE, 
                    "CMTPServiceMgr::EnableService - Fail to Load service! error = %d", err);
        OstTraceFunctionExit0( CMTPSERVICEMGR_ENABLESERVICE_EXIT );
        return err;
        }
    
    OstTrace0(TRACE_NORMAL, DUP1_CMTPSERVICEMGR_ENABLESERVICE, "CMTPServiceMgr::EnableService - Has been loaded!");
    OstTraceFunctionExit0( DUP1_CMTPSERVICEMGR_ENABLESERVICE_EXIT );
    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 )
	{
	OstTraceFunctionEntry0( CMTPSERVICEMGR_LOADSERVICEL_ENTRY );

	iServiceCfg->LoadServiceDataL(aPGUID);

	OstTraceFunctionExit0( CMTPSERVICEMGR_LOADSERVICEL_EXIT );
	}

TInt CMTPServiceMgr::GetServiceProperty( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aPKNamespace, const TUint aPKID, CServiceProperty** aServicePropertye) const
    {
    OstTraceFunctionEntry0( CMTPSERVICEMGR_GETSERVICEPROPERTY_ENTRY );

    CMTPServiceInfo* svcinfo = iServiceCfg->ServiceInfo( aServicePGUID );
    if( NULL == svcinfo )
       return KErrNotSupported;
    
    CServiceProperty* prop = svcinfo->ServiceProperty( aPKNamespace, aPKID );
    if( NULL == prop)
       return KErrNotSupported;
    
    *aServicePropertye = prop;

    OstTraceFunctionExit0( CMTPSERVICEMGR_GETSERVICEPROPERTY_EXIT );
    return KErrNone;
    }

TInt CMTPServiceMgr::GetServiceFormat( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, CServiceFormat** aServiceFormat ) const
   {
    OstTraceFunctionEntry0( CMTPSERVICEMGR_GETSERVICEFORMAT_ENTRY );

    CMTPServiceInfo* svcinfo = iServiceCfg->ServiceInfo( aServicePGUID );
    if( NULL == svcinfo )
       return KErrNotSupported;
    
    CServiceFormat* format = svcinfo->ServiceFormat( aGUID );
    if( NULL == format)
       return KErrNotSupported;
    
    *aServiceFormat = format;

    OstTraceFunctionExit0( CMTPSERVICEMGR_GETSERVICEFORMAT_EXIT );
    return KErrNone;
   }

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

TInt CMTPServiceMgr::GetServiceId( const TMTPTypeGuid& aServiceGUID, TUint& aServiceID) const
	{
	OstTraceFunctionEntry0( CMTPSERVICEMGR_GETSERVICEID_ENTRY );
	
	CMTPServiceInfo* svcinfo = ServiceInfo( aServiceGUID );
	
	if( NULL ==  svcinfo )
	    {
	    OstTrace0(TRACE_ERROR, CMTPSERVICEMGR_GETSERVICEID, "CMTPServiceMgr::GetServiceId - Invalid serviceID");   
	    OstTraceFunctionExit0( CMTPSERVICEMGR_GETSERVICEID_EXIT );
	    return KErrNotFound;
	    }
	else
	    {
	    aServiceID = svcinfo->ServiceID();
	    
	    OstTrace1(TRACE_NORMAL, DUP1_CMTPSERVICEMGR_GETSERVICEID, 
	            "CMTPServiceMgr::GetServiceId = %d", aServiceID);
	    OstTraceFunctionExit0( DUP1_CMTPSERVICEMGR_GETSERVICEID_EXIT );
	    return KErrNone;
	    }
	}

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

    OstTraceFunctionExit0( CMTPSERVICEMGR_GETSERVICEPROPERTYCODE_EXIT );
    return KErrNone;
    }

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

TInt CMTPServiceMgr::GetServiceFormatCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, TUint& aServiceFormatCode ) const
    {
    OstTraceFunctionEntry0( CMTPSERVICEMGR_GETSERVICEFORMATCODE_ENTRY );

    CServiceFormat* format = NULL;
    TInt err = GetServiceFormat( aServicePGUID, aGUID, &format );
    if( KErrNone != err )
        return err;
    
    aServiceFormatCode = format->Code();

    OstTraceFunctionExit0( CMTPSERVICEMGR_GETSERVICEFORMATCODE_EXIT );
    return KErrNone;
    }

TInt CMTPServiceMgr::SetServiceFormatCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, const TUint aCurrFormatCode )
    {
    OstTraceFunctionEntry0( CMTPSERVICEMGR_SETSERVICEFORMATCODE_ENTRY );

    CServiceFormat* format = NULL;
    TInt err = GetServiceFormat( aServicePGUID, aGUID, &format );
    if( KErrNone != err )
       return err;
    
    format->SetCode( aCurrFormatCode );

    OstTraceFunctionExit0( CMTPSERVICEMGR_SETSERVICEFORMATCODE_EXIT );
    return KErrNone;
    }

TInt CMTPServiceMgr::GetServiceMethodCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, TUint& aServiceMethodCode ) const
    {
    OstTraceFunctionEntry0( CMTPSERVICEMGR_GETSERVICEMETHODCODE_ENTRY );

    CServiceMethod* method = NULL;
    TInt err = GetServiceMethod( aServicePGUID, aGUID, &method );
    if ( KErrNone != err )
        return err;
    
    aServiceMethodCode = method->Code();

    OstTraceFunctionExit0( CMTPSERVICEMGR_GETSERVICEMETHODCODE_EXIT );
    return KErrNone;
    }

TInt CMTPServiceMgr::SetServiceMethodCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, const TUint aCurrMethodCode )
    {
    OstTraceFunctionEntry0( CMTPSERVICEMGR_SETSERVICEMETHODCODE_ENTRY );
    
    CServiceMethod* method = NULL;
    TInt err = GetServiceMethod( aServicePGUID, aGUID, &method );
    if ( KErrNone != err )
        return err;
    
    method->SetCode( aCurrMethodCode );
    
    OstTraceFunctionExit0( CMTPSERVICEMGR_SETSERVICEMETHODCODE_EXIT );
    return KErrNone;
    }