/*
* Copyright (c) 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:  Implements getting/setting notifier locks on BT devices
*               from/to P&S KBTNotifierLocks from btengprivatepskeys.h.
*
*/

#include "btengprivatepskeys.h"
#include <e32property.h>

// ----------------------------------------------------------
// Initialize members to zero
// ----------------------------------------------------------
//
inline TBTNotifLock::TBTNotifLock()
    : iAddr(TBTDevAddr()), iLocks(EBTNotifierLockNone)
    {
    }

// ----------------------------------------------------------
// initialize members to the specified values
// ----------------------------------------------------------
//
inline TBTNotifLock::TBTNotifLock(const TBTDevAddr& aAddr, TInt aLocks)
    : iAddr( aAddr ), iLocks( aLocks )
    {
    }

// ----------------------------------------------------------
// returns the address
// ----------------------------------------------------------
//
inline const TBTDevAddr& TBTNotifLock::Addr() const
    {
    return iAddr;
    }

// ----------------------------------------------------------
// returns the lock as value
// ----------------------------------------------------------
//
inline TInt TBTNotifLock::Locks() const
    {
    return iLocks;
    }

// ----------------------------------------------------------
// returns the lock as modifiable reference
// ----------------------------------------------------------
//
inline TInt& TBTNotifLock::Locks()
    {
    return iLocks;
    }

// ----------------------------------------------------------
// Locally instantiate a RProperty and invoke GetNotifLocks
// ----------------------------------------------------------
//
inline void TBTNotifLockPublish::GetNotifLocks( TInt& aLocks, const TBTDevAddr& aAddr )
    {
    RProperty property;
    TInt err = property.Attach( 
                KPSUidBluetoothEnginePrivateCategory, KBTNotifierLocks );
    if ( !err )
        {
        GetNotifLocks( property, aLocks, aAddr );
        }
    property.Close();
    }

// ----------------------------------------------------------
// Extracts from PS key and returns the lock value for
// the specified device
// ----------------------------------------------------------
//
inline void TBTNotifLockPublish::GetNotifLocks(RProperty& aProperty,
        TInt& aLocks, const TBTDevAddr& aAddr )
    {
    aLocks = EBTNotifierLockNone;
    TInt infoSize( sizeof( TBTNotifLock ) );
    TBuf8<sizeof( TBTNotifLock ) * 8> infoDes;
    TInt err = aProperty.Get( infoDes );
    if ( err || infoDes.Length() < infoSize )
        {
        // zero length of the PS content indicates no lock set at all. 
        return;
        }
    TInt infoCount = infoDes.Length() / infoSize;
    
    TPckgBuf<TBTNotifLock> tmpPckg;
    for ( TInt i = 0; i < infoCount; i++ )
        {
        tmpPckg.Copy(infoDes.Mid( i * infoSize, infoSize ));
        if ( tmpPckg().Addr() == aAddr )
            {
            // found the locks for the device, writes to client.
            aLocks = tmpPckg().Locks();
            return;
            }
        }
    }

// ----------------------------------------------------------
// Locally instantiate a RProperty and invoke AddNotifLocks
// ----------------------------------------------------------
//
inline void TBTNotifLockPublish::AddNotifLocks( TInt aLocks, const TBTDevAddr& aAddr )
    {
    RProperty property;
    TInt err = property.Attach( 
                KPSUidBluetoothEnginePrivateCategory, KBTNotifierLocks );
    if ( !err )
        {
        AddNotifLocks( property, aLocks, aAddr );
        }
    property.Close();
    }

// ----------------------------------------------------------
// Find the lock for the device from PS key and updates its value if
// needed.
// ----------------------------------------------------------
//
inline void TBTNotifLockPublish::AddNotifLocks( RProperty& aProperty,
        TInt aLocks, const TBTDevAddr& aAddr )
    {
    TBuf8<sizeof( TBTNotifLock ) * 8> infoDes;
    TInt infoSize( sizeof( TBTNotifLock ) );
    TInt err = aProperty.Get( infoDes );   
    if ( err )
        {
        return;
        }
    TInt infoCount = infoDes.Length() / infoSize;
    TPckgBuf<TBTNotifLock> tmpPckg;

    for ( TInt i = 0; i < infoCount; i++ )
        {
        tmpPckg.Copy(infoDes.Mid( i * infoSize, infoSize ));
        if ( tmpPckg().Addr() == aAddr )
            {
            TInt newOps = tmpPckg().Locks() | aLocks;
            // update the value only if it is really changed:
            if ( tmpPckg().Locks() != newOps )
                {
                tmpPckg().Locks() = newOps;
                infoDes.Replace( i * infoSize, infoSize, tmpPckg );
                (void) aProperty.Set( infoDes );
                }
            return;
            }
        }
    // no lock for the device so far, append it to the end:
    tmpPckg() = TBTNotifLock( aAddr, aLocks );
    if ( infoCount )
        {
        infoDes.Append( tmpPckg );
        (void) aProperty.Set( infoDes );        
        }
    (void) aProperty.Set( tmpPckg ); 
    }

// ----------------------------------------------------------
// Locally instantiate a RProperty and invoke DeleteNotifLocks
// ----------------------------------------------------------
//
inline void TBTNotifLockPublish::DeleteNotifLocks( TInt aLocks, const TBTDevAddr& aAddr )
    {
    RProperty property;
    TInt err = property.Attach( 
                KPSUidBluetoothEnginePrivateCategory, KBTNotifierLocks );
    if ( !err )
        {
        DeleteNotifLocks( property, aLocks, aAddr );
        }
    property.Close();
    }

// ----------------------------------------------------------
// Find the lock for the device from PS key and updates its value if
// needed.
// ----------------------------------------------------------
//
inline void TBTNotifLockPublish::DeleteNotifLocks( RProperty& aProperty,
        TInt aLocks, const TBTDevAddr& aAddr )
    {
    TBuf8<sizeof( TBTNotifLock ) * 8> infoDes;
    TInt infoSize( sizeof( TBTNotifLock ) );
    TInt err = aProperty.Get( infoDes );
    if ( err || infoDes.Length() < infoSize )
        {
        return;
        }
    TInt infoCount = infoDes.Length() / infoSize;
    TPckgBuf<TBTNotifLock> tmpPckg;
    for ( TInt i = 0; i < infoCount; i++ )
        {
        tmpPckg.Copy( infoDes.Mid( i * infoSize, infoSize ) );
        if ( tmpPckg().Addr() == aAddr )
            {
            TInt newOps = tmpPckg().Locks() & ~aLocks;
            // update PS only if the value is changed:
            if ( tmpPckg().Locks() != newOps )
                {
                tmpPckg().Locks() = newOps;
                if ( tmpPckg().Locks() == 0)
                    {
                    // no lock for this device anymore, remove from PS:
                    infoDes.Delete( i * infoSize, infoSize );
                    }
                else
                    {
                    // Update the lock value:
                    infoDes.Replace( i * infoSize, infoSize, tmpPckg );
                    }
                (void) aProperty.Set( infoDes );
                }
            return;
            }
        }
    }