void CxeCameraDeviceControlSymbian::handleReserveComplete(int error)
{
    CX_DEBUG_ENTER_FUNCTION();
    OstTrace0( camerax_performance, CXECAMERADEVICECONTROLSYMBIAN_HANDLERESERVECOMPLETE, "msg: e_CX_RESERVE 0" );

    if(state() == PendingRelease) {
        release();
    } else {
        if (!error) {
            powerOn();
        } else {
            emit initModeComplete(CxeErrorHandlingSymbian::map(error));
            setState(Idle);
        }
    }

    CX_DEBUG_EXIT_FUNCTION();
}

// ---------------------------------------------------------------------------------
// CUpnpTmClientProfileService::GetMaxNumProfilesActionL
// @param aAction pointer to action object
// @return Returns upnp error code
// ---------------------------------------------------------------------------------
//
TUpnpErrorCode CUpnpTmClientProfileService::GetMaxNumProfilesActionL( CUpnpAction* aAction )
{
    OstTraceFunctionEntry0( CUPNPTMCLIENTPROFILESERVICE_GETMAXNUMPROFILESACTIONL_ENTRY );
    TUint profileCount;
    TTerminalModeErrorCode ret = iTmServerImpl.GetMaxNumProfiles( profileCount );
    if ( ret != ETerminalModeSuccess )
    {
        OstTrace0( TRACE_ERROR, DUP1_CUPNPTMCLIENTPROFILESERVICE_GETMAXNUMPROFILESACTIONL, "CUpnpTmClientProfileService::GetMaxNumProfilesActionL" );
        return TUpnpErrorCode( ret );
    }
    OstTrace1( TRACE_NORMAL, CUPNPTMCLIENTPROFILESERVICE_GETMAXNUMPROFILESACTIONL, "CUpnpTmClientProfileService::GetMaxNumProfilesActionL;profileCount=%d", profileCount );
    TBuf8<UpnpString::KMaxTUintLength> countBuf;
    countBuf.Num(profileCount);

    aAction->SetArgumentL( KNumProfilesAllowed, countBuf );
    OstTraceFunctionExit0( CUPNPTMCLIENTPROFILESERVICE_GETMAXNUMPROFILESACTIONL_EXIT );
    return EHttpOk;
}

/**
 * Start observing the connection stage changes.
 */
void CNcmDhcpNotifWatcher::StartL()
	{
	OstTraceFunctionEntry0( CNCMDHCPNOTIFWATCHER_START_ENTRY );
	    
	if(!IsActive())
	    {
        iNcmInteralSvr.DhcpProvisionNotify(iStatus);
        SetActive();
	    }
	else
	    {
	    // Report this to NCM connection manager
	    OstTrace0( TRACE_FATAL, CNCMDHCPNOTIFWATCHER_STARTL, "DHCP notifier already actived!" );
	    User::Leave(KErrInUse);
	    }
    
	OstTraceFunctionExit0( CNCMDHCPNOTIFWATCHER_START_EXIT );
	}

void CAcmWriter::WriteCancel()
/**
 * Cancel a write.
 */
{
    OstTraceFunctionEntry0( CACMWRITER_WRITECANCEL_ENTRY );
    // Cancel any outstanding request on the LDD.
    if ( iPort.Acm() )
    {
        OstTrace0( TRACE_NORMAL, CACMWRITER_WRITECANCEL, "CAcmWriter::WriteCancel;\tiPort.Acm() exists- calling WriteCancel on it" );
        iPort.Acm()->WriteCancel();
    }

    // Reset our flag to say there's no current outstanding request. What's
    // already in our buffer can stay there.
    iCurrentRequest.iClientPtr = NULL;
    OstTraceFunctionExit0( CACMWRITER_WRITECANCEL_EXIT );
}

// given a ptr to a parser, fetch a tag - or zero
TUint CParserList::TagForThisParser(const MParser *const aParser) const
	{
	TUint tagIndex = 0;
	for (TInt count = 0; count < iNumberInList; count++)
		{
		if (aParser == iParserList[count]->Parser())
			{
			tagIndex = iParserList[count]->TagIndex();
			break;
			}
		}
	if (!tagIndex)
	    {
	    OstTrace0( TRACE_DUMP, CPARSERLIST_TAGFORTHISPARSER, "EParserNoSuchTag" );
	    }
	__ASSERT_DEBUG(tagIndex, Panic(EParserNoSuchTag));
	return tagIndex;
	}

