/*
* Copyright (c) 2002-2007 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: 
*     Phonebook image reader class definition.
*
*/


#ifndef CPBK2IMAGEREADER_H
#define CPBK2IMAGEREADER_H

//  INCLUDES
#include <e32base.h>    // CBase
#include <f32file.h>	// RFs
#include "TPbk2ImageManagerParams.h"

// FORWARD DECLARATIONS
class MPbk2ImageReaderObserver;
class CImageDecoder;
class CBitmapScaler;
class TFrameInfo;
class CFbsBitmap;

// CLASS DECLARATIONS

/**
 * Phonebook image file or buffer -> bitmap reader.
 */
NONSHARABLE_CLASS(CPbk2ImageReader) : 
        public CActive
    {
    public: // interface
        /**
         * Creates a new instance of this class.
         *
         * @param aObserver observer to notify about progress of this 
         *        operation.
         * @return Image reader
         */
        static CPbk2ImageReader* NewL(MPbk2ImageReaderObserver& aObserver);
   
        /**
         * Destructor. Cancels any executing read operation and destroys this
         * object. Observer is not notified about the cancellation.
         */
        ~CPbk2ImageReader();

        /**
         * Reads bitmap from file. Cancels any previously executing read 
         * operation. Observer is not notified about the cancellation.
         *
         * @param aFileName name of the image file to read
         * @param aParams   optional parameters, @see TPbkImageLoadParameters
         */
        void ReadFromFileL
            (const TDesC& aFileName, 
            const TPbk2ImageManagerParams* aParams=NULL);

        /**
         * Reads bitmap from buffer. Cancels any previously executing read 
         * operation. Observer is not notified about the cancellation.
         *
         * @param aBuffer   the buffer to read the image from. Caller must keep
         *                  the buffer alive as long as this reader is 
         *                  executing
         * @param aParams   optional parameters, @see TPbkImageLoadParameters
         */
        void ReadFromBufferL
            (const TDesC8& aBuffer, 
            const TPbk2ImageManagerParams* aParams=NULL);

        /**
         * Recognizes image format in a file.
         *
         * @param aFileName file to recognize image format from.
         * @see ImageFormat().
         */
        void RecognizeFormatFromFileL(const TDesC& aFileName);

        /**
         * Recognizes image format in a buffer.
         *
         * @param aBuffer buffer to recognize image format from.
         * @see ImageFormat().
         */
        void RecognizeFormatFromBufferL(const TDesC8& aBuffer);

        /**
         * Returns Mime string of the recognized format. Recognizing
         * function has to be called before this, otherwise Mime string
         * is not known and NULL descriptor will be returned.
         *
         * @return Mime string of the recognized format.
         */
        const TDesC8& MimeString() const;

        /**
         * Returns information about a frame of the image.
         * Can be called after this object calls ImageOpenComplete to its
         * observer.
         *
         * @param aFrame    number of the frame to get inforamtion of.
         * @param aInfo     frame information is written to this parameter.
         * @precond aFrame>=0 && aFrame<FrameCount()
         * @see CImageDecoder::FrameInfo
         */
        void FrameInfo(TInt aFrame, TFrameInfo& aInfo) const;

        /**
         * Returns the frame count of the image.
         * Can be called after this object calls ImageOpenComplete to its
         * observer.
         *
         * @return Frame count
         * @see CImageDecoder::FrameCount
         */
        TInt FrameCount() const;

        /**
         * This is overridden from CActive because 
         * observers may be called from RunL. If observers then call
         * Cancel method, the CActive implementation does not call DoCancel.
         * However, in this case it has to be called so that resources 
         * are freed immediately in case of Cancel.
         */
        void Cancel();

    private: // From CActive
        void RunL();
        TInt RunError(TInt aError);
        void DoCancel();
       
    private: // implementation
        CPbk2ImageReader(MPbk2ImageReaderObserver& aObserver);
        void ConstructL();
        void NextStateL();
        void ConvertImageToBitmapL();
        /*
         * Crops the image to square if the width is bigger than the height
         */
        void CropImageToSquareL();
        void ScaleBitmapL();
        void Complete();
        void InitReadL(const TPbk2ImageManagerParams* aParams);
        void CloseImage();

    private: // data members
        /// Ref: observer
        MPbk2ImageReaderObserver& iObserver;
        /// Own: currect asynchronous step
        TInt iState;
        /// Own: reading parameters
        TPbk2ImageManagerParams iParams;
        /// Own: file server session
        RFs iFsSession;
        /// Own: image decoder
        CImageDecoder* iImageDecoder;        
        /// Own: read bitmap
        CFbsBitmap* iBitmap;
        /// Own: bitmap scaler
        CBitmapScaler* iBitmapScaler;
        /// Own: Mime string of the read image
        HBufC8* iMimeString;
    };

#endif // CPBK2IMAGEREADER_H
	
// End of File