/*

* Copyright (c) 2002-2008 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:  Singleton Data Storage of Accessory Server

*

*/

// INCLUDE FILES

#include "AccSrvServerModel.h"

#include "AccPolGenericIDAccessor.h"

#include "AccPolGenericIDArrayAccessor.h"

#include "AccPolAccessoryPolicy.h"

#include "acc_debug.h"

#include <e32std.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CAccSrvServerModel::CAccSrvServerModel

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CAccSrvServerModel::CAccSrvServerModel() :

    iASYsLoadCompleted( EFalse ),

    iAudioType( EAccMonoAudio ),

    iValueDataObject( NULL, 0, 0 ),

    iAudioLinkOpenCancelled ( EFalse ),

    iAudioLinkCloseCancelled ( EFalse ),

    iSupportedDevices( 0 ),

    iIdleDetected( EFalse )

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::CAccSrvServerModel()" );

    iAccMode.iAccessoryMode     = EAccModeHandPortable;

    iAccMode.iAudioOutputStatus = EFalse;

    iUniqueID = KErrUnknown;

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::CAccSrvServerModel - return" );

    }

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

// CAccSrvServerModel::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAccSrvServerModel::ConstructL()

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::ConstructL()" );

    iConnectionArray.Reset();

    iPhysicalConnectionArray.Reset();

    iRegisteredASYs.Reset();

    iASYThreadID.Reset();

    iASYUniqueID.Reset();

    iThreadIDFilterArray.Reset();

    iCapabilityStorage = CCapabilityStorage::NewL();

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::ConstructL - return void" );

    }

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

// CAccSrvServerModel::NewL

// Two-phased constructor.

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

//

CAccSrvServerModel* CAccSrvServerModel::NewL()

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::NewL()" );

    CAccSrvServerModel* self = new( ELeave ) CAccSrvServerModel;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CAccSrvServerModel::~CAccSrvServerModel()

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::~CAccSrvServerModel()" );

    if ( KErrNotFound != iLastDisconnectedAccessory.UniqueID() )

        {

        //If iLastDisconnectedAccessory is not "empty",

        //then names/values are never removed from AccPolicyDB for that gid.

        TRACE_ASSERT_ALWAYS;

        }

    if ( iConnectionArray.Count() )

        {

        // Not all connections cleared, assert.

        TRACE_ASSERT_ALWAYS;

        }

    if ( iPhysicalConnectionArray.Count() )

        {

        //all possible gids must be handled properly,

        //      i.e. names/values must be removed from AccPolicyDB

        //      for every gid in iPhysicalConnectionArray

        TRACE_ASSERT_ALWAYS;

        }

    iConnectionArray.Close();

    iPhysicalConnectionArray.Close();

    iRegisteredASYs.Close();

    iASYThreadID.Close();

    iASYUniqueID.Close();

    iThreadIDFilterArray.Close();

    delete iCapabilityStorage;

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::~CAccSrvServerModel - return" );

    }

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

// CAccSrvServerModel::IsConnected

//

// Accessory is connected if it can be found from connection array.

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

//

TBool CAccSrvServerModel::IsConnected( const TAccPolGenericID& aGenericID ) const

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::IsConnected()" );

    TBool ret( EFalse );

    if ( KErrNotFound != FindGID( aGenericID, iConnectionArray ) )

        {

        ret = ETrue;

        }

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvServerModel::IsConnected - return %d", ret );

    return ret;

    }

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

// CAccSrvServerModel::IsConnectedL

//

// Accessory is connected if it can be found from connection array.

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

//

void CAccSrvServerModel::IsConnectedL( const TAccPolGenericID& aGenericID ) const

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::IsConnectedL()" );

    if ( !IsConnected( aGenericID ) )

        {

        COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::IsConnectedL - accessory is not connected" );

        User::Leave( KErrArgument );

        }

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::IsConnectedL - return void" );

    }

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

// CAccSrvServerModel::IsConnectedOrDetectedL

//

// Accessory is connected if it can be found from connection array.

// Accessory is detected if it can be found from physical connections array.

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

//

TBool CAccSrvServerModel::IsConnectedOrDetected( const TAccPolGenericID& aGenericID ) const

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::IsConnectedOrDetected()" );

    TBool retval( EFalse );

    if ( IsConnected( aGenericID ) || FindGID( aGenericID, iPhysicalConnectionArray ) >= 0 )

        {

        retval = ETrue;

        }

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::IsConnectedOrDetected - return void" );	

    return retval;

    }            

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

