/*
* Copyright (c) 2005-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:  mmsregisteredapplications implementation
*
*/


   
// INCLUDE FILES   
#include <centralrepository.h>
#include <msvids.h>

// USERINCLUDE FILES
#include "mmsregisteredapplications.h"
#include "mmssettings.h"
#include "mmsdebuglogging.h"
#include "MmsEngineDomainCRKeys.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS
const TInt KMmsApplicationIdArrayGranularity = 4;
const TInt KMmsApplicationNameDefaultLength = 64; // a reasonable guess for the length

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

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

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

// -----------------------------------------------------------------------------
// CMmsRegisteredApplications::NewL
//
// -----------------------------------------------------------------------------
//
EXPORT_C CMmsRegisteredApplications* CMmsRegisteredApplications::NewL()
    {
    CMmsRegisteredApplications* self = new(ELeave) CMmsRegisteredApplications();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CMmsRegisteredApplications::CMmsRegisteredApplications
//
// -----------------------------------------------------------------------------
//
CMmsRegisteredApplications::CMmsRegisteredApplications()
    {
    }

// -----------------------------------------------------------------------------
// CMmsRegisteredApplications::~CMmsRegisteredApplications
//
// -----------------------------------------------------------------------------
//
CMmsRegisteredApplications::~CMmsRegisteredApplications()
    {
    LOG(_L("~CMmsRegisteredApplications"));
    delete iUserFriendlyName;
    delete iRepository;
    delete iAppIdArray;  
    }

// -----------------------------------------------------------------------------
// CMmsRegisteredApplications::ConstructL
//
// -----------------------------------------------------------------------------
//
void CMmsRegisteredApplications::ConstructL()
    {
   
    iAppIdArray = new ( ELeave )CDesCArrayFlat( KMmsApplicationIdArrayGranularity );

    iRepository = CRepository::NewL( KCRUidMMSApplicationRegistrations ); 
    // The length may change later if the names are long.
    iUserFriendlyName = HBufC::NewL( KMmsApplicationNameDefaultLength );
    }

// -----------------------------------------------------------------------------
// CMmsRegisteredApplications::LoadRegisteredApplicationsL
//
// -----------------------------------------------------------------------------
//

EXPORT_C void CMmsRegisteredApplications::LoadRegisteredApplicationsL()
    {
    LOG(_L("CMmsRegisteredApplications::LoadRegisteredApplicationsL"));
    iAppIdArray->Reset();
    TInt count = 0;
    TInt error = iRepository->Get( KMmsEngineNbrOfRegisteredApplications, count );
    if ( error == KErrNotFound )
        {
        iRepository->Set( KMmsEngineNbrOfRegisteredApplications, 0 );   
        }
    
    // KMaxUnicodeStringLength is the maximum length of string in repository -
    // The strings will always fit into the bugger.
    HBufC* buffer = HBufC::NewL( NCentralRepositoryConstants::KMaxUnicodeStringLength );
    CleanupStack::PushL( buffer );
    TPtr ptr = buffer->Des();
    // We use the same buffer for reading everything - AppendL will always allocate
    // a new buffer anyway. No need to keep allocating a new read buffer every time
    for( TInt i = 0; i < count; i++ )
        {
        error = iRepository->Get( KMmsEngineRegisteredApplicationsArrayBase + i, ptr ) ;
        if ( error == KErrNone )
            { 
            iAppIdArray->AppendL( ptr );
            }
        else
            {
            LOG3(_L("- Loading registered appid array item %d returned error %d"), i, error );
            }
        }   
    CleanupStack::PopAndDestroy( buffer );
    buffer = NULL;
    
    }


// -----------------------------------------------------------------------------
// CMmsRegisteredApplications::NumberOfRegisteredApplicationsL
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CMmsRegisteredApplications::NumberOfRegisteredApplicationsL() const
    {
    return iAppIdArray->MdcaCount();
    }
    
// -----------------------------------------------------------------------------
// CMmsRegisteredApplications::RegisteredL
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CMmsRegisteredApplications::RegisteredL( const TDesC& aApplicationId )
    {
    TInt index = -1;
    return Registered( aApplicationId, index );
    }  


    
// -----------------------------------------------------------------------------
// CMmsRegisteredApplications::RegisterL
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CMmsRegisteredApplications::RegisterL( const TDesC& aApplicationId )
    {
    return RegisterL( aApplicationId, TPtrC() );
    }

// -----------------------------------------------------------------------------
// CMmsRegisteredApplications::UnregisterL
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CMmsRegisteredApplications::UnregisterL( const TDesC& aApplicationId )
    {
    TInt index = 0;
    if ( !Registered( aApplicationId, index ) )
        {
        return KErrNone;            
        }
    LOG2(_L("CMmsRegisteredApplications::Unregister: array[%d]"), index );
    
    TInt error = KErrNone;
    
    // if item is not last one in the array. move the last item here.
    TInt lastIndex = iAppIdArray->MdcaCount() - 1;
    if ( index != lastIndex )
        {
        HBufC* buffer = HBufC::NewL( NCentralRepositoryConstants::KMaxUnicodeStringLength );
        CleanupStack::PushL( buffer );
        TPtr ptr = buffer->Des();
    
        error = iRepository->Get(
            KMmsEngineRegisteredApplicationsArrayBase + lastIndex, ptr );
        if ( error == KErrNone )
            {
            error = iRepository->Set(
                KMmsEngineRegisteredApplicationsArrayBase + index, ptr );
            }
        // local array has to follow the same order
        if ( error == KErrNone )
            {
            // delete the old user friendly name.
            // The new one will replace it in a moment, but we make sure 
            // there is no incorrect name left in place in case InsertL
            // leaves because of lack of memory.
            iRepository->Delete( KMmsEngineApplicationNameArrayBase + index );
            // array index should be safe
            iAppIdArray->InsertL( index, ptr );
            iAppIdArray->Delete( index + 1 ); 
            }
        if ( error == KErrNone )
            {
            error = iRepository->Get( KMmsEngineApplicationNameArrayBase + lastIndex, ptr );
            if ( error == KErrNone && ptr.Length() > 0 )
                {
                error = iRepository->Set(
                    KMmsEngineApplicationNameArrayBase + index, ptr );
                }
            // The setting of the name must not prevent final cleanup    
            error = KErrNone;    
            }
            
        CleanupStack::PopAndDestroy( buffer );
        buffer = NULL;
        }
    // delete the last item from the arrays
    if ( error == KErrNone )
        {
        error = iRepository->Delete( KMmsEngineRegisteredApplicationsArrayBase + lastIndex );
        if ( error == KErrNone )
            {
            iAppIdArray->Delete( lastIndex );
            iAppIdArray->Compress();
            SaveCount();        
            }
        // The user friendly name of the last item is deleted in any case
        // We are trying to make sure there are no friendly names pointing
        // to incorrect application ids left over.
        // The name can be fixed by trying to register the application again
        // Even if the application is already registered, the user friedly name
        // can be changed by registering the same application id again. 
        iRepository->Delete( KMmsEngineApplicationNameArrayBase + lastIndex );
        }
    return error;       
  
    }
    
// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
EXPORT_C const CDesCArray& CMmsRegisteredApplications::RegisteredApplicationList() const
    {
    return *iAppIdArray; 
    }
    
// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CMmsRegisteredApplications::RegisterL(
    const TDesC& aApplicationId,
    const TDesC& aUserFriendlyName )
    {
    TInt error = KErrNone;
    TInt index = -1;
    if ( aApplicationId.Length() > NCentralRepositoryConstants::KMaxUnicodeStringLength )
        {
        // The application id is too long, it cannot be registerd
        return KErrArgument;
        }
    if ( aUserFriendlyName.Length() > NCentralRepositoryConstants::KMaxUnicodeStringLength )
        {
        return KErrArgument;
        }
        
    if ( !Registered( aApplicationId, index ) )
        {
        // add new app id to last item in the array.
        index = iAppIdArray->MdcaCount();
        error = iRepository->Create(
            KMmsEngineRegisteredApplicationsArrayBase + index, aApplicationId );
        if ( error == KErrNone || error == KErrAlreadyExists )
            {
            // We should not get "already exists" unless someone has 
            // edited the registry behind our back...
            error = KErrNone;
            // The index now points to the newly created application id
            iAppIdArray->AppendL( aApplicationId );
            // update count in cenrep.
            SaveCount();
            }
        }
        
    // If index == -1 at this point, the registeration has failed.    
    if ( aUserFriendlyName.Length() > 0 && error == KErrNone && index != -1 )
        {
        error = iRepository->Set( KMmsEngineApplicationNameArrayBase + index,
            aUserFriendlyName );
        if ( error == KErrAlreadyExists )
            {
            error = KErrNone;
            }
        }
        
    return error;
    }
    
// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
EXPORT_C TPtrC CMmsRegisteredApplications::UserFriendlyName( const TDesC& aApplicationId )
    {
    // This is a "best effort" function. 
    // If memory runs out or some other error occurs, an empty string is returned
    TInt index = -1;
    if ( !Registered( aApplicationId, index ) )
        {
        return TPtrC();
        }
    
    TInt error = KErrNone;
    if ( !iUserFriendlyName )
        {
        // iUserFriendlyName may be NULL only if we have ran out of memory earlier
        TRAP( error, iUserFriendlyName = HBufC::NewL( KMmsApplicationNameDefaultLength ) );
        }
    if ( error != KErrNone )
        {
        // If no memory, return empty string
        return TPtrC();
        }
        
    TPtr ptr = iUserFriendlyName->Des();
    TInt actualLength = 0;

    error = iRepository->Get( KMmsEngineApplicationNameArrayBase + index, ptr, actualLength );
    if ( error == KErrOverflow )
        {
        delete iUserFriendlyName;
        iUserFriendlyName = NULL;
        TRAP( error,
            {
            iUserFriendlyName = HBufC::NewL( actualLength );
            ptr.Set( iUserFriendlyName->Des() ); 
            error = iRepository->Get( KMmsEngineApplicationNameArrayBase + index, ptr );
            });
        }
    if ( error == KErrNone )
        {
        return iUserFriendlyName->Des();
        }
    return TPtrC();
        
    }

    
