/*
* 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:  This class is a VideoControl.
*
*/


//  INCLUDE FILES
#include <jdebug.h>
#include <lcdui.h>
#include <JniEnvWrapper.h>

#include "com_nokia_microedition_media_control_VideoControl.h"

#include "cmmavideocontrol.h"
#include "cmmacameraplayer.h"
#include "mmmaeventposter.h"
#include "cmmacanvasdisplay.h"
#include "cmmaitemdisplay.h"
#include "cmmasnapshotevent.h"
#include "mmmaguiplayer.h"
#include "cmmasnapshot.h"
#include "mmmadisplaywindow.h"
#include "cmmaplayerproperties.h"
#include "cmmadcdisplay.h"
#include "cmmavideocontrol.h"

_LIT(KControlName, "VideoControl");

EXPORT_C CMMAVideoControl::CMMAVideoControl(MMMAGuiPlayer* aGuiPlayer):
        CMMAControl()
{
    iGuiPlayer = aGuiPlayer;
    iIsForeground = 1;

    iDisplay = 0;
}

EXPORT_C CMMAVideoControl::~CMMAVideoControl()
{
    if (iMidEnv)
    {
        // unregister for getting the foreground change event
        DEBUG("CMMAVideoControl::~CMMAVideoControl() : iMidEnv RemoveObserver +");
        iMidEnv->RemoveObserver(*this);
        DEBUG("CMMAVideoControl::~CMMAVideoControl() : iMidEnv RemoveObserver -");
    }
    delete iDisplay;

    // Event server takes event ownership
    if (iEventPoster)
    {
        iEventPoster->PostEvent(iDeleteRefEvent);
    }
    if (iSnapshot)
    {
        iSnapshot->Cancel();
        delete iSnapshot;
    }
}


void CMMAVideoControl::ConstructL(CMMAVideoControl* aControl,
                                  jobject aControlObject,
                                  JNIEnv* aJni,
                                  MMMAEventPoster* aEventPoster,
                                  CMIDToolkit* aToolkit) // mobitv fix
{

    // JNI interface pointer can't be passed to different thread, so
    // it is needed to get valid JNI interface pointer for Event Server thread
    aJni = JniEnvWrapper::GetValidJniRef();

    aControl->iListenerObject = aControlObject;
    aControl->iJni = aJni;
    aControl->iEventPoster = aEventPoster;

    // snapshot ready method. Created here because jni cannot be used later.
    aControl->iSnapshotReadyMethod = aJni->GetMethodID(
                                         aJni->GetObjectClass(aControlObject),
                                         "snapshotReady",
                                         "(I[B)V");

    aControl->iSnapshot = CMMASnapshot::NewL(aControl->iGuiPlayer,
                          *aControl);
    aControl->RegisterForegroundListenerL(aToolkit);
}

// mobitv fix
void CMMAVideoControl::RegisterForegroundListenerL(CMIDToolkit* aToolkit)
{
    DEBUG("CMMAVideoControl::RegisterForegroundListener + ");

    // Initialize IsForeground to true, we might have already missed the event (HandleForegroundL), events before observer registration
    iIsForeground = ETrue;


    iToolkit = aToolkit;

    if (iToolkit)
    {
        DEBUG("CMMAVideoControl::RegisterForegroundListenerL : iToolkit->Env(); +");
        iMidEnv = iToolkit->Env();
        DEBUG("CMMAVideoControl::RegisterForegroundListenerL : iToolkit->Env(); -");
    }

    if (iMidEnv)
    {
        DEBUG("CMMAVideoControl::RegisterForegroundListenerL : iMidEnv->AddObserverL + ");
        // register for getting the foreground change event
        iMidEnv->AddObserverL(*this);
        DEBUG("CMMAVideoControl::RegisterForegroundListenerL : iMidEnv->AddObserverL - ");
    }

    DEBUG("CMMAVideoControl::RegisterForegroundListenerL - ");
}
void CMMAVideoControl::StaticInitL(CMMAVideoControl* aControl,
                                   MMIDComponent* aComponent,
                                   TInt* aDisplayHandle,
                                   CMMAEvent* aDeleteRefEvent)
{

    DEBUG("MMA::CMMAVideoControl::StaticInitL +");

    aControl->iDeleteRefEvent = aDeleteRefEvent;

    MMIDComponent::TType componentType = aComponent->Type();
    switch (componentType)
    {
    case MMIDComponent::ECustomItem:
    {
        //MMIDCustomItem
        MMIDCustomItem* customItem =
            reinterpret_cast< MMIDCustomItem* >(aComponent);

        CMMAItemDisplay* itemDisplay =
            CMMAItemDisplay::NewLC(customItem);

        aControl->iDisplay = itemDisplay;
        CleanupStack::Pop(itemDisplay);
        *aDisplayHandle = JavaMakeHandle(itemDisplay);
        break;
    }
    case MMIDComponent::ECanvas:
    {
        //MMIDCanvas
        MMIDCanvas* canvas = reinterpret_cast< MMIDCanvas* >(aComponent);

        CMMACanvasDisplay* canvasDisplay =
            CMMACanvasDisplay::NewLC(canvas);

        aControl->iDisplay = canvasDisplay;
        CleanupStack::Pop(canvasDisplay);
        *aDisplayHandle = JavaMakeHandle(canvasDisplay);
        break;
    }
    default:
    {
        // other component types are not supported
        User::Leave(KErrNotSupported);
    }
    }

    aControl->iGuiPlayer->SetDisplayL(aControl->iDisplay);
    DEBUG("MMA::CMMAVideoControl::StaticInitL - ");
}

