/*

* 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 the License "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 <phonetisi.h>                    // For ISI_HEADER_SIZE

#include <pn_const.h>                     // For PN_HEADER_SIZE

#include "isiindicationhandler.h"         // For DISIIndicationHandler

#include "isicommunicationmanagertrace.h" // For C_TRACE..

#include "misiobjectrouterif.h"           // For DISICommunicationManager

#include "memapi.h"                       // For MemApi

const TUint8 KMaxAmountOfResources( 255 );

const TUint8 KPnsSubscribedResourcesExtendLength( 12 );

const TUint8 KResourceArraySize( 4 );

// Faults

enum TISIIndincationHandlerFaults

    {

    EISIIndicationHandlerWrongParameter = 0x01,

    EISIIndicationHandlerMemAllocFailure,

    EISIIndicationHandlerMemAllocFailure1,

    EISIIndicationHandlerMemAllocFailure2,

    EISIIndicationHandlerMemAllocFailure3,

    EISIIndicationHandlerMemAllocFailure4,

    EISIIndicationHandlerMemAllocFailure5,

    EISIIndicationHandlerQueNULLPointer,

    EISIIndicationHandlerQueNULLPointer1,

    EISIIndicationHandlerQueNULLPointer2,

    EISIIndicationHandlerQueNULLPointer3,

    EISIIndicationHandlerQueNULLPointer4,

    EISIIndicationHandlerQueNULLPointer5,

    EISIIndicationHandlerQueNULLPointer6,

    EISIIndicationHandlerQueNULLPointer7,

    EISIIndicationHandlerQueNULLPointer8,

    EISIIndicationHandlerQueNULLPointer9,

    EISIIndicationHandlerQueNULLPointer10,

    EISIIndicationHandlerQueNULLPointer11,

    EISIIndicationHandlerQueNULLPointer12,

    EISIIndicationHandlerQueNULLPointer13,

    EISIIndicationHandlerQueNULLPointer14,

    EISIIndicationHandlerQueNULLPointer15,

    EISIIndicationHandlerQueNULLPointer16,

    EISIIndicationHandlerQueNULLPointer17,

    EISIIndicationHandlerQueNULLPointer18,

    EISIIndicationHandlerQueNULLPointer19,

    EISIIndicationHandlerQueNULLPointer20,

    EISIIndicationHandlerQueNULLPointer21,

    EISIIndicationHandlerQueNULLPointer22,

    EISIIndicationHandlerQueNULLPointer23

    };

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

// DISIIndicationHandler::

//

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

//

DISIIndicationHandler::DISIIndicationHandler(

        MISIObjectRouterIf* aRouter

        ) : iRouter( aRouter )

    {

    C_TRACE( ( _T( "DISIIndicationHandler::DISIIndicationHandler 0x%x>" ), &iRouter ) );

    C_TRACE( ( _T( "DISIIndicationHandler::DISIIndicationHandler 0x%x<" ), &iRouter ) );

    }

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

// DISIIndicationHandler::~DISIIndicationHandler

//

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

//

DISIIndicationHandler::~DISIIndicationHandler(

        // None

        )

    {

    C_TRACE( ( _T( "DISIIndicationHandler::~DISIIndicationHandler>" ) ) );

    SDblQueLink*    deviceAnchor = &iDeviceQ.iA;

    SDblQueLink*    next = deviceAnchor->iNext;

    TDeviceIdLink*  deviceLink = NULL;

    SDblQueLink*        serverAnchor = NULL;

    SDblQueLink*        serverNext = NULL;

    TServerIdLink*      serverLink = NULL;

    SDblQueLink*        indicationAnchor = NULL;

    SDblQueLink*        indicationNext = NULL;

    TIndicationLink*    indicationLink = NULL;

    SDblQueLink*        subscriberAnchor = NULL;

    SDblQueLink*        subscriberNext = NULL;

    TSubscriberLink*    subscriberLink = NULL;

    while( deviceAnchor != next )

        {

        deviceLink = _LOFF( next, TDeviceIdLink, iDeviceLink );

        ASSERT_RESET_ALWAYS( deviceLink, ( EISIIndicationHandlerQueNULLPointer1 | EDISIIndicationHandlerTraceId << KClassIdentifierShift ) );

        C_TRACE( ( _T("DISIIndicationHandler::~DISIIndicationHandler device: 0x%x"), deviceLink->iDeviceId ) );

        serverAnchor = &deviceLink->iServerQ.iA;

        serverNext = serverAnchor->iNext;

        while( serverAnchor != serverNext )

            {

            serverLink = _LOFF( serverNext, TServerIdLink, iServerLink );

            ASSERT_RESET_ALWAYS( serverLink, ( EISIIndicationHandlerQueNULLPointer2 | EDISIIndicationHandlerTraceId << KClassIdentifierShift ) );

            indicationAnchor = &serverLink->iIndicationQ.iA;

            indicationNext = indicationAnchor->iNext;

            while( indicationAnchor != indicationNext )

                {

                indicationLink = _LOFF( indicationNext, TIndicationLink, iIndicationLink );

                ASSERT_RESET_ALWAYS( indicationLink, ( EISIIndicationHandlerQueNULLPointer3 | EDISIIndicationHandlerTraceId << KClassIdentifierShift ) );

                C_TRACE( ( _T("DISIIndicationHandler::~DISIIndicationHandler indication: 0x%x"), indicationLink->iIndication ));

                // get next link already in case if particular link is to be deleted

                indicationNext = indicationNext->iNext;

                subscriberAnchor = &indicationLink->iSubscriberQ.iA;

                subscriberNext = subscriberAnchor->iNext;

                while( subscriberAnchor != subscriberNext )

                    {

                    subscriberLink = _LOFF( subscriberNext, TSubscriberLink, iSubscriberLink );

                    ASSERT_RESET_ALWAYS( subscriberLink, ( EISIIndicationHandlerQueNULLPointer4 | EDISIIndicationHandlerTraceId << KClassIdentifierShift ) );

                    C_TRACE( ( _T("DISIIndicationHandler::~DISIIndicationHandler subscriber: 0x%x"), subscriberLink->iObjId ));

                    TBool onlySubscriber( subscriberLink->iSubscriberLink.Alone() );

                    subscriberLink->iSubscriberLink.Deque();

                    delete subscriberLink;

                    subscriberLink = NULL;

                    if( onlySubscriber )

                        {

                        C_TRACE( ( _T("DISIIndicationHandler::~DISIIndicationHandler remove indication: 0x%x"), indicationLink->iIndication ));

                        indicationLink->iIndicationLink.Deque();

                        delete indicationLink;

                        indicationLink = NULL;

                        }

                    // No need to go through rest of subscriberlinks since this one already found and deleted

                    subscriberNext = subscriberAnchor;      

                    }

                }

            indicationAnchor = &serverLink->iIndicationQ.iA;

            indicationNext = indicationAnchor->iNext;

            serverNext = serverNext->iNext;

            if( indicationAnchor == indicationNext )

                {

                // No more indications on the server -> server link can be deleted

                C_TRACE( ( _T("DISIIndicationHandler::~DISIIndicationHandler remove server: 0x%x"), serverLink->iResourceId ));

                serverLink->iServerLink.Deque();

                delete serverLink;

                serverLink = NULL;

                }

            }

        serverAnchor = &deviceLink->iServerQ.iA;

        serverNext = serverAnchor->iNext;

        next = next->iNext;

        if( serverAnchor == serverNext )

            {

            // No more servers on the device -> device link can be deleted

            C_TRACE( ( _T("DISIIndicationHandler::RemoveSubscription remove device: 0x%x"), deviceLink->iDeviceId ));

            deviceLink->iDeviceLink.Deque();

            delete deviceLink;

            deviceLink = NULL;

            }

        }

    C_TRACE( ( _T( "DISIIndicationHandler::~DISIIndicationHandler<" ) ) );

    }

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

// DISIIndicationHandler::Subscribe

//

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

//

void DISIIndicationHandler::Subscribe(

        )

    {

    TUint32 resourceId( 0 );

    TUint8 deviceId( 0 );

    TUint16 objId( 0 );

    if( msgPtr[ ISI_HEADER_OFFSET_SENDERDEVICE ] == PN_DEV_OWN )

        //If any subblocks

        if( msgPtr[ ISI_HEADER_SIZE + APE_COMMGR_SUBSCRIBE_REQ_OFFSET_FILLERBYTE1 ] != 0 )

            {

            TUint8 indication( 0 );

            for( TInt subBlockOffset( ISI_HEADER_SIZE + SIZE_APE_COMMGR_SUBSCRIBE_REQ ); subBlockOffset < msgLength; subBlockOffset += ( SIZE_APE_COMMGR_SUBSCRIBE_SB ) )

                {

                deviceId = msgPtr[ subBlockOffset + APE_COMMGR_SUBSCRIBE_SB_OFFSET_DEVICEID ];

                resourceId = GETB32( &msgPtr[ subBlockOffset + APE_COMMGR_SUBSCRIBE_SB_OFFSET_FILLERBYTE1 ] ); //resource offset

                indication = msgPtr[ subBlockOffset + APE_COMMGR_SUBSCRIBE_SB_OFFSET_RESOURCEID ];

                TDeviceIdLink* deviceLink = GetDeviceLink( deviceId );

                if( !deviceLink )

                    {

                    deviceLink = new TDeviceIdLink();

                    ASSERT_RESET_ALWAYS( deviceLink, ( EISIIndicationHandlerMemAllocFailure | EDISIIndicationHandlerTraceId << KClassIdentifierShift ) );

                    deviceLink->iDeviceId = deviceId;

                    iDeviceQ.Add( &( deviceLink->iDeviceLink ) );

                    }

                AddServer( *deviceLink, resourceId, indication, objId );

                }

            }

#ifdef _DEBUG

#ifdef COMPONENT_TRACE_FLAG

        PrintSubscriptions();

#endif // COMPONENT_TRACE_FLAG

#endif // _DEBUG

        TDeviceIdLink* deviceLink = NULL;

        SDblQueLink* anchor = &iDeviceQ.iA;

        SDblQueLink* next = anchor->iNext;

        while( anchor != next )

            {

            deviceLink = _LOFF( next, TDeviceIdLink, iDeviceLink );

            ASSERT_RESET_ALWAYS( deviceLink, ( EISIIndicationHandlerQueNULLPointer5 | EDISIIndicationHandlerTraceId << KClassIdentifierShift ) );

            if( deviceLink->iDeviceId != PN_DEV_OWN )

                {

                SendSubscription( *deviceLink );

                }

            next = next->iNext;

            }

        }

    else

        {

        TDeviceIdLink* deviceLink = GetExternalDeviceLink( deviceId );

        if( !deviceLink )

            {

            deviceLink = new TDeviceIdLink();

            ASSERT_RESET_ALWAYS( deviceLink, ( EISIIndicationHandlerMemAllocFailure4 | EDISIIndicationHandlerTraceId << KClassIdentifierShift ) );

            deviceLink->iDeviceId = deviceId;

            }

        else

            {

            SDblQueLink* serverAnchor = NULL;

            SDblQueLink* serverNext = NULL;

            TServerIdLink* serverLink = NULL;

            serverAnchor = &deviceLink->iServerQ.iA;

            serverNext = serverAnchor->iNext;

            while( serverAnchor != serverNext )

                {

                serverLink = _LOFF( serverNext, TServerIdLink, iServerLink );

                ASSERT_RESET_ALWAYS( serverLink, ( EISIIndicationHandlerQueNULLPointer6 | EDISIIndicationHandlerTraceId << KClassIdentifierShift ) );

                serverLink->iServerLink.Deque();

                delete serverLink;

                serverLink = NULL;

                serverNext = serverNext->iNext;           

                }

            }

        for( TInt subBlockOffset( ISI_HEADER_SIZE + PNS_SUBSCRIBED_RESOURCES_EXTEND_IND_OFFSET_RESOURCELIST );

            subBlockOffset < msgLength; subBlockOffset += KResourceArraySize )

            {

            resourceId = GETB32( &msgPtr[ subBlockOffset ] );

            AddServer( *deviceLink, resourceId );

            }

        }

    C_TRACE( ( _T( "DISIIndicationHandler::Subscribe<" ) ) );

    }

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

// DISIIndicationHandler::AddServer

//

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

//

void DISIIndicationHandler::AddServer(

        TDeviceIdLink& aDeviceLink,

        const TUint32 aResourceId,

        const TUint8 aIndication,

        const TUint16 aObjId

        )

    {

    C_TRACE( ( _T( "DISIIndicationHandler::AddServer 0x%x 0x%x 0x%x 0x%x>" ), &aDeviceLink, aResourceId, aIndication, aObjId ) );

    TServerIdLink* serverLink = GetServerLink( aDeviceLink, aResourceId );

    if( !serverLink )

        {

        C_TRACE( ( _T("DISIIndicationHandler::AddServer resource: 0x%x not found, create"), aResourceId ));

        serverLink = new TServerIdLink();

        ASSERT_RESET_ALWAYS( serverLink, ( EISIIndicationHandlerMemAllocFailure1 | EDISIIndicationHandlerTraceId << KClassIdentifierShift ) );

        serverLink->iResourceId = aResourceId;

        aDeviceLink.iServerQ.Add( &( serverLink->iServerLink ) );

        }

    AddIndication( *serverLink, aIndication, aObjId );

    C_TRACE( ( _T( "DISIIndicationHandler::AddServer 0x%x 0x%x 0x%x 0x%x<" ), &aDeviceLink, aResourceId, aIndication, aObjId ) );

    }

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

// DISIIndicationHandler::AddServer

//

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

//

void DISIIndicationHandler::AddServer(

        TDeviceIdLink& aDeviceLink,

        const TUint32 aResourceId

        )

    {

    C_TRACE( ( _T( "DISIIndicationHandler::AddServer external 0x%x 0x%x>" ), &aDeviceLink, aResourceId ) );

    TServerIdLink* serverLink = GetServerLink( aDeviceLink, aResourceId );

    if( !serverLink )

        {

        C_TRACE( ( _T("DISIIndicationHandler::AddServer external resource: 0x%x not found, create"), aResourceId ));

        serverLink = new TServerIdLink();

        ASSERT_RESET_ALWAYS( serverLink, ( EISIIndicationHandlerMemAllocFailure5 | EDISIIndicationHandlerTraceId << KClassIdentifierShift ) );

        serverLink->iResourceId = aResourceId;

        aDeviceLink.iServerQ.Add( &( serverLink->iServerLink ) );

        }

    C_TRACE( ( _T( "DISIIndicationHandler::AddServer 0x%x 0x%x<" ), &aDeviceLink, aResourceId ) );

    }

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

// DISIIndicationHandler::AddIndication

//

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

//

void DISIIndicationHandler::AddIndication(

        TServerIdLink& aServerLink,

        const TUint8 aIndication,

        const TUint16 aObjId

        )

    {

    C_TRACE( ( _T( "DISIIndicationHandler::AddIndication 0x%x 0x%x 0x%x>" ), &aServerLink, aIndication, aObjId ) );

    TIndicationLink* indicationLink = GetIndicationLink( aServerLink, aIndication );

    if( !indicationLink )

        {

        C_TRACE( ( _T("DISIIndicationHandler::AddIndication Indication: 0x%x not found, create"), aIndication ));

        indicationLink = new TIndicationLink();

        ASSERT_RESET_ALWAYS( indicationLink, ( EISIIndicationHandlerMemAllocFailure3 | EDISIIndicationHandlerTraceId << KClassIdentifierShift ) );

        indicationLink->iIndication = aIndication;

        aServerLink.iIndicationQ.Add( &( indicationLink->iIndicationLink ) );

        }

    AddSubscriber( *indicationLink, aObjId );

    C_TRACE( ( _T( "DISIIndicationHandler::AddIndication 0x%x 0x%x 0x%x<" ), &aServerLink, aIndication, aObjId ) );

    }

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

// DISIIndicationHandler::AddSubscriber

//

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

//

void DISIIndicationHandler::AddSubscriber(

        TIndicationLink& aIndicationLink,

        const TUint16 aObjId

        )

    {

    C_TRACE( ( _T( "DISIIndicationHandler::AddSubscriber 0x%x, 0x%x>" ), &aIndicationLink, aObjId ) );

    TSubscriberLink* subscriberLink = GetSubscriberLink( aIndicationLink, aObjId );

    if( !subscriberLink )

        {

        C_TRACE( ( _T("DISIIndicationHandler::AddSubscriber Subscriber not found: 0x%x 0x%x"), aIndicationLink.iIndication, aObjId ) );

        subscriberLink = new TSubscriberLink();

        ASSERT_RESET_ALWAYS( subscriberLink, ( EISIIndicationHandlerMemAllocFailure2 | EDISIIndicationHandlerTraceId << KClassIdentifierShift ) );

        subscriberLink->iObjId = aObjId;

        aIndicationLink.iSubscriberQ.Add( &( subscriberLink->iSubscriberLink ) );

        }

    else

        {

        TRACE_ASSERT_INFO(0, (TUint8)aObjId<<KObjIdShift);

        C_TRACE( ( _T( "DISIIndicationHandler::AddSubscriber double subscription 0x%x" ), aObjId ) );