/*

* Copyright (c) 2002-2009 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:  This class is used for playing camera.

*

*/

//  INCLUDE FILES

#include <sensrvchannelfinder.h>

#include <sensrvorientationsensor.h>

#include <jdebug.h>

#include <fbs.h>

#include "cmmacameraplayer.h"

#include "tmmaparametervalidator.h"

#include "mmmadisplay.h"

#include "cmmacamerasound.h"

#if defined( __WINS__ )

#include <w32std.h>

#endif

// CONSTANTS

_LIT8(KImageJpegMime, "image/jpeg");

_LIT8(KJpegMime, "jpeg");

_LIT(KVideoControlName, "VideoControl");

CMMACameraPlayer* CMMACameraPlayer::NewLC(TCamActiveCamera aCameraIndex)

{

    CMMACameraPlayer* self = new(ELeave) CMMACameraPlayer(aCameraIndex);

    CleanupStack::PushL(self);

    self->ConstructL(aCameraIndex);

    return self;

}

CMMACameraPlayer::~CMMACameraPlayer()

{

    DEBUG("CMMACameraPlayer::~CMMACameraPlayer +");

    // Free (duplicated) UI camera resources first.

    // Window is not able to send any

    // callback requests to UI from now.

    if (iWindow)

    {

        iWindow->SetDisplay(NULL);

    }

    if (iCamera)

    {

        iCamera->CancelCaptureImage();

        iCamera->Release();

        delete iCamera;

    }

    delete iSnapshotEncoded;

    delete iSnapshotBitmap;

    delete iRealizeWait;

    if (iDisplay && iDisplay->HasContainer())

    {

        // Window will delete itself

        // after all pending events are processed

        // (lazy delete)

        iDisplay->UIGetCallback(

            *iWindow, CMMACameraWindow::EDestroyWindow);

    }

    else

    {

        delete iWindow;

    }

    iWindow = NULL;

    // Delete sensor api object

    delete iAccSensorChannel;

    DEBUG("CMMACameraPlayer::~CMMACameraPlayer -");

}

CMMACameraPlayer::CMMACameraPlayer(TCamActiveCamera aCameraIndex):

        iDisplay(NULL),

        iSourceSizeIndex(KErrNotFound),

        iStartTime(KErrNotFound),

        iSnapshotEncoded(NULL),

        iActiveCameraIndex(aCameraIndex),

        iImageOrientation(ECamOrientation0),

        iLastImageOrientation(ECamOrientation0)

{

    iStopViewFinder = ETrue;

}

void CMMACameraPlayer::ConstructL(TCamActiveCamera aCameraIndex)

{

    CMMAPlayer::ConstructL();

    if (aCameraIndex >= CCamera::CamerasAvailable())

    {

        // image capture is not supported

        User::Leave(KErrNotFound);

    }

    iCamera = CCamera::New2L(*this, aCameraIndex, 100);

    iCustomInterfaceOrientation =

      static_cast <MCameraOrientation*>(

        iCamera->CustomInterface(KCameraOrientationUid ));

    iCustomInterfaceUIOrientationOverride =

      static_cast <MCameraUIOrientationOverride*>(

      iCamera->CustomInterface(KCameraUIOrientationOverrideUid));

    // Fix to landscape mode

    iCustomInterfaceUIOrientationOverride->SetOrientationModeL(1);

    iWindow = CMMACameraWindow::NewL(iCamera->Handle());

    TCameraInfo cameraInfo;

    iCamera->CameraInfo(cameraInfo);

    if (cameraInfo.iNumImageSizesSupported < 1)

    {

        // image capture is not supported

        User::Leave(KErrNotFound);

    }

    // default snapshot size

    iSourceSizeIndex = cameraInfo.iNumImageSizesSupported - 1;

    iRealizeWait = new(ELeave)CRealizeWait;

}

TInt64 CMMACameraPlayer::CurrentTime()

{

    TTime time;

    time.HomeTime();

    return time.Int64();

}

