#include <pn_const.h>             // For PN_OBJ_ROUTING_REQ

#include <phonetisi.h>            // For ISI_HEADER_OFFSET_...

//#include "misirouterobjectif.h"  // For MISIRouterObjectIf

const TUint32 KIsiShRouterServiceUID( 0x20026FE7 );

const TUint32 KIsiShPipeHandlerUID( 0x2002E6E2 );

#define ROUTER_OBJECT_IDENTIFIER 0xFA // Only internally agreed inside isi router

#define PIPEHANDLER_OBJECT_IDENTIFIER 0xFB // Only internally agreed inside isi router

    EISIRouterNULLPtr3,

    EISIRouterRouterServiceNULLPtr,

    EISiShPipeHandlerNULLPtr,

    EISIRouterCommunicationManagerNULLPtr,

    EISIRouterNameServiceNULLPtr,

    EISIWrongObjectApiClient,

const TInt KDfcPriority( 5 );

// #define WITHOUT_WRAPPERS_IN_USE //  to be defined on when wrappers are not used anymore

#ifndef WITHOUT_WRAPPERS_IN_USE

#include <iscnokiadefinitions.h> // Only allowed to include when wrappers are used

const TUint16 KFirstUserChannel( EIscNokiaUpdateApplication );

const TUint16 KLastKernelChannel( EIscNokiaLastKernelChannel );

#endif

        MISIRouterObjectIf* aCallback

    C_TRACE( ( _T( "DISIRouter::Connect 0x%x 0x%x 0x%x 0x%x>" ), aUID, aObjId, aCallback, this ) );

    tmp->iUID = aUID;

    TUint8 staticObjId = ReserveStaticObjId( aUID );

    TBool reserved = CheckUIDUniqueness( aUID );

#ifndef WITHOUT_WRAPPERS_IN_USE

    if( reserved )

        NKern::FMSignal( iClientTableFastMutex );

        aObjId = 0xEE;

#endif //WITHOUT_WRAPPERS_IN_USE

        if( KNotInitializedId == staticObjId )

            {

            tmp->iObjId = ReserveNewDynamicObjId();

            ASSERT_RESET_ALWAYS( tmp->iObjId, ( EISIRouterNULLObjId | EDISIRouterTraceId << KClassIdentifierShift ) );

            }

        else

            {

            tmp->iObjId = staticObjId;//  check that dynamic allocation don't return statically reserved object identifiers

            }

        iClientTable[ tmp->iObjId ] = tmp;

        NKern::FMSignal( iClientTableFastMutex );

        aObjId = tmp->iObjId;

#ifndef WITHOUT_WRAPPERS_IN_USE

#endif

    C_TRACE( ( _T( "DISIRouter::Connect 0x%x 0x%x 0x%x<" ), aUID, aObjId, aCallback ) );

TBool DISIRouter::CheckUIDUniqueness( const TInt32 aUID )

    TBool ret(EFalse);

    for( TInt i( 0 ); i < KMaxAmountOfObjId; i++ )

        if( iClientTable[ i ]  && ( iClientTable[ i ]->iUID == aUID ) )

            {

#ifndef WITHOUT_WRAPPERS_IN_USE

            if( aUID <= KLastKernelChannel )

                {

                ret = ETrue;

                }

            else

                {

#endif //WITHOUT_WRAPPERS_IN_USE

                ASSERT_RESET_ALWAYS( 0, ( EISIRouterNotUniqueUID | EDISIRouterTraceId << KClassIdentifierShift ) );

#ifndef WITHOUT_WRAPPERS_IN_USE

                }

#endif //WITHOUT_WRAPPERS_IN_USE

            }

    return ret;

TUint8 DISIRouter::ReserveStaticObjId( const TInt32 aUID )

    C_TRACE( ( _T( "DISIRouter::ReserveStaticObjId 0x%x 0x%x>" ), aUID ) );

            C_TRACE( ( _T( "DISIRouter::ReserveStaticObjId 0x%x 0x%x 0x%x<" ), aUID, iStaticObjIdTable[i]->iUID, iStaticObjIdTable[i]->iObjId ) );

#ifdef WITHOUT_WRAPPERS_IN_USE    

    TUint8 firstAllowedObjId = KFirstAllowedObjId;

#else

    TUint8 firstAllowedObjId = KLastKernelChannel;

#endif

    for( TInt i(firstAllowedObjId); i < KMaxAmountOfObjId; i++ )

        if( !iClientTable[ i ] )

            {

            TBool reserved( EFalse );

            for( TUint8 j = 0; j < iStaticObjIdTable.Count(); j++ )

                {

                if( j == iStaticObjIdTable[ j ]->iObjId )

                    {

                    reserved = ETrue;

                    break;

                    }

                }

            if( !reserved )

                {

                return i;

                }

            }

    return KNotInitializedId;

    iClientTable[ aObjId ] = NULL;

    tmp = NULL;

    return iShClientThreadContainer->AllocateThread( aType );

    iShClientThreadContainer->DeallocateThread( aThread );

