/*
* Copyright (c) 2004 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:  Generic event and message channel for Connection UI.
*
*/


// INCLUDE FILES
#include <E32std.h>
#include <bldvariant.hrh>

#include "CCnUiGroupChannel.h"
#include "ChatNGCommonUIDs.h"
#include "IMPSCommonUiDebugPrint.h"
#include "IMPSSharedDataDefs.h"
#include "CIMPSSharedDataFactory.h"
#include "IMPSUIDDefs.h"



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

// -----------------------------------------------------------------------------
// CCnUiGroupChannel::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCnUiGroupChannel* CCnUiGroupChannel::NewLC( TInt aGroupId,
                                             TGCChannelID aChannelId,
                                             TBool aTemporary )
    {
    CCnUiGroupChannel* self = new ( ELeave ) CCnUiGroupChannel( aGroupId,
                                                                aChannelId );
    CleanupStack::PushL( self );
    self->ConstructL( aTemporary );
    return self;
    }


// -----------------------------------------------------------------------------
// CCnUiGroupChannel::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCnUiGroupChannel* CCnUiGroupChannel::NewL( TInt aGroupId,
                                            TGCChannelID aChannelId,
                                            TBool aTemporary )
    {
    CCnUiGroupChannel* self = CCnUiGroupChannel::NewLC( aGroupId, aChannelId, aTemporary );
    CleanupStack::Pop( self ); //self
    return self;
    }



// Destructor
CCnUiGroupChannel::~CCnUiGroupChannel()
    {
    CancelListen();
    iKeys.Close();
    delete iSharedData;
    }


// C++ default constructor can NOT contain any code, that
// might leave.
//
CCnUiGroupChannel::CCnUiGroupChannel( TInt aGroupId,
                                      TGCChannelID aChannelId )
        :   iGroupId( aGroupId ),
        iChannelId( aChannelId ),
        iChannelSignaled( EFalse )
    {
    }


// EPOC default constructor can leave.
void CCnUiGroupChannel::ConstructL( TBool aTemporary )
    {
    __ASSERT_DEBUG( ( iChannelId >= 0 ), User::Leave( KErrArgument ) );
    __ASSERT_DEBUG( ( iChannelId <=  KMaxChannelIdValue ), User::Leave( KErrArgument ) );

    __ASSERT_DEBUG( ( iGroupId >= 0 ), User::Leave( KErrArgument ) );
    __ASSERT_DEBUG( ( iGroupId <=  KMaxChannelIdValue ), User::Leave( KErrArgument ) );

    //make channel keys based the global / local mode
    if ( aTemporary == ECnUiGlobalGroup )
        {
        //global ones
        iChannelKey.Format( KGlobalChannelKeyNameFormatter, iChannelId );
        iChannelDataKey.Format( KGlobalChannelDataKeyNameFormatter, iChannelId );

        iSharedData = CIMPSSharedDataFactory::CreatePermanentKeyHandlerL(
                          this, KIMPSConnUiPermanentUid );
        iUid = KIMPSConnUiPermanentUid;
        }

    else
        {
        //group ones
        iChannelKey.Format( KGroupChannelKeyNameFormatter, iGroupId, iChannelId );
        iChannelDataKey.Format( KGroupChannelDataKeyNameFormatter, iGroupId, iChannelId );
        iSharedData = CIMPSSharedDataFactory::CreateTemporaryKeyHandlerL(
                          this, KIMPSConnUiTemporaryUid );
        iUid = KIMPSConnUiTemporaryUid;
        }

    //insert permanent / temporary identifier
    if ( aTemporary )
        {
        iChannelKey.Insert( KGlobalChannelTypeIdPosition,
                            KGlobalChannelTemporaryKeyIdentifier );

        iChannelDataKey.Insert( KGlobalChannelTypeIdPosition,
                                KGlobalChannelTemporaryKeyIdentifier );
        }
    else
        {
        iChannelKey.Insert( KGlobalChannelTypeIdPosition,
                            KGlobalChannelPermanentKeyIdentifier );

        iChannelDataKey.Insert( KGlobalChannelTypeIdPosition,
                                KGlobalChannelPermanentKeyIdentifier );
        }

    User::LeaveIfError( iSharedData->ConvertSharedDataKey( iChannelKey, iKey ) );
    User::LeaveIfError( iSharedData->ConvertSharedDataKey( iChannelDataKey, iDataKey ) );

    // initialize "channel signalled"-flag properly
    TInt current = 0;
    TInt err = iSharedData->GetIntKey( iKey, current );
    if ( err == KErrNotFound )
        {
        // if it was not found, correct value is 0
        err = KErrNone;
        }

    User::LeaveIfError( err );
    iChannelSignaled = current > 0;
    }


