// 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 <mtp/cmtpdataproviderplugin.h>
#include <mtp/cmtptypearray.h>
#include <mtp/cmtptypestring.h>
#include <mtp/mtpdataproviderapitypes.h>
#include <mtp/tmtptyperequest.h>
#include <mtp/cmtptypeserviceinfo.h>
#include <mtp/cmtptypeserviceprop.h>
#include <mtp/cmtptypeserviceformat.h>
#include <mtp/cmtptypeservicemethod.h>
#include <mtp/cmtptypeserviceevent.h>
#include <mtp/tmtptypeguid.h>

#include "cmtpgetserviceinfo.h"
#include "rmtpframework.h"
#include "mtpdevdppanic.h"
#include "cmtpservicemgr.h"



// Class constants.
__FLOG_STMT(_LIT8(KComponent,"GetServiceInfo");)

/**
Two-phase construction method
@param aPlugin    The data provider plugin
@param aFramework    The data provider framework
@param aConnection    The connection from which the request comes
@return a pointer to the created request processor object
*/    
MMTPRequestProcessor* CMTPGetServiceInfo::NewL(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection)
    {
    CMTPGetServiceInfo* self = new (ELeave) CMTPGetServiceInfo(aFramework, aConnection);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

/**
Destructor.
*/    
CMTPGetServiceInfo::~CMTPGetServiceInfo()
    {    
    __FLOG(_L8("~CMTPGetServiceInfo - Entry"));
    delete iServiceInfo;

    iSingletons.Close();
    __FLOG(_L8("~CMTPGetServiceInfo - Exit"));
    __FLOG_CLOSE;
    }

/**
Constructor.
*/    
CMTPGetServiceInfo::CMTPGetServiceInfo(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection) :
    CMTPRequestProcessor(aFramework, aConnection, 0, NULL)
    {
    
    }
    
/**
GetServiceInfo request handler. Build and send device info data set.
*/    
void CMTPGetServiceInfo::ServiceL()
    {
    __FLOG(_L8("ServiceL - Entry"));
       
    TUint32 serviceId = Request().Uint32(TMTPTypeRequest::ERequestParameter1);
    if ( KErrNotFound == iSingletons.ServiceMgr().GetServiceIDs().Find(serviceId) )
    	{
    	SendResponseL(EMTPRespCodeInvalidServiceID);
    	}
    else if(iSingletons.ServiceMgr().IsSupportedService(serviceId))
    	{
    	BuildServiceInfoL();
    	SendDataL(*iServiceInfo);
    	}
    else
        {
        //The ServiceID has been allocated by MTP Datacode Generator
        //but Parser&Router fail to get the target DP.
        //it may be caused by: 
        //    1. DP plugin does not register the ServiceID by the Supported() function. Mostly.
        //    2. Framework have some errors while setup the router mapping table.
        Panic(EMTPDevDpUnknownServiceID);
        }
    
    __FLOG(_L8("ServiceL - Exit"));
    }

/**
Second-phase constructor.
*/        
void CMTPGetServiceInfo::ConstructL()
    {
    __FLOG_OPEN(KMTPSubsystem, KComponent);
    __FLOG(_L8("ConstructL - Entry")); 
    iSingletons.OpenL();
    __FLOG(_L8("ConstructL - Exit")); 
    }

/**
Populates service info data set
*/
void CMTPGetServiceInfo::BuildServiceInfoL()
    {
    __FLOG(_L8("BuildServiceInfoL - Entry")); 
    
    delete iServiceInfo;
    iServiceInfo = CMTPTypeServiceInfo::NewL();
    
    TUint32 serviceId = Request().Uint32(TMTPTypeRequest::ERequestParameter1);
    CMTPServiceInfo* svcinfo = iSingletons.ServiceMgr().ServiceInfo( serviceId );
    if( NULL == svcinfo )
        {
        __FLOG_1(_L8("BuildServiceInfoL - CMTPServiceInfo is NULL!!! ServiceID is %d."),serviceId ); 
        __FLOG(_L8("BuildServiceInfoL - Exit")); 
        return;
        }
    BuildServiceInfoHeadL(*svcinfo);
    BuildUsedServiceGUIDL(*svcinfo);
	BuildServicePropertyL(*svcinfo);
	BuildServiceFormatL(*svcinfo);
	BuildServiceMethodL(*svcinfo);
	BuildDataBlockL(*svcinfo);    
    
    __FLOG(_L8("BuildServiceInfoL - Exit")); 
    }


void CMTPGetServiceInfo::BuildServiceInfoHeadL(CMTPServiceInfo& aServiceInfo)
	{
	__FLOG(_L8("BuildServiceInfoHeadL - Entry"));
	
	iServiceInfo->SetUint32L(CMTPTypeServiceInfo::EServiceID,aServiceInfo.ServiceID());
	iServiceInfo->SetUint32L(CMTPTypeServiceInfo::EServiceStorageID,aServiceInfo.ServiceStorageID());
	iServiceInfo->SetL(CMTPTypeServiceInfo::EServicePGUID,aServiceInfo.ServicePersistentGUID());
	iServiceInfo->SetUint32L(CMTPTypeServiceInfo::EServiceVersion,aServiceInfo.ServiceVersion());
	iServiceInfo->SetL(CMTPTypeServiceInfo::EServiceGUID,aServiceInfo.ServiceGUID());
	iServiceInfo->SetStringL(CMTPTypeServiceInfo::EServiceName,aServiceInfo.ServiceName());
	iServiceInfo->SetUint32L(CMTPTypeServiceInfo::EServiceType,aServiceInfo.ServiceType());
	iServiceInfo->SetUint32L(CMTPTypeServiceInfo::EBaseServiceID,aServiceInfo.BaseServiceID());
	
	__FLOG(_L8("BuildServiceInfoHeadL - Exit")); 
	}

void CMTPGetServiceInfo::BuildUsedServiceGUIDL(CMTPServiceInfo& aServiceInfo)
	{
	__FLOG(_L8("BuildUsedServiceGUIDL - Entry"));
	TInt count = aServiceInfo.UsedServiceGUIDs().Count();
	const RArray<TMTPTypeGuid> UsedServiceGUIDs = aServiceInfo.UsedServiceGUIDs();
	for (TInt i=0;i<count;i++)
		{
          iServiceInfo->AppendUsedServiceL( UsedServiceGUIDs[i] );
		}
	
	__FLOG(_L8("BuildUsedServiceGUIDL - Exit"));
	}

void CMTPGetServiceInfo::BuildServicePropertyL(CMTPServiceInfo& aServiceInfo)
	{
	__FLOG(_L8("BuildServicePropertyL - Entry"));

	TInt count = aServiceInfo.ServiceProperties().Count();
	CMTPTypeServicePropertyElement* PropElement = NULL;
	CServiceProperty* prop = NULL;
	const RPointerArray<CServiceProperty> ServiceProperties = aServiceInfo.ServiceProperties();
	for (TInt i=0;i<count;i++)
		{
		prop = ServiceProperties[i];
		if(!prop->IsUsed())
		    continue;
		
		PropElement = CMTPTypeServicePropertyElement::NewLC(prop->Code(),prop->Namespace(),prop->PKeyID(), prop->Name());
		iServiceInfo->ServicePropList().AppendL(PropElement);
		CleanupStack::Pop(PropElement);
		}
	
	__FLOG(_L8("BuildServicePropertyL - Exit"));
	}

void CMTPGetServiceInfo::BuildServiceFormatL(CMTPServiceInfo& aServiceInfo)
	{
	__FLOG(_L8("BuildServiceFormatL - Entry"));

	CMTPTypeServiceFormatElement* FormatElement = NULL; 
	CServiceFormat* format = NULL;  
	TInt count = aServiceInfo.ServiceFormats().Count();
	const RPointerArray<CServiceFormat> ServiceFormats = aServiceInfo.ServiceFormats();
	for (TInt i=0;i<count;i++)
		{
		format = ServiceFormats[i];
		if(!format->IsUsed())
		    continue;
		
		FormatElement = CMTPTypeServiceFormatElement::NewLC( format->Code(), format->GUID(), format->Name(), format->FormatBase(), format->MIMEType1() );
		iServiceInfo->ServiceFormatList().AppendL(FormatElement);
		CleanupStack::Pop(FormatElement);
		}
	
	__FLOG(_L8("BuildServiceFormatL - Exit"));
	}

void CMTPGetServiceInfo::BuildServiceMethodL(CMTPServiceInfo& aServiceInfo)
	{
	__FLOG(_L8("BuildServiceMethodL - Entry"));

	CMTPTypeServiceMethodElement* methodElement = NULL;
	CServiceMethod* method = NULL;
	TInt count = aServiceInfo.ServiceMethods().Count();
	const RPointerArray<CServiceMethod> ServiceMethods = aServiceInfo.ServiceMethods();
	for (TInt i=0;i<count;i++)
		{
		method = ServiceMethods[i];
		if(!method->IsUsed())
		    continue;
		methodElement = CMTPTypeServiceMethodElement::NewLC( method->Code(), method->GUID(), method->Name(), method->ObjAssociateFormatCode() );
		iServiceInfo->ServiceMethodList().AppendL(methodElement);
		CleanupStack::Pop(methodElement);		
		}
	
	__FLOG(_L8("BuildServiceMethodL - Exit"));
	}


void CMTPGetServiceInfo::BuildDataBlockL(CMTPServiceInfo& aServiceInfo)
    {
    __FLOG(_L8("BuildDataBlockL - Entry"));
    TInt count = aServiceInfo.DataBlockGUIDs().Count();
    const RArray<TMTPTypeGuid> DataBlockGUIDs = aServiceInfo.DataBlockGUIDs();
    for (TInt i=0;i<count;i++)
        {
        iServiceInfo->AppendServiceDataBlockL( DataBlockGUIDs[i] );
        }

    __FLOG(_L8("BuildDataBlockL - Exit"));
    }