/*
* Copyright (c) 2006 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:  mpx user helper classes
*
*/

#include <s32mem.h>
#include <f32file.h>
#include <e32property.h>
#include <ctsydomainpskeys.h>
#include <mpxmediageneraldefs.h>
#include <mpxmedia.h>
#include <mpxattribute.h>
#include <mpxlog.h>
#include "mpxuser.h"

// ----------------------------------------------------------------------------
// Recreate a buffer
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::RecreateBufferL(TInt aSize, CBufBase*& aBuf)
    {
    delete aBuf;
    aBuf=NULL;
    CBufBase* buf=CBufFlat::NewL(aSize);
    CleanupStack::PushL(buf);
    buf->ResizeL(aSize);
    CleanupStack::Pop(buf);
    aBuf = buf;
    }


// ----------------------------------------------------------------------------
// Helper funciton to create descriptor array from buffer
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::CreateFromBufferL(
    const CBufBase &aBuf,
    CDesCArray*& aArray)
    {
    delete aArray;
    aArray = NULL;
    RBufReadStream rs(aBuf);
    CleanupClosePushL(rs);
    InternalizeL(aArray, rs);
    CleanupStack::PopAndDestroy(&rs);
    }

// ----------------------------------------------------------------------------
// Helper funciton to create a buffer
// ----------------------------------------------------------------------------
//
EXPORT_C CBufBase* MPXUser::CreateBufferLC(TInt aSize)
    {
    CBufBase* buf=CBufFlat::NewL(aSize);
    CleanupStack::PushL(buf);
    buf->ResizeL(aSize);
    return buf;
    }

// ----------------------------------------------------------------------------
// Create a buffer from an array
// aBuf replaced with the contents of the descriptor array and its sizes.
// The size of the buffer is the size of data in the buffer
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::CreateBufferL(const MDesCArray* aArray, CBufBase*& aBuf)
    {
    delete aBuf;
    aBuf = NULL;

    CBufBase* buffer=CreateBufferLC(KMPXBufGranularity);
    RBufWriteStream ws(*buffer);
    CleanupClosePushL(ws);
    ExternalizeL(aArray, ws);
    ws.CommitL();
    CleanupStack::PopAndDestroy(&ws);
    buffer->Compress();
    CleanupStack::Pop(buffer);
    aBuf = buffer;
    }

// ----------------------------------------------------------------------------
// Create buffer from message
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::CreateBufferL(
    const RMessage2& aMessage,
    TInt aMsgSlot,
    CBufBase*& aBuffer)
    {
    TInt s=aMessage.GetDesLengthL(aMsgSlot);
    if ( s <= 0 )
        {
        User::Leave( KErrArgument );
        }
    RecreateBufferL(s, aBuffer);
    TPtr8 p(aBuffer->Ptr(0));
    aMessage.Read(aMsgSlot,p);
    }

// ----------------------------------------------------------------------------
// Create buffer from a descriptor
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::CreateBufferL(const TDesC& aDes, CBufBase*& aBuffer)
    {
    TPtrC8 ptr8 = MPXUser::Ptr(aDes);
    RecreateBufferL(ptr8.Length(), aBuffer);
    aBuffer->Write(0, ptr8);
    aBuffer->Compress();
    }

// ----------------------------------------------------------------------------
// Creates a narrow heap descriptor from a unicode descriptor.
// No character conversion
// ----------------------------------------------------------------------------
//
EXPORT_C HBufC8* MPXUser::Alloc8L(const TDesC& aDes)
    {
    HBufC8* des8=HBufC8::NewL(aDes.Length());
    des8->Des().Copy(aDes);
    return des8;
    }

// ----------------------------------------------------------------------------
// Creates a zero-terminated narrow heap descriptor from a unicode descriptor.
// No character conversion
// ----------------------------------------------------------------------------
//
EXPORT_C HBufC8* MPXUser::Alloc8ZL(const TDesC& aDes)
    {
    HBufC8* des8=HBufC8::NewL(aDes.Length()+1);
    des8->Des().Copy(aDes);
    des8->Des().ZeroTerminate();
    return des8;
    }

