/*

* 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:

*

*/

#include <es_sock.h>

#include <es_enum.h>

#include <upnpsettingsengine.h>

#include <upnpavcontrollerfactory.h>

#include <upnpavcontroller.h>

#include <upnpavdevice.h>

#include <upnpavdevicelist.h>

#include <upnprenderingstatemachine.h>

#include <upnpavrenderingsession.h>

#include <upnpvolumestatemachine.h>

#include <upnpitemresolverfactory.h>

#include <upnpitemresolver.h>

#include <upnpconnectionmonitor.h>

#include "exampleappengine_p.h"

#include "trace.h"

/*!

    /class ExampleAppEnginePrivate

    /brief Implements interface to Symbian side DLNA APIs.

    This is the "rendering engine" class, implementing various UPnP callback

    interfaces. Some of the callbacks are lacking implementation because this

    simple example application does not require all that functionality.

*/

/*!

    C++ constructor.

*/

ExampleAppEnginePrivate::ExampleAppEnginePrivate():

    q_ptr(0),

    mSettingsEngine(0),

    mAVRenderingSession(0),

    mRenderingStateMachine(0),

    mVolumeStateMachine(0),

    mAVController(0),

    mIap(0),

    mIapName(""),

    mDevices(0),

    mDevice(0),

    mPlaybackState(ExampleAppEngine::PlaybackStateStopped),

    mItemResolver(0)

{

    FUNC_LOG    

    TRAP_IGNORE(mSettingsEngine = CUPnPSettingsEngine::NewL());

    TRAP_IGNORE(mDevices = CUpnpAVDeviceList::NewL());

    TRAP_IGNORE(mConnectionMonitor = CUPnPConnectionMonitor::NewL(0));

    mConnectionMonitor->SetObserver(*this);

}

/*!

    C++ destructor.

*/

ExampleAppEnginePrivate::~ExampleAppEnginePrivate()

{

    FUNC_LOG

    delete mItemResolver;

    delete mDevices;

    delete mSettingsEngine;

    if (mAVRenderingSession)

    {

        if (mAVController)

        {

            mAVController->StopRenderingSession(*mAVRenderingSession);

        }

    }

    delete mRenderingStateMachine;

    delete mVolumeStateMachine;

    if (mAVController)

    {

        mAVController->Release();

    }

    delete mConnectionMonitor;

}

/*!

    Checks for connected IAP.

*/

void ExampleAppEnginePrivate::construct()

{

    FUNC_LOG

    resolveIapL();

    resolveIapNameL();

}

/*!

    Returns currently connected IAP.

*/

int ExampleAppEnginePrivate::getConnectedIap() const

{

    FUNC_LOG

    return mIap;

}

/*!

    Returns the name of the currently connected IAP.

*/

QString ExampleAppEnginePrivate::getConnectedIapName() const

{

    FUNC_LOG

    return mIapName;

}

/*!

    Returns the current playback state.

*/

int ExampleAppEnginePrivate::getPlaybackState() const

{

    FUNC_LOG

    return mPlaybackState;

}

/*!

    Returns whether the currently selected renderer supports seek functionality.

*/

bool ExampleAppEnginePrivate::isSeekSupported() const

{

    FUNC_LOG

    // TODO: return real value when seek is implemented

    return false;

}

/*!

    Returns whether the currently selected renderer supports pause functionality.

*/

bool ExampleAppEnginePrivate::isPauseSupported() const

{

    FUNC_LOG

    bool isSupported(false);

    if (mDevice)

    {

        isSupported = mDevice->PauseCapability();

    }

    return isSupported;

}

/*!

    This function causes renderingDeviceFound() signals to be emitted in two different ways:

    first the current device list in UPnP AV Controller is gone through and for each

    renderer device found from there one signal is emitted. Also, this object is set as a

    device observer to the UPnP AV Controller, causing it to call this class's callback

    function UPnPDeviceDiscovered() upon every new device that is discovered from the current network.

*/

