/*
* Copyright (c) 2006-2008 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:    
*
*/




#include "dtmfpayloadformatwrite.h"

const TUint KDtmfDefSampleRate      = 8000;
const TInt  KDefaultTickPeriodInMs  = 1;

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::CDTMFPayloadFormatWrite
// C++ default constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------------------------
//
CDTMFPayloadFormatWrite::CDTMFPayloadFormatWrite()
    :
    iSampleRate( KDtmfDefSampleRate ), 
    iTickPeriod( KDefaultTickPeriodInMs )
    {
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::NewL
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CDTMFPayloadFormatWrite* CDTMFPayloadFormatWrite::NewL( MDataSink* /*aSink*/ )
    {
    return new( ELeave ) CDTMFPayloadFormatWrite;
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::~CDTMFPayloadFormatWrite
// Destructor.
// ---------------------------------------------------------------------------
//
CDTMFPayloadFormatWrite::~CDTMFPayloadFormatWrite()
    {
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::SinkThreadLogon
// Passes the logon command to the sink clip.
// ---------------------------------------------------------------------------
//
TInt CDTMFPayloadFormatWrite::SinkThreadLogon( 
    MAsyncEventHandler& /*aEventHandler*/ )
    {
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::SinkThreadLogoff
// Passes the logoff command to the sink clip.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::SinkThreadLogoff()
    {
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::SetSinkDataTypeCode
// Set the sink data type to the given FourCC code for the given media.
// ---------------------------------------------------------------------------
//
TInt CDTMFPayloadFormatWrite::SetSinkDataTypeCode( 
    TFourCC aSinkFourCC, 
    TMediaId /*aMediaId*/ )
    {
    iFourCC = aSinkFourCC;
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::CanCreateSinkBuffer
// EmptyBufferL() is not used.
// ---------------------------------------------------------------------------
//
TBool CDTMFPayloadFormatWrite::CanCreateSinkBuffer()
    {
    return EFalse;
    }
    
// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::CreateSinkBufferL
// Create a sink buffer.
// ---------------------------------------------------------------------------
//
CMMFBuffer* CDTMFPayloadFormatWrite::CreateSinkBufferL( 
    TMediaId /*aMediaId*/,
    TBool& /*aReference*/ )
    {
    return NULL;
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::SinkPrimeL
// Passes prime transition to the RTP data sink.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::SinkPrimeL()
    {
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::SinkPlayL
// Passes play transition to the RTP data sink and resets state variables.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::SinkPlayL()
    {
    }
    
// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::SinkPauseL
// Passes pause transition to the RTP data sink.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::SinkPauseL()
    {
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::SinkStopL
// Passes stop transition to the RTP data sink.
// ---------------------------------------------------------------------------
//  
void CDTMFPayloadFormatWrite::SinkStopL()
    {
    }
    
// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::ConfigurePayloadFormatL
// Configure payload encoding parameters.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::ConfigurePayloadFormatL( 
    const TDesC8& /*aConfigParams*/,
    CMccRtpMediaClock& /*aClock*/ )
    {
    delete HBufC::NewL( 10 );
    }    

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::SetSinkPrioritySettings
// Used to tell audio policy whether to mix locally played DTMFs to the record
// stream.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::SetSinkPrioritySettings( 
    const TMMFPrioritySettings& /*aPrioritySettings*/ )
    {
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::StartDTMFToneL
// Starts a timer which sends specified DTMF digit periodically until 
// StopDTMFTone() is called.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::StartDTMFToneL( const TChar /*aTone*/ )
    {
    delete HBufC::NewL( 10 );
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::StopDTMFToneL
// Stops the timer for DTMF digit update packet sending. Starts a timer for 
// sending Final Packet three times according to RFC 2833, section 2.5.1.4.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::StopDTMFToneL()
    {
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::SendDTMFTonesL
// Starts to send DTMF string incrementally until the string is sent.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::SendDTMFTonesL( const TDesC8& /*aTones*/ )
    {
    delete HBufC::NewL( 10 );
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::NotifyStopInDTMFString
// Request to notify client when stop in DTMF string is
// encountered ('w' char).
// ---------------------------------------------------------------------------
//    
void CDTMFPayloadFormatWrite::NotifyStopInDTMFString( TBool /*aFlag*/ )
    {
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::ContinueDTMFStringSending
// Allows a client to continue or cancel the sending of a DTMF string when it 
// was stopped by the use of 'w' char in the string.
// ---------------------------------------------------------------------------
//
TInt CDTMFPayloadFormatWrite::ContinueDTMFStringSending( TBool /*aContinue*/ )
    {
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::CancelDTMFStringSending
// 
// ---------------------------------------------------------------------------
//    
void CDTMFPayloadFormatWrite::CancelDTMFStringSending()
    {
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::HandleTimerEventL
// STATIC METHOD. Passes timer events to the class instance interested
// about them.
// ---------------------------------------------------------------------------
//
TInt CDTMFPayloadFormatWrite::HandleTimerEventL( TAny* /*aObjectPtr*/ )
    {
    delete HBufC::NewL( 10 );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::SinkDataTypeCode
// Return the sink data type (four CC code) for the given media.
// ---------------------------------------------------------------------------
//
TFourCC CDTMFPayloadFormatWrite::SinkDataTypeCode( TMediaId /*aMediaId*/ )
    {
    return iFourCC;    
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::FrameTimeInterval
// Gets audio frame size in milliseconds.
// ---------------------------------------------------------------------------
//
TTimeIntervalMicroSeconds CDTMFPayloadFormatWrite::FrameTimeInterval( 
    TMediaId /*aMediaType*/ ) const
    {
    return TTimeIntervalMicroSeconds( TInt64( 0 ) );
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::Duration
// Gets the duration of the sink clip for the specified media ID.
// ---------------------------------------------------------------------------
//
TTimeIntervalMicroSeconds CDTMFPayloadFormatWrite::Duration( 
    TMediaId /*aMediaType*/ ) const
    {
    return TTimeIntervalMicroSeconds( TInt64( 0 ) );
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::BufferEmptiedL
// Called by RTP data sink. Indicates that DTMF data is sent to the network.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::BufferEmptiedL( CMMFBuffer* /*aBuffer*/ )
    {
    delete HBufC::NewL( 10 );
    }
    
// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::EmptyBufferL
// Not used because DTMF payload formatter generates DTMF independently.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::EmptyBufferL( CMMFBuffer* /*aBuffer*/, 
                                            MDataSource* /*aSupplier*/, 
                                            TMediaId /*aMediaId*/ )
    {
    delete HBufC::NewL( 10 );
    }
                    
// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::PayloadFormat
// Returns payload format used in DTMF encoding.
// ---------------------------------------------------------------------------
//
TDTMFPayloadFormat CDTMFPayloadFormatWrite::PayloadFormat() const
    {    
    return iPayloadFormat;
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::SetPayloadFormat
// Sets payload format used in DTMF encoding.
// ---------------------------------------------------------------------------
//
TInt CDTMFPayloadFormatWrite::SetPayloadFormat( 
    TDTMFPayloadFormat aPayloadFormat )
    {
    iPayloadFormat = aPayloadFormat;
    return KErrNone;
    }
           
// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::DeliverPacketL
// Prepare the RTP packet header and deliver the packet to the datasink.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::DeliverPacketL( 
    CMMFDataBuffer& /*aPayload*/, 
    TBool /*aMarkerBit*/ )
    {
    delete HBufC::NewL( 10 );
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::IsValidDigit
// Check is digit valid DTMF.
// ---------------------------------------------------------------------------
//
TBool CDTMFPayloadFormatWrite::IsValidDigits( 
    const TDesC8& /*aDigits*/ ) const
    {
    return ETrue;
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::HandleControlChar
// Takes care of handling 'p' and 'w' chars in a DTMF string.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::HandleControlChar( const TChar& /*aChar*/ )
    {
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::DoHandleTimerEvent
// Does actions depending on current state on timer event.
// ---------------------------------------------------------------------------
//
TInt CDTMFPayloadFormatWrite::DoHandleTimerEventL()
    {    
    delete HBufC::NewL( 10 );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::EncodeNextDigitL
// Encodes next digit in sequence.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::EncodeNextDigitL()
    {
    delete HBufC::NewL( 10 );
    }
    
// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::DoToneOnActionsL
// Called by sendtimer. Does actions belonging to tone on state and exits
// state when exit conditions are met. Actions to do are: Send update packets
// at certain time interval.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::DoToneOnActionsL( TBool /*aEntryToState*/ )
    {
    delete HBufC::NewL( 10 );
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::DoToneOffActionsL
// Called by sendtimer. Does actions belonging to tone off state and exits
// state when exit conditions are met. Actions include: sending final packets.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::DoToneOffActionsL( TBool /*aEntryToState*/ )
    {
    delete HBufC::NewL( 10 );
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::SendEventSignalToClient
// Signaling about events to the client.
// ---------------------------------------------------------------------------
//
void CDTMFPayloadFormatWrite::SendEventSignalToClient( 
    TMccDtmfEventType /*aEventType*/ ) const
    {
    }

// ---------------------------------------------------------------------------
// CDTMFPayloadFormatWrite::IsValidDigit
// ---------------------------------------------------------------------------
//
TBool CDTMFPayloadFormatWrite::IsValidDigit( const TChar& aTone ) const
    {
    return ( KErrNotFound != iValidDigits.Find( aTone ) );
    }

//  End of File