/*

* Copyright (c) 2002-2006 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:  Private, Accessory Policy

*

*/

// INCLUDE FILES

#include <AccPolCommonNameValuePairs.h>

#include <AccPolSubblockNameArray.h>

#include <AccessoryTypes.h>

#include <featmgr.h>

#include "AccPolGenericIDAccessor.h"

#include "AccPolNameValueArraySerial.h"

#include "AccPolAccessoryPolicy.h"

#include "AccPolSubblockNameArrayAccessor.h"

#include "acc_debug.h"

#include "AccPolicyDB.h"

#include "AccPolGenericIDArrayAccessor.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KAccMaxRules = 7;

const TInt  KAccConfigMaxCapabilityGroups = 64;

const TInt  KAccGidIntBuf                 = 100;

const TInt  KCapabilityGroupMaxLength     = 12;//32 bit number presented in decimal format is 10 character lenght

// bit mask

const TUint8 KDT  = 0x1;        // 00000001

const TUint8 KPC  = 0x2;        // 00000010

const TUint8 KAP  = 0x4;        // 00000100

const TUint8 KCG  = 0x8;        // 00001000

const TUint8 KDI  = 0x10;       // 00010000

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

struct TAccPolMultibleConnectionRules

    {

    TUint32 iPhysicalConnection;

    TUint32  iCapabiltyName;

    };

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CAccPolAccessoryPolicy::CAccPolAccessoryPolicy

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

// might leave.

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

//

CAccPolAccessoryPolicy::CAccPolAccessoryPolicy( CCapabilityStorage * aCapabilityStorage )

  : iCapabilityStorage( aCapabilityStorage ),

    iCriticalCaps( EFalse )

    {

    API_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::CAccPolAccessoryPolicy()" );

    API_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::CAccPolAccessoryPolicy() - return void" );

    }

// Destructor

    {

    API_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::~CAccPolAccessoryPolicy()" );

    API_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::~CAccPolAccessoryPolicy() - return void" );

    }

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

// TAccPolGenericID::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAccPolAccessoryPolicy::ConstructL()

    {

    API_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::ConstructL()" );

    API_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::ConstructL() - return void" );

    }

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

// TAccPolGenericID::NewL

// Two-phased constructor.

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

//

EXPORT_C CAccPolAccessoryPolicy* CAccPolAccessoryPolicy::NewL( 

    CCapabilityStorage * aCapabilityStorage )

    {

    API_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::NewL()" );

    CAccPolAccessoryPolicy* self = new( ELeave ) CAccPolAccessoryPolicy( aCapabilityStorage );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    API_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::CAccPolAccessoryPolicy::NewL() - return" );

    return self;

    }

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

// CAccPolAccessoryPolicy::ResolveCriticalCapabilitiesL

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

//