void CMMACameraPlayer::ResolveViewFinderSizeL(TSize& aSize)

{

    DEBUG("CMMACameraPlayer::ResolveViewFinderSizeL");

    TSize resultSize;

    // The only way to find out the size is to start the view finder

    // with a proper size (screen size).

    ResolveScreenSizeL(resultSize);

    // StartViewFinderBitmapsL changes resultSize to

    // the used view finder size.

    // Used to get the source size only.

    iCamera->StartViewFinderBitmapsL(resultSize);

    // Bitmap viewfinder is not used anymore.

    iCamera->StopViewFinder();

    aSize = resultSize;

}

void CMMACameraPlayer::ResolveScreenSizeL(TSize& aSize)

{

    DEBUG("CMMACameraPlayer::ResolveScreenSizeL");

#if defined( __WINS__ )

    TSize size(0,0);

    RWsSession ws;

    if (ws.Connect() == KErrNone)

    {

        CleanupClosePushL(ws);

        CWsScreenDevice* wsScreenDevice = new(ELeave)CWsScreenDevice(ws);

        CleanupStack::PushL(wsScreenDevice);

        User::LeaveIfError(wsScreenDevice->Construct());

        size = wsScreenDevice->SizeInPixels();

        CleanupStack::PopAndDestroy(2);    // wsScreenDevice, ws.Close()

    }

    aSize = size;

#else

    TScreenInfoV01 info;

    TPckgBuf< TScreenInfoV01 > buf(info);

    UserSvr::ScreenInfo(buf);

    info = buf();

    aSize = info.iScreenSize;

#endif

}

void CMMACameraPlayer::ResolveCaptureSizes(const CCamera::TFormat aFormat,

        const TInt aNumImageSizesSupported,

        const TSize& aRequestSize,

        TSize& aSourceSize,

        TInt& aSourceIndex,

        TInt& aLargestIndex)

{

    // Largest image size

    TSize largestSize;

    // Index to largest image size

    TInt largestSizeIndex = 0;

    // Source size

    TSize sourceSize;

    // Default source size index not set

    TInt sourceSizeIndex = KErrNotFound;

    // Temporary size for iterating capture sizes

    TSize tmpSize;

    DEBUG_INT("MMA::CMMACameraPlayer::ResolveCaptureSizes: aFormat = 0x%x", aFormat);

    // go through all supported sizes.

    // Notice: Capture sizes are assumed to be in order from smaller to larger sizes

    for (TInt i = 0; i < aNumImageSizesSupported; i++)

    {

        iCamera->EnumerateCaptureSizes(tmpSize,

                                       i,

                                       aFormat);

        DEBUG_INT("MMA::CMMACameraPlayer::ResolveCaptureSizes: tmpSize.iWidth = %d", tmpSize.iWidth);

        DEBUG_INT("MMA::CMMACameraPlayer::ResolveCaptureSizes: tmpSize.iHeight = %d", tmpSize.iHeight);

        // Check if current is the largest

        if ((largestSize.iWidth < tmpSize.iWidth) &&

                (largestSize.iHeight < tmpSize.iHeight))

        {

            largestSize = tmpSize;

            largestSizeIndex = i;

        }

        // If wanted size is smaller than tmpSize we can use it

        if ((aRequestSize.iWidth <= tmpSize.iWidth) &&

                (aRequestSize.iHeight <= tmpSize.iHeight))

        {

            sourceSize = tmpSize;

            sourceSizeIndex = i;

        }

    }

    DEBUG_INT("MMA::CMMACameraPlayer::ResolveCaptureSizes: sourceSizeIndex = %d", sourceSizeIndex);

    DEBUG_INT("MMA::CMMACameraPlayer::ResolveCaptureSizes: largestSizeIndex = %d", largestSizeIndex);

    aSourceSize = sourceSize;

    aSourceIndex = sourceSizeIndex;

    aLargestIndex = largestSizeIndex;

}

void CMMACameraPlayer::StartL(TBool aPostEvent)