// CAccSrvServerModel::IsConnectedOrDetectedL

//

// Accessory is connected if it can be found from connection array.

// Accessory is detected if it can be found from physical connections array.

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

//

void CAccSrvServerModel::IsConnectedOrDetectedL( const TAccPolGenericID& aGenericID ) const

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::IsConnectedOrDetectedL()" );

    if ( !IsConnected( aGenericID ) )

        {

        if ( KErrNotFound == FindGID( aGenericID, iPhysicalConnectionArray ) )

            {

            User::Leave( KErrArgument );

            }

        }

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::IsConnectedOrDetectedL - return void" );

    } 

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

// CAccSrvServerModel::FindGID

//

// Returns index to GID given as a parameter.

// Comparison is done according HWDeviceID.

// (Comparison can be made also according to the unique DB id)

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

//

TInt CAccSrvServerModel::FindGID( const TAccPolGenericID& aGenericID,

                                  const RArray<TAccPolGenericID>& aArray ) const

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::FindGID()" );

    TInt index( KErrNotFound );

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

        {

        if ( aGenericID.UniqueID() == aArray.operator[](i).UniqueID() )

            {

            index = i;

            break;// found matching GID (according to HWDeviceID)

                  // ->no need to continue

            }

        }

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvServerModel::FindGID - return %d", index );

    return index;

    }

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

// CAccSrvServerModel::AddConnectionL

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

//

void CAccSrvServerModel::AddConnectionL( const TAccPolGenericID& aGenericID )

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::AddConnectionL()" );

    if ( iConnectionArray.Count() >= KMaxGenericIDInstances )

        {

        User::Leave( KErrOverflow );

        }

    else

        {

        iConnectionArray.InsertL( aGenericID, 0 );//i.e. last connected sccessory in index 0

        TAccPolGenericIDAccessor::DebugPrint( aGenericID );

        }

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvServerModel::AddConnectionL - return void - current count = %d", iConnectionArray.Count() );

    }

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

// CAccSrvServerModel::UpdateConnectionL

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

//

void CAccSrvServerModel::UpdateConnectionL( const TAccPolGenericID& aGenericID )

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::UpdateConnectionL()" );

	RemoveConnectionL( aGenericID, EFalse );

	AddConnectionL( aGenericID );

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvServerModel::UpdateConnectionL - return void - current count = %d", iConnectionArray.Count() );  	

    }

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

// CAccSrvServerModel::AddPhysicalConnectionL

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

//

void CAccSrvServerModel::AddPhysicalConnectionL( const TAccPolGenericID& aGenericID )

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::AddPhysicalConnectionL()" );

    if ( iPhysicalConnectionArray.Count() >= KMaxGenericIDInstances )

        {

        User::Leave( KErrOverflow );

        }

    else

        {

        iPhysicalConnectionArray.InsertL( aGenericID, 0 );//i.e. last connected sccessory in index 0

        TAccPolGenericIDAccessor::DebugPrint( aGenericID );

        }

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvServerModel::AddPhysicalConnectionL - return void - current count = %d", iPhysicalConnectionArray.Count() );

    }

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

// CAccSrvServerModel::RemovePhysicalConnectionL

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

//

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::RemovePhysicalConnection()" );

    TInt index( FindGID( aGenericID, iPhysicalConnectionArray ) );

    // KErrNotFound is not an error case since accessory can be detected 

    // (stored in PhysicalConnection array) or connected (stored in Connection array)

    if ( KErrNotFound != index )

        {

        iPhysicalConnectionArray.Remove( index );

        }

    }

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

// CAccSrvServerModel::RemoveConnectionL

//

// Move disconnected gid to "iLastDisconnectedAccessory" for later

// names/values removal from AccPolicyDB.

// This is done while disconnecting accessory(aDisconnect=ETrue).

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

//