EXPORT_C void CAccPolAccessoryPolicy::ResolveCriticalCapabilitiesL(

    const TAccPolGenericID& aGenericID,

    CAccPolSubblockNameArray& aCriticalCapabilities )

    {

    API_TRACE_1( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::ResolveCriticalCapabilitiesL() UniqueId: %d", aGenericID.UniqueID() );

    if( !iCriticalCaps )

        {

        //At first time, read all critical capabilities from AccessoryPolicyDB and store them to capability storage.           

        GetAllCriticalCapabilitiesL();

        iCriticalCaps = ETrue;

        }

    iCapabilityStorage->ResolveCriticalCapabilitiesL( aGenericID, aCriticalCapabilities );    

    API_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::ResolveCriticalCapabilitiesL - return void" );

    }

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

// CAccPolAccessoryPolicy::GetAllCriticalCapabilities

//

// Critical capabilities are read from Policy DB

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

//

EXPORT_C void CAccPolAccessoryPolicy::GetAllCriticalCapabilitiesL() const

    {

    API_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::GetAllCriticalCapabilitiesL()" );

    TUint32 name( 0 ); 

	TInt32  value( 0 );

	TInt capabilityCount( 0 );    

    CAccPolicyDB* db = CAccPolicyDB::NewL();

    CleanupStack::PushL( db );

    TRAPD( err, db->OpenDBL() );

    if ( KErrNone == err )

        {

        // Check do we use type as extra search criteria

        capabilityCount = db->ReadAllCriticalCapabilitiesL();

        //Go throught all critical capabilities and store them

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

	        {        

	        db->GetNextCriticalCapabilityL( name, value );//Get next capability from filtered view...

	        iCapabilityStorage->SetCriticalCapabilityL( name, EAPVNotDefined, EAPVInt, value ); //...and store it 

	        }

        }

    else

        {

        // No need to leave. Result of this is that GenericID contains

        // unique ID with value KErrNotFound.

        capabilityCount = 0;

        }

    db->CloseDB();

    CleanupStack::PopAndDestroy( db );

    API_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::GetAllCriticalCapabilitiesL - return void" );

    }

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

// CAccPolAccessoryPolicy::IsValidConnectionL

//

// Check if connection of the accessory is allowed.

// Connection is allowed if all critical capabilities have non-critical value.

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

//

EXPORT_C TAccSrvConnection CAccPolAccessoryPolicy::IsValidConnectionL(

    const TAccPolGenericID& aGenericID,

    TInt& aError )

    {

    API_TRACE_1( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::IsValidConnectionL() 0x%x", aGenericID.UniqueID() );

    TAccSrvConnection         ret( EAccSrvConnect );

    //Chek if all critical capabilities have correct value

    if( !iCapabilityStorage->CompareCriticalValuesL( aGenericID ) )

        {

        ret = EAccSrvDetect;

        }

    //*************************************************************************

    // BT-specific connection checkings

    //

    // 1. It is not possible to connect more than one

    //    Bluetooth Handsfree Profile accessory at any time.

    // 2. It is not possible to connect a Bluetooth Handsfree Profile accessory

    //    while in Bluetooth Headset Profile mode.

    // 3  It is not possible to connect a Bluetooth Headset Profile accessory

    //    while in Bluetooth Handsfree Profile accessory mode.

    // 4. It is not possible to connect more than one

    //    Bluetooth Headset Profile accessory at any time.

    //*******************************************************************

    if( aGenericID.PhysicalConnectionCaps( KPCBluetooth ) )

        {

        API_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::IsValidConnectionL() - BT checks" );

        CAccPolSubblockNameArray* nameArray = CAccPolSubblockNameArray::NewL();

        CleanupStack::PushL( nameArray );

        if( iCapabilityStorage->GetCapability( aGenericID, KAccBTHSP))

            {

            // Accessory supports Headset Profile (HSP).

            if( iCapabilityStorage->CapabilityInUse( aGenericID, KAccBTHSP ))

                {

                // Accessory with Headset Profile (HSP) is allready connected

                // #4

                aError = KErrInUse;

                }

            if( iCapabilityStorage->CapabilityInUse( aGenericID, KAccBTHFP ) )

                {

                // Accessory with Handsfree Profile (HFP) is allready connected

                // #3

                aError = KErrInUse;

                }

            }

        if( iCapabilityStorage->GetCapability( aGenericID, KAccBTHFP)  )

            {

            //Accessory supports Handsfree Profile (HFP).

            if( iCapabilityStorage->CapabilityInUse( aGenericID, KAccBTHSP ) )

                {

                // Accessory with Headset Profile (HSP) is allready connected

                // #2

                aError = KErrInUse;

                }

            if( iCapabilityStorage->CapabilityInUse( aGenericID, KAccBTHFP ) )

                {

                // Accessory with Handsfree Profile (HFP) is allready connected

                // #1

                aError = KErrInUse;

                }

            }

        CleanupStack::PopAndDestroy( nameArray );

        }

    API_TRACE_1( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::IsValidConnectionL() - return %d", ret );

    return ret;

    }

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

// CAccPolAccessoryPolicy::ResolveAccessoryModeL

// Resolve the accessory mode based on the given set of accessories.

// (other items were commented in a header).

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

//

EXPORT_C TAccPolAccessoryMode CAccPolAccessoryPolicy::ResolveAccessoryModeL(

    const TAccPolGenericIDArray& aGenericIDArray,

    const TInt aPresentUniqueID,

    const TBool aCurrentAudioOutputStatus,

    const TAccPolAccessoryMode aCurrentAccessoryMode,

    const TInt aCurrentAudioOutputStatusUniqueID )

    {

    COM_TRACE_3( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::ResolveAccessoryModeL(mode=%d dbID=%d audio=%d)", aCurrentAccessoryMode.iAccessoryMode, aPresentUniqueID, aCurrentAudioOutputStatus );

    TAccPolAccessoryMode accMode( aCurrentAccessoryMode );

    switch ( aPresentUniqueID )

        {

        // KErrUnknown means that HandleAccessoryModeChanged() is

        // NOT called via AudioRoutingStatusNotify() method.

        case KErrUnknown:

            {

            // Check current mode, if audio is already routed.

            if( aCurrentAccessoryMode.iAudioOutputStatus && aGenericIDArray.Count() > 0 )

                {

                TInt index( TAccPolGenericIDArrayAccessor::FindWithUniqueIDL( 

                    aGenericIDArray, aCurrentAudioOutputStatusUniqueID ) );

                if ( KErrNotFound != index )

                    {

                    // Audio is routed to current GID, so resolve mode because this can be accessory settings case.

                    SetAccessoryModeL( aGenericIDArray.GetGenericIDL( index ), accMode );

                    if( accMode.iAccessoryMode == aCurrentAccessoryMode.iAccessoryMode )

                        {

                        accMode.iAudioOutputStatus = aCurrentAccessoryMode.iAudioOutputStatus;

                        }

                    COM_TRACE_2( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::ResolveAccessoryModeL - set mode according to current audio output status UniqueID, (UniqueID=%d, mode=%d) ", aCurrentAudioOutputStatusUniqueID, accMode.iAccessoryMode );

                    }

                else

                    {

                    // Case when accessory is removed and GID count > 0.

                    GetAccessoryModeFromRulesTableL( aGenericIDArray, accMode );

                    accMode.iAudioOutputStatus = EFalse;

                    COM_TRACE_2( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::ResolveAccessoryModeL - No need to resolve accessory mode, (UniqueID=%d, mode=%d) ", aCurrentAudioOutputStatusUniqueID, accMode.iAccessoryMode );

                    }

                }

            else

                {

                // Set accessory mode using rules table, audio is not routed.

                GetAccessoryModeFromRulesTableL( aGenericIDArray, accMode );

                COM_TRACE_1( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::ResolveAccessoryModeL - mode is changed: %d", accMode.iAccessoryMode );

                }

            }

            break;

        // AudioRoutingStatusNotify() method is called with a Gereric ID

        default:

            {

            if ( aCurrentAudioOutputStatus )

                {								

                TInt index( TAccPolGenericIDArrayAccessor::FindWithUniqueIDL( 

                    aGenericIDArray, aPresentUniqueID ) );

                if ( KErrNotFound != index )

                    {

                    // Audio is routed to current GID

                    SetAccessoryModeL( aGenericIDArray.GetGenericIDL( index ), accMode );

                    accMode.iAudioOutputStatus = aCurrentAudioOutputStatus;

                    COM_TRACE_1( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::ResolveAccessoryModeL - set mode according to audio routing notification : %d", accMode.iAccessoryMode );

                    }

                else if ( KErrNotFound == aPresentUniqueID )

                    {

                    // AudioRoutingStatusNotify() method is called with empty Generic ID

                    // which means that audio is routed to phone.

                    accMode.iAccessoryMode     = EAccModeHandPortable;

                    accMode.iAudioOutputStatus = aCurrentAudioOutputStatus;

                    COM_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::ResolveAccessoryModeL - mode is handportable" );

                    }

                else

                    {

                    // AudioRoutingStatusNotify() is called with Generic ID that doesn't exist anymore

                    GetAccessoryModeFromRulesTableL( aGenericIDArray, accMode );

                    accMode.iAudioOutputStatus = EFalse;

                    }

                }

            else

                {

                // Set accessory mode using rules table.

                GetAccessoryModeFromRulesTableL( aGenericIDArray, accMode );

                accMode.iAudioOutputStatus = aCurrentAudioOutputStatus;

                COM_TRACE_1( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::ResolveAccessoryModeL - mode is changed to %d", accMode.iAccessoryMode );

                }

            }

            break;

        }

    COM_TRACE_2( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::ResolveAccessoryModeL - return %d (audio=%d)", accMode.iAccessoryMode, accMode.iAudioOutputStatus );

    return accMode;

    }

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

// CAccPolAccessoryPolicy::GetAccessoryModeFromRulesTableL

// (other items were commented in a header).

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

//

void CAccPolAccessoryPolicy::GetAccessoryModeFromRulesTableL(

     const TAccPolGenericIDArray& aGenericIDArray,

     TAccPolAccessoryMode& aAccMode)

    {

    COM_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::GetAccessoryModeFromRulesTableL()" );

    TInt rulesCount(0);

    TInt GIDIndex;

    TInt count( aGenericIDArray.Count() );

    // This should allocated from heap in future

    TAccPolMultibleConnectionRules aAccPolConnRules[KAccMaxRules] =

    {

     {KPCHDMI,      0}, 

     {KPCWired,     KAccStereoAudio},

     {KPCWired,     KAccMonoAudio},

     {KPCBluetooth, KAccStereoAudio},

     {KPCBluetooth, KAccMonoAudio},

     {KPCWired,     0},

     {KPCBluetooth, 0}

    };

  rulesCount = sizeof ( aAccPolConnRules ) / sizeof ( TAccPolMultibleConnectionRules );

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

      {

        for( GIDIndex = 0; GIDIndex < count;  GIDIndex++ )

            {

          TAccPolGenericID gID( aGenericIDArray.GetGenericIDL( GIDIndex ) );

      if( aAccPolConnRules[i].iCapabiltyName != 0 )

          {

          if( gID.PhysicalConnectionCaps(aAccPolConnRules[i].iPhysicalConnection )

               && iCapabilityStorage->GetCapability( gID , aAccPolConnRules[i].iCapabiltyName ))

              {

            i = rulesCount; //break from rules count loop

            COM_TRACE_1( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::GetAccessoryModeFromRulesTableL() - mode found (index=%d)",

                          GIDIndex );

            break;

            }

          }

      else

         {

        if( gID.PhysicalConnectionCaps( aAccPolConnRules[i].iPhysicalConnection ) )

            {

            i = rulesCount; //break from rules count loop

            COM_TRACE_1( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::GetAccessoryModeFromRulesTableL() - mode found (index=%d)",

                          GIDIndex );

            break;

            }

         }

        }

      }

    if(count == GIDIndex)

        {

        GIDIndex = 0; // Just get first one in GID array to set mode handportable.

        COM_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::GetAccessoryModeFromRulesTableL() - mode not found, set default" );

        }

    SetAccessoryModeL( aGenericIDArray.GetGenericIDL( GIDIndex ), aAccMode);

    COM_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::GetAccessoryModeFromRulesTableL() - Return void" );

    }

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

// CAccPolAccessoryPolicy::SetAccessoryModeL

// (other items were commented in a header).

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

//

void CAccPolAccessoryPolicy::SetAccessoryModeL(

    const TAccPolGenericID& gID,

    TAccPolAccessoryMode& aAccMode) const

    {

    COM_TRACE_( "[AccFW: ACCPOLICY] CAccPolAccessoryPolicy::SetAccessoryModeL() )" );

    TUint32 physicalCon( gID.PhysicalConnectionCaps() );

    if ( physicalCon == 0  )

        {

        aAccMode.iAccessoryMode = EAccModeHandPortable;

        }

    else if ( gID.PhysicalConnectionCaps( KPCBluetooth ) )

        {

        if( gID.DeviceTypeCaps( KDTHeadset ) )

            {

            aAccMode.iAccessoryMode = EAccModeWirelessHeadset;

            }

        else if( gID.DeviceTypeCaps( KDTCarKit ) )

            {

            aAccMode.iAccessoryMode = EAccModeWirelessCarKit;

            }

        }

    else if ( gID.PhysicalConnectionCaps( KPCWired ) ||

        {

        if( gID.DeviceTypeCaps( KDTHeadset ) )

            {

            if( iCapabilityStorage->GetCapability( gID  , KAccIntegratedAudioInput ) )

                {

                aAccMode.iAccessoryMode = EAccModeWiredHeadset;

                }

            else

                {

                aAccMode.iAccessoryMode = EAccModeHeadphones;

                }

            }

        else if( gID.DeviceTypeCaps( KDTCarKit ) )

            {

            aAccMode.iAccessoryMode = EAccModeWiredCarKit;

            }

        else if(  gID.DeviceTypeCaps( KDTLoopset ) )

            {

            aAccMode.iAccessoryMode = EAccModeLoopset;

            }

        else if( gID.DeviceTypeCaps( KDTTTY ) )

            {

            aAccMode.iAccessoryMode = EAccModeTextDevice;

            }

        else if( gID.DeviceTypeCaps( KDTOffice ) )

            {

            //Office device is interpreted as MusicStand if it has

            //mono or stereo audio capability

            if ( iCapabilityStorage->GetCapability( gID, KAccStereoAudio ) || 

                 iCapabilityStorage->GetCapability( gID, KAccMonoAudio ) )

                {

                aAccMode.iAccessoryMode = EAccModeMusicStand;

                }

            else

                {

                aAccMode.iAccessoryMode = EAccModeHandPortable;

                }

            }

        else if( gID.DeviceTypeCaps( KDTAVDevice ) )

            {

            if( gID.SubblockCaps( KSBVideoSubblock ) )

                {

                if( gID.PhysicalConnectionCaps( KPCHDMI ) )

                	{

                	aAccMode.iAccessoryMode = EAccModeHDMI;