// -----------------------------------------------------------------------------
// CCnUiGroupChannel::WriteL()
// -----------------------------------------------------------------------------
//
void CCnUiGroupChannel::WriteL( TInt aMsg )
    {
    User::LeaveIfError( iSharedData->SetIntKey( iKey, aMsg ) );
    }

// -----------------------------------------------------------------------------
// CCnUiGroupChannel::WriteL()
// -----------------------------------------------------------------------------
//
void CCnUiGroupChannel::WriteL( TInt aMsg, const TDesC& aExtraData )
    {
    //write first the extra data
    WriteExtraDataL( aExtraData );

    //and then signal the channel with message
    WriteL( aMsg );
    }



// -----------------------------------------------------------------------------
// CCnUiGroupChannel::Read()
// -----------------------------------------------------------------------------
//
TInt CCnUiGroupChannel::Read( TInt& aMsg )
    {
    TInt msg = 0;

    if ( iSharedData->GetIntKey( iKey, msg ) == KErrNone )
        {
        aMsg = msg;
        IMPSCUI_DP( D_IMPSCUI_LIT( "CCnUiGroupChannel msg[%d] <== [%S]" ),
                    aMsg, &iChannelKey );
        return KErrNone;
        }

    IMPSCUI_DP( D_IMPSCUI_LIT( "CCnUiGroupChannel [msg not found] <== [%S]" ),
                &iChannelKey );
    return KErrNotFound;
    }


// -----------------------------------------------------------------------------
// CCnUiGroupChannel::ReadL()
// -----------------------------------------------------------------------------
//
void CCnUiGroupChannel::ReadL( HBufC*& aExtraData )
    {
    //read the extra data

    HBufC* shBuffer = HBufC::NewLC( KMaxValueSize );
    TPtr ptr = shBuffer->Des();
    TInt err = iSharedData->GetStringKey( iDataKey, ptr );

    if ( err != KErrNone )
        {
        shBuffer->Des().Copy( KNullDesC() );
        }

    aExtraData = shBuffer->AllocL();

    CleanupStack::PopAndDestroy( shBuffer );

    }



// -----------------------------------------------------------------------------
// CCnUiGroupChannel::SignalL()
// -----------------------------------------------------------------------------
//
TInt CCnUiGroupChannel::SignalL()
    {
    if ( iChannelSignaled )
        {
        return KErrInUse;
        }

    User::LeaveIfError( iSharedData->Signal( iKey ) );

    iChannelSignaled = ETrue;

    return KErrNone;
    }


// -----------------------------------------------------------------------------
// CCnUiGroupChannel::SignalL()
// -----------------------------------------------------------------------------
//
TInt CCnUiGroupChannel::SignalL( const TDesC& aExtraData )
    {
    if ( iChannelSignaled )
        {
        return KErrInUse;
        }

    //write first the extra data
    WriteExtraDataL( aExtraData );

    //and then signal the channel
    return SignalL();
    }


// -----------------------------------------------------------------------------
// CCnUiGroupChannel::CancelSignal()
// -----------------------------------------------------------------------------
//
void CCnUiGroupChannel::CancelSignal()
    {
    if ( iChannelSignaled )
        {
        // we can't do anything else except ignore this error
        iSharedData->CancelSignal( iKey );
        iChannelSignaled = EFalse;
        }
    }