// ----------------------------------------------------------------------------
// Creates a heap descriptor from a narrow descriptor.
// No character conversion
// ----------------------------------------------------------------------------
//
EXPORT_C HBufC* MPXUser::AllocL(const TDesC8& aDes)
    {
    HBufC* item = HBufC::NewL(aDes.Length());
    item->Des().Copy(aDes);
    return item;
    }

// ----------------------------------------------------------------------------
// Creates a narrow ptr descriptor on a unicode descriptor
// ----------------------------------------------------------------------------
//
EXPORT_C TPtrC8 MPXUser::Ptr(const TDesC& aDes)
    {
#ifdef _UNICODE
    TInt len=aDes.Length()*2; // Unicode->Narrow
    return TPtrC8((TUint8*)(&aDes[0]),len);
#else
    return TPtrC8(aDes);
#endif
    }

// ----------------------------------------------------------------------------
// Creates a wide ptr descriptor on a narrow descriptor
// ----------------------------------------------------------------------------
//
EXPORT_C TPtrC MPXUser::Ptr(const TDesC8& aDes)
    {
#ifdef _UNICODE
    TInt len=aDes.Length()/2; // Narrrow->Unicode
    return TPtrC((TUint16*)(&aDes[0]),len);
#else
    return TPtrC(aDes);
#endif
    }

// ----------------------------------------------------------------------------
// Helper internalize a descriptor array from a stream
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::InternalizeL(
    CDesCArray*& aArray,
    RReadStream& aStream)
    {
    delete aArray;
    aArray = NULL;
    TInt n=aStream.ReadInt32L();
    if( n )
        {
        CDesCArray* array=new(ELeave)CDesCArrayFlat(n);
        CleanupStack::PushL(array);
        TInt len;
        for (TInt i=0;i<n;++i)
            {
            len=aStream.ReadInt32L();
            HBufC* item=HBufC::NewLC(len);
            TPtr bp = item->Des();
            aStream.ReadL(bp,len);
            array->AppendL(*item);
            CleanupStack::PopAndDestroy(item);
            }
        CleanupStack::Pop(array);
        aArray = array;
        }
    else
        {
        // Dummy
        aArray = new(ELeave)CDesCArrayFlat(1);
        }
    }

// ----------------------------------------------------------------------------
// Helper externalize a descriptor array to a stream
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::ExternalizeL(
    const MDesCArray* aArray,
    RWriteStream& aStream)
    {
    if (aArray)
        {
        TInt n = aArray->MdcaCount();
        aStream.WriteInt32L(n);
        for (TInt i=0;i<n;++i)
            {
            TPtrC item=aArray->MdcaPoint(i);
            aStream.WriteInt32L( item.Length() );
            aStream.WriteL(item, item.Length());
            }
        }
    else
        {
        // Nothing to externalize
        aStream.WriteInt32L(0);
        }
    }

// ----------------------------------------------------------------------------
// Group attributes belonging to one content into an item in the array
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::MergeAttributeL(
    const TArray<TMPXAttribute>& aSrc,
    RArray<TMPXAttribute>& aDest)
    {
    aDest.Reset();
    for (TInt i = 0; i < aSrc.Count(); i++)
        {
        const TMPXAttribute& s = aSrc[i];
        TInt index = aDest.Find(s, TMPXAttribute::MatchContentId);
        if ( KErrNotFound == index )
            {
            aDest.AppendL(s);
            }
        else
            {
            TMPXAttribute& d = aDest[index];
            d = TMPXAttribute(d.ContentId(), d.AttributeId() | s.AttributeId());
            }
        }
    }

