/*

* Copyright (c) 2009 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 <ximpobjectfactory.h>

#include <imobjectfactory.h>

#include <simplefactory.h>

#include <imconversationinfo.h>

#include <utf.h>

#include <ximpprotocolconnectionhost.h>

#include <protocolimdatahost.h>

#include <protocolimconversationdatahost.h>

#include <spsettings.h>

#include <cch.h>

#include <cimcachefactory.h>

#include <mimcacheupdater.h>

#include "simpleimconversation.h"

#include "presenceplugincommon.h"

#include "mpresencepluginconnectionobs.h"

#include "simpleimplugindefs.h"

#include "simpleimlogger.h"

// ======== MEMBER FUNCTIONS ========

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

// CPresencePluginGroups::CPresencePluginGroups

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

//

CSimpleImConversation::CSimpleImConversation( 

    MPresencePluginConnectionObs& aObs, MSimpleConnection& aConn,

    TUint aServiceId ):

  	iConnectionObs( &aObs ),

  	iConnection( &aConn ),

  	iServiceId( aServiceId )  	

    {

    }

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

// CSimpleImConversation::NewL

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

//

CSimpleImConversation* CSimpleImConversation::NewL(

    MPresencePluginConnectionObs& aObs,

    MSimpleConnection& aConn, TUint aServiceId)

    { 

    CSimpleImConversation* self = 

        new( ELeave ) CSimpleImConversation ( aObs, aConn, aServiceId );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSimpleImConversation::ConstructL()

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

//

void CSimpleImConversation::ConstructL()

    {

    DP_IMP("CSimpleImConversation::ConstructL")

    iImHandler = TSimpleFactory::NewInstantMessageL( 

        *iConnection, *this );

    iImCacheFactory = CIMCacheFactory::InstanceL();

    }

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

// CSimpleImConversation::~CSimpleImConversation

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

//

CSimpleImConversation::~CSimpleImConversation()

    {

    DP_IMP("CSimpleImConversation::~CSimpleImConversation")

    if ( iImHandler )

        {

        DP_IMP("Close the msg handler")

        iImHandler->Close();

        }

    // Release the imcache, all the conversation will lost here

    if ( iImCacheFactory )

        {

        DP_IMP("Release IM Cache")

        CIMCacheFactory::Release();

        iImCacheFactory = NULL;

        }

    iImCacheUpdater = NULL;

    iHost = NULL;

    }

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

// CSimpleImConversation::SetHost

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

//

void CSimpleImConversation::SetHost( MProtocolImDataHost& aHost )

    {

    DP_IMP("CSimpleImConversation::SetHost")

    iHost = &aHost;

    }

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

// CSimpleImConversation::GetInterface()

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

//

TAny* CSimpleImConversation::GetInterface(

    TInt32 aInterfaceId,

    TIfGetOps aOptions )

    {

    DP_IMP("CSimpleImConversation::GetInterface")

    if ( MProtocolImConversation::KInterfaceId == aInterfaceId )

        {

        return this;

        }

    if ( MXIMPBase::EPanicIfUnknown == aOptions )

        {

        User::Panic( KSimpleImPluginName, KErrExtensionNotSupported );

        }

    return NULL;

    }

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

// CSimpleImConversation::GetInterface() const

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

//

const TAny* CSimpleImConversation::GetInterface(

        TInt32 aInterfaceId, TIfGetOps aOptions ) const

    {

    DP_IMP("CSimpleImConversation::GetInterface")

    if ( MProtocolImConversation::KInterfaceId == aInterfaceId )

        {

        // caller wants this interface

        return const_cast<CSimpleImConversation*>( this );

        }

    if ( MXIMPBase::EPanicIfUnknown == aOptions )

        {

        User::Panic( KSimpleImPluginName, KErrExtensionNotSupported );

        }

    return NULL;

    }

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

// CSimpleImConversation::GetInterfaceId() const

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

//

TInt32 CSimpleImConversation::GetInterfaceId() const

    {

    DP_IMP("CSimpleImConversation::GetInterfaceId")

    return MProtocolImConversation::KInterfaceId;

    }

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

// From MProtocolImConversation.

// CSimpleImConversation::DoSendMessageL()

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

//

void CSimpleImConversation::DoSendMessageL(

    const MImConversationInfo& aImMessage,

    TXIMPRequestId aReqId )

    {

    DP_IMP( "CSimpleImConversation::DoSendMessageL" )

    iCompleted = EFalse;    

    TPtrC16 msgText16 = aImMessage.TextMessage();

    DP_IMP2( "CSimpleImConversation::DoSendMessageL, CONTENT: %S",

        &msgText16 )

    HBufC8* contentData = CnvUtfConverter::ConvertFromUnicodeToUtf8L(

        msgText16 );

    CleanupStack::PushL( contentData );

    const MDesCArray& recipients = aImMessage.RecipientL();

    for ( TInt i = 0; i < recipients.MdcaCount(); i++ )

        {

        TPtrC16 recipientsPtr16 = recipients.MdcaPoint( i );

        HBufC8* recipientsData = CnvUtfConverter::ConvertFromUnicodeToUtf8L(

                    recipientsPtr16 );

        CleanupStack::PushL( recipientsData );

        DP_IMP2( "CSimpleImConversation::DoSendMessageL, RECIPIENT: %S",

            &recipientsPtr16 )

        TInt result = iImHandler->SendInstantMessage( *contentData,

            *recipientsData );

        CleanupStack::PopAndDestroy( recipientsData );

        if ( KErrInUse == result )

            {

            User::Leave( KErrInUse );

            }

        }

    CleanupStack::PopAndDestroy( contentData );

    iXimpId = aReqId;

    }

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

// From MProtocolImConversation.

// CSimpleImConversation::DoForwardMessageL()

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

//

void CSimpleImConversation::DoForwardMessageL(

    const MImConversationInfo& /*aImMessage*/,

    TXIMPRequestId /*aReqId*/ )

    {

    DP_IMP( "CSimpleImConversation::DoForwardMessageL, NOT SUPPORTED" )

    User::Leave( KErrNotSupported );

    }

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

