/*

* Copyright (c) 2005-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:  Keeps info about Services, MIMEs and Applications

*

*/

// System includes

#include <e32def.h> // STATIC_CAST

#include <defaultappserver.rsg> // R_DAS_SERVICESMIMES_LISTBOX

#include <StringLoader.h> // StringLoader

#include <barsread.h> //TResourceRead

#include <eikenv.h> //CEikonEnv

#include <apgcli.h>

#include <apgicnfl.h> // CApaMaskedBitmap

#include <serviceregistry.h>

#include "das_servmimeapps.h"

#include "das_app.h" // KUidDefaultAppServer

#include <services_db.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <apmstd.h>

#else

#include <apmstd.h>

#include <apmfndr.h> // KDataTypePrioritySystem

#endif

const TInt KStringMargin = 10; //10 is a sufficiently large margin

// ======== MEMBER FUNCTIONS ======== CAppHelper

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

// Symbian 2-phased constructor

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

// 

CAppHelper* CAppHelper::NewLC(const TDesC& aName, const TInt aUid)

    {

    CAppHelper* self = new (ELeave) CAppHelper(aUid,0);

    CleanupStack::PushL(self);

    //construct iName, copy it

    self->iName = HBufC::NewL(aName.Size());

    TPtr* ptr=new (ELeave) TPtr(self->iName->Des());

    ptr->Copy(aName);

    delete ptr;

    return self;

    }

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

// Symbian 2-phased constructor

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

//     

CAppHelper* CAppHelper::NewLC(const CAppHelper& aApp)

    {

    CAppHelper* self = new (ELeave) CAppHelper(aApp.iUid,1,aApp.iFlags);

    CleanupStack::PushL(self);

    //construct iName, get pointer and flag it

    self->iName = aApp.iName;

    self->iFlags |= EFlagNameNotOwned;

    return self;

    }

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

// C++ Constructor

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

//     

CAppHelper::CAppHelper(const TInt aUid, const TInt aScore, const TInt aFlags):

    iName(NULL), iUid(aUid), iScore(aScore), iFlags(aFlags)

    {

    //no implementation needed

    }

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

// Destructor

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

//    

CAppHelper::~CAppHelper(void)

    {

    if(!( iFlags&EFlagNameNotOwned ))

        delete iName;

    iName = NULL;

    }

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

// This function is used to order Applications

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

//  

TInt CAppHelper::OrderApplications(const CAppHelper& a1, const CAppHelper& a2)

    {

    //if a1<a2 return -1, otherwise 0 or 1

    //platform applications are always first (smaller)

    if(a1.iFlags&EFlagPlatformApp && !(a2.iFlags&EFlagPlatformApp))

        return -1; //a1 is platform app, a2 is not

    if(!(a1.iFlags&EFlagPlatformApp) && a2.iFlags&EFlagPlatformApp)

        return 1; //a1 is not platform app, a2 is

    //look into names names

    if(*a1.iName < *a2.iName) return -1;

    if(*a1.iName > *a2.iName) return 1;

    //if we are here, strings were equal

    return 0;

    }

// ======== MEMBER FUNCTIONS ======== CServiceMime

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

// C++ Constructor

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

//     

CServiceMime::CServiceMime() : iServiceMime(NULL), iMime(NULL)

    {

    iDefaultAppUid=TUid::Uid(0);

    iDefaultApp=-1;//currently we do not know the default index

    iUsedByTasks=EFalse;

    }

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

// Destructor

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

//

CServiceMime::~CServiceMime()

    {

    if (iServiceMime) delete iServiceMime;

    if (iMime) delete iMime;

    for (TInt i=0 ; i<iApplications.Count() ; i++)

        delete iApplications[i];

    iApplications.Close();

    }

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

// This function is used to order Services & MIMEs

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

//  

TInt CServiceMime::OrderServiceMimes(const CServiceMime& a1, const CServiceMime& a2)

    {

    //if a1<a2 return -1, otherwise 0 or 1

    //we sort by the MIME, then by the service

    if(*a1.iMime<*a2.iMime)return -1;

    if(*a1.iMime>*a2.iMime)return 1;

    //if we are here, MIMEs are the same

    if(*a1.iServiceMime<*a2.iServiceMime)return -1;

    if(*a1.iServiceMime>*a2.iServiceMime)return 1;

    //if we are here, strings were equal

    return 0;

    }

// ======== MEMBER FUNCTIONS ======== CMediaTask

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

// Symbian 2-phased constructor

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

// 

