/*
* 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 "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:  CSconBtEngine implementation
*
*/



#include <centralrepository.h>
#include <btengdomaincrkeys.h>

#include <e32property.h>
#include <bttypes.h> 
#include <bt_subscribe.h>

#include "sconbtengine.h"
#include "debug.h"

CSconBtEngine* CSconBtEngine::NewL()
    {
    TRACE_FUNC;
    CSconBtEngine* self = new (ELeave) CSconBtEngine();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

CSconBtEngine::~CSconBtEngine()
    {
    TRACE_FUNC;
    if ( iBtEng )
        {
        iBtEng->Cancel();
        delete iBtEng;
        }
    
    delete iBtSettings;
    }

CSconBtEngine::CSconBtEngine()
    {
    }

void CSconBtEngine::ConstructL()
    {
    iBtEng = CBTEngDevMan::NewL( this );
    iBtSettings = CBTEngSettings::NewL( this );
    iState = EIdle;
    }

void CSconBtEngine::ReadBTInfoL( RBufWriteStream& aStream )
    {
    TRACE_FUNC_ENTRY;
    if ( iState != EIdle )
        {
        User::Leave( KErrInUse );
        }
    iStream = &aStream;
    iOperationError = KErrNone;
    
    // Write local name (8 bit name length + unicode name)
    TBuf<100> localName;
    TInt err = iBtSettings->GetLocalName( localName );
    User::LeaveIfError( err );
    LOGGER_WRITE_1("localName: %S", &localName);
    iStream->WriteUint8L( localName.Length() );
    iStream->WriteL( localName, localName.Length() );
    
    if ( iBtAddress.Length() == 0 )
        {
        LOGGER_WRITE("Try to read bt address");
        
        CRepository* cenRep = NULL;
        // Use TRAP to catch a leave if the CenRep key does not exist.
        TRAP( err, cenRep = CRepository::NewL( KCRUidBluetoothLocalDeviceAddress ) );
        CleanupStack::PushL( cenRep );
        if( !err )
            {
            err = cenRep->Get( KBTLocalDeviceAddress, iBtAddress );
            LOGGER_WRITE_1("cenRep->Get err: %d", err);
            }
        CleanupStack::PopAndDestroy( cenRep );
        
        if ( err )
            {
            iBtAddress.Zero();
            }
        }
    
    // Write bt address (8 bit addr length + unicode address)
    if ( iBtAddress.Length() > 0 )
        {
        LOGGER_WRITE_1("btAddr: %S", &iBtAddress);
        iStream->WriteUint8L( iBtAddress.Length() );
        iStream->WriteL( iBtAddress, iBtAddress.Length() );
        }
    else
        {
        iStream->WriteUint8L( 0 );
        }
    
    // Write BT Power State (8-bit, 0=Off, 1=On)
    TBTPowerStateValue state;
    err = iBtSettings->GetPowerState( state );
    User::LeaveIfError( err );
    LOGGER_WRITE_1("PowerState: %d", state);
    iStream->WriteUint8L( state );
    
    // Get device info
    TBTRegistrySearch crit;
    crit.FindAll();
    if ( !iBtDevArray )
        {
        LOGGER_WRITE("create arr");
        iBtDevArray = new (ELeave) CBTDeviceArray(5);
        LOGGER_WRITE("create arr -ok");
        }
    else
        {
        iBtDevArray->ResetAndDestroy();
        }
    err = iBtEng->GetDevices( crit, iBtDevArray );
    LOGGER_WRITE_1("GetDevices err: %d", err);
    User::LeaveIfError( err );
    iState = ERequestBtInfo;
    
    // Wait until completed
    iWait.Start();
    iState = EIdle;
    if ( iOperationError )
        {
        LOGGER_WRITE_1("Operation failed, leave %d", iOperationError);
        User::Leave( iOperationError );
        }
    TRACE_FUNC_EXIT;
    }

void CSconBtEngine::SetBtAuthorizedL( const TDesC& aBtDevAddress, TBool aAuthorized )
    {
    TRACE_FUNC_ENTRY;
    if ( iState != EIdle )
        {
        User::Leave( KErrInUse );
        }
    
    TBTRegistrySearch crit;
    TBTDevAddr addr;
    addr.SetReadable( aBtDevAddress );
    crit.FindAddress( addr );
    
    if ( !iBtDevArray )
        {
        LOGGER_WRITE("create arr");
        iBtDevArray = new (ELeave) CBTDeviceArray(5);
        LOGGER_WRITE("create arr -ok");
        }
    else
        {
        iBtDevArray->ResetAndDestroy();
        }
    TInt err = iBtEng->GetDevices( crit, iBtDevArray );
    LOGGER_WRITE_1("GetDevices err: %d", err);
    User::LeaveIfError( err );
    iState = EChangeAuthorized;
    iOperationError = KErrNone;
    iAuthorizedValue = aAuthorized;
    
    // Wait until completed
    iWait.Start();
    iState = EIdle;
    if ( iOperationError )
        {
        LOGGER_WRITE_1("Operation failed, leave %d", iOperationError);
        User::Leave( iOperationError );
        
        }
    
    TRACE_FUNC_EXIT;
    }

TInt CSconBtEngine::SetBtPowerState( TBool aPower )
    {
    TRACE_FUNC_ENTRY;
    if ( iState != EIdle )
        {
        return KErrInUse;
        }
    
    TBTPowerStateValue state;
    iOperationError = iBtSettings->GetPowerState( state );
    if ( iOperationError )
        {
        return iOperationError;
        }
    else if ( ( aPower && state == EBTPowerOn )
            || ( !aPower && state == EBTPowerOff ) )
        {
        // No need to change state
        return KErrNone;
        }
    
    state = EBTPowerOff;
    if ( aPower )
        {
        state = EBTPowerOn;
        }
    iOperationError = iBtSettings->SetPowerState( state );
    if ( iOperationError )
        {
        return iOperationError;
        }
    iState = EChangeBtState;
    
    // Wait until completed
    iWait.Start();
    
    iState = EIdle;
    TRACE_FUNC_RET( iOperationError );
    return iOperationError;
    }

TInt CSconBtEngine::SetBtName( const TDesC& aBtName )
    {
    LOGGER_WRITE_1("SetBtName aBtName: %S", &aBtName);
    TInt err = iBtSettings->SetLocalName( static_cast<const TDes&>( aBtName ) );
    TRACE_FUNC_RET( err );
    return err;
    }

// From MBTEngDevManObserver
void CSconBtEngine::HandleDevManComplete( TInt aErr )
    {
    TRACE_FUNC;
    LOGGER_WRITE_1("aErr: %d", aErr );
    if ( iState == EChangeAuthorized )
        {
        if ( iWait.IsStarted() )
            {
            iOperationError = aErr;
            iWait.AsyncStop();
            }
        }
    
    }

void CSconBtEngine::HandleGetDevicesComplete( TInt aErr, 
       CBTDeviceArray* aDeviceArray )
    {
    TRACE_FUNC_ENTRY;
    LOGGER_WRITE_1("aErr: %d", aErr);
    //iBtReqOngoing = EFalse;
    if ( iState == ERequestBtInfo )
        {
        // Continue to write devices info
        TRAP( iOperationError, PrintDevicesL() );
        LOGGER_WRITE_1("PrintDevicesL err: %d", iOperationError);
        
        if ( iWait.IsStarted() )
            {
            iWait.AsyncStop();
            }
        }
    else if ( iState == EChangeAuthorized )
        {
        iOperationError = aErr;
        if ( !aErr && aDeviceArray->Count() == 1 )
            {
            CBTDevice* btRef = aDeviceArray->At(0);
            TBTDeviceSecurity devSec = btRef->GlobalSecurity();
            if ( btRef->IsPaired() && !devSec.Banned() )
                {
                LOGGER_WRITE8_1("btAdrr: %S", &btRef->BDAddr().Des() );
                CBTDevice* btDevice = CBTDevice::NewLC( btRef->BDAddr() );
                
                btDevice->SetPaired( ETrue );
                
                btDevice->SetDeviceNameL( btRef->DeviceName() );
                btDevice->SetFriendlyNameL( btRef->FriendlyName() );
                LOGGER_WRITE8_1("name: %S", &btRef->DeviceName());
                LOGGER_WRITE8_1("FriendlyName: %S", &btRef->FriendlyName());
                
                LOGGER_WRITE_1("iAuthorizedValue: %d", iAuthorizedValue);
                // Set as authorized and store the device
                TBTDeviceSecurity security;
                security.SetNoAuthenticate( EFalse );
                security.SetNoAuthorise( iAuthorizedValue );
                security.SetBanned( EFalse );
                
                btDevice->SetGlobalSecurity (security );
                
                //iOperationError = iBtEng->ModifyDevice(*aDeviceArray->At(0));
                iOperationError = iBtEng->ModifyDevice( *btDevice );
                LOGGER_WRITE_1( "ModifyDevice err: %d", iOperationError );
                CleanupStack::PopAndDestroy( btDevice );
                }
            else
                {
                LOGGER_WRITE("Device was not paired or it's banned")
                iOperationError = KErrAccessDenied;
                }
            }
        
        // If error occured stop waiting, otherwise continue waiting until
        // HandleDevManComplete has been called
        if ( iOperationError && iWait.IsStarted() )
            {
            iWait.AsyncStop();
            }
        }
    TRACE_FUNC_EXIT;
    }

void CSconBtEngine::PrintDevicesL()
    {
    TRACE_FUNC_ENTRY;
    // calculate devices count
    TInt devCount(0);
    
    for ( TInt i=0 ; i<iBtDevArray->Count(); i++ )
        {
        CBTDevice* device = iBtDevArray->At(i);
        // show only paired and banned devices
        if ( device->IsPaired() || device->GlobalSecurity().Banned() )
            {
            devCount++;
            }
        }
    
    // Print info
    iStream->WriteUint8L( devCount );
    
    for ( TInt i=0 ; i<iBtDevArray->Count(); i++ )
        {
        CBTDevice* device = iBtDevArray->At(i);
        
        const TBTDeviceSecurity btSec = device->GlobalSecurity();
        
        // show only paired and banned devices
        if ( device->IsPaired() || btSec.Banned() )
            {
            LOGGER_WRITE_1("IsValidDeviceName: %d", device->IsValidDeviceName());
            const TDesC8& deviceName = device->DeviceName();
            LOGGER_WRITE8_1("DeviceName: %S", &deviceName );
            iStream->WriteUint8L( deviceName.Length() );
            iStream->WriteL( deviceName, deviceName.Length() );
            
            LOGGER_WRITE_1("IsValidFriendlyName: %d", device->IsValidFriendlyName());
            LOGGER_WRITE_1("FriendlyName: %S", &device->FriendlyName() );
            
            const TBTDevAddr& addr = device->BDAddr();
            
            TBuf<100> readable;
            addr.GetReadable( readable );
            LOGGER_WRITE_1("readable addr: %S", &readable);
            iStream->WriteUint8L( readable.Length() );
            iStream->WriteL( readable, readable.Length() );
            
            LOGGER_WRITE_1("paired: %d", device->IsPaired() );
            LOGGER_WRITE_1("IsValidPaired: %d", device->IsValidPaired() );
            TUint8 paired(0);
            if ( device->IsPaired() && device->IsValidPaired() )
                {
                paired = 1;
                }
            iStream->WriteUint8L( paired );
            
            TUint8 noAuthorise(0);
            if ( btSec.NoAuthorise() )
                {
                noAuthorise = 1;
                }
            iStream->WriteUint8L( noAuthorise );
            
            TUint8 banned(0);
            if ( btSec.Banned() )
                {
                banned = 1;
                }
            iStream->WriteUint8L( banned );
            
            LOGGER_WRITE("");
            }
        }
    iStream->CommitL();
    iStream = NULL; //delete reference only
    TRACE_FUNC_EXIT;
    }

// From MBTEngSettingsObserver
void CSconBtEngine::PowerStateChanged( TBTPowerStateValue /*aState*/ )
    {
    TRACE_FUNC;
    if ( iState == EChangeBtState && iWait.IsStarted() )
        {
        iWait.AsyncStop();
        }
    
    }

void CSconBtEngine::VisibilityModeChanged( TBTVisibilityMode /*aState*/ )
    {
    TRACE_FUNC;
    }