void CMTPFSEnumerator::RunL()
{
    OstTraceFunctionEntry0( CMTPFSENUMERATOR_RUNL_ENTRY );
    if(iSkipCurrentStorage)
    {
        OstTrace0( TRACE_NORMAL, CMTPFSENUMERATOR_RUNL, "RunL - iSkipCurrentStorage - ETrue." );
        iSkipCurrentStorage = EFalse;
        ScanNextStorageL();
    }
    else if (iEntries.Count() == 0)
    {
        // No entries to process, scan next dir or storage
        ScanNextL();
    }
    else if (iFirstUnprocessed < iEntries.Count())
    {
        ProcessEntriesL();

        // Complete ourselves with current TRequestStatus
        // since we need to run again to either scan a new dir or drive
        // or process more entries
        TRequestStatus* status = &iStatus;
        User::RequestComplete(status, iStatus.Int());
        SetActive();
    }
    else
    {
        switch (iStatus.Int())
        {
        case KErrNone:
            // There are still entries left to be read
            ScanDirL();
            break;

        case KErrEof:
        // There are no more entries
        default:
            // Error, ignore and continue with next dir
            ScanNextL();
            break;
        }
    }
    OstTraceFunctionExit0( CMTPFSENUMERATOR_RUNL_EXIT );
}

// ---------------------------------------------------------
// CDpDte2Tx::WriteTx
// This method puts write pending and signals itself
// (Dte2Tx).
// ---------------------------------------------------------
//
TInt CDpDte2Tx::WriteTx(
    const TAny* aClientBuffer,
    const TInt aLength)
    {
    OstTrace0( TRACE_NORMAL, CDPDTE2TX_WRITETX, "CDpDte2Tx::WriteTx" );
    OstTrace1( TRACE_NORMAL, DUP1_CDPDTE2TX_WRITETX, "CDpDte2Tx:: Port: %u", iDataPort.PortUnit() );

    LOGM1("CDpDte2Tx::WriteTx - Port %d", iDataPort.PortUnit() );

    TInt ret( KErrNone );

    if ( iWritePending )
        {
        //double write
        ret = KErrWrite;
        }
    else if ( 0 > aLength  )
        {
        //underflow
        ret = KErrArgument;
        }
    else if ( 0 != aLength )
        {
        // store pointer of client buffer
        iPendingClientBuffer = ( TAny* ) aClientBuffer;
        iPendingLength = aLength;

        iWritePending = ETrue;

        if ( !IsActive() )
            {
            iRequestActive = ETrue;
            iStatus = KRequestPending;
            SetActive();
            }
        //no else

        iDataPort.SignalDte2Tx();
        ret = KErrNotReady;
        }

    return ret;
    }

/*!
    Tests if CmManagerShim has been created successfully
    earlier. If not, it retries.
 */
bool CpIapItem::isCmManagerAvailable()
{
    OstTraceFunctionEntry0(CPIAPITEM_ISCMMANAGERAVAILABLE_ENTRY);
    bool retval = false;
    if (mCmm == NULL) {
        try {
            mCmm = new CmManagerShim();
            retval = true;
        }
        catch (const std::exception&) {
            OstTrace0(TRACE_NORMAL, CPIAPITEM_ISCMMANAGERAVAILABLE, "CpIapItem::isCmManagerAvailable: Exception caught");
            mCmm = NULL;
        }
    } else {
        retval = true;
    }
    OstTraceFunctionExit0(CPIAPITEM_ISCMMANAGERAVAILABLE_EXIT);
    return retval;
}

void CUT_PBASE_T_USBDI_0479::HostRunL()
	{
	OstTraceFunctionEntry1( CUT_PBASE_T_USBDI_0479_HOSTRUNL_ENTRY, this );
	// Obtain the completion code
	TInt completionCode(iStatus.Int());
	
	if(completionCode == KErrNone)
		{
		// Action timeout
		OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0479_HOSTRUNL, "<Error> Action timeout");
		TestFailed(KErrTimedOut);
		}
	else
		{
		OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_0479_HOSTRUNL_DUP01, "<Error %d> Timeout timer could not complete",completionCode);
		TestFailed(completionCode);
		}
	OstTraceFunctionExit1( CUT_PBASE_T_USBDI_0479_HOSTRUNL_EXIT, this );
	}