// ----------------------------------------------------------------------------
// Determines the owning process id of the thread
// ----------------------------------------------------------------------------
//
EXPORT_C TProcessId MPXUser::ProcessIdL(TThreadId aId)
    {
    RThread t;
    User::LeaveIfError(t.Open(aId));
    CleanupClosePushL(t);
    RProcess p;
    User::LeaveIfError(t.Process(p));
    TProcessId pid=p.Id();
    p.Close();
    CleanupStack::PopAndDestroy(&t);
    return pid;
    }

// ----------------------------------------------------------------------------
// Add array items in aSrc into sorted array aDest if the item is not in
// the aDest yet
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::MergeArray(const MDesCArray& aSrc, CDesCArray& aDest)
    {
    for (TInt i=aSrc.MdcaCount(); --i>=0 ;)
        {
        ////ignore leave when insert the same item
        TRAP_IGNORE(aDest.InsertIsqL(aSrc.MdcaPoint(i)));
        }
    }

// ----------------------------------------------------------------------------
// Copies elements from one array of descriptors to another
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::CopyArrayL(const MDesCArray& aSrc, CDesCArray& aDest)
    {
    aDest.Reset();
    for (TInt i=0; i < aSrc.MdcaCount(); ++i)
        {
        aDest.AppendL(aSrc.MdcaPoint(i));
        }
    }

// ----------------------------------------------------------------------------
// Compare two uids
// ----------------------------------------------------------------------------
//
EXPORT_C TInt MPXUser::CompareUids(const TUid& aId1, const TUid& aId2)
    {
    TInt ret(0);
    if (aId1.iUid > aId2.iUid)
        {
        ret=1;
        }
    else if (aId1.iUid < aId2.iUid)
        {
        ret=-1;
        }
    return ret;
    }

// ----------------------------------------------------------------------------
// Compare two sorted arrays of uids
// ----------------------------------------------------------------------------
//
EXPORT_C TInt MPXUser::CompareOrderedUidArrays(
    const TArray<TUid>& aArray1,
    const TArray<TUid>& aArray2)
    {
    TInt ret(-1);
    TInt count1 = aArray1.Count();
    TInt count2 = aArray2.Count();
    if (count1 >= count2)
        {
        TInt s1(0); // start point of array 1
        TBool found(ETrue);
        for (TInt i=0; i<count2 && found; ++i)
            {
            found = EFalse;
            for (TInt j=s1; j<count1; ++j)
                {
                if (aArray1[j].iUid == aArray2[i].iUid)
                    {
                    s1=j+1; // compare from next item
                    found = ETrue;
                    break;
                    }
                }
            }
        if (found)
            {
            if (count1==count2)
                {
                ret=0;
                }
            else
                {
                ret=1;
                }
            }
        }
    return ret;
    }

// ----------------------------------------------------------------------------
// Internalize an array of item ids from stream
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::InternalizeL(RArray<TMPXItemId>& aArray, RReadStream& aStream)
    {
    TInt n=aStream.ReadInt32L();
    for (TInt i=0;i<n;++i)
        {
        TUint32 id1(aStream.ReadUint32L());
        TUint32 id2(aStream.ReadUint32L());
        aArray.AppendL(TMPXItemId(id1,id2));
        }
    }

// ----------------------------------------------------------------------------
// Externalize an array of itemids to stream
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::ExternalizeL(const TArray<TMPXItemId>& aArray, RWriteStream& aStream)
    {
    TInt n=aArray.Count();
    aStream.WriteInt32L(n);
    for (TInt i=0;i<n;++i)
        {
        aStream.WriteUint32L(aArray[i].iId1);
        aStream.WriteUint32L(aArray[i].iId2);
        }
    }

