/*

* Copyright (c) 2008 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:   Server side texture manager implementation

*

*/

#include <uiacceltk/HuiEnv.h>

#include <uiacceltk/HuiUtil.h>

#include "alfsrvtexturemanager.h"

#include "alfappsrvsession.h"

/**

 * Granularity of CAlfSrvTextureManager::iClients array.

 */

const TInt KAlfSrvClientsGranularity = 4;

/**

 * Values for auto size min change.

 */

const TInt KAlfTextureManagerAutoSizeMinSizeChange[] =

    {

    0,

    4,

    8,

    64,

    128

    };

/**

 * Values for auto size lower threshold (256 = 1.0f).

 */

const TInt KAlfTetureManagerAutoSizeRelativeThresholdLower[] =

    {

    13,     // 0.05f

    26,     // .10f

    64,     // .25f

    128,    // .50f

    256     // 1.0f

    };

/**

 * Values for auto size upper threshold (256 = 1.0f).

 */

const TInt KAlfTetureManagerAutoSizeRelativeThresholdUpper[] =

    {

    13,     // 0.05f

    26,     // .10f

    64,     // .25f

    256,    // 1.0f

    25600   // 100.f

    };

/**

 * Values for auto size downsize settle threshold.

 */

const TInt KAlfTextureManagerAutoSizeDownsizeSettleThreshold[] =

    {

    0,

    8,

    64,

    128,

    256

    };

/**

 * If width/height is below this low boundary, then one pixel precision

 * is used.

 */

const TInt KAlfSrvTextureManagerAutoSizeLowBoundary = 48;

/**

 * If width/height is above low boundary, but below this high boundary,

 * then KAlfSrvTextureManagerAutoSizeMiddleRoundTo precision is used.

 */

const TInt KAlfSrvTextureManagerAutoSizeHighBoundary = 128;

/**

 * Precision used when width/heigth is above low, but below high 

 * boundary. This must be power of two.

 */

const TInt KAlfSrvTextureManagerAutoSizeMiddleRoundTo = 2;

/**

 * Precision used when width/height is above high boundary.

 * This must be power of two.

 */

const TInt KAlfSrvTextureManagerAutoSizeHighRoundTo = 4;

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

CAlfSrvTextureManager* CAlfSrvTextureManager::NewL()

    {

    CAlfSrvTextureManager* self = new (ELeave) CAlfSrvTextureManager;

    return self;

    }

CAlfSrvTextureManager::~CAlfSrvTextureManager()

    {

    iClients.Close();

    iUsedTextures.Close();

    }

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

// Starts using CHuiEnv.

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

// 

void CAlfSrvTextureManager::HandleEnvCreateL( CHuiEnv& aEnv )

    {

    iEnv = &aEnv;

    iEnv->TextureManager().

        iTextureAutoSizeObservers.AppendL( *this );

    iIsRendererHWA = ( iEnv->Renderer() != EHuiRendererBitgdi );

    }

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

// Stops using CHuiEnv.

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

// 

void CAlfSrvTextureManager::HandleEnvToBeDeleted()

    {

    if ( iEnv )

        {

        iEnv->TextureManager().

            iTextureAutoSizeObservers.Remove( *this );

        iEnv = NULL;

        }

    }

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

// This functions converts texture ID used in the client side into id that

// can be used in the serverside HuiTextureManager without the textures getting

// accidentally shared between apps.

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

// 