void CCdcDataInterface::NotifyDataAvailableCompleted(TInt aError)
/**
 * Called by the active data available notifier object when it completes.
 *
 * @param aError Error.
 */
	{
	OstTraceFunctionEntry0( CCDCDATAINTERFACE_NOTIFYDATAAVAILABLECOMPLETED_ENTRY );
	OstTrace1( TRACE_NORMAL, CCDCDATAINTERFACE_NOTIFYDATAAVAILABLECOMPLETED, 
			"CCdcDataInterface::NotifyDataAvailableCompleted;aError=%d", aError );	
	
	// See comment in WriteCompleted.
	MNotifyDataAvailableObserver* temp = iNotifyDataAvailableObserver;
	iNotifyDataAvailableObserver = NULL;
	OstTrace0( TRACE_NORMAL, CCDCDATAINTERFACE_NOTIFYDATAAVAILABLECOMPLETED_DUP1, 
			"CCdcDataInterface::NotifyDataAvailableCompleted;\tcalled NotifyDataAvailableCompleted on observer" );
	temp->NotifyDataAvailableCompleted(aError);
	OstTraceFunctionExit0( CCDCDATAINTERFACE_NOTIFYDATAAVAILABLECOMPLETED_EXIT );
	}

//------------------------------------------------------------------------------
// CAddBuffer::AddNodeToBuffer()
//------------------------------------------------------------------------------
void CAddBuffer::AddNodeToBufferL( const TDesC8& aUri, 
                                   const TDesC8& aLUID,
                                   const TDesC8& aObject,
                                   const TInt    aStatusRef )
    {
    OstTraceExt1( TRACE_NORMAL, CADDBUFFER_ADDNODETOBUFFERL_LEAF_ENTRY, "ENTRY: CAddBuffer::AddNodeToBufferL;aUri=%s", aUri );
    
    CConnMoNodeElement* newNode = new (ELeave) CConnMoNodeElement();
    
    newNode->iUri.Copy( aUri );
    newNode->iParentLUID.Copy( aLUID );
    newNode->iObject.Copy( aObject );
    newNode->iStatusRef = aStatusRef;
    newNode->iProcessed = EFalse;
    newNode->iLeaf = ETrue;
    
    iBuffer.AppendL( newNode );
    OstTrace0( TRACE_NORMAL, CADDBUFFER_ADDNODETOBUFFERL_LEAF_EXIT, "EXIT: CAddBuffer::AddNodeToBufferL");
    }

 void CSignalIndReq::RunL() 
     {
    OstTrace0( TRACE_NORMAL, CSIGNALINDREQ_RUNL, "CSignalIndReq::RunL" );
    C_TRACE((_L("CSignalIndReq::RunL()")));
     if( iStatus.Int() == KErrNone || iStatus.Int() > 0 ) 
        {
        OstTrace1( TRACE_NORMAL, DUP1_CSIGNALINDREQ_RUNL, "CSignalIndReq::RunL - Completing with;iStatus.Int()=%d", iStatus.Int() );
        C_TRACE((_L("Completing with %d"), iStatus.Int()));
        iClient->SignalIndReceived( iStatus.Int() );
        iClient->SendReceiveSignalInd( iStatus );
        SetActive();
        }
     else
        {
        OstTrace1( TRACE_NORMAL, DUP2_CSIGNALINDREQ_RUNL, "CSignalIndReq::RunL -  delete;iStatus.Int()=%d", iStatus.Int() );
        C_TRACE((_L("CSignalIndReq RunL delete %d"), iStatus.Int()));
        delete this;
        }
     }

// -----------------------------------------------------------------------------
// CMmConferenceCallMessHandler::MapETelCallIdToISACallId
// Utility function that maps an ETel call id to a call id
// in ISA Call Server's format.
// -----------------------------------------------------------------------------
//
TUint8 CMmConferenceCallMessHandler::MapETelCallIdToISACallId(
    const TInt aETelCallId )
    {
TFLOGSTRING("TSY: CMmConferenceCallMessHandler::MapETelCallIdToISACallId");
OstTrace0( TRACE_NORMAL,  CMMCONFERENCECALLMESSHANDLER_MAPETELCALLIDTOISACALLID_TD, "CMmConferenceCallMessHandler::MapETelCallIdToISACallId" );

    TUint8 callId( CALL_MODEM_ID_NONE );

    if ( CALL_MODEM_ID_1 > aETelCallId || CALL_MODEM_ID_7 < aETelCallId )
        {
        callId = CALL_MODEM_ID_NONE;
        }
    else
        {
        callId = static_cast<TUint8>( aETelCallId );
        }

    return callId;
    }

