diff -r e5618cc85d74 -r 6c158198356e javauis/mmapi_akn/baseline/src.nga/cmmacameraplayer.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javauis/mmapi_akn/baseline/src.nga/cmmacameraplayer.cpp	Thu Aug 19 09:48:13 2010 +0300
@@ -0,0 +1,964 @@
+/*
+* 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 <e32svr.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);
+    bitmapDevice->CreateContext(bitmapGc);
+    bitmapGc->BitBlt(TPoint(0,0), aSrcBitmap);
+
+    delete bitmapGc;
+    delete bitmapDevice;
+    DEBUG("MMA::CMMACameraPlayer::HandleBitmapCopyL -");
+}
+
+void CMMACameraPlayer::SetDisplayL(MMMADisplay* aDisplay)
+{
+    DEBUG("MMA::CMMACameraPlayer::SetDisplay");
+
+    // now it is ready to draw
+    iDisplay = aDisplay;
+
+    // Passes display into iWindow.
+    // Allocates all resources needed to use a camera DirectViewFinder.
+    iWindow->SetDisplay(aDisplay);
+
+    iDisplay->SetWindowL(iWindow);
+
+    // Set view finder size to the display only if the view finder
+    // size has been resolved.
+    if (iSize != TSize(0, 0))
+    {
+        iDisplay->SourceSizeChanged(iSize);
+        NotifyWithStringEvent(CMMAPlayerEvent::ESizeChanged, KVideoControlName);
+    }
+
+    iDisplay->FixUIOrientation(ETrue);
+    UpdateSensorInfoL();
+}
+
+TSize CMMACameraPlayer::SourceSize()
+{
+    return iSize;
+}
+
+MMMASnapshot::TEncoding CMMACameraPlayer::TakeSnapshotL(TRequestStatus* aStatus,
+        const TSize& aSize,
+        const CMMAImageSettings& aSettings)
+{
+    __ASSERT_DEBUG(!iSnapshotStatus, User::Invariant());
+    __ASSERT_DEBUG(!iSnapshotBitmap, User::Invariant());
+    __ASSERT_DEBUG(!iSnapshotEncoded, User::Invariant());
+
+    // snapshots can not be taken if player is not realized
+    if (iState < ERealized)
+    {
+        User::Leave(KErrNotReady);
+    }
+    // save status which will be notified
+    iSnapshotStatus = aStatus;
+
+    // changing status to pending
+    *iSnapshotStatus = KRequestPending;
+
+    // Source size not set in the beginning
+    TSize sourceSize;
+
+    // Use default if size is not specified.
+    TInt sourceSizeIndex;
+    
+    if (aSize.iWidth != KErrNotFound &&
+            aSize.iHeight != KErrNotFound)
+        {
+        sourceSizeIndex = iSourceSizeIndex;
+        }
+    else
+        {
+        sourceSizeIndex = 0;
+        }
+    
+    // Largest image size index
+    TInt largestSizeIndex = 0;
+
+    // Get camera characteristics
+    TCameraInfo cameraInfo;
+    iCamera->CameraInfo(cameraInfo);
+
+    // Set default snapshot encoding type
+    TEncoding encoding = EEncoded;
+    // Set default image capture format
+    CCamera::TFormat format = CCamera::EFormatExif;
+
+    DEBUG_INT("MMA::CMMACameraPlayer::TakeSnapshotL: cameraInfo.iImageFormatsSupported = 0x%x", cameraInfo.iImageFormatsSupported);
+    DEBUG_INT("MMA::CMMACameraPlayer::TakeSnapshotL: cameraInfo.iNumImageSizesSupported = %d", cameraInfo.iNumImageSizesSupported);
+
+    // Check if size was set in Java
+    if (aSize.iWidth != KErrNotFound &&
+            aSize.iHeight != KErrNotFound)
+    {
+        DEBUG("MMA::CMMACameraPlayer::TakeSnapshotL size was set in MIDlet");
+        // Determine if jpeg capture was requested
+        if ((*aSettings.iMimeType == KJpegMime) ||
+                (*aSettings.iMimeType == KImageJpegMime))
+        {
+            // Shortcut for supported image formats
+            TUint32 imageFormats = cameraInfo.iImageFormatsSupported;
+
+            // Jpeg subtype constants
+            _LIT8(KJpegJfif, "jfif");
+            _LIT8(KJpegExif, "exif");
+
+            // Resolve requested jpeg subtype from settings and camerainfo
+            if ((imageFormats & CCamera::EFormatJpeg) &&
+                    (*aSettings.iType == KJpegJfif))
+            {
+                // JFIF JPEG
+                format = CCamera::EFormatJpeg;
+                encoding = EEncoded;
+            }
+            else if ((imageFormats & CCamera::EFormatExif) &&
+                     (*aSettings.iType == KJpegExif))
+            {
+                // EXIF JPEG
+                format =  CCamera::EFormatExif;
+                encoding = EEncoded;
+            }
+        }
+
+        // Try to resolve nearest source size to the one requested,
+        // except for the JFIF and EXIF jpeg subtypes the match has
+        // to be exact otherwise non-encode capture format will be
+        // used
+        ResolveCaptureSizes(format,
+                            cameraInfo.iNumImageSizesSupported,
+                            aSize,
+                            sourceSize,
+                            sourceSizeIndex,
+                            largestSizeIndex);
+
+        // Format was either of the jpeg formats and requested size
+        // didn't match the source size
+        if ((format >= CCamera::EFormatJpeg &&
+                format <= CCamera::EFormatExif) &&
+                (aSize != sourceSize))
+        {
+            // Try again with an non-encoded format
+            format = CCamera::EFormatFbsBitmapColor16M;
+            encoding = EBitmap;
+            ResolveCaptureSizes(format,
+                                cameraInfo.iNumImageSizesSupported,
+                                aSize,
+                                sourceSize,
+                                sourceSizeIndex,
+                                largestSizeIndex);
+        }
+
+        if (sourceSizeIndex == KErrNotFound)
+        {
+            // If correct index was not found use the largest.
+            sourceSizeIndex = largestSizeIndex;
+        }
+    }
+    // else use default iSourceSizeIndex and default image capture format
+
+    iCamera->PrepareImageCaptureL(format,
+                                  sourceSizeIndex);
+
+    // play sound when capturing image
+    CMMACameraSound::PlayImageCaptureSoundL();
+
+    // start capture, ImageBufferReady will be called when ready
+    iWindow->SetStarted(EFalse);
+
+    iCamera->CaptureImage();
+
+    DEBUG_INT("MMA::CMMACameraPlayer::TakeSnapshotL: format = 0x%x", format);
+    DEBUG_INT("MMA::CMMACameraPlayer::TakeSnapshotL: sourceSizeIndex = %d", sourceSizeIndex);
+    DEBUG_INT("MMA::CMMACameraPlayer::TakeSnapshotL: encoding = %d", encoding);
+
+    // Inform caller which snapshot encoding was ultimately used
+    return encoding;
+}
+
+CFbsBitmap* CMMACameraPlayer::SnapshotBitmap()
+{
+    CFbsBitmap* bitmap = iSnapshotBitmap;
+
+    // ownership transfers to the caller
+    iSnapshotBitmap = NULL;
+    return bitmap;
+}
+
+HBufC8* CMMACameraPlayer::SnapshotEncoded()
+{
+    HBufC8* encoded = iSnapshotEncoded;
+
+    // ownership transfers to the caller
+    iSnapshotEncoded = NULL;
+    return encoded;
+}
+
+void CMMACameraPlayer::NotifyWithStringEvent(
+    CMMAPlayerEvent::TEventType aEventType,
+    const TDesC& aStringEventData)
+{
+    PostStringEvent(aEventType, aStringEventData);
+}
+
+MMMASnapshot* CMMACameraPlayer::SnapshoterL()
+{
+    return this;
+}
+
+TInt CMMACameraPlayer::CameraHandle()
+{
+    return iCamera->Handle();
+}
+
+void CMMACameraPlayer::SetViewFinderMode(TBool aStopViewFinder)
+{
+    iStopViewFinder = aStopViewFinder;
+}
+
+void CMMACameraPlayer::UpdateSensorInfoL()
+{
+    DEBUG("CMMACameraPlayer::UpdateSensorInfoL +");
+    CSensrvChannelFinder* channelFinder;
+    channelFinder = CSensrvChannelFinder::NewL();
+    CleanupStack::PushL(channelFinder);
+
+    //List of found channels.
+    RSensrvChannelInfoList channelInfoList;
+    CleanupClosePushL(channelInfoList);
+
+    //Create and fill channel search criteria.
+    TSensrvChannelInfo channelInfo;
+    channelInfo.iChannelType = KSensrvChannelTypeIdOrientationData;
+    //Find the orientation channel
+    channelFinder->FindChannelsL(channelInfoList, channelInfo);
+
+    if(channelInfoList.Count() != 1)
+    {
+        DEBUG("CMMACameraPlayer::UpdateSensorInfoL, Orientation channel not found");
+        User::Leave( KErrNotSupported );
+    }
+    else
+    {
+        DEBUG("CMMACameraPlayer::UpdateSensorInfoL, Orientation channel found");
+    }
+
+    iAccSensorChannel = CSensrvChannel::NewL(channelInfoList[ 0 ]);
+    CleanupStack::PopAndDestroy(&channelInfoList);
+    CleanupStack::PopAndDestroy(channelFinder);
+
+    TRAPD(channelerror, iAccSensorChannel->OpenChannelL());
+    if (channelerror!=KErrNone)
+    {
+        User::Leave( channelerror );
+    }
+    
+    // start listening
+    iAccSensorChannel->StartDataListeningL(this, //this object is data listener for this channel
+                                            1, //aDesiredCount is one, i.e. each orientation change is notified separately
+                                            1, //aMaximumCount is one, i.e. object count in receiving data buffer is one
+                                            0);//buffering period is not used
+    iLastImageOrientation = ECamOrientation0;
+    DEBUG("CMMACameraPlayer::UpdateSensorInfoL -");
+}
+
+void CMMACameraPlayer::DataReceived(CSensrvChannel& aChannel,
+                                    TInt /*aCount*/, 
+                                    TInt /*aDataLost*/)
+{
+    DEBUG_INT("CMMACameraPlayer::DataReceived aChannel %d", aChannel.GetChannelInfo().iChannelType);
+
+    if (KSensrvChannelTypeIdOrientationData == aChannel.GetChannelInfo().iChannelType)
+    {
+        TSensrvOrientationData orientationData;
+        TPckg<TSensrvOrientationData> orientationPackage(orientationData);
+        aChannel.GetData(orientationPackage);
+
+        iImageOrientation =
+                MapSensorOrientatio2CamOrientation(orientationData.iDeviceOrientation, 
+                                                   iLastImageOrientation,
+                                                   iActiveCameraIndex);
+
+        TRAPD(error, iCustomInterfaceOrientation->SetOrientationL(Map2CameraOrientation(iImageOrientation)));
+        if (KErrNone == error)
+        {
+            DEBUG_INT("CMMACameraPlayer::DataReceived SetOrientationL error = %d", error);
+        }
+
+        iLastImageOrientation = iImageOrientation;
+    }
+}
+
+void CMMACameraPlayer::DataError(CSensrvChannel& /*aChannel*/,
+                                 TSensrvErrorSeverity aError)
+{
+    DEBUG_INT("MMA::CMMACameraPlayer::DataError: aError = %d", aError);
+    if ( ESensrvErrorSeverityFatal == aError ) 
+    {
+        // Delete sensor api object
+        delete iAccSensorChannel;
+        iAccSensorChannel = NULL;
+
+        // Set orientation back to default if not already there.
+        iImageOrientation   = ECamOrientation0;
+    }
+}
+
+void CMMACameraPlayer::GetDataListenerInterfaceL(TUid /*aInterfaceUid*/,
+                                                 TAny*& /*aInterface*/)
+{
+}
+
+TCamImageOrientation CMMACameraPlayer::MapSensorOrientatio2CamOrientation( 
+    const TSensrvOrientationData::TSensrvDeviceOrientation& aSensorOrientation, 
+    TCamImageOrientation aLastImageOrientation,
+    TCamActiveCamera aActiveCameraIndex)
+{
+    DEBUG_INT("MMA::CMMACameraPlayer::MapSensorOrientatio2CamOrientation: aSensorOrientation = %d", 
+    aSensorOrientation);
+
+    TCamImageOrientation cameraOrientation( ECamOrientation0 );
+
+    // Primary camera rotation
+    if (aActiveCameraIndex == ECamActiveCameraPrimary) 
+    {
+      switch(aSensorOrientation)
+      {
+        case TSensrvOrientationData::EOrientationDisplayUpwards:
+            DEBUG("CMMACameraPlayer::MapSensorOrientatio2CamOrientation EOrientationDisplayUpwards");
+            // If coming from upside down portrait...
+            if ( ECamOrientation270 == aLastImageOrientation )
+            {
+                // Switch from upside down portrait to normal portrait.") )
+                cameraOrientation = ECamOrientation90; // Set normal portrait
+            }
+            // If coming from upside down landscape...
+            else if ( ECamOrientation180 == aLastImageOrientation )
+            {
+                // Switch from upside down landscape to normal landscape...") )
+                cameraOrientation = ECamOrientation0; // Set normal lanscape
+            }
+            // If neither one, keep the current image orientation.
+            else
+            {
+                cameraOrientation = ECamOrientationIgnore;
+            }
+            break;
+
+        case TSensrvOrientationData::EOrientationDisplayDownwards:
+            DEBUG("CMMACameraPlayer::MapSensorOrientatio2CamOrientation EOrientationDisplayDownwards");
+            // Camera is pointing up now. Check if it was upside down previously.
+            // If coming from upside down portrait...
+            if ( ECamOrientation270 == aLastImageOrientation )
+            {
+                // Switch from upside down portrait to normal portrait...") )
+                cameraOrientation = ECamOrientation90; // Set normal portrait
+            }
+            // If coming from upside down landscape...
+            else if ( ECamOrientation180 == aLastImageOrientation )
+            {
+                // Switch from upside down landscape to normal landscape...") )
+                cameraOrientation = ECamOrientation0; // Set normal lanscape
+            }
+            // If neither one, keep the current image orientation.
+            else
+            {
+                cameraOrientation = ECamOrientationIgnore;
+            }
+        	  break;
+        case TSensrvOrientationData::EOrientationDisplayRightUp:
+            DEBUG("CMMACameraPlayer::MapSensorOrientatio2CamOrientation EOrientationDisplayRightUp");
+        case TSensrvOrientationData::EOrientationUndefined:
+            DEBUG("CMMACameraPlayer::MapSensorOrientatio2CamOrientation EOrientationUndefined");
+            cameraOrientation = ECamOrientation0;     
+            break;
+        case TSensrvOrientationData::EOrientationDisplayUp:
+            DEBUG("CMMACameraPlayer::MapSensorOrientatio2CamOrientation EOrientationDisplayUp");
+            cameraOrientation = ECamOrientation90;
+            break;
+        case TSensrvOrientationData::EOrientationDisplayLeftUp:
+            DEBUG("CMMACameraPlayer::MapSensorOrientatio2CamOrientation EOrientationDisplayLeftUp");
+            cameraOrientation = ECamOrientation180;
+            break;
+        case TSensrvOrientationData::EOrientationDisplayDown:
+            DEBUG("CMMACameraPlayer::MapSensorOrientatio2CamOrientation EOrientationDisplayDown");
+            cameraOrientation = ECamOrientation270;
+            break;
+        default:
+            DEBUG("Camera <> Unexpected orientation value");
+            break;
+        }
+      }
+    // Secondary camera rotations
+    else if (aActiveCameraIndex == ECamActiveCameraSecondary)
+    {
+      if (aSensorOrientation == TSensrvOrientationData::EOrientationDisplayUp) // Portrait
+      {
+        DEBUG("CMMACameraPlayer::MapSensorOrientatio2CamOrientation Secondary-camera EOrientationDisplayUp");
+        cameraOrientation = ECamOrientation180; 
+      }
+      else if (aSensorOrientation == TSensrvOrientationData::EOrientationDisplayDown)  // Upside down portrait
+      {
+        DEBUG("CMMACameraPlayer::MapSensorOrientatio2CamOrientation Secondary-camera EOrientationDisplayDown");
+        cameraOrientation = ECamOrientation180;
+      }
+      else
+      {
+        DEBUG("CMMACameraPlayer::MapSensorOrientatio2CamOrientation Secondary-camera else");
+        cameraOrientation = ECamOrientation0;
+      }
+    }
+
+    return cameraOrientation;
+}
+
+MCameraOrientation::TOrientation CMMACameraPlayer::Map2CameraOrientation( 
+    const TCamImageOrientation& aSettingOrientation )
+{
+    DEBUG("CMMACameraPlayer::Map2CameraOrientation +");
+    switch(aSettingOrientation)
+    {
+    case ECamOrientation90:
+      DEBUG("CMMACameraPlayer::Map2CameraOrientation ECamOrientation90");
+      return MCameraOrientation::EOrientation90;
+    case ECamOrientation180:
+      DEBUG("CMMACameraPlayer::Map2CameraOrientation ECamOrientation180");
+      return MCameraOrientation::EOrientation180;
+    case ECamOrientation270:
+      DEBUG("CMMACameraPlayer::Map2CameraOrientation ECamOrientation270");
+      return MCameraOrientation::EOrientation270;
+    case ECamOrientation0:    // <<fall through>>
+    default:                  
+      DEBUG("CMMACameraPlayer::Map2CameraOrientation ECamOrientation0 or default");
+      return MCameraOrientation::EOrientation0;
+    }
+}
+
+//  END OF FILE