// From MProtocolImConversation.

// CSimpleImConversation::DoSendMessageToGroupL()

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

//

void  CSimpleImConversation::DoSendMessageToGroupL(

    const MImConversationInfo& /*aImMessage*/,

    const TDesC* /*aGroupId*/, TXIMPRequestId /*aReqId*/ )

    {

    DP_IMP( "CSimpleImConversation::DoSendMessageToGroupL, NOT SUPPORTED" )

    User::Leave( KErrNotSupported );

    }

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

// From MProtocolImConversation.

// CSimpleImConversation::DoBlockUsersL()

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

//

TXIMPRequestId CSimpleImConversation::DoBlockUsersL(

    const MDesCArray* /*aUserIds*/,

    TXIMPRequestId /*aReqId*/ )

    {

    DP_IMP( "CSimpleImConversation::DoBlockUsersL, NOT SUPPORTED" )

    User::Leave( KErrNotSupported );

    return TXIMPRequestId();

    }

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

// From MProtocolImConversation.

// CSimpleImConversation::DoUnBlockUsersL()

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

//

TXIMPRequestId CSimpleImConversation::DoUnBlockUsersL(

    const MDesCArray* /*aUserIds*/,

    TXIMPRequestId /*aReqId*/ )

    {

    DP_IMP( "CSimpleImConversation::DoUnBlockUsersL, NOT SUPPORTED" )

    User::Leave( KErrNotSupported );

    return TXIMPRequestId();

    }

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

// From MProtocolImConversation.

// CSimpleImConversation::DoGetBlockedListRequestL()

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

//

void CSimpleImConversation::DoGetBlockedListRequestL(

    const MXIMPIdentity& /*aImMessageId*/,

    TXIMPRequestId /*aReqId*/ )

    {

    DP_IMP( "CSimpleImConversation::DoGetBlockedListRequestL, NOT SUPPORTED" )

    User::Leave( KErrNotSupported );

    }

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

// From MProtocolImConversation.

// CSimpleImConversation::DoGetMessageListL()

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

//

void CSimpleImConversation::DoGetMessageListL(

    const MXIMPIdentity& /*aImMessageId*/,

    const TDesC* /*aGroupId*/,

    const TInt /*aMessageCount*/,

    TBool /*aDeliveryReportWanted*/,

    TXIMPRequestId /*aReqId*/ )

    {

    DP_IMP( "CSimpleImConversation::DoGetMessageListL, NOT SUPPORTED" )

    User::Leave( KErrNotSupported );

    }

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

// From MProtocolImConversation.

// CSimpleImConversation::DoRejectMessageL()

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

//

void CSimpleImConversation::DoRejectMessageL(

    const MXIMPIdentity& /*aImMessageId*/,

    const TDesC& /*aMessageID*/,

    TXIMPRequestId /*aReqId*/ )

    {

    DP_IMP( "CSimpleImConversation::DoRejectMessageL, NOT SUPPORTED" )

    User::Leave( KErrNotSupported );

    }

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

// From MSimpleInstantMsgObserver.

// CSimpleImConversation::SendInstantMsgReqComplete()

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

//