void CMMAVideoControl::StaticInitDynamicModeL(
    CMMAVideoControl* aVideoControl,
    TInt* aContentHandle,
    CMMAEventSource* aEventSource,
    jobject aGUIObject,
    CMMAEvent* aDeleteRefEvent)
{
    DEBUG("MMA::CMMAVideoControl::StaticInitDynamicModeL+");
    aVideoControl->iDeleteRefEvent = aDeleteRefEvent;

    CMMADCDisplay* dcDisplay = CMMADCDisplay::NewLC(aVideoControl->iGuiPlayer,
                               aEventSource,
                               aGUIObject);

    MMMADirectContent* content = dcDisplay;
    *aContentHandle = reinterpret_cast< TInt >(content);
    aVideoControl->iDisplay = dcDisplay;
    aVideoControl->iGuiPlayer->SetDisplayL(aVideoControl->iDisplay);
    CleanupStack::Pop(dcDisplay);
    DEBUG("MMA::CMMAVideoControl::StaticInitDynamicModeL-");
}

void CMMAVideoControl::StaticGetPropertyL(CMMAVideoControl* aControl,
        TInt aPropertyType,
        TInt* aReturnValue)
{
    DEBUG_INT("MMA::CMMAVideoControl::StaticGetPropertyL property %d",
              aPropertyType);

    MMMADisplay* display = aControl->iDisplay;

    if (aPropertyType != com_nokia_microedition_media_control_VideoControl_PROPERTY_SOURCE_WIDTH &&
            aPropertyType != com_nokia_microedition_media_control_VideoControl_PROPERTY_SOURCE_HEIGHT &&
            !display)
    {
        DEBUG("MMA::CMMAVideoControl::StaticGetPropertyL not initialized yet");
        // init is not done yet, returning 0
        *aReturnValue = 0;
        return;
    }

    switch (aPropertyType)
    {
    case com_nokia_microedition_media_control_VideoControl_PROPERTY_DISPLAY_WIDTH:
    {
        *aReturnValue = display->DisplaySize().iWidth;
        break;
    }
    case com_nokia_microedition_media_control_VideoControl_PROPERTY_DISPLAY_HEIGHT:
    {
        *aReturnValue = display->DisplaySize().iHeight;
        break;
    }
    case com_nokia_microedition_media_control_VideoControl_PROPERTY_DISPLAY_X:
    {
        *aReturnValue = display->DisplayLocation().iX;
        break;
    }
    case com_nokia_microedition_media_control_VideoControl_PROPERTY_DISPLAY_Y:
    {
        *aReturnValue = display->DisplayLocation().iY;
        break;
    }
    case com_nokia_microedition_media_control_VideoControl_PROPERTY_SOURCE_WIDTH:
    {
        DEBUG("MMA::CMMAVideoControl::StaticGetPropertyL get source width");
        *aReturnValue = aControl->iGuiPlayer->SourceSize().iWidth;
        break;
    }
    case com_nokia_microedition_media_control_VideoControl_PROPERTY_SOURCE_HEIGHT:
    {
        DEBUG("MMA::CMMAVideoControl::StaticGetPropertyL get source height");
        *aReturnValue = aControl->iGuiPlayer->SourceSize().iHeight;
        break;
    }
    default:
    {
        *aReturnValue = KErrNotFound;
        User::Leave(KErrNotFound);
        break;
    }
    }
}


