/*

* Copyright (c) 2007 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:  Fetches the presence status,the corresponding presence icon 

                 and its bitmask.

*

*/

// INCLUDE FILES

//for block list

#include <presenceblockinfo.h>

// presence cache

#include <presencecachereader2.h>

#include <mpresencebuddyinfo2.h>

#include "clogsextservicehandler.h"

#include "clogsextensioncchhandler.h"

#include "tlogsextutil.h"

#include "logsextconsts.h"

#include "clogsextpresentitydata.h"

#include "mlogsextservicehandlerobserver.h"

#include "simpledebug.h"

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

// NewL

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

//

CLogsExtServiceHandler* CLogsExtServiceHandler::NewL(

    const TUint32 aServiceId,

    MLogsExtServiceHandlerObserver& aObserver )

    {

    _LOGP("CLogsExtServiceHandler::NewL(): begin %d", aServiceId)

    CLogsExtServiceHandler* self = 

        CLogsExtServiceHandler::NewLC( aServiceId, aObserver );

    CleanupStack::Pop( self );

    _LOG("CLogsExtServiceHandler::NewL(): end" )

    return self;

    }

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

// NewLC

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

//

CLogsExtServiceHandler* CLogsExtServiceHandler::NewLC(    

    const TUint32 aServiceId,

    MLogsExtServiceHandlerObserver& aObserver )

    {

    _LOG("CLogsExtServiceHandler::NewLC(): begin" )

    CLogsExtServiceHandler* self = 

        new( ELeave ) CLogsExtServiceHandler( aServiceId, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    _LOG("CLogsExtServiceHandler::NewLC(): end" )

    return self;

    }

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

// ~CLogsExtServiceHandler

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

//

CLogsExtServiceHandler::~CLogsExtServiceHandler()

    {

    _LOG("CLogsExtServiceHandler::~CLogsExtServiceHandler(): begin" )

    // Trap is easiest approach for this, deletion can occur any time

    // ( user initiated )

    TRAP_IGNORE( UnSubscribePresenceInfosL() );

    delete iCacheReader;

    iPresentityDataArray.ResetAndDestroy();

    _LOG("CLogsExtServiceHandler::~CLogsExtServiceHandler(): end" )

    }

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

// CLogsExtServiceHandler

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

//

CLogsExtServiceHandler::CLogsExtServiceHandler(

    const TUint32 aServiceId,

    MLogsExtServiceHandlerObserver& aObserver) : 

        iServiceId( aServiceId ),        

        iPresentityDataArray( KPresenceFetcherArrayGranularity ),

        iObserver( &aObserver )

    {

    _LOG("CLogsExtServiceHandler::CLogsExtServiceHandler(): begin" )

    _LOG("CLogsExtServiceHandler::CLogsExtServiceHandler(): end" )

    }

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

// ConstructL

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

//

void CLogsExtServiceHandler::ConstructL()

    {

    _LOG("CLogsExtServiceHandler::ConstructL(): begin" )

    iCacheReader = MPresenceCacheReader2::CreateReaderL();

    iCacheReader->SetObserverForSubscribedNotifications(this);

    _LOG("CLogsExtServiceHandler::ConstructL(): end" )  

    }

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

// ServiceId

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

//

TUint32 CLogsExtServiceHandler::ServiceId()

    {

    _LOG("CLogsExtServiceHandler::ServiceId(): start" )

    _LOGP("CLogsExtServiceHandler::iServiceId = %d",iServiceId )

    _LOG("CLogsExtServiceHandler::ServiceId(): finish" )

    return iServiceId;

    }

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

// Tests whether presentity data object exists or not.

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

//

TBool CLogsExtServiceHandler::PresentityDataExists( 

    const TDesC16& aPresentityId )

    {

    TBool fetcherFound( EFalse );    

    _LOG("CLogsExtServiceHandler::PresentityDataExists begin" )

    // check if there is already a presentity data object for the 

    // speciifed presentityid

    CLogsExtPresentityData* presData = NULL;    

    if ( KErrNone == GetPresentityData( aPresentityId, presData ) )

        {            

        fetcherFound = ETrue;    

        }       

    _LOGP("CLogsExtServiceHandler::PresentityDataExists %d", fetcherFound );

    _LOG("CLogsExtServiceHandler::PresentityDataExists end" )

    return fetcherFound;

    }

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

// Gets presentity data object of a certain presentity.

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

//

TInt CLogsExtServiceHandler::GetPresentityData(

        const TDesC& aPresentityId,

        CLogsExtPresentityData*& aPresentityData )

    {

    _LOG("CLogsExtServiceHandler::GetPresentityData begin" )

    TInt error( KErrNotFound );

    TBool dataFound( EFalse );

    // check if there is already a fetcher for the brand

    CLogsExtPresentityData* presData = NULL;

    for ( TInt i = 0 ; i < iPresentityDataArray.Count() && !dataFound; i++ )

        {

        presData = iPresentityDataArray[i];

        if ( presData && aPresentityId == presData->PresentityId() )

            {

            dataFound = ETrue;

            aPresentityData = presData;

            }

        }

    error = dataFound ? KErrNone : KErrNotFound;

    _LOGP("CLogsExtServiceHandler::GetPresentityData() error=%d",error )

    _LOG("CLogsExtServiceHandler::GetPresentityData end" )

    return error;

    }

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

// Adds the specified presentity to this service handler and starts to 

// handle subscription/event handling etc. for this presentity.

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

//

void CLogsExtServiceHandler::AddPresentityL( const TDesC& aPresentityId )

    {

    _LOG("CLogsExtServiceHandler::HandlePresentityL begin" )

    //add presentityData if it not already exists,

    //and start handling the presentity (make subscription if

    //needed and so on)

    DoPresentityDataCreationL( aPresentityId );

    _LOG("CLogsExtServiceHandler::HandlePresentityL end" )

    }

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

// CLogsExtServiceHandler::HandlePresenceReadL()

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

//

void CLogsExtServiceHandler::HandlePresenceReadL(TInt /*aErrorCode*/,

        RPointerArray<MPresenceBuddyInfo2>&  /*aPresenceBuddyInfoList*/)

    {

    //intentionally not implemented

    }

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

// CLogsExtServiceHandler::HandlePresenceNotificationL()

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

//

void CLogsExtServiceHandler::HandlePresenceNotificationL( TInt aErrorCode,

    MPresenceBuddyInfo2* aPresenceBuddyInfo )

    {

    if( aErrorCode == KErrNone && aPresenceBuddyInfo )

        {

        CleanupDeletePushL( aPresenceBuddyInfo );

        TBool showStatus = EFalse;

        TInt index = KErrNotFound;

        MPresenceBuddyInfo2::TAvailabilityValues value = aPresenceBuddyInfo->Availability();

        TPtrC presTextValue = aPresenceBuddyInfo->AvailabilityText();

        TPtrC buddyId = aPresenceBuddyInfo->BuddyId();

        // Presence Cache gives only buddy id and in shown presenties array

        // is only presentity id... so find index of that presentity which

        // buddy id is in buddyinfo object for checking shown presentity

        // from shown presentities array.

        for ( TInt j = 0 ; j < iPresentityDataArray.Count(); j++ )

                { 

                CLogsExtPresentityData* presData = iPresentityDataArray[j];

                if ( buddyId == presData->PresentityId() )

                    {

                    index = j;

                    break;

                    }

                }

        if( index != KErrNotFound )

            {

            showStatus = ETrue;

            if( value == MPresenceBuddyInfo2::EAvailable )

                {

                _LIT( KConvAvailable, "available" );

                presTextValue.Set( KConvAvailable );    

                }

            else if ( value == MPresenceBuddyInfo2::ENotAvailable /*presTextValue == KConvUnavailable*/ )

                {

                // Presence offline value is modified to match branding

                _LIT( KConvOffline, "offline" );

                presTextValue.Set( KConvOffline );

                }

            iObserver->HandlePresentityPresenceStatusL(

                                                iServiceId,

                                                iPresentityDataArray[index]->PresentityId(),                                            

                                                presTextValue,

                                                showStatus );

            }

        CleanupStack::PopAndDestroy( aPresenceBuddyInfo );

        }

    }

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

// Create presentity data object for a presentity.

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

//

void CLogsExtServiceHandler::DoPresentityDataCreationL( 

        const TDesC& aPresentityId )

    {

    _LOG("CLogsExtServiceHandler::DoPresentityDataCreationL begin" )

    if ( !PresentityDataExists( aPresentityId ) )

        {

        CLogsExtPresentityData* presData = 

            CLogsExtPresentityData::NewLC( aPresentityId, *this );

        iPresentityDataArray.AppendL( presData );

        CleanupStack::Pop( presData );

        // check the current state, make subscriptions if necessary, etc.

        CheckServiceHandler();

        }    

    _LOG("CLogsExtServiceHandler::DoPresentityDataCreationL end" )

    }

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

// Subscribe presentity presence

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

//    

void CLogsExtServiceHandler::DoPresentitySubscriptionL( 

        CLogsExtPresentityData& aPresentityData )

    {

    _LOG("CLogsExtServiceHandler::DoPresentitySubscriptionL(): begin" )    

    const TDesC& presentityId = aPresentityData.PresentityId();

    // Watch for changes

    TInt err = iCacheReader->SubscribePresenceBuddyChangeL( presentityId );

    // Synch check

    MPresenceBuddyInfo2* buddy = iCacheReader->PresenceInfoLC( presentityId );

    aPresentityData.SetStatus( CLogsExtPresentityData::ESubscribed );

    if ( buddy )

        {

        // Ownership is transferred

        CleanupStack::Pop(); // buddy

        HandlePresenceNotificationL( KErrNone, buddy );

        }

    _LOG("CLogsExtServiceHandler::DoPresentitySubscriptionL(): end")         

    }

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

// CLogsExtServiceHandler::UnSubscribePresenceInfosL

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

//

void CLogsExtServiceHandler::UnSubscribePresenceInfosL()

    {

    TInt contactsCount = iPresentityDataArray.Count();

    TPtrC subUri(KNullDesC);

    // go through the array of presentityData objects 

    CLogsExtPresentityData* presData = NULL;

    for(TInt i=0;i<contactsCount;i++)

        {

        presData = iPresentityDataArray[i];

            if ( presData )

                {

                iCacheReader->UnSubscribePresenceBuddyChangeL( presData->PresentityId() );

                }

         }  

    }

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

// Determines whether the service handler has to make subscriptions

// and also initiates those. It also informs the service handler 

// oberver in case the status of a presentity should not be displayed

// (e.g. because the presentity is not found from the subscribed buddy

// list anymore)

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

//

void CLogsExtServiceHandler::CheckServiceHandler()

    {

    _LOG("CLogsExtServiceHandler::CheckServiceHandler() begin" )

    _LOG("CLogsExtServiceHandler::CheckServiceHandler() make check!" )

    TRAPD( error , DoCheckServiceHandlerL(); );

    if ( KErrNone != error )

        {

        _LOGP("CLogsExtServiceHandler::CheckServiceHandler()ERROR! = %d",

            error )

        }     

    _LOG("CLogsExtServiceHandler::CheckServiceHandler() end" )

    }

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

// DoCheckServiceHandlerL

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

//

void CLogsExtServiceHandler::DoCheckServiceHandlerL()

    {

    _LOG("CLogsExtServiceHandler::DoCheckServiceHandlerL() begin" )

    // go through the array of presentityData objects 

    CLogsExtPresentityData* presData = NULL;

    for ( TInt i(0); i < iPresentityDataArray.Count(); i++ )

        {        

        presData = iPresentityDataArray[i];

        if ( presData )

            {

            TInt state = presData->Status(); 

            _LOGP("CLogsExtServiceHandler::DoCheckServiceHandlerL():state=%d",

                state )

            // subscribe those presentities which are:

            // 1) not subcribed

            if ( state == CLogsExtPresentityData::EUnsubscribed )

                {

                _LOG("CLogsExtServiceHandler::DoCheckServiceHandlerL()...")

                _LOG("...DoPresentitySubscriptionL( *presData )" )

                DoPresentitySubscriptionL( *presData );

                }                  

            }        

        }           

    _LOG("CLogsExtServiceHandler::DoCheckServiceHandlerL() end" )

    }

//End of file