// -----------------------------------------------------------------------------
// DDmcExtension::PowerDown
// Handles the powering down of the extension.
// -----------------------------------------------------------------------------
//
void DDmcExtension::PowerDown(TPowerState aTargetState)
    {
    OstTrace1(TRACE_ENTRY_EXIT, DDMC_POWERDOWN_ENTRY,
              "DMC:KERN_EXTEN: PowerDown() # IN - aTargetState: 0x%x", (TUint)(aTargetState));
    // TPowerState is printed only for debugging purpose. See the values in e32power.h.
    DMC_TRACE((("DMC:KERN_EXTEN: PowerDown() # IN - aTargetState: 0x%x "), aTargetState));

    if (NKern::CurrentContext() == NKern::EInterrupt)
        {
        iPowerDownDfcPtr->Add();
        }
    else
        {
        iPowerDownDfcPtr->Enque();
        }

    OstTrace0(TRACE_ENTRY_EXIT, DDMC_POWERDOWN_RETURN, "DMC:KERN_EXTEN: PowerDown() # OUT");
    DMC_TRACE(("DMC:KERN_EXTEN: PowerDown() # OUT"));
    }

/*!         
   Constructor.
   
   @param[in] itemDataHelper Helper for connecting signals and slots.
   @param[in] iapId Unique ID if the access point this object represents.
   @param[in] iapName Name of the access point this object represents.
   @param[in] destId Unique ID of the destination that contains reference to 
              the access point this object represents.
   @param[in] bearerPlugin Pointer to the object that implements settings view
              for this access point.
 */
CpIapItem::CpIapItem(
    CpItemDataHelper &itemDataHelper,  
    int iapId, 
    const QString &iapName, 
    int destId,
    bool apProtected,
    CpBearerApPluginInterface *bearerPlugin) :
    CpSettingFormEntryItemData(CpSettingFormEntryItemData::ButtonEntryItem, itemDataHelper), 
    mIapId(iapId), 
    mIapName(iapName),
    mDestId(destId),
    mItemDataHelper(&itemDataHelper),
    mBearerPlugin(bearerPlugin),
    mMoveOngoing(false),
    mDialog(0),
    mList(0)
{
    OstTraceFunctionEntry0(CPIAPITEM_CPIAPITEM_ENTRY);
    try {
        mCmm = new CmManagerShim();
    } catch (const std::exception&) {
        OstTrace0(TRACE_NORMAL, CPIAPITEM_CPIAPITEM, "CpIapItem::CpIapItem: Exception caught");
        mCmm = NULL;
    }
    
    // Fix connections
    itemDataHelper.removeConnection(this,SIGNAL(pressed()),this,SLOT(onLaunchView()));
    if (!apProtected) {
        itemDataHelper.addConnection(
            this,
            SIGNAL(longPress(QPointF)),
            this,
            SLOT(showItemMenu(QPointF)));
        itemDataHelper.addConnection(this,SIGNAL(clicked()),this,SLOT(onLaunchView()));
        itemDataHelper.addConnection(
            this,
            SIGNAL(visibleChanged()),
            this, 
            SLOT(updateIap()));
    }
    OstTraceFunctionExit0(CPIAPITEM_CPIAPITEM_EXIT);
}

void CMTPPlaybackProperty::GetDefaultPropertyValueL(TMTPDevicePropertyCode aProp, TUint32& aValue)
    {
    OstTraceFunctionEntry0( DUP1_CMTPPLAYBACKPROPERTY_GETDEFAULTPROPERTYVALUEL_ENTRY );
    switch(aProp)
        {
    case EMTPDevicePropCodeVolume:
        {
        if(iPlaybackVolumeData != NULL)
            {
            aValue = iPlaybackVolumeData->DefaultVolume();            
            }
        else
            {
            aValue = KMTPDefaultPlaybackVolume;
            }
        }
        break;
        
    case EMTPDevicePropCodePlaybackObject:
        {
        aValue = KMTPDefaultPlaybackObject;
        }
        break;
        
    case EMTPDevicePropCodePlaybackContainerIndex:
        {
        aValue = KMTPDefaultPlaybackIndex;
        }
        break;
        
    case EMTPDevicePropCodePlaybackPosition:
        {
        aValue = KMTPDefaultPlaybackPosition;
        }
        break;
        
    default:
        LEAVEIFERROR(KErrArgument, 
                                OstTrace0( TRACE_ERROR, DUP1_CMTPPLAYBACKPROPERTY_GETDEFAULTPROPERTYVALUEL, "Error argument" ));
        }
    OstTraceFunctionExit0( DUP1_CMTPPLAYBACKPROPERTY_GETDEFAULTPROPERTYVALUEL_EXIT );
    }

