/*

* Copyright (c) 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:  Implementation for PC Group Interface

*

*/

// INCLUDE FILES

#include "ccagrouppc.h"

#include "MCAStoredGroups.h"

#include "CCAStorageManagerFactory.h"

#include "mcagroupobserverpc.h"

#include "CCAEngine.h"

#include "MCAChatInterface.h"

#include "mcamessageswriteinterface.h"

#include "mcamessagecontainerinfo.h"

#include "MCAStoredGroup.h"

#include "MCAMessage.h"

#include "MCAStoredContacts.h"

#include "MCAGroupEventObserverPC.h"

#include "MCAGroupOperations.h"

#include "MCAGroupManagerInterface.h"

#include "MCAExtendedStoredGroup.h"

#include "MCAMessageUtils.h"

#include "MCAMessageErrorInformer.h"

#include "MCAMessageCreator.h"

#include "CAUtils.h"

#include "CCAServerContactsArrayPC.h"

#include "CAPresenceManager.h"

#include "MCAPresence.h"

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

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

// CCAGroupPC: Constructor

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

//

CCAGroupPC::CCAGroupPC( MCAGroupManagerInterface* aGroupInterface,

                        MCAChatInterface& aChatInterface,

                        const MCAMessageUtils& aMessageUtils  )

        : iGroupInterface( aGroupInterface ),

        iChatInterface( aChatInterface ),

        iMessageUtils( aMessageUtils )

    {

    }

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

// CCAGroupPC: NewL

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

//