TInt CAlfSrvTextureManager::CreateTextureId(

        const TProcessId& aClientOwnerId,

        TInt aClientSideId, 

        TInt aClientSideManagerId, 

        TBool aReUseAnyDeletedId )

    {

    TInt exisitingSharedTextureId = 0;

    // Look for an existing entry for the id.

    for(TInt i = 0; i < iUsedTextures.Count(); i++)

        {

        if (aClientSideManagerId == 0)

            {

            // Normal texture, "private" to client

            if(iUsedTextures[i].iClientSideId == aClientSideId &&

               iUsedTextures[i].iOwnerId == aClientOwnerId)

                {

                // Re-use old id

                iUsedTextures[i].iReleased = EFalse;

                return iUsedTextures[i].iServerSideId;

                }                

            }

        else

            {

            // Shared texture

            if(iUsedTextures[i].iClientSideId == aClientSideId &&

               iUsedTextures[i].iClientSideManagerId == aClientSideManagerId)

                {

                // Re-use old id                

                if (iUsedTextures[i].iOwnerId == aClientOwnerId)

                    {

                    iUsedTextures[i].iReleased = EFalse;

                    return iUsedTextures[i].iServerSideId;

                    }

                else

                    {

                    exisitingSharedTextureId = iUsedTextures[i].iServerSideId;

                    break;    

                    }    

                }                                

            }    

        }

    // Look for an existing deleted entry for the id i.e. recycle deleted texture id.

    // Only non-shared textures are recycled to keep things more simple and safe.

    if (aReUseAnyDeletedId && aClientSideManagerId == 0)

        {            

        for(TInt i = 0; i < iUsedTextures.Count(); i++)

            {

            if (iUsedTextures[i].iOwnerId == aClientOwnerId &&

                iUsedTextures[i].iDeleted &&

                iUsedTextures[i].iClientSideManagerId == aClientSideManagerId)

                {

                // Re-use old deleted id even if it had different id

                iUsedTextures[i].iClientSideId = aClientSideId;

                iUsedTextures[i].iReleased = EFalse;

                iUsedTextures[i].iDeleted = EFalse;

                iUsedTextures[i].iSkinChangeCoordinator = EFalse;

                return iUsedTextures[i].iServerSideId;                    

                }

            }

        }

    // No existing entry found, create new one.

    TUsedTexture usedTexture;

    usedTexture.iClientSideId = aClientSideId;

    usedTexture.iClientSideManagerId = aClientSideManagerId;

    usedTexture.iOwnerId = aClientOwnerId;

    if (aClientSideManagerId == 0 || !exisitingSharedTextureId)

        {

        // Select new id and make sure it is not used

        ++iNextTextureId; 

        TBool alreadyExists = ETrue;

        while(alreadyExists)

            {

            alreadyExists = EFalse;

            for(TInt i = 0; i < iUsedTextures.Count(); i++)

                {

                if (iUsedTextures[i].iServerSideId == iNextTextureId || iNextTextureId == 0)

                    {

                    iNextTextureId++;

                    alreadyExists = ETrue;

                    break;    

                    }

                }            

            }                            

        usedTexture.iServerSideId = iNextTextureId; 

        }

    else

        {

        usedTexture.iServerSideId = exisitingSharedTextureId;                    

        }        

    TBool entryAdded = EFalse;

    for(TInt i = 0; i < iUsedTextures.Count(); i++)

        {

        if (iUsedTextures[i].iOwnerId == aClientOwnerId &&

            iUsedTextures[i].iClientSideId == 0 &&

            usedTexture.iClientSideManagerId == 0 &&

            usedTexture.iServerSideId == 0)

            {

            entryAdded = ETrue;

            iUsedTextures[i] = usedTexture;

            }                                          

        }

    if (!entryAdded)

        {

        iUsedTextures.Append(usedTexture);        

        }

    return usedTexture.iServerSideId;    

    }

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

// 

// 

// 

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

// 

TInt CAlfSrvTextureManager::ExistingTextureId(

        const TProcessId& aClientOwnerId,

        TInt aClientSideId, 

        TInt aClientSideManagerId,

        TBool aIgnoreOwnerForSharedTextures )

    {

    // Look for an existing entry for the id.

    for(TInt i = 0; i < iUsedTextures.Count(); i++)

        {

        if (aClientSideManagerId == 0)

            {

            // Normal texture, "private" to client

            if(iUsedTextures[i].iClientSideId == aClientSideId &&

               iUsedTextures[i].iOwnerId == aClientOwnerId &&

               iUsedTextures[i].iReleased == EFalse)

                {

                return iUsedTextures[i].iServerSideId;

                }                

            }

        else

            {

            // Shared texture

            if(iUsedTextures[i].iClientSideId == aClientSideId &&

               iUsedTextures[i].iClientSideManagerId == aClientSideManagerId &&

               iUsedTextures[i].iReleased == EFalse)

                {

                if (iUsedTextures[i].iOwnerId == aClientOwnerId || 

                    aIgnoreOwnerForSharedTextures)

                    {

                    return iUsedTextures[i].iServerSideId;

                    }

                }                                

            }    

        }

    // not found

    return 0;

    }

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

//

//

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

// 

TInt CAlfSrvTextureManager::ReleaseTextureId(

        const TProcessId& aClientOwnerId,

        TInt aClientSideId, 

        TInt aClientSideManagerId )

    {    

    TInt sharedTextureReferenceCount = 0;

    TInt toBeRemovedIndex = KErrNotFound;

    // Look for an existing entry for the id.

    for(TInt i = 0; i < iUsedTextures.Count(); i++)

        {

        if (aClientSideManagerId == 0)

            {

            // Normal texture, "private" to client

            if(iUsedTextures[i].iClientSideId == aClientSideId &&

               iUsedTextures[i].iOwnerId == aClientOwnerId &&

               iUsedTextures[i].iReleased == EFalse)

                {

                toBeRemovedIndex = i;

                break;

                }

            }

        else

            {

            // Shared texture

            if(iUsedTextures[i].iClientSideId == aClientSideId &&

               iUsedTextures[i].iClientSideManagerId == aClientSideManagerId  &&

               iUsedTextures[i].iReleased == EFalse)               

                {

                if (iUsedTextures[i].iOwnerId == aClientOwnerId)

                    {

                    toBeRemovedIndex = i;

                    }

                sharedTextureReferenceCount++;    

                }                                                

            }    

        }

    if (toBeRemovedIndex != KErrNotFound)

        {

        iUsedTextures[toBeRemovedIndex].iReleased = ETrue;

        iUsedTextures[toBeRemovedIndex].iSkinChangeCoordinator = EFalse;

        if (sharedTextureReferenceCount > 0)

            {

            sharedTextureReferenceCount--;    

            }

        }

    return sharedTextureReferenceCount;    

    }

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