// ---------------------------------------------------------
// CDpDataBuffer::UsedBytes
// This method gets the amount of used bytes.
// Note that when virtual circular buffer has wrapped around
// there might be iTailWhenWrappedAround > 0 and therefore we
// have to notice that also in calculation. Normally
// iTailWhenWrappedAround == 0.
//
// In other words: When we have data in ebs (enhanced buffer
// space) we have to calculate it too. When
// iTailWhenWrappedAround>0 iTail==0.
//
// t     h               twr
// |     |              n |
// |-------pbs--------|--ebs--|
//
// ---------------------------------------------------------
//
TInt CDpDataBuffer::UsedBytes()
    {
    OstTrace0( TRACE_NORMAL, CDPDATABUFFER_USEDBYTES, "CDpDataBuffer::UsedBytes" );
    LOGM(" CDpDataBuffer::UsedBytes");
    TInt ret( 0 );

    if ( iHead != iTail  )
        {
        if ( iHead > ( iTail + iTailWhenWrappedAround )  )
            {
            ret = iHead - iTail;
            }
        else
            {
            ret = iEnd - iTail - iTailWhenWrappedAround + iHead;
            }
        }

    return ret;
    }

    TInt CUT_PBASE_T_USBDI_1231::Interface1ResumedL(TAny* aPtr)
        {
        OstTraceFunctionEntryExt( CUT_PBASE_T_USBDI_1231_INTERFACE1RESUMEDL_ENTRY, 0 );

        OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_1231_DCUT_PBASE_T_USBDI_1231_DUP16, "====> Interface1ResumedL entry priority = %d", RThread().Priority());

        OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_1231_DCUT_PBASE_T_USBDI_1231_DUP17, "Interface 1 resumed");
        
        CUT_PBASE_T_USBDI_1231* self = reinterpret_cast<CUT_PBASE_T_USBDI_1231*>(aPtr);
        
#ifdef OST_TRACE_COMPILER_IN_USE        
        TInt status = 
#endif        
        self->iInterface1Watcher->CompletionCode();
        
        OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_1231_DCUT_PBASE_T_USBDI_1231_DUP18, "watcher 1 iStatus=%d",status);
                
        OstTraceFunctionExitExt( CUT_PBASE_T_USBDI_1231_INTERFACE1RESUMEDL_EXIT, 0, KErrNone );
        return KErrNone;
        }

// -----------------------------------------------------------------------------
// CSatFlightModeStatus::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSatFlightModeStatus* CSatFlightModeStatus::NewL
        (
        CSatMessHandler* aSatMessHandler,
        CTsySatMessaging* aSatMessaging
        )
    {
    OstTrace0( TRACE_NORMAL,  CSATFLIGHTMODESTATUS_NEWL_TD, "CSatFlightModeStatus::NewL" );
    TFLOGSTRING("TSY: CSatFlightModeStatus::NewL");

    CSatFlightModeStatus* self =
        new( ELeave ) CSatFlightModeStatus(
            aSatMessHandler,
            aSatMessaging );

    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }

void CMTPPbCmdParam::ConstructL(const CMTPPbCmdParam& aParam)
    {
    OstTraceFunctionEntry0( DUP4_CMTPPBCMDPARAM_CONSTRUCTL_ENTRY );
    TMTPPbDataType type(aParam.Type());

    __ASSERT_DEBUG((type > EMTPPbTypeNone && type < EMTPPbTypeEnd), Panic(EMTPPBArgumentErr));
	__ASSERT_ALWAYS_OST((type > EMTPPbTypeNone && type < EMTPPbTypeEnd), OstTrace0( TRACE_ERROR, CMTPPBCMDPARAM_CONSTRUCTL, "Error argument" ), User::Leave(KErrArgument));

    if(type == EMTPPbVolumeSet)
        {
        TMTPPbDataVolume* val = new (ELeave) TMTPPbDataVolume(aParam.VolumeSetL());
        CMTPPbParamBase::SetData(static_cast<TAny*>(val));
        CMTPPbParamBase::SetType(type);
        }
    else
        {
        CMTPPbParamBase::ConstructL(aParam);
        }
    OstTraceFunctionExit0( DUP4_CMTPPBCMDPARAM_CONSTRUCTL_EXIT );
    }