/*
* Copyright (c) 2005-2006 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:  The Mus ECOM interface implementation of the SIP
*                stack client.
*
*/



#include "mussipcrplugin.h"
#include "muscommon.h"
#include "muslogger.h"
#include "musmanager.h"
#include "musuid.hrh"
#include "musunittesting.h"
#include "mussettings.h"

#include <mussettingskeys.h>
#include <sipstrings.h>
#include <sipstrconsts.h>
#include <sdpdocument.h>
#include <sdpmediafield.h>
#include <sdpcodecstringpool.h>
#include <sdpcodecstringconstants.h>
#include <sdpattributefield.h>

_LIT8( KSendRecv, "sendrecv");                  // For attribute checks
_LIT8( KRecvOnly, "recvonly");                  // For attribute checks
_LIT8( KSendOnly, "sendonly" );                 // For attribute checks

_LIT8(KCapabilities,
"<SIP_CLIENT ALLOW_STARTING=\"YES\">\
<SIP_HEADERS>\
<ACCEPT value=\"application/sdp\"/>\
<ACCEPT_CONTACT value=\"*;+g.3gpp.cs-voice\"/>\
</SIP_HEADERS>\
<SDP_LINES>\
<LINE name=\"m\" value=\"video 0 RTP/AVP 96\">\
<MEDIA_ATTRIBUTE value=\"application:com.nokia.rtvs\"/>\
<MEDIA_ATTRIBUTE value=\"X-application:com.nokia.rtvs\"/>\
</LINE>\
<LINE name=\"m\" value=\"audio 0 RTP/AVP 97\">\
</LINE>\
</SDP_LINES>\
</SIP_CLIENT>");


// -------------------------------------------------------------------------
// Two-phased constructor.
// -------------------------------------------------------------------------
//
CMusSipCrPlugin* CMusSipCrPlugin::NewL()
    {
    MUS_LOG( "mus: [MUSSCR]  -> CMusSipCrPlugin::NewL()" );
    CMusSipCrPlugin* self = new(ELeave) CMusSipCrPlugin;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    MUS_LOG( "mus: [MUSSCR]  <- CMusSipCrPlugin::NewL()" );
    return self;
    }


// -------------------------------------------------------------------------
// C++ destructor.
// -------------------------------------------------------------------------
//
CMusSipCrPlugin::~CMusSipCrPlugin()
    {
    MUS_LOG( "mus: [MUSSCR]  -> CMusSipCrPlugin::~CMusSipCrPlugin()" );
    delete iManager;
    if ( iCloseStringPool )
        {
        SdpCodecStringPool::Close();
        }
    MUS_LOG( "mus: [MUSSCR]  <- CMusSipCrPlugin::~CMusSipCrPlugin()" );
    }


// -------------------------------------------------------------------------
// C++ constructor.
// -------------------------------------------------------------------------
//
CMusSipCrPlugin::CMusSipCrPlugin()
    {
    }


// -------------------------------------------------------------------------
// Symbian second-phase constructor.
// -------------------------------------------------------------------------
//
void CMusSipCrPlugin::ConstructL()
    {
    MUS_LOG( "mus: [MUSSCR]  -> CMusSipCrPlugin::ConstructL()" );
    iManager = CMusManager::NewL();
    
    TRAPD( err, SdpCodecStringPool::OpenL() );
    
    switch ( err )
        {
        case KErrNone:
            {
            //close pool at destructor, not opened by others
            iCloseStringPool = ETrue;
            break;
            }
        
        case KErrAlreadyExists:
            {
            //already opened, do not try to close at destructor
            iCloseStringPool = EFalse;
            break;
            }
        
        default:
            {
            User::Leave( err );
            }
        }
    
    MUS_LOG( "mus: [MUSSCR]  <- CMusSipCrPlugin::ConstructL()" );
    }


// -------------------------------------------------------------------------
// CMusSipCrPlugin::ChannelL
// -------------------------------------------------------------------------
//
TUid CMusSipCrPlugin::ChannelL( RStringF aMethod,
    const TDesC8& /*aRequestUri*/,
    const RPointerArray<CSIPHeaderBase>& /*aHeaders*/,
    const TDesC8& aContent,
    const CSIPContentTypeHeader* /*aContentType*/ )
    {
    MUS_LOG( "mus: [MUSSCR]  -> CMusSipCrPlugin::ChannelL()" );
    
    if ( aMethod == SIPStrings::StringF( SipStrConsts::EOptions ) )
        {
        TUid uid;
        uid.iUid = ( TInt ) CMusManager::ESipOptions;
        MUS_LOG1( "mus: [MUSSCR]     <- CMusSipCrPlugin::ChannelL(): KSipOptions %d",
                  uid.iUid );
        return uid;
        }
    else
        {
        MultimediaSharing::TMusAvailabilityStatus capability
            = iManager->AvailabilityL();

        if( capability < KErrNone || 
            capability >= MultimediaSharing::EErrServerShutDown )
            {
            TUid uid;
            uid.iUid = ( TInt ) CMusManager::ESipInviteNotDesired;
            MUS_LOG1( "mus: [MUSSCR]     <- CMusSipCrPlugin::ChannelL(): \
                      KNotAllowedSipInvite %d", uid.iUid );
            return uid;
            }
        else
            {
            TUid uid;
            uid.iUid = ( TInt ) CMusManager::ESipInviteDesired;
            TBool twoWaySupported = MultimediaSharingSettings::VideoDirectionL() == 
                                    MusSettingsKeys::ETwoWayVideo;
            
            if ( ( aContent.Length() > 0 ) && twoWaySupported )
                {
                MUS_LOG( "mus: [MUSSCR]  2 way supported, parsing SDP..." );
                CSdpDocument* sdpDocument = CSdpDocument::DecodeLC( aContent );
                TBool sendRecv = CheckForSendRecvAttributeL( sdpDocument->MediaFields() );
                if ( sendRecv )
                    {
                    uid.iUid = ( TInt ) CMusManager::ESipInviteDesired2WayVideo;
                    }
                    
                CleanupStack::PopAndDestroy( sdpDocument );
                }

            MUS_LOG1( "mus: [MUSSCR]     <- CMusSipCrPlugin::ChannelL(): \
                      KAllowedSipInvite %d", uid.iUid );
            return uid;
            }
        }
    }