CMediaTask* CMediaTask::NewLC( TResourceReader& aReader )

    {

    CMediaTask* self = new (ELeave) CMediaTask();

    CleanupStack::PushL(self);

    self->ConstructL(aReader);

    return self;

    }

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

// Destructor

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

//    

CMediaTask::~CMediaTask()

    {

    if(iTaskList)delete iTaskList;

    if(iTaskTitle)delete iTaskTitle;

    if(iMimeLabel)delete iMimeLabel;

    iMimes.ResetAndDestroy();

    iServicesUids.Close();

    iSMs.Close();//elements not owned

    iApplications.ResetAndDestroy();

    }

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

// C++ Constructor

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

// 

CMediaTask::CMediaTask() : iMimeLabel(NULL), iDefaultApp(-1)

    {

    }

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

// The construction means reading the task details from the resource file

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

//    

void CMediaTask::ConstructL( TResourceReader& aReader )

    {

    TInt i,count;

    //read the task name

    iTaskList = aReader.ReadHBufCL();

    if( !iTaskList )User::Leave(KErrArgument);

    //read the task title

    iTaskTitle = aReader.ReadHBufCL();

    if( !iTaskTitle )User::Leave(KErrArgument);

    //read the mime label

    iMimeLabel = aReader.ReadHBufC8L();

    if( !iMimeLabel )User::Leave(KErrArgument);

    //read the service mimes entries

    count = aReader.ReadInt16();

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

        {

        //read the service uid

        TInt uid=aReader.ReadInt32();

        if(uid == 0)User::Leave(KErrArgument);

        //read the mime

        HBufC8* mime=aReader.ReadHBufC8L();

        if( !mime )User::Leave(KErrArgument);

        //append both things

        iServicesUids.Append(uid);

        iMimes.Append(mime);//takes ownership

        }

    }

// ======== MEMBER FUNCTIONS ======== CDefaultAppServMimeApps

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

// Symbian 2-phased constructor

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

// 

CDefaultAppServMimeApps* CDefaultAppServMimeApps::NewL(const TUid& aAppUid, TInt aServiceFlags)

    {

    CDefaultAppServMimeApps* self = CDefaultAppServMimeApps::NewLC(aAppUid, aServiceFlags);

    CleanupStack::Pop(self);

    return self;

    }

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

// Symbian 2-phased constructor

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

// 

CDefaultAppServMimeApps* CDefaultAppServMimeApps::NewLC(const TUid& aAppUid, TInt aServiceFlags)

    {

    CDefaultAppServMimeApps* self = new (ELeave) CDefaultAppServMimeApps();

    CleanupStack::PushL(self);

    self->ConstructL(aAppUid, aServiceFlags);

    return self;

    }

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

// This function builds the data structures for the dialog:

// It reads the considered services from the resource files, then it builds the

// task list and the associated list of Services& MIMEs and applications.

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

//

void CDefaultAppServMimeApps::ConstructL(TUid aAppUid, TInt aServiceFlags)

    {

    //set the client app uid

    /* Uncomment this for testing the General Settings (Control Pannel) specific view from another application (R&D purpose)

     * 

    TBool flagGsClient = aServiceFlags & EFlagGsClient;

    if(flagGsClient)aAppUid=KUidGS; //we mimic the GS Client. 

    */

    iAppUid = aAppUid;

    //for all the available services, launch the AddMIMEsForServiceL function

    TResourceReader reader;

    CEikonEnv::Static()->CreateResourceReaderLC( reader, R_DA_SERVICE_MIME );

    CServicesDB* sdb = CServicesDB::NewLC(&reader);

    TInt i;

    TUid uid;

    for(i=0; i<sdb->Count(); i++)

        {

        uid = sdb->ServiceUidL(i);

        AddMIMEsForServiceL(uid,i,aServiceFlags,sdb);

        };

    CleanupStack::PopAndDestroy(sdb);

    CleanupStack::PopAndDestroy( ); // reader

    //change MIMEs & sort

    BeautifyAndSortServMimeApps();

    }

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

// this is by far the most complicated function in the entire subsystem

// some more comments are needed, but after this function will be split in 2

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

//