void CMMAVideoControl::StaticSetPropertyL(CMMAVideoControl* aControl,
        TInt aPropertyType,
        TInt aPropertyA,
        TInt aPropertyB)
{
    DEBUG_INT("MMA::CMMAVideoControl::StaticSetPropertyL property type %d",
              aPropertyType);
    DEBUG_INT("MMA::CMMAVideoControl::StaticSetPropertyL a property %d",
              aPropertyA);
    DEBUG_INT("MMA::CMMAVideoControl::StaticSetPropertyL b property %d",
              aPropertyB);

    MMMADisplay* display = aControl->iDisplay;

    __ASSERT_DEBUG(display != NULL,
                   User::Panic(_L("display not initialized"), KErrNotReady));

    switch (aPropertyType)
    {
    case com_nokia_microedition_media_control_VideoControl_SET_DISPLAY_SIZE:
    {
        TSize displaySize(aPropertyA, aPropertyB);
        display->SetDisplaySizeL(displaySize);

        // inform java side
        if (!display->IsFullScreen())
        {
            aControl->iGuiPlayer->NotifyWithStringEvent(
                CMMAPlayerEvent::ESizeChanged, KControlName);
        }
        break;
    }
    case com_nokia_microedition_media_control_VideoControl_SET_DISPLAY_LOCATION:
    {
        TPoint displayLocation(aPropertyA, aPropertyB);
        display->SetDisplayLocationL(displayLocation);
        break;
    }
    case com_nokia_microedition_media_control_VideoControl_SET_DISPLAY_VISIBLE_TRUE:
    {
        display->SetVisible(ETrue);
        break;
    }
    case com_nokia_microedition_media_control_VideoControl_SET_DISPLAY_VISIBLE_FALSE:
    {
        display->SetVisible(EFalse);
        break;
    }
    case com_nokia_microedition_media_control_VideoControl_SET_DISPLAY_FULLSCREEN_TRUE:
    {
        // store old user rect to determine if SIZE_CHANGED event
        // has to be delivered when full screen mode is turned off.
        aControl->iOldDisplaySize = display->DisplaySize();

        display->SetFullScreenL(ETrue);
        break;
    }
    case com_nokia_microedition_media_control_VideoControl_SET_DISPLAY_FULLSCREEN_FALSE:
    {
        display->SetFullScreenL(EFalse);

        // Send SIZE_CHANGED event when fullscreen is turned off if
        // size of the video display has changed. Possible position
        // change is however disregarded
        if (aControl->iOldDisplaySize != display->DisplaySize())
        {
            aControl->iGuiPlayer->NotifyWithStringEvent(
                CMMAPlayerEvent::ESizeChanged, KControlName);
        }

        break;
    }
    default:
    {
        User::Leave(KErrNotFound);
        break;
    }
    }
}


void CMMAVideoControl::TakeSnapShotL(CMMAVideoControl* aControl,
                                     const TDesC* aProperties)
{
    __ASSERT_DEBUG(
        aControl,
        User::Panic(_L("CMMAVideoControl::TakeSnapShotL CMMAVideoControl is NULL"),
                    KErrArgument)
    );

    ASSERT(aProperties);
    aControl->iSnapshot->TakeSnapShotL(*aProperties);
}

EXPORT_C void CMMAVideoControl::SnapshotReady()
{
    DEBUG("MMA::CMMAVideoControl::SnapshotReady()");

    // now this class owns the buffer
    HBufC8* imageBuffer = iSnapshot->ImageBuffer();
    // Use standard new to avoid useless trap.
    CMMASnapshotEvent* event =
        new CMMASnapshotEvent(iListenerObject,
                              iSnapshotReadyMethod,
                              iSnapshot->iStatus.Int(),
                              imageBuffer,
                              CMMAEvent::EDisposableEvent);
    if (event)
    {
        // ok, ownership of buffer transfered to event

        // event poster takes the ownership of the event
        iEventPoster->PostEvent(event, CJavaEventBase::ENotifyPriority);
    }
    else
    {
        // we own the buffer
        delete imageBuffer;
    }
}

EXPORT_C const TDesC& CMMAVideoControl::ClassName() const
{
    return KControlName;
}
TBool CMMAVideoControl::IsForeground()
{
    DEBUG_INT("CMMAVideoControl::IsForeground() %d",iIsForeground);

    return iIsForeground;
}

void CMMAVideoControl::StaticSetForegroundL(CMMAVideoControl* aControl,
        TInt aForeground)
{
    DEBUG_INT("MMA::CMMAVideoControl::StaticSetForegroundL + aForeground %d",
              aForeground);

    __ASSERT_DEBUG(
        aControl,
        User::Panic(_L("MMA::CMMAVideoControl::StaticSetForegroundL : CMMAVideoControl is NULL"),
                    KErrArgument)
    );

    if (aControl)
    {
        aControl->SetForeground(aForeground, EFalse);
    }

    DEBUG("MMA::CMMAVideoControl::StaticSetForegroundL - ");
}
// Implement MMIDEnvObserver

EXPORT_C void CMMAVideoControl::HandleSwitchOnL(TBool /*aSwitchOn*/)
{
    // Dummy implementation, no intent to do anything
}

/**
 * Handles the case when the MIDlet is brought to the foreground.
 */
EXPORT_C void CMMAVideoControl::HandleForegroundL(TBool aForeground)
{

    SetForeground(aForeground, ETrue);

}
void CMMAVideoControl::SetForeground(TBool aForeground, TBool aUseEventServer)
{
    iIsForeground = aForeground;
    if (iDisplay)
    {
        iDisplay->SetForeground(iIsForeground, aUseEventServer);
    }
}

/**
 * Handles a change to resources which are shared accross the environment.
 */
EXPORT_C void CMMAVideoControl::HandleResourceChangeL(TInt /*aType*/)
{
    // Dummy implementation, no intent to do anything
}
//  END OF FILE