void ExampleAppEnginePrivate::searchRenderingDevices()

{

    FUNC_LOG

    if (mIap)

    {

        // first create av controller

        if (!mAVController)

        {

            TRAP_IGNORE(mAVController = UPnPAVControllerFactory::NewUPnPAVControllerL());

            if (!mAVController)

            {

                return;

            }

            mAVController->SetDeviceObserver(*this);

        }

        // check if devices have been found

        TRAP_IGNORE(searchRenderingDevicesL());

    }    

}

/*!

    Start a rendering session with the renderer provided in /a uuid.

*/

void ExampleAppEnginePrivate::prepareRenderingDevice(const QString &uuid)

{

    FUNC_LOG

    TRAP_IGNORE(prepareRenderingDeviceL(uuid));    

}

/*!

    Start file initialization for sharing.

*/

int ExampleAppEnginePrivate::initFile(const QString& file)

{

    FUNC_LOG

    TRAPD(err, initFileL(file));

    return err;

}

/*!

    Issues the play() command to the renderer.

*/

void ExampleAppEnginePrivate::play()

{

    FUNC_LOG

    TRAP_IGNORE(playL());

}

/*!

    Issues the pause() command to the renderer.

*/

void ExampleAppEnginePrivate::pause()

{

    FUNC_LOG

    TRAP_IGNORE(pauseL());

}

/*!

    Issues the stop() command to the renderer.

*/

void ExampleAppEnginePrivate::stop()

{

    FUNC_LOG

    TRAP_IGNORE(stopL());

}

/*!

    Issues the volumeUp() command to the renderer.

*/

void ExampleAppEnginePrivate::volumeUp()

{

    FUNC_LOG

    // TODO: implement

}

/*!

    Issues the volumeDown() command to the renderer.

*/

void ExampleAppEnginePrivate::volumeDown()

{

    FUNC_LOG

    // TODO: implement

}

/*!

    Issues the rew() command to the renderer.

*/

void ExampleAppEnginePrivate::rew()

{

    FUNC_LOG

    // TODO: implement

}

/*!

    Issues the ff() command to the renderer.

*/

void ExampleAppEnginePrivate::ff()

{

    FUNC_LOG

    // TODO: implement

}

/*!    

    Callback function that UPnP AV Controller calls when a new UPnP AV Device is

    found from the network.

    From MUPnPAVDeviceObserver

*/

void ExampleAppEnginePrivate::UPnPDeviceDiscovered(const CUpnpAVDevice& aDevice)

{

    FUNC_LOG

    TRAP_IGNORE(upnpDeviceDiscoveredL(aDevice));

}

/*!

    Callback function that UPnP AV Controller calls when a UPnP AV Device has

    disappeared from the network.

    From MUPnPAVDeviceObserver

*/

void ExampleAppEnginePrivate::UPnPDeviceDisappeared(const CUpnpAVDevice& aDevice)

{

    FUNC_LOG

    // search device from list

    CUpnpAVDevice *device(NULL);

    int count(mDevices->Count());

    int index(0);

    for (int i = 0; i < count; i++)

    {

        device = (*mDevices)[i];

        if (device->Uuid() == aDevice.Uuid())

        {

            index = i;

            break;

        }

        device = NULL;

    }

    // remove if device was found

    if (device)

    {

        mDevices->Remove(index);

        if (device->Uuid() == mDevice->Uuid())

        {

            stopRenderingSession();

        }

        QString name = asString8(device->FriendlyName());

        QString uuid = asString8(device->Uuid());        

        emit q_ptr->renderingDeviceDisappeared(name, uuid);

        delete device;

    }

}

/*!

    Callback function that UPnP AV Controller calls when the WLAN

    connection has been lost. All existing sessions should be considered

    invalid.

    From MUPnPAVDeviceObserver

*/

void ExampleAppEnginePrivate::WLANConnectionLost()

{

    FUNC_LOG

    // no implementation required

}

