/*
* Copyright (c) 2010 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:  an extended BT device offering properties of
* a Bluetooth device that may be needed by Bluetooth UIs
*
*/

#include <btservices/btdevextension.h>

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

// ---------------------------------------------------------------------------
// C++ default constructor
// ---------------------------------------------------------------------------
//
CBtDevExtension::CBtDevExtension( TDefaultDevNameOption aNameOption ) 
: iNameOption( aNameOption )
    {
    }

// ---------------------------------------------------------------------------
// Symbian 2nd-phase constructor
// ---------------------------------------------------------------------------
//
void CBtDevExtension::ConstructL(  CBTDevice* aDev )
    {
    SetDeviceL( aDev );
    }

// ---------------------------------------------------------------------------
// NewLC
// ---------------------------------------------------------------------------
//
EXPORT_C CBtDevExtension* CBtDevExtension::NewLC( 
        CBTDevice* aDev, TDefaultDevNameOption aNameOption )
    {
    CBtDevExtension* self = NULL;
    self = new (ELeave) CBtDevExtension( aNameOption );
    CleanupStack::PushL( self );
    self->ConstructL( aDev );
    return self;
    }

// ---------------------------------------------------------------------------
// NewL
// ---------------------------------------------------------------------------
//
EXPORT_C CBtDevExtension* CBtDevExtension::NewLC( 
        const TInquirySockAddr& aAddr,
        const TDesC& aName,
        TDefaultDevNameOption aNameOption )
    {
    CBtDevExtension* self = new (ELeave) CBtDevExtension( aNameOption );
    CleanupStack::PushL( self );
    CBTDevice* dev = CBTDevice::NewLC( aAddr.BTAddr() );
    TBTDeviceClass cod( aAddr.MajorServiceClass(), 
            aAddr.MajorClassOfDevice(), aAddr.MinorClassOfDevice() );
    dev->SetDeviceClass( cod );
    if ( aName.Length() )
        {
        dev->SetDeviceNameL(  BTDeviceNameConverter::ToUTF8L( aName ) );
        }
    self->ConstructL( dev );
    CleanupStack::Pop( dev );
    return self;
    }