void CAccSrvServerModel::RemoveConnectionL( const TAccPolGenericID& aGenericID,

                                            TBool aDisconnect )

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::RemoveConnectionL()" );

    TInt index( FindGID( aGenericID, iConnectionArray ) );

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvServerModel::RemoveConnectionL - handling index %x", index );

    if ( aDisconnect )

        {

        if ( KErrNotFound != iLastDisconnectedAccessory.UniqueID() )

            {

            //If iLastDisconnectedAccessory is not "empty" and its overwritten,

            //then names/values are never removed from from AccPolicyDB for that gid.

            //This is an error.

            TRACE_ASSERT_ALWAYS;

            }

        if ( KErrNotFound != index )

            {

            //This is not an error case since accessory can be

            //detected (stored in PhysicalConnection array) or

            //connected (stored in Connection array)

            COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::RemoveConnectionL - GID stored" );

            iLastDisconnectedAccessory = iConnectionArray[ index ];

            }

        else

            {

            //Try to search accessory from Physical connection array

            TInt ind( FindGID( aGenericID, iPhysicalConnectionArray ) );

            if ( KErrNotFound != ind )

                {

                iLastDisconnectedAccessory = iPhysicalConnectionArray[ ind ];

                }

            }

        }

    //Remove GID from connection array

    //KErrNotFound is not an error case since accessory can be detected 

    //(stored in PhysicalConnection array) or connected (stored in Connection array)

    if ( KErrNotFound != index )

        {

        iConnectionArray.Remove( index );

        }

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::RemoveConnectionL - return void" );

    }

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

// CAccSrvServerModel::CurrentConnectionStatusL

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

//

void CAccSrvServerModel::CurrentConnectionStatusL(

    TAccPolGenericIDArray& aGenericIDArray )

    {

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvServerModel::CurrentConnectionStatusL(0x%x)", &aGenericIDArray );

    if (iConnectionArray.Count() != 0 )

        {

        TAccPolGenericIDArrayAccessor::ReplaceArrayL( aGenericIDArray, iConnectionArray );

        }

    else

        {

        COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::CurrentConnectionStatusL - No connected accessories" );

        }

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::CurrentConnectionStatusL - return void" );

    }

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

// CAccSrvServerModel::FindWithUniqueIDL

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

//

void CAccSrvServerModel::FindWithUniqueIDL( TInt aUniqueID,

                                            TAccPolGenericID& aGenericID ) const

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::FindWithUniqueIDL()" );

    TInt index( 0 );

    TAccPolGenericIDArray genericIDArray;

    TAccPolGenericIDArrayAccessor::ReplaceArrayL( genericIDArray, iConnectionArray );

    index = TAccPolGenericIDArrayAccessor::FindWithUniqueIDL( genericIDArray,

                                                              aUniqueID );

    if ( index < 0 )

        {

        COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::FindWithUniqueIDL - Unique ID not found" );

        }

    else

        {

        aGenericID = iConnectionArray.operator[]( index );

        }

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::FindWithUniqueIDL - return void" );

    }

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

// CAccSrvServerModel::FindWithDeviceAddressL

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

//

TInt CAccSrvServerModel::FindWithDeviceAddressL( TUint64 aDeviceAddress,

                                                 TInt& aUniqueID ) const

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::FindWithDeviceAddressL()" );

    TInt index( 0 );

    TAccPolGenericIDArray genericIDArray;

    TAccPolGenericIDArrayAccessor::ReplaceArrayL( genericIDArray, iConnectionArray );

    index = TAccPolGenericIDArrayAccessor::FindWithDeviceAddressL( genericIDArray,

                                                                   aDeviceAddress );

    if ( index < 0 )

        {

        COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::FindWithDeviceAddressL - Device Address not found" );

        }

    else

        {

        aUniqueID = iConnectionArray.operator[]( index ).UniqueID();

        }

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvServerModel::FindWithDeviceAddressL return %d", index );

    return index;

    }

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

// CAccSrvServerModel::AccessoryMode

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

//

TAccPolAccessoryMode CAccSrvServerModel::AccessoryMode() const

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::AccessoryMode()" );

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvServerModel::AccessoryMode - return 0x%x", iAccMode );

    return iAccMode;

    }

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

// CAccSrvServerModel::GetLastConnectedAccessoryL

//

// Last connected accessory is allways in index 0.

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

//

void CAccSrvServerModel::GetLastConnectedAccessoryL( TAccPolGenericID& aGenericID ) const

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::GetLastConnectedAccessoryL()" );

    if ( iConnectionArray.Count() != 0 )

        {

        aGenericID = iConnectionArray[ 0 ];

        }

    else

        {

        TRACE_ASSERT_ALWAYS;

        User::Leave( KErrGeneral );

        }

    COM_TRACE_( "[AccFW:AccServer] CAccSrvServerModel::GetLastConnectedAccessoryL - return" );

    }