// -----------------------------------------------------------------------------
// CCnUiGroupChannel::ListenL()
// -----------------------------------------------------------------------------
//
void CCnUiGroupChannel::ListenL( MCnUiGroupChannelListener* aListener )
    {
    __ASSERT_ALWAYS( !iListener, User::Leave( KErrInUse ) );
    __ASSERT_ALWAYS( aListener, User::Leave( KErrArgument ) );

    User::LeaveIfError( iSharedData->SubscribeSet( iUid, iKey ) );
    iListener = aListener;
    }


// -----------------------------------------------------------------------------
// CCnUiGroupChannel::CancelListen()
// -----------------------------------------------------------------------------
//
void CCnUiGroupChannel::CancelListen()
    {
    if ( iSharedData )
        {
        iSharedData->UnSubscribe( iUid, iKey );
        }
    iListener = NULL;
    }


// -----------------------------------------------------------------------------
// CCnUiGroupChannel::GroupID()
// -----------------------------------------------------------------------------
//
TInt CCnUiGroupChannel::GroupID()
    {
    return iGroupId;
    }


// -----------------------------------------------------------------------------
// CCnUiGroupChannel::ChannelId()
// -----------------------------------------------------------------------------
//
TGCChannelID CCnUiGroupChannel::ChannelId()
    {
    return iChannelId;
    }


// -----------------------------------------------------------------------------
// CCnUiGroupChannel::WriteExtraDataL()
// -----------------------------------------------------------------------------
//
void CCnUiGroupChannel::WriteExtraDataL( const TDesC& aExtraData )
    {
    User::LeaveIfError( iSharedData->SetStringKey( iDataKey, aExtraData ) );
    }


// ---------------------------------------------------------
// CCnUiGroupChannel::HandleTemporaryKeyNotifyL()
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CCnUiGroupChannel::HandleTemporaryKeyNotifyL( const TUid aUid,
                                                   const TIMPSSharedKeys aKey  )
    {
    if ( ( aUid != iUid ) || ( aKey != iKey ) )
        {
        return;
        }

    //Notify came trough the channel key
    //ignore key value corruptions, key value will be
    //rewritten on next client specific change

    TInt receivedMsg( 0 );
    TInt error = iSharedData->GetIntKey( aKey, receivedMsg );

    if ( error == KErrNone )
        {
        IMPSCUI_DP( D_IMPSCUI_LIT( "CCnUiGroupChannel [%S] ==> event[%d] " ),
                    &iChannelKey, receivedMsg );

        if ( iListener )
            {
            iListener->HandleChannelMsg( iGroupId, iChannelId, receivedMsg );
            }
        }

#ifdef IMPSCUI_ENABLE_DEBUG_PRINT
    else
        {
        IMPSCUI_DP( D_IMPSCUI_LIT( "CCnUiGroupChannel [%S] ==> event conversion error [%d] " ),
                    &iChannelKey, error );
        }
#endif //IMPSCUI_ENABLE_DEBUG_PRINT
    }

// ---------------------------------------------------------
// CCnUiGroupChannel::HandlePermanentKeyNotifyL()
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CCnUiGroupChannel::HandlePermanentKeyNotifyL( const TUid aUid,
                                                   const TIMPSSharedKeys aKey  )
    {
    if ( ( aUid != iUid ) || ( aKey != iKey ) )
        {
        return;
        }

    //Notify came trough the channel key
    //ignore key value corruptions, key value will be
    //rewritten on next client specific change

    TInt receivedMsg( 0 );
    TInt error = iSharedData->GetIntKey( aKey, receivedMsg );

    if ( error == KErrNone )
        {
        IMPSCUI_DP( D_IMPSCUI_LIT( "CCnUiGroupChannel [%S] ==> event[%d] " ),
                    &iChannelKey, receivedMsg );

        if ( iListener )
            {
            iListener->HandleChannelMsg( iGroupId, iChannelId, receivedMsg );
            }
        }

#ifdef IMPSCUI_ENABLE_DEBUG_PRINT
    else
        {
        IMPSCUI_DP( D_IMPSCUI_LIT( "CCnUiGroupChannel [%S] ==> event conversion error [%d] " ),
                    &iChannelKey, error );
        }
#endif //IMPSCUI_ENABLE_DEBUG_PRINT
    }

// end of file