// -------------------------------------------------------------------------
// CMusSipCrPlugin::CheckForSendRecvAttribute
// -------------------------------------------------------------------------
//
TBool CMusSipCrPlugin::CheckForSendRecvAttributeL(
    RPointerArray<CSdpMediaField>& aFields ) const
    {
    MUS_LOG( "mus: [MUSSCR]  -> CMusSipCrPlugin::CheckForSendRecvAttribute()" );
    
    TBool sendRecv = EFalse;
    TBool sendAttrFound = EFalse;
    TBool videoFound = EFalse;
    RStringF videoType = SdpCodecStringPool::StringPoolL().StringF(
                    SdpCodecStringConstants::EMediaVideo,
                    SdpCodecStringPool::StringTableL() );
    const TInt fieldcount = aFields.Count();
    
    for ( TInt i = 0; i < fieldcount && !videoFound; i++ )
        {
        CSdpMediaField* mField = aFields[i];
        
        //only check video fields
        videoFound = mField->Media() == videoType;
        
        if ( videoFound )
            {
            RPointerArray< CSdpAttributeField > attrList =
                mField->AttributeFields();
            
            TInt attrCount = attrList.Count();
            for (TInt j = 0; j < attrCount && !sendAttrFound; j++ )
                {
                CSdpAttributeField* attributeField = attrList[j];
                RStringF attribute = attributeField->Attribute();                
                
                if ( KErrNotFound != attribute.DesC().FindF( KSendRecv ) )
                    {
                    sendRecv = ETrue;
                    sendAttrFound = ETrue;
                    MUS_LOG( "mus: [MUSSCR]  <sendrecv> attribute found!" );
                    }
                else if ( ( KErrNotFound != attribute.DesC().FindF( KSendOnly ) ) ||
                          ( KErrNotFound != attribute.DesC().FindF( KRecvOnly ) ) )
                    {
                    MUS_LOG( "mus: [MUSSCR]  <sendonly>/<recvonly> attribute found!" );
                    sendAttrFound = ETrue;
                    }
                }
            
            if ( !sendAttrFound )
                {
                MUS_LOG( "mus: [MUSSCR]  no send/recv related attributes found!" );
                sendRecv = ETrue;
                }
            }
        }
    MUS_LOG1( "mus: [MUSSCR]  <- CMusSipCrPlugin::CheckForSendRecvAttribute(), \
            sendrecv: %d", sendRecv );
   
    return sendRecv;
    }

// -------------------------------------------------------------------------
// CMusSipCrPlugin::ConnectL
// -------------------------------------------------------------------------
//
void CMusSipCrPlugin::ConnectL( TUid aUid )
    {
    MUS_LOG1( "mus: [MUSSCR]     -> CMusSipCrPlugin::ConnectL( %d )", aUid.iUid );
    if ( aUid.iUid == CMusManager::ESipOptions ||
         aUid.iUid == CMusManager::ESipInviteDesired ||
         aUid.iUid == CMusManager::ESipInviteDesired2WayVideo ||
         aUid.iUid == CMusManager::ESipInviteNotDesired )
        {
        iManager->HandleSipRequestL(( CMusManager::TRequestType ) aUid.iUid );
        }
    else
        {
        MUS_LOG( "mus: [MUSSCR]  <- CMusSipCrPlugin::ChannelL()\
                       ( User::Leave KErrNotSupported )" );
        User::Leave( KErrNotSupported );
        }        
    MUS_LOG( "mus: [MUSSCR]  <- CMusSipCrPlugin::ConnectL()" );
    }


// -------------------------------------------------------------------------
// CMusSipCrPlugin::Capabilities()
// -------------------------------------------------------------------------
//
const TDesC8& CMusSipCrPlugin::Capabilities()
    {
    MUS_LOG( "mus: [MUSSCR]  -> CMusSipCrPlugin::Capabilities()" );
    MUS_LOG( "mus: [MUSSCR]  <- CMusSipCrPlugin::Capabilities()" );
    return KCapabilities;
    }