// 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:
// Interface to find out when a particular content update 
// for a given surface has been delivered to the compositor
// and will be used in future compositions involving that 
// surface.
// 
//

/**
 @file
 @publishedPartner
 @released
*/

#ifndef __CONTENTREADYFORCOMPOSITION_H__
#define __CONTENTREADYFORCOMPOSITION_H__


#include <e32std.h>
#include <graphics/surface.h>


/**
MContentReadyForComposition is an interface to find out when a 
particular content update for a given surface has been delivered to
the compositor and will be used in future compositions involving that 
surface.

Each compositor in the system maintains its own content update count 
for each registered surface that determines when content ready 
notifications will be completed. Therefore the content update count is
considered per-surface-per-screen. The content update count is 
internally incremented by the compositor every time it receives a 
valid content update for a registered surface. Frames may be skipped 
if the client submits content updates too fast, meaning that not every
update is displayed on screen. The first valid content update sets the
content update count to one. Updates sent before the surface is 
registered do not affect the content update count. Content ready 
notifications for aContentUpdate = 1 will only be successfully 
completed after at least one content update has been received.
*/
class MContentReadyForComposition
    {
public:
    enum
        {
        KUidContentReadyForComposition = 0x2002E6D5,
        ETypeId = KUidContentReadyForComposition
        };
public:

    /**
    Requests a notification when a particular content update for a 
    given surface has been delivered to the compositor. Further, 
    notification implies that this newest content will be used in 
    future compositions until such time that newer content is 
    available.

    @param  aSurface        Id of the surface for which the
                            notification is required.
    @param  aNotifyReady    Request status that is signaled on the 
                            calling thread.
    @param  aContentUpdate  Content update number for which 
                            notification is required.

    @note   aContentUpdate is one-based. Content update one 
            corresponds to the first content submitted to the 
            compositor for a given surface.

    @note   If aContentUpdate is less than or equal to the current 
            content that the compositor uses for aSurface during 
            composition, aNotifyReady is completed with KErrNone 
            without delay. Else aNotifyReady is completed with 
            KErrNone when the compositor has received content update
            number aContentUpdate for the surface.

    @note   aNotifyReady is set to KRequestPending during the call
            to NotifyContentReady() and remains set to this value 
            until the request is completed with the appropriate 
            return code. The client must wait for this asynchronous 
            completion before attempting to read the return value.

    @note   If the registration count for aSurface becomes zero and 
            the surface is no longer in use in either the committed 
            or uncommitted scene while a notification request is 
            outstanding, the notification is completed with KErrAbort,
            without delay soon after the surface is unregistered.

    @note   Due to the 64-bit precision of aContentUpdate, the 
            probability of wrap around is considered slim and 
            therefore ignored. If wrap around does occur, behaviour of
            the API is undefined.

    @pre    aSurface is registered.
    @pre    aContentUpdate >= 1.
    @pre    There is no outstanding notification request for aSurface. 

    @error  If aSurface is not registered, aNotifyReady is completed
            with KErrArgument without delay.
    @error  If aContentUpdate == 0, aNotifyReady is completed with 
            KErrArgument without delay.
    @error  If there is an outstanding notification request for 
            aSurface, aNotifyReady is completed with KErrInUse without
            delay.

    @post   aNotifyReady will be signaled on the calling thread
            according to the above criteria.
    */
    virtual void NotifyContentReady(const TSurfaceId& aSurface, TUint64 aContentUpdate, TRequestStatus& aNotifyReady) = 0;

    /**
    Cancels a notification request made previously with 
    MContentReadyForComposition::NotifyContentReady() for a specific
    surface.

    @see    MContentReadyForComposition::NotifyContentReady().

    @param  aSurface        Id of the surface for which the 
                            notification request will be cancelled.

    @pre    aSurface is registered. 
    
    @error  If aSurface is not registered, this function is a noop.

    @post   If there is an outstanding notification request for 
            aSurface at the time of the call, it is completed with 
            KErrCancel without delay on the thread that originally 
            called NotifyContentReady() to make the request. If there
            is no outstanding notification request, this function is 
            a noop.

    @note   Completion of an outstanding request with KErrCancel
            must not rely on the calling thread entering the active 
            scheduler after the call to NotifyContentReadyCancel(). 
            It is valid for the client to call User::
            WaitForRequest(aNotifyRequest), where aNotifyRequest is 
            the outstanding request, immediately after calling 
            NotifyContentReadyCancel().
    */
    virtual void NotifyContentReadyCancel(const TSurfaceId& aSurface) = 0;
    };


#endif //__CONTENTREADYFORCOMPOSITION_H__