//

//

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

// 

TInt CAlfSrvTextureManager::DeleteTextureId(

        const TProcessId& aClientOwnerId,

        TInt aClientSideId, 

        TInt aClientSideManagerId )

    {    

    TInt sharedTextureReferenceCount = 0;

    TInt toBeRemovedIndex = KErrNotFound;

    // Look for an existing entry for the id, it has

    // to be released. 

    for(TInt i = 0; i < iUsedTextures.Count(); i++)

        {

        if (aClientSideManagerId == 0)

            {

            // Normal texture, "private" to client

            if(iUsedTextures[i].iClientSideId == aClientSideId &&

               iUsedTextures[i].iOwnerId == aClientOwnerId &&

               iUsedTextures[i].iReleased)

                {

                toBeRemovedIndex = i;

                break;

                }

            }

        else

            {

            // Shared texture

            if(iUsedTextures[i].iClientSideId == aClientSideId &&

               iUsedTextures[i].iClientSideManagerId == aClientSideManagerId  &&

               iUsedTextures[i].iReleased)               

                {

                if (iUsedTextures[i].iOwnerId == aClientOwnerId)

                    {

                    toBeRemovedIndex = i;

                    }

                sharedTextureReferenceCount++;

                }                                                

            }    

        }

    if (toBeRemovedIndex != KErrNotFound)

        {

        iUsedTextures[toBeRemovedIndex].iDeleted = ETrue;

        iUsedTextures[toBeRemovedIndex].iSkinChangeCoordinator = EFalse;

        if (sharedTextureReferenceCount > 0)

            {

            sharedTextureReferenceCount--;    

            }

        }

    return sharedTextureReferenceCount;

    }

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

// After skin change event this function determines if given texture content

// is valid or not.

//

// Return value 0 indicates invalid, other valid.

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

// 

TInt CAlfSrvTextureManager::ValidateSkinForTextureId(

        const TProcessId& aClientOwnerId,

        TInt aClientSideId, 

        TInt aClientSideManagerId )

    {

    TInt ownEntryIndex = -1;

    TInt retVal = 0;

    // Look for an existing entry for the id.

    for(TInt i = 0; i < iUsedTextures.Count(); i++)

        {

        if (aClientSideManagerId == 0)

            {

            // Normal texture, "private" to client

            if(iUsedTextures[i].iClientSideId == aClientSideId &&

               iUsedTextures[i].iOwnerId == aClientOwnerId &&

               iUsedTextures[i].iReleased == EFalse)

                {                

                retVal = 0; // Not shared texture, always invalid.

                break;

                }                

            }

        else

            {

            // Shared texture

            if(iUsedTextures[i].iClientSideId == aClientSideId &&

               iUsedTextures[i].iClientSideManagerId == aClientSideManagerId &&

               iUsedTextures[i].iReleased == EFalse)

                {

                if (iUsedTextures[i].iOwnerId == aClientOwnerId)

                    {

                    ownEntryIndex = i;

                    }

                else

                    {

                    if (iUsedTextures[i].iSkinChangeCoordinator)

                        {

                        retVal = 1; // For shared textures, only one entry is invalid to avoid multiple reloads.   

                        break;

                        }                        

                    }    

                }                                

            }    

        }

    if (retVal == 0 && ownEntryIndex != -1)

        {

        // This index becomes the one that handles skin change

        iUsedTextures[ownEntryIndex].iSkinChangeCoordinator = ETrue;    

        }

    return retVal;        

    }

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

// Destroyes deleted texture ids.

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

// 

TInt CAlfSrvTextureManager::DestroyDeletedTextureIds(const TProcessId& aOwnerId)

    {    

    // Look for an existing entry for the id.

    TInt i = 0;

    for(i = 0; i < iUsedTextures.Count(); i++)

        {

        if (iUsedTextures[i].iDeleted &&

            iUsedTextures[i].iClientSideManagerId == 0 &&

            iUsedTextures[i].iOwnerId == aOwnerId)

            {

            iUsedTextures.Remove(i);

            i = 0;                

            }

        }

    return 0;    

    }

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

// Adds client item to iClients array.

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

// 

void CAlfSrvTextureManager::AddClientL( 

        const TProcessId& aClientOwnerId, 

        MAlfSrvTextureManagerClient& aClient )

    {

    if ( FindClient( aClient ) == KErrNotFound )

        {

        TClientItem item;

        item.iOwnerId = aClientOwnerId;

        item.iClient = &aClient;

        item.iIsMarked = EFalse;

        iClients.AppendL( item );

        }

    }

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

// Removes client item from iClients array

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

// 

void CAlfSrvTextureManager::RemoveClient( MAlfSrvTextureManagerClient& aClient )