EXPORT_C MISIObjectRouterIf* MISIObjectRouterIf::GetIf()

    C_TRACE( ( _T( "MISIObjectRouterIf::GetIf<>" ) ) );

    iShClientThreadContainer = new DISIThreadContainer();

    ASSERT_RESET_ALWAYS( iShClientThreadContainer, ( EISIRouterMemAllocFailure1 | EDISIRouterTraceId << KClassIdentifierShift ) );

    iInitThread = iShClientThreadContainer->AllocateThread( MISIObjectRouterIf::EISIKernelMainThread );

    C_TRACE( ( _T( "DISIRouter::Initialize> this: 0x%x" ), this ) );

    iSelfPtr = this;

    //  comment improve hex or des

    //  nameservice, communication manager, routerservice...

    iStaticObjIdTable.Append( new TStaticId( 123, 0x70 ) ); //  for testing ISI API

    iStaticObjIdTable.Append( new TStaticId( 200, 0x71 ) ); //  for testing ISI API

    iStaticObjIdTable.Append( new TStaticId( 201, 0x72 ) ); //  for testing ISI API

    iStaticObjIdTable.Append( new TStaticId( 202, 0x73 ) ); //  for testing ISI API

    //

#ifndef WITHOUT_WRAPPERS_IN_USE

    // Map all the kernel channels as they used to be

    for( TInt id( KFirstUserChannel ); id < KLastKernelChannel; id++ )

        {

        if ( ( id != KNotInitializedId ) &&

             ( id != PN_OBJ_EVENT_MULTICAST ) &&

             ( id != PN_OBJ_EVENT_MULTICAST ) &&

             ( id != ROUTER_OBJECT_IDENTIFIER ) &&

             ( id != PIPEHANDLER_OBJECT_IDENTIFIER ) ) 

            {        

            iStaticObjIdTable.Append( new TStaticId( id, id ) );

            }

        else

            {

            iStaticObjIdTable.Append( new TStaticId( id, 0xEE ) );

            }

        }

    // Map all the kernel channels as they used to be

#endif // WITHOUT_WRAPPERS_IN_USE

    // ? vaikutus iShClientThreadContainer->DeallocateThread( iInitThread );

    iStaticObjIdTable.Append( new TStaticId( 0xD11BADA1, KNotInitializedId ) );// Make sure no one can get KNotInitializedId obj id

    iStaticObjIdTable.Append( new TStaticId( KCommunicationManagerUID, PN_OBJ_EVENT_MULTICAST ) );

    iStaticObjIdTable.Append( new TStaticId( KNameServiceUID, PN_OBJ_ROUTING_REQ ) );

    iStaticObjIdTable.Append( new TStaticId( KIsiShRouterServiceUID, ROUTER_OBJECT_IDENTIFIER ) );

    iStaticObjIdTable.Append( new TStaticId( KIsiShPipeHandlerUID, PIPEHANDLER_OBJECT_IDENTIFIER ) );

    iShCLTransceiver = new DISICLTransceiver( *this, iInitThread );

    ASSERT_RESET_ALWAYS( iShCLTransceiver, ( EISIRouterNULLPtr1 | EDISIRouterTraceId << KClassIdentifierShift ) ); 

    // All must exist otherways reseted.

    delete iShClientThreadContainer;

    iShClientThreadContainer = NULL;

    delete iShCLTransceiver;

    iShCLTransceiver = NULL;

    if( ( ( aObjId == EIscNokiaUsbPhonetLink ) && ( GET_SENDER_DEV( aMessage.Ptr() ) == PN_DEV_PC ) ) ||

        ( aObjId == PN_OBJ_ROUTING_REQ ) || 

        ( aObjId == PN_OBJ_EVENT_MULTICAST ) ||

        ( aObjId == ROUTER_OBJECT_IDENTIFIER ) ||

        ( aObjId == PIPEHANDLER_OBJECT_IDENTIFIER ) ) 

        // No need to update sender dev and obj id

        C_TRACE( ( _T( "DISIRouter::Send message tx address not needed to updata 0x%x 0x%x>" ), aObjId, GET_SENDER_DEV( aMessage.Ptr() ) ) );

        }

    else

        {

        TUint8* messageBlockPtr( const_cast<TUint8*>( aMessage.Ptr() ) );        

    TInt error = iShCLTransceiver->RouteISIMessage( aMessage );

    C_TRACE( ( _T( "DISIRouter::Send 0x%x 0x%x<" ), &aMessage, aObjId ) );

    NKern::FMWait( iClientTableFastMutex );

    if( iClientTable[ aObjId ] )

        NKern::FMSignal( iClientTableFastMutex );

        ( iClientTable[ aObjId ]->iChannel )->Receive( aMessage ); //may not be safe, consider receive/delete sync

        C_TRACE( ( _T( "DISIRouter::Receive ok 0x%x 0x%x" ), &aMessage, aObjId ) );

        error = ETrue;

        }

    else

        {

        NKern::FMSignal( iClientTableFastMutex );

        C_TRACE( ( _T( "DISIRouter::Receive failed 0x%x 0x%x" ), &aMessage, aObjId ) );

        error = EFalse;

        }

    C_TRACE( ( _T( "DISIRouter::Receive 0x%x 0x%x %d<" ), &aMessage, aObjId, error ) );

    return error;

    Kern::Printf( "ISI Router kext>" );

    Kern::Printf( "ISI Router kext 0x%x<", extension );

    Kern::Printf( "ISI Router kextldd>" );

    Kern::Printf( "ISI Router kextldd 0x%x<", device );

    return device;