/*
* Copyright (c) 2002-2005 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:  Header file for supl 2.0 triggered start  message
*
*/

#include "epos_comasupltriggeredstart.h"
#include "epos_comasuplsessionid.h"
#include "epos_comasuplstartver2.h"
#include "epos_suplconstants.h"
#include "epos_comasupllocationidver2.h"
#include  "lbs/epos_eomasuplposerrors.h"
#include "epos_comasuplsetcapabilitiesver2.h"

const TInt KQopShift = 5;
const TInt KVerShift = 4;
const TInt KTrigTypeShift = 3;
const TInt KTrigParamsShift = 2;
const TInt KRepCapShift = 1;


EXPORT_C COMASuplTriggeredStart::COMASuplTriggeredStart()
    {
    iOptionalMask = 0;
    }

EXPORT_C COMASuplTriggeredStart::~COMASuplTriggeredStart()
    {
    // SetCapabilities*/
    if(iSETCapabilities)
        {
        delete iSETCapabilities;
        iSETCapabilities = NULL;
        }
    // Location Id*/
    if(iLocationId)
        {
        delete iLocationId;
        iLocationId = NULL;
        }
    if(iMultipleLocIds)
        {
        delete iMultipleLocIds;
        iMultipleLocIds = NULL;
        }

    if(iThirdparty)
        {
        delete iThirdparty;
        iThirdparty = NULL;
        }

    if(iPosition)
        {
        delete iPosition;
        iPosition = NULL;
        }
    }