CCAGroupPC* CCAGroupPC::NewL( MCAGroupManagerInterface* aGroupInterface,

                              MCAChatInterface& aChatInterface,

                              const MCAMessageUtils& aMessageUtils )

    {

    CCAGroupPC* self = new ( ELeave ) CCAGroupPC( aGroupInterface,

                                                  aChatInterface, aMessageUtils );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCAGroupPC: ConstructL

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

//

void CCAGroupPC::ConstructL(  )

    {

    iStoredGroups = CCAStorageManagerFactory::GroupListInterfaceL();

    iStoredContacts = CCAStorageManagerFactory::ContactListInterfaceL();

    }

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

// CCAGroupPC: Destructor

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

//

CCAGroupPC::~CCAGroupPC()

    {

    }

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

// CCAGroupPC: RegisterGroupObserver

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

//

void CCAGroupPC::RegisterGroupObserver( MCAGroupObserverPC*  aGroupObserverPC )

    {

    ASSERT( aGroupObserverPC );

    iGroupObserverPC = aGroupObserverPC;

    }

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

// CCAGroupPC: UnRegisterGroupObserver

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

//

void CCAGroupPC::UnRegisterGroupObserver()

    {

    iGroupObserverPC = NULL;

    }

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

// CCAGroupPC: SetGroupEventObserverL

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

//

void CCAGroupPC::SetGroupEventObserverL( MCAGroupEventObserverPC* aGroupEventObserverPC,

                                         const TDesC& aGroupId )

    {

    iGroupEventObserverPC = aGroupEventObserverPC;

    if ( !iGroupInterface )

        {

        return;

        }

    // Register this as chat observer

    if ( iGroupEventObserverPC )

        {

        iGroupInterface->SetGroupEventObserverL( aGroupId, this );

        }

    else

        {

        iGroupInterface->SetGroupEventObserverL( aGroupId, NULL );

        }

    }

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

// CCAGroupPC: ActiveGroupId

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

//

const TDesC& CCAGroupPC::ActiveGroupId()

    {

    return iReadInterface->TargetId().Target();

    }

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

// CCAGroupPC: ScreenName

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

//

const TDesC& CCAGroupPC::ScreenName() const

    {

    if ( iReadInterface )

        {

        return iReadInterface->TargetId().ScreenName();

        }

    // Fix warning: #940-D: missing return statement at end of non-void function

    else

        {

        return KNullDesC();

        }

    }

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

// CCAGroupPC: IsLoggingOn

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

//

TBool CCAGroupPC::IsLoggingOn() const

    {

    return iReadInterface->IsLoggingOn();

    }

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

// CCAGroupPC: EndLoggingL

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

//

void CCAGroupPC::EndLoggingL()

    {

    iReadInterface->EndLoggingL();

    }

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

// CCAGroupPC: SaveChatL

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

//

void CCAGroupPC::SaveChatL( const TDesC& aLogFilename )

    {

    iReadInterface->StartLoggingL( aLogFilename );

    if ( iReadInterface->IsLoggingOn() )

        {

        iReadInterface->EndLoggingL();

        }

    }

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

// CCAGroupPC: GetPropertiesL

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

//

TInt CCAGroupPC::GetPropertiesL( TBool& aIsGroupProps )

    {

    if ( !iGrOps )

        {

        return KErrGeneral;

        }

    TInt err( KErrNone );

    err = iGrOps->GetPropertiesL( iGroupProps, iPrivateProps );

    if ( iGroupProps )

        {

        aIsGroupProps = ETrue;

        }

    else

        {

        aIsGroupProps = EFalse;

        }

    return err;

    }

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

// CCAGroupPC: GroupName

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

//

TPtrC CCAGroupPC::GroupName( ) const

    {

    if ( !iGroupProps )

        {

        return KNullDesC();

        }

    return iGroupProps->GroupName();

    }

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

// CCAGroupPC: IsPrivateAllowed

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

//

TEnumsPC::TImpsPropertyBoolPC CCAGroupPC::IsPrivateAllowed()

    {

    return ConvertTImpsPropertyBoolToTEnumsPC( iGroupProps->IsPrivateAllowed() );

    }

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

// CCAGroupPC: IsOpen

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

//

TEnumsPC::TImpsPropertyBoolPC CCAGroupPC::IsOpen()

    {

    return ConvertTImpsPropertyBoolToTEnumsPC( iGroupProps->IsOpen() );

    }

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

// CCAGroupPC::ConvertTImpsPropertyBoolToTEnumsPC

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

//

TEnumsPC::TImpsPropertyBoolPC CCAGroupPC::ConvertTImpsPropertyBoolToTEnumsPC

( TImpsPropertyBool aEventSource )

    {

    switch ( aEventSource )

        {

        case EImpsPropUndef:

            {

            return TEnumsPC::EImpsPropUndef;

            }

        case EImpsPropNo:

            {

            return TEnumsPC::EImpsPropNo;

            }

        case EImpsPropYes:

            {

            return TEnumsPC::EImpsPropYes;

            }

        default:

            {

            return TEnumsPC::EImpsPropUndef;

            }

        }

    }

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

// CCAGroupPC::GroupCount

// (other items were commented in a header).

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

//

TInt CCAGroupPC::GroupCount( TBool aOnlyVisible ) const

    {

    return iStoredGroups->GroupCount( aOnlyVisible );

    }

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

// CCAGroupPC::ContactCount

// (other items were commented in a header).

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

//

TInt CCAGroupPC::ContactCount( TBool aSkipOfflineContacts ) const

    {

    return iStoredContacts->ContactCount( aSkipOfflineContacts );

    }

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

// CCAGroupPC: InitialiseResourcesL

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

//

void CCAGroupPC::InitialiseResourcesL( const TDesC& aGroupId )

    {

    //can be used as data member if used many times

    if ( iGroupId )

        {

        delete iGroupId ;

        iGroupId = NULL;

        }

    iGroupId = aGroupId.AllocL();

    // resolve message read interface

    //read/write interface can be done in ctor after complete refactoring

    iReadInterface =

        &( iChatInterface.MessageReadInterfaceL( KNullDesC, KNullDesC, *iGroupId ) );

    iWriteInterface =

        &( iChatInterface.MessageWriteInterfaceL( KNullDesC, KNullDesC ) );

    iStoredGroup = iStoredGroups->FindGroup( *iGroupId );

    if ( iGroupInterface )

        {

        iGrOps = iGroupInterface->GroupOperationsL( *iGroupId );

        }

    // Register this as chat observer

    iChatInterface.RegisterChatObserver( this );

    //register this as message error observer

    iMessageUtils.MessageErrorInformer().RegisterObserver( this );

    }

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

// CCAGroupPC: ReleaseResources

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

//

void CCAGroupPC::ReleaseResources()

    {

    iChatInterface.UnregisterChatObserver( this );

    iMessageUtils.MessageErrorInformer().UnregisterObserver( this );

    delete iGroupId;

    iGroupId = NULL;

    }

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

// CCAGroupPC: ReadInterface

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

//

MCAMessagesReadInterface& CCAGroupPC::ReadInterfaceL() const

    {

    if ( !iReadInterface )

        {

        User::Leave( KErrGeneral );

        }

    return *iReadInterface;

    }

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

// CCAGroupPC: WriteInterface

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

//

MCAMessagesWriteInterface& CCAGroupPC::WriteInterfaceL() const

    {

    if ( !iWriteInterface )

        {

        User::Leave( KErrGeneral );

        }

    return *iWriteInterface;

    }

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

// CCAGroupPC: HandleChatEvent

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

//

void CCAGroupPC::HandleChatEvent( TChatEventType aEvent, MCAMessage* aMessage )

    {

    if ( aEvent == EUnreadCountChanged && aMessage )

        {

        if ( aMessage->MessageType() != MCAMessage::EMessagePTOP )

            {

            // don't show flasher if this isn't p2p message

            // or if there's no container (this view isn't active)

            return;

            }

        const TDesC& wvid( aMessage->Sender() );

        // nickname or wv-less contact id

        if ( iGroupObserverPC && iStoredContacts )

            {

            iGroupObserverPC->HandleChatEvent( wvid ,

                                               iStoredContacts->Identification( wvid ) ) ;

            }

        }

    }

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

// CCAGroupPC::HandleGroupLeft

// (other items were commented in a header).

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

//

void CCAGroupPC::HandleGroupLeft( TInt aReason )

    {

    if ( iGroupEventObserverPC )

        {

        iGroupEventObserverPC->HandleGroupLeft( aReason );

        }

    }

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

// CCAGroupPC::HandleGroupPropertiesChanged()

// (other items were commented in a header).

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

//

void CCAGroupPC::HandleGroupPropertiesChanged()

    {

    if ( iGroupEventObserverPC )

        {

        iGroupEventObserverPC->HandleGroupPropertiesChanged( );

        }

    }

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

// CCAGroupPC::HandleMessageError()

// (other items were commented in a header).

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

//

void CCAGroupPC::HandleMessageError( TInt aError, MCAMessage* aMessage )

    {

    TPtrC nick( KNullDesC );

    if ( !iGroupObserverPC )

        {

        return;

        }

    if ( aMessage )

        {

        if ( aMessage->ContentType() == MCAMessage::EContentPicture )

            {

            iGroupObserverPC->HandleMessageError( aError );

            return;

            }

        nick.Set( iStoredContacts->Identification( aMessage->Recipient() ) );

        }

    iGroupObserverPC->HandleMessageError( aError, nick );

    }

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

// CCAGroupPC: SendMessageL

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

//

void CCAGroupPC::SendMessageL( const TDesC& aMessageBuffer,

                               CDesCArrayFlat& aRecipients )

    {

    MCAMessageCreator& creator = iMessageUtils.MessageCreator();

    const MCAMessageContainerInfo& info = iReadInterface->TargetId();

    MCAMessageCreator::SMessageData data =

        {

        KMessageDataVersion,

        0,

        KNullDesC,

        KNullDesC,

        info.ScreenName(), // Sender

        info.Target(), // Recipient

        NULL,

        &aRecipients,

        aMessageBuffer,

        KNullDesC8,

        KNullDesC8,

        MCAMessage::EMessageSent

        };

    iWriteInterface->AppendL( creator.CreateMessageL( data ) );

    }

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

// CCAGroupPC: SetActiveGroupChatL

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

//

void CCAGroupPC::SetActiveGroupChatL( const TDesC& aGroupId )

    {

    if ( iGroupId )

        {

        delete iGroupId;

        iGroupId = NULL;

        }

    iGroupId = aGroupId.AllocL();

    iReadInterface =

        &( iChatInterface.MessageReadInterfaceL( KNullDesC, KNullDesC, *iGroupId ) );

    iStoredGroup = iStoredGroups->FindGroup( *iGroupId );

    iGrOps = iGroupInterface->GroupOperationsL( *iGroupId );

    if ( !iGroupId )

        {

        iGroupId = KNullDesC().AllocL();