{

    DEBUG_INT("CMMACameraPlayer:StartL iState %d", iState);

    // start can't be called to not ready player

    if (iState == EPrefetched)

    {

        // camera passes ready images through

        // ViewFinderFrameReady method

        // set time when started

        iStartTime = CurrentTime();

        // inform java side

        ChangeState(EStarted);

        TInt64 time;

        GetMediaTime(&time);

        // Notify the camera window

        // about the status change

        iWindow->SetStarted(ETrue);

        if (aPostEvent)

        {

            // inform java side

            PostLongEvent(CMMAPlayerEvent::EStarted, time);

        }

    }

    PostActionCompleted(KErrNone);   // java start return

}

void CMMACameraPlayer::StopL(TBool aPostEvent)

{

    DEBUG_INT("CMMACameraPlayer::StopL", iState);

    if (iState == EStarted)

    {

        TInt64 time;

        GetMediaTime(&time);   // add played time to media time

        if (iStopViewFinder && iWindow->ViewFinderActive())

        {

            iWindow->SetStarted(EFalse);

        }

        iStartTime = KErrNotFound;

        if (aPostEvent)

        {

            PostLongEvent(CMMAPlayerEvent::EStopped, time);

        }

        // go back to prefetched state

        ChangeState(EPrefetched);

    }

}

void CMMACameraPlayer::DeallocateL()

{

    // If player is started when deallocate is called,

    // player is stopped from java side -> state is changed to

    // prefetched.

    // In prefetched state only reserved resource is

    // camera reserve( released with iCamera->Release() )

    // In realized state no resources have been reserved.

    // CHANGED: not releasing camera anymore, since it is already

    // done in realized state

    if (iState == EPrefetched)

    {

        ChangeState(ERealized);

    }

}

void CMMACameraPlayer::RealizeL()

{

    iCamera->Reserve();

    // this lock will be released when power on is completed (or error)

    if (!iRealizeWait->IsStarted())

    {

        iRealizeWait->Start();

    }

    User::LeaveIfError(iRealizeWait->iError);

    CMMAPlayer::RealizeL();

}

void CMMACameraPlayer::PrefetchL()

{

    DEBUG("MMA::CMMACameraPlayer::PrefetchL");

    // nothing to do here

    ChangeState(EPrefetched);

    PostActionCompleted(KErrNone);

}

void CMMACameraPlayer::GetDuration(TInt64* aDuration)

{

    // camera viewer has no duration.

    *aDuration = KTimeUnknown;

}

void CMMACameraPlayer::SetMediaTimeL(TInt64* /*aTime*/)

{

    DEBUG("MMA::CMMACameraPlayer::SetMediaTimeL ");

    // with camera media time is not supported.

}

void CMMACameraPlayer::GetMediaTime(TInt64* aMediaTime)

{

    if (iState == EStarted)

    {

        // add play time to media time

        iMediaTime += CurrentTime() - iStartTime;

        // set new start time

        iStartTime = CurrentTime();

    }

    // set value to parameter

    (*aMediaTime) = iMediaTime;

}

void CMMACameraPlayer::CloseL()

{

    DEBUG("MMA::CMMACameraPlayer::CloseL()");

    // cancel all activity

    iCamera->CancelCaptureImage();

    // Stop and release UI Camera instance

    iWindow->SetDisplay(NULL);

    // we don't need reserve camera anymore

    iCamera->Release();

    iCustomInterfaceOrientation = NULL;

    if (iAccSensorChannel)

    {

        iAccSensorChannel->StopDataListening();

    }

    if (iDisplay)

    {

        iDisplay->FixUIOrientation(EFalse);

    }

    CMMAPlayer::CloseL();

}

const TDesC& CMMACameraPlayer::Type()

{

    return KMMACameraPlayer;

}

void CMMACameraPlayer::HandleEvent(const TECAMEvent& aEvent)

