/*

* Copyright (c) 2006, 2007 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:  These classes implement dps operations replies. 

*

*/

#include "dpsoperation.h"

#include "dpsconst.h"

#include "dpstransaction.h"

#include "pictbridge.h"

#include "dpsxmlparser.h"

#include "dpsxmlgenerator.h"

#include "dpsstatemachine.h"

const TInt KConfigPrintService = 5;

const TInt KCopyFileWidth = 3;

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

EXPORT_C void TMDpsOperation::CreateReqScriptL(

                                      const TDpsArgArray& aArguments, 

                                      const TDpsEleArray& /*aElements*/,

                                      TDpsAttribute /*aAttribute*/, 

                                      RWriteStream& aScript, 

                                      CDpsTransaction* aTrader)

    {

    CDpsXmlGenerator* g = aTrader->Generator();

    g->StartDocumentL(aScript);

    g->StartInputL(aScript);

    TInt count = aArguments.Count();

    if (!count)

	    {

		g->StartOperationL((TDpsOperation)iOperation, aScript, ETrue);

		}

	else

		{

		g->StartOperationL((TDpsOperation)iOperation, aScript);

		for (TInt i = 0; i < count; i++)

			{

			g->CreateArgL(aScript, aArguments[i]);

			}

		g->EndOperationL((TDpsOperation)iOperation, aScript);	

		}

    g->EndInputL(aScript);

    }

// ---------------------------------------------------------------------------

// Some request parameters should be checked

// ---------------------------------------------------------------------------

//