// ----------------------------------------------------------------------------
// Helper to get the window group ID associated with a process
// ----------------------------------------------------------------------------
//
EXPORT_C TInt MPXUser::FindWindowGroupIdL(
    TProcessId aProcId,
    RWsSession& aWsSession )
    {
    TInt wgId( KErrNotFound );
    RArray<RWsSession::TWindowGroupChainInfo> windowArray;
    CleanupClosePushL( windowArray );
    aWsSession.WindowGroupList( &windowArray );
    TInt wgCount( windowArray.Count() );

    for ( TInt i = 0; i < wgCount && wgId == KErrNotFound; i++ )
        {
        TThreadId threadId;
        User::LeaveIfError(
            aWsSession.GetWindowGroupClientThreadId(
                windowArray[i].iId, threadId ) );
        RThread thread;
        CleanupClosePushL( thread );
        User::LeaveIfError( thread.Open( threadId ));
        RProcess proc;
        CleanupClosePushL( proc );
        User::LeaveIfError( thread.Process( proc ));
        if ( proc.Id() == aProcId )
            {
            wgId = windowArray[i].iId;
            }
        CleanupStack::PopAndDestroy( &proc );
        CleanupStack::PopAndDestroy( &thread );
        }
    CleanupStack::PopAndDestroy( &windowArray );
    return wgId;
    }

// -----------------------------------------------------------------------------
// Check if there is the given type call ongoing.
// -----------------------------------------------------------------------------
//
EXPORT_C TBool MPXUser::IsCallOngoing( TInt aCallType )
    {
    MPX_FUNC( "MPXUser::IsCallOngoing" );
    // In case call info not fully received (err != KErrNone),
    // assume no call exists.
    TBool ret( EFalse );

    // Get call status and type.
    TInt callState( EPSCTsyCallStateUninitialized );

    TInt err( RProperty::Get(
        KPSUidCtsyCallInformation,
        KCTsyCallState,
        callState ) );

    MPX_DEBUG3("MPXUser::IsCallOngoing() call state: %d , error (%d)", callState, err );

    if ( !err &&
         ( callState != EPSCTsyCallStateUninitialized &&
           callState != EPSCTsyCallStateNone ) )
        {
        TInt callType( EPSCTsyCallTypeUninitialized );

        // There is call ongoing, check it's type.
        err = RProperty::Get(
            KPSUidCtsyCallInformation,
            KCTsyCallType,
            callType );

        MPX_DEBUG3("MPXUser::IsCallOngoing() call type:  %d, error (%d)", callType,  err );

        if ( !err )
            {
            if ( aCallType == KMPXCallTypeGenericVoice )
                {
                // Return true for CSVoice/Video/VOIP calls
                ret = ( callType == EPSCTsyCallTypeCSVoice ||
                        callType == EPSCTsyCallTypeH324Multimedia ||
                        callType == EPSCTsyCallTypeVoIP );
                MPX_DEBUG2("MPXUser::IsCallOngoing KMPlayerCallTypeGenericVoice return (%d) ", ret );
                }
            else
                {
                // Check the requested type call.
                ret = ( callType == aCallType );
                MPX_DEBUG2("MPXUser::IsCallOngoing return (%d) ", ret );
                }
            }
        }
    MPX_DEBUG2("MPXUser::IsCallOngoing return (%d) ", ret );
    return ret;
    }

// -----------------------------------------------------------------------------
// Compelete file name with file path of the dll
// -----------------------------------------------------------------------------
//
EXPORT_C TInt MPXUser::CompleteWithDllPath(const TDesC& aDllName, TDes& aFileName)
    {
    MPX_DEBUG2("==>MPXUser::CompleteWithDllPath aFileName %S", &aFileName);
    TInt error(KErrNotSupported);
    MPX_DEBUG2("MPX Dll file path: %S", &aDllName);
    TPtrC driveAndPath = TParsePtrC(aDllName).DriveAndPath();
    TParse parse;
    error = parse.Set(aFileName, &driveAndPath, NULL);
    if (!error)
        {
        aFileName.Zero();
        aFileName.Append(parse.FullName());
        }
    MPX_DEBUG2("<==MPXUser::CompleteWithDllPath aFileName %S", &aFileName);
    return error;
    }

// End of file