{

    TInt error = aEvent.iErrorCode;

    if (KUidECamEventReserveComplete == aEvent.iEventType)

    {

        DEBUG_INT("MMA::CMMACameraPlayer::HandleEvent:KUidECamEventReserveComplete error  %d", error);

        if (error == KErrNone)

        {

            // camera will notify completion with PowerOnComplete method.

            iCamera->PowerOn();

        }

        else

        {

            // release lock and store error. State doesn't change.

            iRealizeWait->iError = error;

            iRealizeWait->AsyncStop();

        }

    }

    else if (KUidECamEventPowerOnComplete == aEvent.iEventType)

    {

        DEBUG_INT("MMA::CMMACameraPlayer::HandleEvent:KUidECamEventPowerOnComplete error  %d", error);

        TSize viewFinderSize;

        if (error == KErrNone)

        {

            // The view finder size must be known after prefetching.

            TRAP(error, ResolveViewFinderSizeL(viewFinderSize));

        }

        if (error == KErrNone)

        {

            iSize = viewFinderSize;

            if (iDisplay)

            {

                iDisplay->SourceSizeChanged(iSize);

                NotifyWithStringEvent(CMMAPlayerEvent::ESizeChanged, KVideoControlName);

                iDisplay->FixUIOrientation(ETrue);

            }

        }

        iRealizeWait->iError = error;

        iRealizeWait->AsyncStop();

    }

}

void CMMACameraPlayer::ViewFinderReady(MCameraBuffer& aCameraBuffer,

                                       TInt /*aError*/)

{

    aCameraBuffer.Release();

}

void CMMACameraPlayer::ImageBufferReady(MCameraBuffer& aCameraBuffer,TInt aError)

{

    DEBUG_INT("MMA::CMMACameraPlayer::ImageBufferReady %d", aError);

    // This method should never be called,

    // unless we are taking snapshot

    __ASSERT_DEBUG(iSnapshotStatus, User::Invariant());

    __ASSERT_DEBUG(!iSnapshotBitmap, User::Invariant());

    __ASSERT_DEBUG(!iSnapshotEncoded, User::Invariant());

    TInt error = aError;

    if (aError == KErrNone)

    {

        CFbsBitmap* srcBitmap = NULL;

        TRAP(error, HandleBitmapCopyL(aCameraBuffer, srcBitmap));

        DEBUG_INT("MMA::CMMACameraPlayer::ImageBufferReady HandleBitmapCopyL %d", error);

        // picture data is not of bitmap type

        if (!srcBitmap && (KErrNotSupported == error))

        {

            TDesC8* temp = NULL;

            TRAP(error, temp = aCameraBuffer.DataL(0));

            DEBUG_INT("CMMACameraPlayer::CopyImageDataL DataL error %d", error);

            if (KErrNone == error)

            {

                iSnapshotEncoded = temp->Alloc();

            }

        }

    }

    // notify the caller, error code or KErrNone

    User::RequestComplete(iSnapshotStatus, error);

    iWindow->SetStarted(ETrue);

    // Status is not needed anymore

    // and this class don't own the status.

    iSnapshotStatus = NULL;

    aCameraBuffer.Release();

}

void CMMACameraPlayer::VideoBufferReady(MCameraBuffer& aCameraBuffer,

                                        TInt /*aError*/)

{

    aCameraBuffer.Release();

}

void CMMACameraPlayer::HandleBitmapCopyL(MCameraBuffer& aCameraBuffer, 

                                         CFbsBitmap* aSrcBitmap)

{

    DEBUG("MMA::CMMACameraPlayer::HandleBitmapCopyL +");

    aSrcBitmap = &(aCameraBuffer.BitmapL(0)); // not owned

    iSnapshotBitmap = new(ELeave)CFbsBitmap();

    User::LeaveIfError(iSnapshotBitmap->Create(aSrcBitmap->SizeInPixels(),

                                             aSrcBitmap->DisplayMode()));

    CFbsBitmapDevice* bitmapDevice = NULL;

    CFbsBitGc* bitmapGc = NULL;

    bitmapDevice = CFbsBitmapDevice::NewL(iSnapshotBitmap);