// ---------------------------------------------------------------------------
// NewLC
// ---------------------------------------------------------------------------
//
EXPORT_C CBtDevExtension* CBtDevExtension::NewLC( 
        const TBTDevAddr& aAddr,
        const TDesC& aName,
        TDefaultDevNameOption aNameOption )
    {
    CBtDevExtension* self = new (ELeave) CBtDevExtension( aNameOption );
    CleanupStack::PushL( self );
    CBTDevice* dev = CBTDevice::NewLC( aAddr );
    if ( aName.Length() )
        {
        dev->SetDeviceNameL(  BTDeviceNameConverter::ToUTF8L( aName ) );
        }
    self->ConstructL( dev );
    CleanupStack::Pop( dev );
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
EXPORT_C CBtDevExtension::~CBtDevExtension()
    {
    iAlias.Close();
    delete iDev;
    }

// ---------------------------------------------------------------------------
// IsBonded
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CBtDevExtension::IsBonded( const TBTNamelessDevice &dev )
    {
    // IsValidPaired tells if the paired bit of dev is valid
    // and IsPaired tells if the device is paired or not:
    return dev.IsValidPaired() && 
           dev.IsPaired() && 
           // Authentication due to OBEX cases e.g. file transfer, is not 
           // considered as bonded in Bluetooth UI:
           dev.LinkKeyType() != ELinkKeyUnauthenticatedUpgradable;
    }

// ---------------------------------------------------------------------------
// IsJustWorksBonded
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CBtDevExtension::IsJustWorksBonded( const TBTNamelessDevice &dev )
    {
    return IsBonded( dev ) && 
         dev.LinkKeyType() == ELinkKeyUnauthenticatedNonUpgradable;
    }

// ---------------------------------------------------------------------------
// IsUserAwareBonded
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CBtDevExtension::IsUserAwareBonded( const TBTNamelessDevice &dev )
    {
    if ( IsJustWorksBonded( dev ) )
        {
        // Just Works bonded devices can happen without user awareness.
        // For example, authentication due to an incoming service connection request 
        // from a device without IO.
        // We use cookies to identify if this JW pairing is user aware or not:
        TInt32 cookie = dev.IsValidUiCookie() ? dev.UiCookie() : EBTUiCookieUndefined;
        return (cookie & EBTUiCookieJustWorksPaired );        
        }
    // Pairing in other mode than Just Works are always user-aware:
    return IsBonded( dev );
    }

// ---------------------------------------------------------------------------
// IsHeadset
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CBtDevExtension::IsHeadset( const TBTDeviceClass &aCod )
    {
    if ( ( aCod.MajorServiceClass() & EMajorServiceAudioService ) &&
         ( aCod.MajorDeviceClass() & EMajorDeviceAudioDevice ) )
        {
        if (aCod.MinorDeviceClass() == EMinorDeviceAVHandsfree ||
            aCod.MinorDeviceClass() == EMinorDeviceAVCarAudio)
            {
            // This is the typical CoD setting used by carkits:
            return false;
            }
        return true;
        }
    return false;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C const TDesC& CBtDevExtension::Alias() const
    {
    return iAlias;
    }

// ---------------------------------------------------------------------------
// Addr()
// ---------------------------------------------------------------------------
//
EXPORT_C const TBTDevAddr& CBtDevExtension::Addr() const
    {
    return iDev->BDAddr();
    }

// ---------------------------------------------------------------------------
// Device
// ---------------------------------------------------------------------------
//
EXPORT_C const CBTDevice& CBtDevExtension::Device() const
    {
    return *iDev;
    }



// ---------------------------------------------------------------------------
// IsUserAwareBonded
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CBtDevExtension::IsUserAwareBonded() const
    {
    return IsUserAwareBonded( iDev->AsNamelessDevice() );
    }

// ---------------------------------------------------------------------------
// ServiceConnectionStatus()
// ---------------------------------------------------------------------------
//
EXPORT_C TBTEngConnectionStatus CBtDevExtension::ServiceConnectionStatus() const
    {
    return iServiceStatus;
    }

// ---------------------------------------------------------------------------
// SetDeviceL
// ---------------------------------------------------------------------------
//
EXPORT_C void CBtDevExtension::SetDeviceL( CBTDevice* aDev )
    {
    delete iDev;
    iDev = aDev;
    // It is possible that the client set a NULL object to us.
    if ( !iDev )
        {
        iDev = CBTDevice::NewL();
        }
    // No optimization here. If client sets an identical device instance
    // We will still execute these steps:
    UpdateNameL();
    //UpdateServiceStatusL();
    }

EXPORT_C CBtDevExtension* CBtDevExtension::CopyL()
    {
    CBtDevExtension* newDev = CBtDevExtension::NewLC( NULL );
    CBTDevice* dev = iDev->CopyL();
    CleanupStack::PushL( dev );
    newDev->SetDeviceL( dev );
    CleanupStack::Pop( dev);
    newDev->SetServiceConnectionStatus( ServiceConnectionStatus() );
    CleanupStack::Pop( newDev );
    return newDev;
    }

// ---------------------------------------------------------------------------
// ServiceConnectionStatus()
// ---------------------------------------------------------------------------
//
void CBtDevExtension::SetServiceConnectionStatus(
        TBTEngConnectionStatus aStatus )
    {
    iServiceStatus = aStatus;
    }

// ---------------------------------------------------------------------------
// UpdateL()
// ---------------------------------------------------------------------------
//
void CBtDevExtension::UpdateNameL()
    {
    // UI takes friendly name for displaying if it is available
    iAlias.Zero();
    if ( iDev->IsValidFriendlyName() && iDev->FriendlyName().Length() != 0 )
        {
        iAlias.ReAllocL(iDev->FriendlyName().Length());
        iAlias.Append(iDev->FriendlyName());
        }
    // otherwise, device name, if it is available, will be displayed
    else if ( iDev->IsValidDeviceName() && iDev->DeviceName().Length() != 0 )
        {
        TBTDeviceName name = BTDeviceNameConverter::ToUnicodeL(iDev->DeviceName());
        iAlias.ReAllocL(name.Length());
        iAlias.Append(name);
        }
    if ( iAlias.Length() == 0 && 
        ( iNameOption == EColonSeperatedBDAddr || iNameOption == EPlainBDAddr ) )
        {
        // Name for display is still missing. We need to make one for user to 
        // identify it.
        FormatAddressAsNameL();
        }
    }

// ---------------------------------------------------------------------------
// FormatAddressAsNameL()
// ---------------------------------------------------------------------------
//
void CBtDevExtension::FormatAddressAsNameL()
    {
    // readable format of BD_ADDR is double size of BD ADDR size,
    // and plus the seperators.
    iAlias.ReAllocL( KBTDevAddrSize * 3 );
    _LIT(KColon, ":");
    if ( iNameOption == EColonSeperatedBDAddr )
        {
        iDev->BDAddr().GetReadable( iAlias, KNullDesC, KColon, KNullDesC );         
        }
    else
        {
        iDev->BDAddr().GetReadable( iAlias );
        }
    }