void CSimpleImConversation::SendInstantMsgReqComplete( 

    TInt /*aOpid*/, TInt aStatus)

    {

    DP_IMP("CSimpleImConversation::SendInstantMsgReqComplete")

    CompleteXimpReq( aStatus );

    }

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

// From MSimpleInstantMsgObserver.

// CSimpleImConversation::HandleReceiveTextMessage()

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

//

void CSimpleImConversation::HandleReceiveTextMessage( 

    TPtrC8 aFrom, TPtrC8 aContent )

    {

    DP_IMP( "CSimpleImConversation::HandleReceiveTextMessage" )

    TRAPD( err, DoHandleReceiveTextMessageL( aFrom, aContent ) )

    if ( KErrNone != err )

        {

        // Do nothing

        DP_IMP2( "CSimpleImConversation::HandleReceiveTextMessage, ERROR: %i",

            err )

        }

    }

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

// CSimpleImConversation::CompleteXimpReq()

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

//

void CSimpleImConversation::CompleteXimpReq( TInt aStatus )

    {

    DP_IMP( "CSimpleImConversation::CompleteXimpReq" )

    if ( iCompleted )

        {

        DP_IMP("CSimpleImConversation::CompleteXimpReq return")

        return;

        }

    iCompleted = ETrue;

    iConnectionObs->CompleteReq( iXimpId, aStatus );

    iXimpId = TXIMPRequestId();

    }

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

// CSimpleImConversation::DoHandleReceiveTextMessageL()

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

//

void CSimpleImConversation::DoHandleReceiveTextMessageL( TPtrC8 aFrom,

    TPtrC8 aContent )

    {

    DP_IMP( "CSimpleImConversation::DoHandleReceiveTextMessageL" )

    CreateImCacheUpdaterIfNeededL();

    if ( iHost )

        {

        MXIMPObjectFactory& objFact = iConnectionObs->Host()->ObjectFactory();

        MImObjectFactory& imObjFact = iHost->ImObjectFactory();

        MXIMPIdentity* identity = objFact.NewIdentityLC(); // CS:1

        MImConversationInfo* convinfo = imObjFact.

            NewImConversationInfoLC(); // CS:2

        HBufC16* sendername = CnvUtfConverter::ConvertToUnicodeFromUtf8L(

            aFrom );

        CleanupStack::PushL( sendername ); // CS:3

        identity->SetIdentityL( *sendername );

        CleanupStack::PopAndDestroy( sendername ); // CS:2

        convinfo->SetMessageIdL( identity );

        HBufC16* messagecontent = CnvUtfConverter::ConvertToUnicodeFromUtf8L(

            aContent );

        CleanupStack::PushL( messagecontent ); // CS:3

        convinfo->SetTextMessageL( *messagecontent );

        CleanupStack::PopAndDestroy( messagecontent ); // CS:2

        iHost->ConversationDataHost().HandleNewTextMessageL( convinfo );

        TRAP_IGNORE( iImCacheUpdater->AppendReceiveMessageL(

            identity->Identity(), convinfo->TextMessage() ) );

        CleanupStack::Pop(); // CS:1

        CleanupStack::Pop(); // CS:0

        }

    else

        {

        DP_IMP( " --> PROTOCOL IM DATA HOST IS NULL!" )

        }

    }

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

// CSimpleImConversation::ResolveUsernameL

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

//

void CSimpleImConversation::ResolveUsernameL( 

        TUint aServiceId, RBuf& aUserName ) const

    {

    DP_IMP( "CSimpleImConversation::ResolveUsernameL" )

    CCch* cchApi = CCch::NewLC();

    CCchService* service = cchApi->GetService( aServiceId );

    User::LeaveIfError( service->GetConnectionParameter( 

        ECCHUnknown, ECchUsername, aUserName ) );

    DP_IMP2( "CSimpleImConversation::ResolveUsernameL, USERNAME: %S",

        &aUserName )

    CleanupStack::PopAndDestroy( cchApi );

    }

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

// CSimpleImConversation::CreateImCacheUpdaterIfNeededL()

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

//

void CSimpleImConversation::CreateImCacheUpdaterIfNeededL()

    {

    if ( !iImCacheUpdater )

        {

        DP_IMP( "CSimpleImConversation::CreateImCacheUpdaterIfNeededL," )

        DP_IMP( "CREATING UPDATER" )

        RBuf username;

        CleanupClosePushL( username );

        const TInt KMaxUserNameLength = 255;

        username.CreateL( KMaxUserNameLength );

        ResolveUsernameL( iServiceId, username );

        iImCacheUpdater =

            iImCacheFactory->CreateUpdaterL( iServiceId, username, EFalse );

        CleanupStack::PopAndDestroy( &username );

        }

    }

// End of file