void CDefaultAppServMimeApps::AddMIMEsForServiceL(TUid aServiceUid, TInt aServiceIndex, TInt aServiceFlags, CServicesDB* aServicesDb)

    {

    CServiceMime *sm = NULL;

    TUid uid;

    RApaLsSession ls;

    TApaAppInfo info;

    CApaAppServiceInfoArray* serv=NULL;

    CServiceRegistry *sr=NULL;

    TInt i,j,k;

    TInt it,jt;//indexes for iterating inside tasks

    TInt lowerMarker, upperMarker;

    //flags

    TBool flagShowAll = EFalse;

    /*

     * Uncomment the line below to show all the Services & MIMEs in views, and not only those for which default app can be changed.

     * This can be used for R&D, to see all the MIMEs&Services in the system.

    flagShowAll = aServiceFlags & EFlagShowAllServicesAndMimes;

     */

    iFlagNoObserver = aServiceFlags & EFlagNoObserver;

    //check who is connecting, so that we can set the view

    if(iAppUid == KUidGS)

        {

        iSimplifiedView=ETrue; //at least in the beginning. 

                               //For this function, this is also a flag that says if we have GS as client or not

        GetTaskListL(R_DA_TASKS);

        }

    else iSimplifiedView=EFalse;

    //connect

    User::LeaveIfError( ls.Connect() );

    CleanupClosePushL( ls );

    //Get all the apps and MIMEs for the current service

    ls.GetAppInfo(info,iAppUid);

    serv=ls.GetServiceImplementationsLC(aServiceUid);

    lowerMarker = upperMarker = iServMimes.Count();

    //create entries for the MIMEs supported by the client application

    for (i=0; i<serv->Array().Count(); i++)

        {

        uid=serv->Array()[i].Uid();

        if( iSimplifiedView || uid == iAppUid) //this means that for app clients, we first skip all the other applications

            {

            //if iSimplifiedView is true, then we have GS as a client    

            for(j=0; j<serv->Array()[i].DataTypes().Count(); j++)

                {

                TBool createSM=ETrue;

                if(iSimplifiedView)

                    {

                    //check if we already have an entry for this service & MIME

                    for(k=lowerMarker; k<upperMarker; k++)

                        if(iServMimes[k]->iMime->Des() == serv->Array()[i].DataTypes()[j].iDataType.Des8())

                            {

                            //we found it!

                            sm=iServMimes[k];

                            createSM=EFalse;

                            break;//we found the sm, no need to search for it any more

                            }

                    //if we don't find it, we will create an entry ...

                    }

                if(createSM)

                    {

                    //we have to create sm, we did not found it previously (or we were not looking for it)

                    sm=new (ELeave) CServiceMime;

                    CleanupStack::PushL(sm);

                    sm->iMime = HBufC8::NewL(serv->Array()[i].DataTypes()[j].iDataType.Des8().Size());

                    *(sm->iMime) = serv->Array()[i].DataTypes()[j].iDataType.Des8();

                    //transform the MIME from audio/mpeg to audio mpeg

                    HBufC *transformedMime=HBufC::NewLC(serv->Array()[i].DataTypes()[j].iDataType.Des().Size());

                    TPtr *ptr=new (ELeave) TPtr(transformedMime->Des());

                    CleanupStack::PushL(ptr);

                    ptr->Copy(serv->Array()[i].DataTypes()[j].iDataType.Des());

                    TInt location=ptr->Locate('/');

                    if(location>0)ptr->Replace(location,1,_L(" "));

                    //transforming done

                    //sm->iServiceMime = aServicesDb->ServiceStringLC(aServiceIndex, serv->Array()[i].DataTypes()[j].iDataType.Des());

                    sm->iServiceMime = aServicesDb->ServiceStringLC(aServiceIndex, transformedMime->Des());

                    CleanupStack::Pop(sm->iServiceMime);

                    CleanupStack::PopAndDestroy(ptr);

                    CleanupStack::PopAndDestroy(transformedMime);

                    //StringLoader::LoadL( R_DA_SERVICE_OPEN, serv->Array()[i].DataTypes()[j].iDataType.Des());

                    sm->iServiceUid=aServiceUid;

                    }

                //insert the client application

                InsertApplicationL(*sm, uid, serv->Array()[i].DataTypes()[j].iPriority, &ls);

                //get the Uid of the default application for this service and MIME

                ls.AppForDataType(serv->Array()[i].DataTypes()[j].iDataType,sm->iDefaultAppUid);

                if(createSM)

                    {

                    //sm was created this iteration, ad it.

                    iServMimes.AppendL(sm);//takes ownership of sm

                    upperMarker++;

                    CleanupStack::Pop(sm);

                    }

                }//for

                /*

                 * If a service that has no MIME will be considered, some code must be added (probably in this place)

                 */

            }//if (

        }

    __ASSERT_DEBUG(upperMarker == iServMimes.Count(), User::Panic( _L("upperMarker bad value"), 1));

    if(sr)

        {

        //we do not need it any more

        delete sr;

        sr=NULL;

        }

    if(lowerMarker == upperMarker)

        {

        //current app does not support any MIME for the current service, clean and get out of here

        CleanupStack::PopAndDestroy(serv);

        CleanupStack::PopAndDestroy();  // closes RApaLsSession

        return;

        }

    if(!iSimplifiedView)

        {

        //if we are here, we have MIMEs for the current service

        //iterate once more and add applications for MIMEs already in the list

        for (i=0; i<serv->Array().Count(); i++)

            {

            uid=serv->Array()[i].Uid();

            if( uid == iAppUid) continue; //we don't add our client application once more in the list (it is already there)

            for(j=0; j<serv->Array()[i].DataTypes().Count(); j++)

                for(k=lowerMarker; k<upperMarker; k++)

                    if(iServMimes[k]->iMime->Des() == serv->Array()[i].DataTypes()[j].iDataType.Des8())

                        {

                        InsertApplicationL(*(iServMimes[k]), serv->Array()[i].Uid(), serv->Array()[i].DataTypes()[j].iPriority, &ls);

                        }//if same MIME

            }

        }

    //before deleting some of the entries ...    

    if(iSimplifiedView)

        {

        //check the service & MIMEs against the task list...

        //first, check the service against task services

        for(it=0; it<iTasks.Count(); it++)

            for(jt=0; jt<iTasks[it]->iServicesUids.Count(); jt++)

                if(aServiceUid.iUid == iTasks[it]->iServicesUids[jt])

                    {

                    //lets check if the MIME matches too...

                    for(k=lowerMarker; k<upperMarker; k++)

                        if(*iServMimes[k]->iMime == *iTasks[it]->iMimes[jt])

                            {

                            //this entry matches an entry in the task list

                            //add the applications to the list

                            PopulateTaskWithApplicationsL(*iTasks[it],iServMimes[k]);

                            //link the sm, if it has more than 1 application

                            break;//sm found, no need to search for it further

                            }

                    }

        }

    //iterate from the newly added entries and set the index

    for(k=lowerMarker; k<upperMarker; k++)

        {

        TBool smSetOrRemoved = EFalse;

        //check for single applications

        if( iServMimes[k]->iApplications.Count() <2 && !flagShowAll)

            {

            //this entry has a single element (that should not be shown)

            //we either delete it, or move it

            if(iServMimes[k]->iUsedByTasks)

                {

                //the sm is used by tasks, we move it

                iTaskServMimes.AppendL(iServMimes[k]);//takes ownership of sm

                }

            else

                {

                //the sm is not used by tasks, we delete it.

                delete iServMimes[k];

                }

            //we remove the entry from the iServMimes (so that it is not shown)

            iServMimes.Remove(k);

            k--;

            upperMarker--;

            smSetOrRemoved=ETrue;

            }

        //set the index

        if(!smSetOrRemoved)

            {

            for(i=0 ; i< iServMimes[k]->iApplications.Count() ; i++)

                {

                if(iServMimes[k]->iApplications[i]->iUid == iServMimes[k]->iDefaultAppUid.iUid)

                    iServMimes[k]->iDefaultApp=i;

                }

            }

        };

    if(iSimplifiedView)

    for(it=0; it<iTasks.Count(); it++)

        if(iTasks[it]->iDefaultAppUid.iUid == 0 && iTasks[it]->iApplications.Count()>0)

            {

            //there is no uid, look for the platform App and make it the default

            for(jt=0; jt<iTasks[it]->iApplications.Count(); jt++)

                if(iTasks[it]->iApplications[jt]->iFlags & CAppHelper::EFlagPlatformApp)

                    {

                    iTasks[it]->iDefaultAppUid.iUid = iTasks[it]->iApplications[jt]->iUid;

                    iTasks[it]->iDefaultApp=jt;

                    break;//app found, no need to search for it any longer

                    };

            //if no app found, mark the first one as default

            if(iTasks[it]->iDefaultAppUid.iUid == 0)

                {

                iTasks[it]->iDefaultAppUid.iUid = iTasks[it]->iApplications[0]->iUid;

                iTasks[it]->iDefaultApp = 0;//the index

                };

            }

        else

            for(jt=0; jt<iTasks[it]->iApplications.Count(); jt++)

                if(iTasks[it]->iApplications[jt]->iUid == iTasks[it]->iDefaultAppUid.iUid)

                    {

                    iTasks[it]->iDefaultApp=jt;

                    break;//app found, no need to search for it any longer