EXPORT_C COMASuplTriggeredStart* COMASuplTriggeredStart::NewLC()
    {
    COMASuplTriggeredStart* self = new (ELeave)COMASuplTriggeredStart();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

EXPORT_C COMASuplTriggeredStart* COMASuplTriggeredStart::NewL()
    {
    COMASuplTriggeredStart* self=COMASuplTriggeredStart::NewLC();
    CleanupStack::Pop(self); // self;
    return self;
    }

EXPORT_C void COMASuplTriggeredStart::ConstructL()
    {
    SetMessageType(COMASuplAsnMessageBase::ESUPL_TRIG_START);            
    }

// -----------------------------------------------------------------------------
// COMASuplTriggeredStart::SetECellId() 
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//   			
EXPORT_C void COMASuplTriggeredStart::SetECellId(TOMASuplECellInfo& aECId)
    {
    iMmCellInfo = aECId;
    }

// -----------------------------------------------------------------------------
// COMASuplTriggeredStart::GetECellId() 
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//              
EXPORT_C void COMASuplTriggeredStart::GetECellId(TOMASuplECellInfo& aECId)
    {
    aECId = iMmCellInfo;
    }
EXPORT_C void COMASuplTriggeredStart::GetSETCapabilities(COMASuplSETCapabilitiesVer2*& aSETCapabilities) const
    {
    if(iSETCapabilities)
        aSETCapabilities = iSETCapabilities;
    }
EXPORT_C void COMASuplTriggeredStart::GetLocationId(COMASuplLocationIdVer2*& aLocationId) const
    {
    if(iLocationId)
        aLocationId = iLocationId;
    }
EXPORT_C TInt COMASuplTriggeredStart::GetQop(TOMASuplQop& aSuplQop) const
    {
    if(iOptionalMask & (1<<KQopShift))
        {
        aSuplQop = iSuplQop;
        return KErrNone;
        }
    else
        return KErrOMASuplParamNotSet;
    }
EXPORT_C TInt COMASuplTriggeredStart::GetVer(TDes8& aVer)const
    {
    if( iOptionalMask & (1<<KVerShift) )
        {
        if(aVer.MaxLength() >= iVer.Length())
            aVer = iVer;
        else
            return KErrArgument;
        return KErrNone;
        }
    else
        return KErrOMASuplParamNotSet;
    }
EXPORT_C void COMASuplTriggeredStart::GetMultipleLocIds(COMASuplMultipleLocIds*& aMultipleLocIds)const
    {
    if(iMultipleLocIds)
        aMultipleLocIds = iMultipleLocIds;
    }
EXPORT_C void COMASuplTriggeredStart::GetThirdParty(COMASuplThirdPartyIds*& aThirdparty)const
    {
    if(iThirdparty)
        aThirdparty = iThirdparty;
    }
EXPORT_C TInt COMASuplTriggeredStart::GetTriggerType(TOMASuplTrigType&  aTrigType)const
    {
    if(iOptionalMask & (1<<KTrigTypeShift))
        {
        aTrigType = iTrigType;
        return KErrNone;
        }
    else
        return KErrOMASuplParamNotSet;
    }
EXPORT_C TInt COMASuplTriggeredStart::GetTriggerParams(TOMASuplTriggerParams& aTriggerParams)const
    {
    if(iOptionalMask & (1<<KTrigParamsShift))
        {
        aTriggerParams = iTriggerParams;
        return KErrNone;
        }
    else
        return KErrOMASuplParamNotSet;
    }
EXPORT_C void COMASuplTriggeredStart::GetPosition(COMASuplPosition*& aPosition)const
    {
    if(iPosition)
        aPosition = iPosition;
    }
EXPORT_C TInt COMASuplTriggeredStart::GetReportingCaps(TOMASuplReportingCap& aReportingCap)const
    {
    if(iOptionalMask & (1<<KRepCapShift))
        {
        aReportingCap = iReportingCap;
        return KErrNone;
        }
    else
        return KErrOMASuplParamNotSet;
    }
EXPORT_C TInt COMASuplTriggeredStart::GetCauseCode(TOMASuplTrigStartCauseCode& aCauseCode)const
    {
    if(iOptionalMask & (1))
        {
        aCauseCode = iCauseCode;
        return KErrNone;
        }
    else
        return KErrOMASuplParamNotSet;
    }
EXPORT_C void COMASuplTriggeredStart::SetSETCapabilities(COMASuplSETCapabilitiesVer2* aSETCapabilities)
    {
    if(iSETCapabilities)
        {
        delete iSETCapabilities;
        iSETCapabilities = NULL;
        }
    iSETCapabilities = aSETCapabilities;
    }
EXPORT_C void COMASuplTriggeredStart::SetLocationId(COMASuplLocationIdVer2* aLocationId)
    {
    if(iLocationId)
        {
        delete iLocationId;
        iLocationId = NULL;
        }
    iLocationId = aLocationId;
    }
EXPORT_C void COMASuplTriggeredStart::SetQop(TOMASuplQop aSuplQop)
    {
    iOptionalMask |= (1<<KQopShift);
    iSuplQop = aSuplQop;
    }
EXPORT_C void COMASuplTriggeredStart::SetVer(TDes8& aVer)
    {    
    iOptionalMask |= 1<<KVerShift; //set the bit to indicate version field is set
    iVer = aVer;
    }
EXPORT_C void COMASuplTriggeredStart::SetMultipleLocIds(COMASuplMultipleLocIds* aMultipleLocIds)
    {
    if(iMultipleLocIds)
        {
        delete iMultipleLocIds;
        iMultipleLocIds = NULL;
        }
    iMultipleLocIds = aMultipleLocIds;
    }
EXPORT_C void COMASuplTriggeredStart::SetThirdParty(COMASuplThirdPartyIds* aThirdparty)
    {
    if(iThirdparty)
        {
        delete iThirdparty;
        iThirdparty = NULL;
        }
    iThirdparty = aThirdparty;
    }
EXPORT_C void COMASuplTriggeredStart::SetTriggerType(TOMASuplTrigType  aTrigType)
    {
    iOptionalMask |= (1<<KTrigTypeShift);
    iTrigType = aTrigType;
    }
    
EXPORT_C void COMASuplTriggeredStart::SetTriggerParams(TOMASuplTriggerParams aTriggerParams)
    {
    iOptionalMask |= (1<<KTrigParamsShift);
    iTriggerParams = aTriggerParams;
    }
EXPORT_C void COMASuplTriggeredStart::SetPosition(COMASuplPosition* aPosition)
    {
    if(iPosition)
        {
        delete iPosition;
        iPosition = NULL;
        }
    iPosition = aPosition;
    }
EXPORT_C void COMASuplTriggeredStart::SetReportingCaps(TOMASuplReportingCap       aReportingCap)
    {
    iOptionalMask |= (1<<KRepCapShift);
    iReportingCap = aReportingCap;
    }
EXPORT_C void COMASuplTriggeredStart::SetCauseCode(TOMASuplTrigStartCauseCode aCauseCode)
    {
    iOptionalMask |= (1);
    iCauseCode = aCauseCode;
    }

// -----------------------------------------------------------------------------
// COMASuplTriggeredStart::CloneL() 
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//              
EXPORT_C void COMASuplTriggeredStart::Clone(const COMASuplAsnMessageBase* aTrigStart,TInt& aErrorCode)
    {
    TRAP(aErrorCode, CloneBaseL(aTrigStart,aErrorCode));
    COMASuplTriggeredStart* trigStart = (COMASuplTriggeredStart*)aTrigStart;
    
    TOMASuplQop suplQop;
    if(trigStart->GetQop(suplQop) == KErrNone)
        SetQop(suplQop);
    
    COMASuplTriggeredStart::TOMASuplTrigStartCauseCode causeCode;
    if(trigStart->GetCauseCode(causeCode) == KErrNone)
        SetCauseCode(causeCode);
    if(trigStart->ieCID)
        {
        TOMASuplECellInfo mmCellInfo;
        trigStart->GetECellId(mmCellInfo);
        SetECellId(mmCellInfo);
        ieCID = trigStart->ieCID;
        }
    
    COMASuplSETCapabilitiesVer2* sETCapabilities = NULL; 
    trigStart->GetSETCapabilities(sETCapabilities);
    if(sETCapabilities)
        TRAP(aErrorCode,iSETCapabilities = sETCapabilities->CloneL());

    COMASuplLocationIdVer2* locationId = NULL; 
    trigStart->GetLocationId(locationId);
    if(locationId)
        TRAP(aErrorCode,SetLocationId(locationId->CloneL()));
 
    TBuf8<KVer> ver;
    trigStart->GetVer(ver);
    SetVer(ver);
    

    COMASuplMultipleLocIds* multipleLocIds = NULL;
    trigStart->GetMultipleLocIds(multipleLocIds);
    if(multipleLocIds)
        TRAP(aErrorCode,SetMultipleLocIds(multipleLocIds->CloneL()));
    
    COMASuplThirdPartyIds* thirdparty = NULL; 
    trigStart->GetThirdParty(thirdparty);
    if(thirdparty)
        TRAP(aErrorCode,SetThirdParty(thirdparty->CloneL()));
    
    TOMASuplTrigType trigType; 
    if(trigStart->GetTriggerType(trigType) == KErrNone)
        SetTriggerType(trigType);

    TOMASuplTriggerParams      triggerParams;
    if(trigStart->GetTriggerParams(triggerParams) == KErrNone)
        SetTriggerParams(triggerParams);
    
    COMASuplPosition*          position; //optional parameter
    trigStart->GetPosition(position);
    if(position)
        TRAP(aErrorCode,SetPosition(static_cast <COMASuplPosition*> (position->CloneL())));
        
    TOMASuplReportingCap       reportingCap; 
    if(trigStart->GetReportingCaps(reportingCap) == KErrNone)
        SetReportingCaps(reportingCap);    
    
    }
EXPORT_C TOMASuplTriggerParams::TOMASuplTriggerParams()
    {
    iEventType = ETOMASuplTrigParamTypeUnknown;
    }
EXPORT_C void TOMASuplTriggerParams::SetAreaEventParams(const TOMASuplAreaEventParams areaEventParams)
    {
    iEventType = ETOMASuplAreaEventParams;
    iAreaEventParams = areaEventParams;
    }
EXPORT_C void TOMASuplTriggerParams::SetPeriodicParams(const TOMASuplPeriodicParams periodicEventParams)
    {
    iEventType = ETOMASuplPeriodicParams;
    iPeriodicEventParams = periodicEventParams;
    }

EXPORT_C TInt TOMASuplTriggerParams::GetAreaEventParams(TOMASuplAreaEventParams& areaEventParams)const
    {
    if(iEventType == ETOMASuplPeriodicParams)
        {
        areaEventParams = iAreaEventParams;
        return KErrNone;
        }
    return KErrOMASuplParamNotSet;
    }
EXPORT_C TInt TOMASuplTriggerParams::GetPeriodicParams(TOMASuplPeriodicParams& periodicEventParams)const
    {
    if(iEventType == ETOMASuplPeriodicParams)
        {
        periodicEventParams = iPeriodicEventParams;
        return KErrNone;
        }
    return KErrOMASuplParamNotSet;
    }

EXPORT_C void TOMASuplTriggerParams::GetEventType(TOMASuplTriggerParamsType& aType)const
    {
    aType = iEventType;
    }
EXPORT_C TOMASuplPeriodicParams::TOMASuplPeriodicParams()
    {
    iIsStartTimeSet = EFalse;
    }
EXPORT_C void TOMASuplPeriodicParams::GetSuplPeriodicParams(TInt32& aNoOfFixes,TInt32& aIntervalBetFixes)const
    {
    aNoOfFixes = numberOfFixes;
    aIntervalBetFixes = intervalBetweenFixes;
   
    }
EXPORT_C TInt TOMASuplPeriodicParams::GetStartTimeSet(TInt32& aStartTime)const
    {
    if(iIsStartTimeSet)
        {
        aStartTime = startTime;
        return KErrNone;
        }
    return KErrOMASuplParamNotSet;
    }
EXPORT_C void TOMASuplPeriodicParams::SetSuplPeriodicParams(const TInt32 aNoOfFixes,const TInt32 aIntervalBetFixes)
    {
    numberOfFixes = aNoOfFixes;
    intervalBetweenFixes = aIntervalBetFixes;
    }
EXPORT_C void TOMASuplPeriodicParams::SetStartTimeSet(TInt32 aStartTime)
    {
    iIsStartTimeSet = ETrue;
    startTime = aStartTime;
    }
    
// -----------------------------------------------------------------------------
// COMASuplStart::SetSuplStart() 
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//   			
EXPORT_C void COMASuplTriggeredStart::SetSuplTriggeredStart(COMASuplSETCapabilitiesVer2* aSuplSETCaps,
        COMASuplLocationIdVer2* aSuplLocationId,
        TBool	aeCID)
    {
    delete iLocationId;
    iLocationId = NULL;

    delete iSETCapabilities;
    iSETCapabilities = NULL;

    iSETCapabilities = aSuplSETCaps;
    iLocationId      = aSuplLocationId;
    ieCID            = aeCID;
    }