// -----------------------------------------------------------------------------
// CMmsRegisteredApplications::Registered
// -----------------------------------------------------------------------------
//
TBool CMmsRegisteredApplications::Registered( const TDesC& aApplicationId, TInt& aIndex )
    {
    aIndex = -1; 
    TInt count = iAppIdArray->MdcaCount();
    for( TInt i = 0; i < count && aIndex == -1; ++i )
        {
        TPtrC16 ptr = iAppIdArray->MdcaPoint( i );
        if ( ptr.Compare( aApplicationId ) == 0 )
            {
            aIndex = i; 
            }
        }
    return ( aIndex != -1 );        
    } 

// -----------------------------------------------------------------------------
// CMmsRegisteredApplications::SaveCount
// -----------------------------------------------------------------------------
//
TInt CMmsRegisteredApplications::SaveCount()
    {
    TInt count = iAppIdArray->MdcaCount();
    // Set also creates a new key if it does not exist
    TInt error = iRepository->Set( KMmsEngineNbrOfRegisteredApplications, count );
    if( error != KErrNone )
        {
        LOG3( _L("-ERROR saving appid count %d: %d"), KMmsEngineNbrOfRegisteredApplications, error );
        }
    return error;   
    }
    
    
// =========================== OTHER EXPORTED FUNCTIONS ========================

//  End of File