EXPORT_C TInt TDpsStartJob::FillReqArgs(TDpsArgArray& aArgs, 

                                        TDpsEleArray& aElements,

                                        TDpsAttribute& /*aAttrib*/, 

                                        CDpsTransaction* aTrader)

    {

    TInt imageCount = iReqParam.iPrintInfo.Count();

    if (!imageCount) 

        {

        return KErrUnknown;

        }

    TUint32* objectHandles = new TUint32[imageCount];

    if (!objectHandles)

        {

        return KErrNoMemory;

        }

    for (TInt i = 0; i < imageCount; i++)

        {

        TInt err = aTrader->Engine()->Ptp().

             GetObjectHandleByName(

                 iReqParam.iPrintInfo[i].iFile, objectHandles[i], ETrue); 

        if (err != KErrNone)

            {

            delete[] objectHandles;

            return err;

            }

        }

    TDpsArg* argsP = new TDpsArg[iReqParam.GetParamNum()];

    if (!argsP)

        {

		delete[] objectHandles;

        return KErrNoMemory;

        }

    TDpsEle* elemsP = new TDpsEle[1 + imageCount];

    if (!elemsP)

        {

		delete[] argsP;

		delete[] objectHandles;

        return KErrNoMemory;

        }

    // jobConfig    

    TInt count = iReqParam.iJobConfig.Count();

    elemsP[0].iElement = EDpsJobConfig;

    elemsP[0].iNum = count;

    aElements.Append(elemsP[0]);

    for (TInt i = 0; i < count; i++)

        {

        argsP[i].iElement = iReqParam.iJobConfig[i].iElement;

    	// the parameter only has high bytes (0x1234)

    	argsP[i].iContent.AppendNumUC(iReqParam.iJobConfig[i].iContent, EHex);

    	// we have to append the low bytes (0000)

    	argsP[i].iContent.Append(KDpsLowZero);

    	aArgs.Append(argsP[i]);

    	}    

    // printInfo

    for (TInt j = 0; j < imageCount; j++)

        {

    	// there is at least one argument for fileID

    	TInt k = 1;

    	elemsP[j + 1].iElement = EDpsPrintInfo;

    	argsP[count].iElement = EDpsArgFileID;

    	argsP[count].iContent.AppendNumFixedWidth(objectHandles[j], EHex, 

    	                                          KFullWordWidth);

    	aArgs.Append(argsP[count]);

    	count++;

    	// not empty

    	if (iReqParam.iPrintInfo[j].iFileName)

    	    {

    	    argsP[count].iElement = EDpsArgFileName;

    	    argsP[count].iContent.Copy(iReqParam.iPrintInfo[j].iFile);

    	    aArgs.Append(argsP[count]);

    	    k++; count++;

    	    }

    	// not empty    

    	if (iReqParam.iPrintInfo[j].iDate.Size())

    	    {

            argsP[count].iElement = EDpsArgDate;

            argsP[count].iContent.Copy(iReqParam.iPrintInfo[j].iDate);

            aArgs.Append(argsP[count]);

            k++; count++;

    	    }

    	if (iReqParam.iPrintInfo[j].iCopies != 0)

    	    {

            argsP[count].iElement = EDpsArgCopies;

            argsP[count].iContent.AppendNumFixedWidthUC(

                iReqParam.iPrintInfo[j].iCopies, EDecimal, KCopyFileWidth);

            aArgs.Append(argsP[count]);

    	    k++; count++;

    	    }    

    	if (iReqParam.iPrintInfo[j].iPrtPID != 0)

    	    {

            argsP[count].iElement = EDpsArgPrtPID;

            argsP[count].iContent.AppendNumUC(iReqParam.iPrintInfo[j].iPrtPID);

            aArgs.Append(argsP[count]);

    	    k++; count++;

    	    }

    	if (iReqParam.iPrintInfo[j].iCopyID != 0)

    	    {

            argsP[count].iElement = EDpsArgCopyID;

            argsP[count].iContent.AppendNumUC(iReqParam.iPrintInfo[j].iCopyID);

            aArgs.Append(argsP[count]);

    	    k++; count++;

    	    }

    	elemsP[j + 1].iNum = k;

    	aElements.Append(elemsP[j + 1]);    

    	}

    delete[] objectHandles;	

    delete[] argsP;

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

// 

EXPORT_C void TDpsStartJob::CreateReqScriptL(const TDpsArgArray& aArguments, 

                                            const TDpsEleArray& aElements,

                                            TDpsAttribute /*aAttribute*/,  

                                            RWriteStream& aScript, 

                                            CDpsTransaction* aTrader)

    {

    CDpsXmlGenerator* g = aTrader->Generator();

    g->StartDocumentL(aScript);

    g->StartInputL(aScript);

    g->StartOperationL((TDpsOperation)iOperation, aScript);

    TInt count = aElements.Count();

    TInt limit = 0;

    for (TInt i = 0; i < count; i++)

	    {

		g->StartElementL(aElements[i].iElement, aScript);

		TInt init = limit;

		limit = (i == 0 ? aElements[0].iNum : limit + aElements[i].iNum);

		for (TInt j = init; j < limit; j++)

			{

			g->CreateArgL(aScript,aArguments[j]);

			}

		g->EndElementL(aElements[i].iElement, aScript);	

		}

	g->EndOperationL((TDpsOperation)iOperation, aScript);

	g->EndInputL(aScript);

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//    

EXPORT_C TInt TDpsAbortJob::FillReqArgs(TDpsArgArray& aArgs, 

                                        TDpsEleArray& /*aElems*/,

                                        TDpsAttribute& /*aAttrib*/, 

                                        CDpsTransaction* /*aParam*/)

    {

    TDpsArg arg;

    arg.iElement = EDpsArgAbortStyle;

    arg.iContent.AppendNumUC(iReqParam.iAbortStyle, EHex);

    arg.iContent.Append(KDpsLowZero);

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// Some request parameters should be checked

// ---------------------------------------------------------------------------

//    

EXPORT_C TInt TDpsGetCapability::FillReqArgs(TDpsArgArray& aArgs, 

                                             TDpsEleArray& aElements,

                                             TDpsAttribute& aAttrib, 

                                             CDpsTransaction* /*aParam*/)

    {

    // only one element

    TDpsEle elems;

    elems.iElement = EDpsCapability;

    elems.iNum = 1;

    aElements.Append(elems);

    // only one parameter

    TDpsArg argsP;

    argsP.iElement = iReqParam.iCap;

    aArgs.Append(argsP);

    if (EDpsArgPaperTypes == iReqParam.iCap || EDpsArgLayouts == iReqParam.iCap)

        {

        if (iReqParam.iAttribute != 0)

            {

            aAttrib = iReqParam.iAttribute;

            }

    return KErrNone;    

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//    

EXPORT_C void TDpsGetCapability::CreateReqScriptL(

                                             const TDpsArgArray& aArguments, 

                                             const TDpsEleArray& aElements,

                                             TDpsAttribute aAttribute, 

                                             RWriteStream& aScript, 

                                             CDpsTransaction* aTrader)

    {

    CDpsXmlGenerator* g = aTrader->Generator();

    g->StartDocumentL(aScript);

    g->StartInputL(aScript);

    g->StartOperationL((TDpsOperation)iOperation, aScript);

	g->StartElementL(aElements[0].iElement, aScript);

	const TInt count = aArguments.Count();

	for (TInt i = 0; i < count; i++)

		{

		g->CreateArgL(aScript, aArguments[i], aAttribute);

		}

	g->EndElementL(aElements[0].iElement, aScript);

	g->EndOperationL((TDpsOperation)iOperation, aScript);	

	g->EndInputL(aScript);

    }

// ---------------------------------------------------------------------------

// Some request parameters should be checked

// ---------------------------------------------------------------------------

//    

EXPORT_C TInt TDpsConfigPrintService::FillReqArgs(TDpsArgArray& aArgs, 

                                                  TDpsEleArray& /*aElems*/,

                                                  TDpsAttribute& /*aAttrib*/, 

                                                  CDpsTransaction* /*aParam*/)

    {

    TDpsArg* argsP = new TDpsArg[KConfigPrintService]; 

    if (!argsP)

        {

        return KErrNoMemory;

        }

    TInt count;     

    for (TInt i = 0; i < KConfigPrintService; i++)

        {

        switch (i)

            {

        // there might be several versions

        case EDpsArgDpsVersions:

            argsP[i].iElement = EDpsArgDpsVersions;

            count = iReqParam.iDpsVersions.Count();

            for (TInt j = 0; j < count; j++)

                {

                argsP[i].iContent.AppendNumUC

                    (iReqParam.iDpsVersions[j].iMajor);

                argsP[i].iContent.Append(_L("."));    

                argsP[i].iContent.AppendNumUC

                    (iReqParam.iDpsVersions[j].iMinor);    

                }

            aArgs.Append(argsP[i]);

        break;    

        case EDpsArgVendorName: // vender name

            argsP[i].iElement = EDpsArgVendorName;

            argsP[i].iContent.Append(iReqParam.iVendorName);

            aArgs.Append(argsP[i]);

        break;  

        case EDpsArgVendorSpecificVersion: // vender version (optional)

            if (iReqParam.iVendorVersion.iMajor && 

                iReqParam.iVendorVersion.iMinor)

                {

                argsP[i].iElement = EDpsArgVendorSpecificVersion;

                argsP[i].iContent.AppendNumUC(iReqParam.iVendorVersion.iMajor);

                argsP[i].iContent.Append(_L("."));    

                argsP[i].iContent.AppendNumUC(iReqParam.iVendorVersion.iMinor);

                aArgs.Append(argsP[i]);        

                }

        break;

        case EDpsArgProductName: // produce name

            argsP[i].iElement = EDpsArgProductName;

            argsP[i].iContent.Append(iReqParam.iProductName);

            aArgs.Append(argsP[i]);

        break;

        case EDpsArgSerialNo: // serialNo (optional)

            if (iReqParam.iSerialNo.Length())

                {

                argsP[i].iElement = EDpsArgSerialNo;

                argsP[i].iContent.Append(iReqParam.iSerialNo);    

                aArgs.Append(argsP[i]);

                }

        break;

        default:

            delete[] argsP;

            return KErrArgument;

            }

        }

    return KErrNone;    

    }

// ---------------------------------------------------------------------------

//  Not all parameters are checked. If the invalid parameter can pass the 

//  the complaint test, it should not be checked. Instead, the client will see

//  it as unknown error. Otherwise, there might be unnecessary code and the

//  client cannot be informed. 

// ---------------------------------------------------------------------------

//    

EXPORT_C TInt TDpsGetCapability::FillRepArgs(const TDpsArgArray& aArgs, 

                                             CDpsTransaction* aTrader)

    {

    CDpsXmlParser* XmlPar = aTrader->Parser();

    if (aArgs.Count())

        {

        if (EDpsArgPaperTypes == aArgs[0].iElement || 

            EDpsArgLayouts == aArgs[0].iElement)

            {

            if (XmlPar->HasAttribute())

                {

                TDpsAttribute attrib;

		        XmlPar->GetAttribute(attrib);

		        iRepParam.iContent.Append(attrib);            

                }

            else

                {

                iRepParam.iContent.Append(0);

                }    

            }

        TUint32 value;

        TLex8 converter;

        TLex8 parser(aArgs[0].iContent);

        parser.SkipSpace();

        while (!parser.Eos())

            {

            parser.Mark();

            parser.SkipCharacters();

            if (KFullWordWidth == parser.TokenLength())

                {

                TPtrC8 token = parser.MarkedToken();

                converter.Assign(token);

                parser.SkipSpace();  

                }

            else

                {

                return KErrArgument;

                }

            TInt error = converter.Val(value, EHex);

            if (error != KErrNone)

                {

                return error;

                }

            if (EDpsArgPaperTypes == aArgs[0].iElement)

                {

                TDpsPaperType paperType;

                TInt major = value >> KShiftLength;

                paperType.iMajor = (TDpsPaperTypeMajor)major;

                paperType.iMinor = (TDpsPaperTypeMinor)(value & KDpsMinorMask);

                iRepParam.iPaperType.Append(paperType);

                }

            else

                {

                // remove the extra zeros

                value = value >> KShiftLength; 

                iRepParam.iContent.Append(value);

                }

            }

        iRepParam.iCap = aArgs[0].iElement;

        }

    return KErrNone;    

    }

// ---------------------------------------------------------------------------

//  Not all parameters are checked. If the invalid parameter can pass the 

//  the complaint test, it should not be checked. Instead, the client will see

//  it as unknown error. Otherwise, there might be unnecessary code and the

//  client cannot be informed. 

// ---------------------------------------------------------------------------

//    

EXPORT_C TInt TDpsConfigPrintService::FillRepArgs(const TDpsArgArray& aArgs, 

                                                  CDpsTransaction* aTrader)

    {

    TInt error = KErrNone;

    TLex8 converter, parser;

    const TInt count = aArgs.Count();

    for (TInt i = 0; i < count; i++)

        {

        switch (aArgs[i].iElement)

            {

            case EDpsArgPrintServiceAvailable: 

                converter.Assign(aArgs[i].iContent);

                TInt64 result;

                error = converter.Val(result, EHex);

                if (error != KErrNone)

                    {