/*!

    Just pass to volume state machine

    From MUPnPAVRenderingSessionObserver

*/

void ExampleAppEnginePrivate::VolumeResult(TInt aError,

    TInt aVolumeLevel,

    TBool aActionResponse)

{

    FUNC_LOG

    if (mVolumeStateMachine)

    {

        mVolumeStateMachine->VolumeResult(aError, aVolumeLevel, aActionResponse);

    }

}

/*!

    Just pass to volume state machine

    From MUPnPAVRenderingSessionObserver

*/

void ExampleAppEnginePrivate::MuteResult(TInt aError,

    TBool aMute,

    TBool aActionResponse)

{

    FUNC_LOG

    if (mVolumeStateMachine)

    {

        mVolumeStateMachine->MuteResult(aError, aMute, aActionResponse);

    }

}

/*!

    Just pass to rendering state machine

    From MUPnPAVRenderingSessionObserver

*/

void ExampleAppEnginePrivate::InteractOperationComplete(TInt aError,

    TUPnPAVInteractOperation aOperation)

{

    FUNC_LOG

    if (mRenderingStateMachine)

    {

        mRenderingStateMachine->InteractOperationComplete(aError, aOperation);

    }

}

/*!

    Just pass to rendering state machine

    From MUPnPAVRenderingSessionObserver

*/

void ExampleAppEnginePrivate::PositionInfoResult(TInt aError,

    const TDesC8& aTrackPosition,

    const TDesC8& aTrackLength)

{

    FUNC_LOG

    if (mRenderingStateMachine)

    {

        mRenderingStateMachine->PositionInfoResult(aError, aTrackPosition, aTrackLength);

    }

}

/*!

    Just pass to rendering state machine

    From MUPnPAVRenderingSessionObserver

*/

void ExampleAppEnginePrivate::SetURIResult(TInt aError)

{

    FUNC_LOG

    if (mRenderingStateMachine)

    {

        mRenderingStateMachine->SetURIResult(aError);

    }

}

/*!

    Just pass to rendering state machine

    From MUPnPAVRenderingSessionObserver

*/

void ExampleAppEnginePrivate::SetNextURIResult(TInt aError)

{

    FUNC_LOG

    if (mRenderingStateMachine)

    {

        mRenderingStateMachine->SetNextURIResult(aError);

    }

}

/*!

    Renderer to which there was an active session has disappeared. The session should be

    considered invalid.

    From MUPnPAVRenderingSessionObserver

*/

void ExampleAppEnginePrivate::MediaRendererDisappeared(TUPnPDeviceDisconnectedReason /*aReason*/)

{

    FUNC_LOG

    // TODO: implement

}

/*!

    Callback for telling that the rendering state machine is in synch with

    the rendering device.

    From MUpnpRenderingStateMachineObserver

*/

void ExampleAppEnginePrivate::RendererSyncReady(TInt /*aError*/, Upnp::TState /*aState*/)

{

    FUNC_LOG

    // TODO: implement

}

/*!

    Rendering device's state has been changed.

    From MUpnpRenderingStateMachineObserver

*/

void ExampleAppEnginePrivate::RenderingStateChanged(TInt aError,

    Upnp::TState aState,

    TBool /*aUserOriented*/,

    TInt /*aStateParam*/)

{

    FUNC_LOG

    int state(ExampleAppEngine::PlaybackStateStopped);

    if (aError == KErrNone)

    {

        switch (aState)

        {

            case Upnp::EBuffering:

            {

                state = ExampleAppEngine::PlaybackStateBuffering;

                break;

            }

            case Upnp::EPlaying:

            {

                state = ExampleAppEngine::PlaybackStatePlaying;

                break;

            }

            case Upnp::EPaused:

            {

                state = ExampleAppEngine::PlaybackStatePaused;

                break;

            }

            default:

            {

                // no actions, stopped state is used

                break;

            }

        }

    }

    mPlaybackState = state;

    emit q_ptr->stateChanged(mPlaybackState);

}