/*

 * Copyright (c) 2007-2008 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:  Implements RVoIPAudioSession object.

 *

 */

#include <s32mem.h>

#include "debugtracemacros.h"

#include "VoIPAudioClientServer.h"

#include "VoIPAudioSession.h"

// CONSTANTS

const TUint KServerConnectRetries = 2;

const TUint KSessionMessageSlots = 10;

// -----------------------------------------------------------------------------

// StartServer

// Static function to start the server process thread.

// Start the server process/thread which lives in an EPOCEXE object.

// Returns: TInt: KErrNone (0) if no error

// -----------------------------------------------------------------------------

//

static TInt StartServer()

    {

    const TUidType serverUid(KNullUid, KNullUid, KVoIPServerUid3);

    // Only one instance of the server is allowed. Attempt of launching

    // second instance of the server will fail with KErrAlreadyExists.

    RProcess server;

    TInt r = server.Create(KVoIPServerName, KNullDesC, serverUid);

    if (r != KErrNone)

        {

        return r;

        }

    TRequestStatus stat;

    server.Rendezvous(stat);

    if (stat != KRequestPending)

        {

        server.Kill(0); // abort startup

        }

    else

        {

        server.Resume(); // logon OK - start the server

        }

    User::WaitForRequest(stat); // wait for start or death

    // Panic reason cannot be '0' as it would conflict with KErrNone

    r = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();

    server.Close();

    return r;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::Connect

// Create a client-side session. Start the server if not started already.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::Connect()

    {

    TRACE_PRN_FN_ENT;

    TInt retry = KServerConnectRetries;

    TInt err = KErrGeneral;

    TInt numMessageSlots = KSessionMessageSlots;

    for (;;)

        {

        // Try to create a new session with the server

        err = CreateSession(KVoIPServerName, Version(), numMessageSlots);

        if ((err != KErrNotFound) && (err != KErrServerTerminated))

            {

            TRACE_PRN_N1(_L("[VAS session created; err==%d]"), err);

            break; // Connected to existing server - ok

            }

        if (--retry == 0)

            {

            break; // Failed.

            }

        // Server not running, try to start it.

        err = StartServer();

        TRACE_PRN_N1(_L("[VAS server started; err==%d]"), err);

        if ((err != KErrNone) && (err != KErrAlreadyExists))

            {

            break; // Server not launched - propagate error

            }

        }

    TRACE_PRN_FN_EXT;

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::Version

// -----------------------------------------------------------------------------

//

EXPORT_C TVersion RVoIPAudioSession::Version() const

    {

    return (TVersion(KVoIPServMajorVersionNumber,

            KVoIPServMinorVersionNumber, KVoIPServBuildVersionNumber));

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::Close

// -----------------------------------------------------------------------------

//

EXPORT_C void RVoIPAudioSession::Close()

    {

    TRACE_PRN_FN_ENT;

    SendClientRequest(EVoIPSessionClose, TIpcArgs(TIpcArgs::ENothing));

    RSessionBase::Close();

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::OpenDownlink

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::OpenDownlink(

        const TMMFPrioritySettings aPriority)

    {

    TMMFPrioritySettingsPckg pckg;

    pckg() = aPriority;

    TIpcArgs args(&pckg);

    TInt err = SendClientRequest(EVoIPOpenDownlink, args);

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::GetMaxVolume

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::GetMaxVolume()

    {

    TPckgBuf<TInt> pckg;

    TIpcArgs args(&pckg);

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::SetVolume

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::SetVolume(const TInt aVolume)

    {

    TInt err = SendClientRequest(EVoIPSetVolume, TIpcArgs(aVolume));

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::GetVolume

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::GetVolume()

    {

    TInt vol = 0;

    TVoIPMsgBufPckg pckg;

    TIpcArgs args(&pckg);

    TInt err = SendClientRequest(EVoIPGetVolume, args);

    if (err == KErrNone)

        {

        vol = pckg().iInt;

        err = pckg().iStatus;

        }

    return (err == KErrNone) ? vol : err;

    }

// ---------------------------------------------------------------------------

// RVoIPAudioSession::GetSupportedDecoders

// ---------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::GetSupportedDecoders(

        const TMMFPrioritySettings aPriority, RArray<TUint32>& aDecoders,

        TInt& aFrameSize)

    {

    TRACE_PRN_FN_ENT;

    TMMFPrioritySettingsPckg pckg;

    pckg() = aPriority;

    TIpcArgs args(&pckg);

    TInt err = SendClientRequest(EVoIPSetDecoderPriority, args);

    TVoIPMsgBufPckg pckg1;

    TIpcArgs args1(&pckg1);

    err = SendClientRequest(EVoIPGetSupportedDecodersCount, args1);

    TInt count = 0;

    aFrameSize = 0;

    if (err == KErrNone)

        {

        count = pckg1().iInt;

        aFrameSize = pckg1().iUint; //for 10/20ms frame detection

        err = pckg1().iStatus;

        }

    if (count > 0 && err == KErrNone)

        {

        TRAP(err, PopulateArrayL(EVoIPGetSupportedDecoders, aDecoders, count));

        }

    TRACE_PRN_FN_EXT;

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::SetDecoder

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::SetDecoder(const TUint32 aDecoder)

    {

    TPckgBuf<TUint32> pckg;

    pckg() = aDecoder;

    TIpcArgs args(&pckg);

    TInt err = SendClientRequest(EVoIPSetDecoder, args);

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::SetAudioDevice

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::SetAudioDevice(

        const CVoIPAudioDownlinkStream::TVoIPOutputDevice aDevice)

    {

    TPckgBuf<TUint> pckg;

    pckg() = TUint(aDevice);

    TIpcArgs args(&pckg);

    TInt err = SendClientRequest(EVoIPSetAudioDevice, args);

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::GetAudioDevice

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::GetAudioDevice(

        CVoIPAudioDownlinkStream::TVoIPOutputDevice& aDevice)

    {

    TVoIPMsgBufPckg pckg;

    TIpcArgs args(&pckg);

    TInt err = SendClientRequest(EVoIPGetAudioDevice, args);

    if (err == KErrNone)

        {

        aDevice = (CVoIPAudioDownlinkStream::TVoIPOutputDevice) pckg().iUint;

        err = pckg().iStatus;

        }

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::StartDownlink

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::StartDownlink()

    {

    TInt err = SendClientRequest(EVoIPStartDownlink, TIpcArgs(TIpcArgs::ENothing));

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::StopDownlink

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::StopDownlink()

    {

    TInt err = SendClientRequest(EVoIPStopDownlink, TIpcArgs(TIpcArgs::ENothing));

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::CloseDownlink

// -----------------------------------------------------------------------------

//

EXPORT_C void RVoIPAudioSession::CloseDownlink()

    {

    SendClientRequest(EVoIPCloseDownlink, TIpcArgs(TIpcArgs::ENothing));

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::BufferFilled

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::BufferFilled(TPtr8 aBuffer,

        const TUint aBufferSequence)

    {

    TVoIPMsgBufPckg pckg;

    pckg().iInt = aBuffer.Size();

    pckg().iUint = aBufferSequence;

    TIpcArgs args(&pckg);

    TInt err = SendClientRequest(EVoIPBufferFilled, args);

    return err;

    }

// For uplink stream

// -----------------------------------------------------------------------------

// RVoIPAudioSession::OpenUplink

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::OpenUplink(

        const TMMFPrioritySettings aPriority)

    {

    TMMFPrioritySettingsPckg pckg;

    pckg() = aPriority;

    TIpcArgs args(&pckg);

    TInt err = SendClientRequest(EVoIPOpenUplink, args);

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::GetMaxGain

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::GetMaxGain()

    {

    TPckgBuf<TInt> pckg;

    TIpcArgs args(&pckg);

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::SetGain

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::SetGain(const TInt aGain)

    {

    TInt err = SendClientRequest(EVoIPSetGain, TIpcArgs(aGain));

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::GetGain

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::GetGain()

    {

    TInt gain = 0;

    TVoIPMsgBufPckg pckg;

    TIpcArgs args(&pckg);

    TInt err = SendClientRequest(EVoIPGetGain, args);

    if (err == KErrNone)

        {

        gain = pckg().iInt;

        err = pckg().iStatus;

        }

    return (err == KErrNone) ? gain : err;

    }

// ---------------------------------------------------------------------------

// RVoIPAudioSession::GetSupportedEncodersL

// ---------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::GetSupportedEncoders(

        const TMMFPrioritySettings aPriority, RArray<TUint32>& aEncoders,

        TInt& aFrameSize)

    {

    TRACE_PRN_FN_ENT;

    TMMFPrioritySettingsPckg pckg;

    pckg() = aPriority;

    TIpcArgs args(&pckg);

    TInt err = SendClientRequest(EVoIPSetEncoderPriority, args);

    TVoIPMsgBufPckg pckg1;

    TIpcArgs args1(&pckg1);

    err = SendClientRequest(EVoIPGetSupportedEncodersCount, args1);

    TInt count = 0;

    aFrameSize = 0;

    if (err == KErrNone)

        {

        count = pckg1().iInt;

        aFrameSize = pckg1().iUint; //for 10/20ms frame detection

        err = pckg1().iStatus;

        }

    if (count > 0 && err == KErrNone)

        {

        TRAP(err, PopulateArrayL(EVoIPGetSupportedEncoders, aEncoders, count));

        }

    TRACE_PRN_FN_EXT;

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::SetEncoder

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::SetEncoder(const TUint32 aEncoder)

    {

    TPckgBuf<TUint32> pckg;

    pckg() = aEncoder;

    TIpcArgs args(&pckg);

    TInt err = SendClientRequest(EVoIPSetEncoder, args);

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::StartUplink

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::StartUplink()

    {

    TInt err = SendClientRequest(EVoIPStartUplink, TIpcArgs(TIpcArgs::ENothing));

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::StopUplink

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::StopUplink()

    {

    TInt err = SendClientRequest(EVoIPStopUplink, TIpcArgs(TIpcArgs::ENothing));

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::CloseUplink

// -----------------------------------------------------------------------------

//

EXPORT_C void RVoIPAudioSession::CloseUplink()

    {

    SendClientRequest(EVoIPCloseUplink, TIpcArgs(TIpcArgs::ENothing));

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::BufferEmptied

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::BufferEmptied(TPtr8 aBuffer)

    {

    TVoIPMsgBufPckg pckg;

    pckg().iInt = aBuffer.Size();

    TIpcArgs args(&pckg);

    TInt err = SendClientRequest(EVoIPBufferEmptied, args);

    return err;

    }

// For codec CIs

// -----------------------------------------------------------------------------

// RVoIPAudioSession::GetSupportedBitRatesL

// -----------------------------------------------------------------------------

//

EXPORT_C void RVoIPAudioSession::GetSupportedBitRatesL(RArray<TUint>& aArray)

    {

    TRACE_PRN_FN_ENT;

    TInt brCount = 0;

    TVoIPMsgBufPckg pckg;

    TIpcArgs args(&pckg);

    TInt err = SendClientRequest(EVoIPGetSupportedBitratesCount, args);

    if (err == KErrNone)

        {

        brCount = pckg().iInt;

        err = pckg().iStatus;

        }

    TRACE_PRN_N1(_L("BRCount [%d]"), brCount);

    if (brCount > 0 && err == KErrNone)

        {

        HBufC8* buf = HBufC8::NewLC(brCount * sizeof(TUint));

        TPtr8 ptr = buf->Des();

        TIpcArgs args1;

        args1.Set(0, &ptr);

        err = SendClientRequest(EVoIPGetSupportedBitrates, args1);

        if (err == KErrNone)

            {

            RDesReadStream stream(ptr);

            CleanupClosePushL(stream); // stream on cleanup

            aArray.Reset();

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

                {

                aArray.Append(stream.ReadUint32L());

                }

            CleanupStack::PopAndDestroy(&stream);

            }

        CleanupStack::PopAndDestroy(buf);

        }

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::SetBitRate

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RVoIPAudioSession::SetBitRate(const TUint aBitrate)

    {

    TInt err = SendClientRequest(EVoIPSetBitrate, TIpcArgs(aBitrate));

    return err;

    }

// -----------------------------------------------------------------------------

// RVoIPAudioSession::GetBitRate

// -----------------------------------------------------------------------------