diff -r 90fe62538f66 -r 5f281e37a2f5 defaultapplicationsettings/server/src/das_servmimeapps.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/defaultapplicationsettings/server/src/das_servmimeapps.cpp Wed Sep 01 12:33:30 2010 +0100 @@ -0,0 +1,1073 @@ +/* +* 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 // STATIC_CAST +#include // R_DAS_SERVICESMIMES_LISTBOX +#include // StringLoader +#include //TResourceRead +#include //CEikonEnv +#include +#include // CApaMaskedBitmap + +#include + +#include "das_servmimeapps.h" +#include "das_app.h" // KUidDefaultAppServer +#include + +#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#else +#include +#include // 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.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*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; iConstructL(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; iCount(); 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; iArray().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; jArray()[i].DataTypes().Count(); j++) + { + TBool createSM=ETrue; + if(iSimplifiedView) + { + //check if we already have an entry for this service & MIME + for(k=lowerMarker; kiMime->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; iArray().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; jArray()[i].DataTypes().Count(); j++) + for(k=lowerMarker; kiMime->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; itiServicesUids.Count(); jt++) + if(aServiceUid.iUid == iTasks[it]->iServicesUids[jt]) + { + //lets check if the MIME matches too... + for(k=lowerMarker; kiMime == *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; kiApplications.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; itiDefaultAppUid.iUid == 0 && iTasks[it]->iApplications.Count()>0) + { + //there is no uid, look for the platform App and make it the default + for(jt=0; jtiApplications.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; jtiApplications.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 + } + + //done, destroy serv + CleanupStack::PopAndDestroy(serv); + CleanupStack::PopAndDestroy( ); // closes RApaLsSession + } + +// --------------------------------------------------------------------------- +// C++ Constructor +// --------------------------------------------------------------------------- +// +CDefaultAppServMimeApps::CDefaultAppServMimeApps(): iList(4) + { + } + +// --------------------------------------------------------------------------- +// Destructor +// --------------------------------------------------------------------------- +// +CDefaultAppServMimeApps::~CDefaultAppServMimeApps() + { + iServMimes.ResetAndDestroy(); + iTasks.ResetAndDestroy(); + iTaskServMimes.ResetAndDestroy(); + } + +// --------------------------------------------------------------------------- +// This function sorts the Services & MIMEs and their applications. +// It also sorts the Serivces & MIMEs associated with tasks +// --------------------------------------------------------------------------- +// +void CDefaultAppServMimeApps::BeautifyAndSortServMimeApps(void) + { + //first, go through the Services & MIMEs localized names and sort them + TLinearOrder order(&CServiceMime::OrderServiceMimes); + iServMimes.Sort(order); + + //go through applications and sort them + TInt i,j; + for(i=0; i order2(&CAppHelper::OrderApplications); + iServMimes[i]->iApplications.Sort(order2); + //get our app index + for(j=0; jiApplications.Count(); j++) + if(iServMimes[i]->iApplications[j]->iUid == iServMimes[i]->iDefaultAppUid.iUid) + iServMimes[i]->iDefaultApp = j; + }; + //if we have tasks, we sort their apps too + for(i=0; i order2(&CAppHelper::OrderApplications); + iTasks[i]->iApplications.Sort(order2); + //get our app index + for(j=0; jiApplications.Count(); j++) + if(iTasks[i]->iApplications[j]->iUid == iTasks[i]->iDefaultAppUid.iUid) + iTasks[i]->iDefaultApp = j; + }; + } + + +// --------------------------------------------------------------------------- +// This function reads from the resource file the list of tasks (and associated data). +// This function is used during construction +// --------------------------------------------------------------------------- +// +void CDefaultAppServMimeApps::GetTaskListL( TInt aResourceId ) + { + TResourceReader reader; + TInt i; + CServiceRegistry* sr=CServiceRegistry::NewL(); + CleanupStack::PushL(sr); + + // Read tasks + + CEikonEnv::Static()->CreateResourceReaderLC( reader, aResourceId ); + + TInt count = reader.ReadInt16(); + for ( i = 0; i < count; i++ ) + { + CMediaTask* task=CMediaTask::NewLC(reader); + // Read the default application for this task ... + sr->GetDefault(KOpenServiceUid, *task->iMimeLabel, task->iDefaultAppUid); + + //add the task to the list + iTasks.Append(task); + CleanupStack::Pop(task); + } + + CleanupStack::PopAndDestroy(); // reader + CleanupStack::PopAndDestroy(sr); + } + +// --------------------------------------------------------------------------- +// This function adds a new Application to a list of an Service & Mime object. +// --------------------------------------------------------------------------- +// +void CDefaultAppServMimeApps::InsertApplicationL(CServiceMime& aServMime, const TUid& aAppUid, const TDataTypePriority& aPrio, const RApaLsSession *aLs) + { + TBool addIt = ETrue; + + if(aPrio == KDataTypePrioritySystem) + { + // the application to be inserted has system priority + if(aServMime.iDefaultApp == -1) + { + //we have non-system applications in the list + //delete them ... + aServMime.iApplications.ResetAndDestroy(); + + //... and make the default -2 ... (it means single app with system priority) + aServMime.iDefaultApp = -2; + //... and add our application (after exiting from the "if") + } + else + { + //do not delete the applications, but just add our application + //...and make the default -3 (it means multiple apps with system priority) + aServMime.iDefaultApp = -3; + //... and add our application (after exiting from the "if") + } + } + else + { + // the application to be inserted does NOT have system priority + if(aServMime.iDefaultApp < -1) + { + // there are only System apps in the list, do not add ours + addIt = EFalse; + } + // else there are normal applications in the list, insert ours, as well + } + //add the application to the list + if(addIt) + { + TApaAppInfo info; + aLs->GetAppInfo(info,aAppUid); + //find the best name for the application + CAppHelper *app = NULL; + if(info.iCaption.Size() != 0) + { + //this is for now, the preferred name + app = CAppHelper::NewLC(info.iCaption, aAppUid.iUid); + } + else + { + //fall-back name + app = CAppHelper::NewLC(info.iShortCaption, aAppUid.iUid); + }; + //is the app platform application?? + if (info.iFullName.Left(1) == _L("Z") || + info.iFullName.Left(1) == _L("z")) + app->iFlags |= CAppHelper::EFlagPlatformApp; + //append the name + aServMime.iApplications.AppendL(app); + CleanupStack::Pop(app); + } + } + +// --------------------------------------------------------------------------- +// This function takes a task and a Service & MIME object. It checks all the applications that support the given +// Service & MIME object (from its list). If an application is not in the task's application list, this function adds +// it there, with a score of 1. If the application is already in the list, then its score is incremented. +// The Service & MIME object is also marked as being used by a task. +// --------------------------------------------------------------------------- +// +void CDefaultAppServMimeApps::PopulateTaskWithApplicationsL(CMediaTask& aTask,CServiceMime* aServMime) + { + TInt i,j; + TBool found; + //add the applications to the list + for(i=0; iiApplications.Count(); i++) + { + found=EFalse; + for(j=0; jiApplications[i]->iUid == aTask.iApplications[j]->iUid) + { + //we found this application... + found=ETrue; + //... increase its score + aTask.iApplications[j]->iScore++; + //... and get to the next application + break; //application found, no need to search for it any more + } + //if the application was not found, we have to add it! + if(!found) + { + CAppHelper *app = CAppHelper::NewLC(*aServMime->iApplications[i]); + aTask.iApplications.AppendL(app); + CleanupStack::Pop(app); + } + } + //mark the sm + aServMime->iUsedByTasks=ETrue; + //link the sm + aTask.iSMs.Append(aServMime); + } + +// --------------------------------------------------------------------------- +// This function fills with entries a data structure used by a List Box to display Services & MIMEs or Tasks +// --------------------------------------------------------------------------- +// +void CDefaultAppServMimeApps::GetServicesAndMimesListL(CDesCArray& aServicesAndMimesArray) + { + TInt i; + aServicesAndMimesArray.Reset(); + if(iSimplifiedView) + { + for ( i=0 ; i *apps=NULL; + + //get the proper list + if(iSimplifiedView) + apps = &(iTasks[aIndex]->iApplications); + else + apps = &(iServMimes[aIndex]->iApplications); + + for ( i=0 ; iCount() ; i++ ) + { + len=(*apps)[i]->iName->Size() + KStringMargin ; + if(len>bufLen) + { + newString=string->ReAllocL(len); + if(newString != string) + { + CleanupStack::Pop(string);//already destroyed + string=newString; + CleanupStack::PushL(string); + } + bufLen=len; + newString=NULL; + } + //copy the application into the string buffer + TPtr ptr=string->Des(); + TBool isDefault=EFalse; + + if( iSimplifiedView && iTasks[aIndex]->iDefaultApp==i) isDefault=ETrue; + if( !iSimplifiedView && iServMimes[aIndex]->iDefaultApp==i) isDefault=ETrue; + + if( isDefault ) ptr.Copy(KStringAppsDefault); + else ptr.Copy(KStringAppsNonDefault); + ptr.Append(*(*apps)[i]->iName); + + aApplicationsArray.AppendL (ptr); + } + + CleanupStack::PopAndDestroy(string); //data in ptr is out of scope + + //get the title now + if ( iSimplifiedView ) + aTitle = GetMediaTaskStringLC(*iTasks[aIndex], EFalse); + else + aTitle = GetServiceAndMimeStringLC(*iServMimes[aIndex], EFalse); + CleanupStack::Pop(aTitle); + } + +// --------------------------------------------------------------------------- +// This function sets a new default, for a Service & MIME pair or for a Task. +// The function also updates the list of Services & MIMEs (or Tasks), to display the new default application +// --------------------------------------------------------------------------- +// +void CDefaultAppServMimeApps::UpdateDefaultL(TInt aServiceAndMimeIndex, TInt aDefaultAppIndex, CDesCArray *aServicesAndMimesArray) + { + //check for correct parameters + if (aServiceAndMimeIndex <0 || aDefaultAppIndex <0) User::Leave(KErrArgument); + if(iSimplifiedView) + { + if( aServiceAndMimeIndex >= iTasks.Count() || + aDefaultAppIndex >= iTasks[aServiceAndMimeIndex]->iApplications.Count()) + User::Leave(KErrArgument); + } + else + { + if( aServiceAndMimeIndex >= iServMimes.Count() || + aDefaultAppIndex >= iServMimes[aServiceAndMimeIndex]->iApplications.Count()) + User::Leave(KErrArgument); + } + + //if we are here, parameters are within their range + TBool doUpdate=ETrue; + TUid defaultAppUid; + CServiceRegistry *sr=CServiceRegistry::NewL(); + CleanupStack::PushL(sr); + + //update the default in the Service Registry + if(iSimplifiedView) + { + TInt i,j; + TUid serviceUid; + //set the default for the generic MIME (and our server application) + TDataType dt(*iTasks[aServiceAndMimeIndex]->iMimeLabel); + defaultAppUid=TUid::Uid(iTasks[aServiceAndMimeIndex]->iApplications[aDefaultAppIndex]->iUid); + if(sr->SetDefault(KOpenServiceUid, dt,defaultAppUid)) + { + //if we are here, SetDefault returned an error. + //so we do not update the default... + doUpdate=EFalse; + } + //set the selected default for all the Services & MIME that it supports + if(doUpdate) + { + for(i=0; iiSMs.Count(); i++) + for(j=0; jiSMs[i]->iApplications.Count(); j++) + if(defaultAppUid.iUid == iTasks[aServiceAndMimeIndex]->iSMs[i]->iApplications[j]->iUid ) + { + //the selected application supports this Service & MIME pair. + //make the app default for the pair. + dt=*iTasks[aServiceAndMimeIndex]->iSMs[i]->iMime; + serviceUid=iTasks[aServiceAndMimeIndex]->iSMs[i]->iServiceUid; + sr->SetDefault(serviceUid, dt,defaultAppUid); + //update the sm so that it reflects the new default + iTasks[aServiceAndMimeIndex]->iSMs[i]->iDefaultAppUid=defaultAppUid; + iTasks[aServiceAndMimeIndex]->iSMs[i]->iDefaultApp=j; + break; //application found in sm's list, do not need to search for it any more + } + //update the default entries + iTasks[aServiceAndMimeIndex]->iDefaultApp=aDefaultAppIndex; + iTasks[aServiceAndMimeIndex]->iDefaultAppUid=defaultAppUid; + } + + } + else + { + TDataType dt(*iServMimes[aServiceAndMimeIndex]->iMime); + defaultAppUid=TUid::Uid(iServMimes[aServiceAndMimeIndex]->iApplications[aDefaultAppIndex]->iUid); + if(sr->SetDefault(iServMimes[aServiceAndMimeIndex]->iServiceUid, dt,defaultAppUid)) + { + //if we are here, SetDefault returned an error. + //so we do not update the default... + doUpdate=EFalse; + } + //update the default entries + if(doUpdate) + { + iServMimes[aServiceAndMimeIndex]->iDefaultApp=aDefaultAppIndex; + iServMimes[aServiceAndMimeIndex]->iDefaultAppUid=defaultAppUid; + } + } + CleanupStack::PopAndDestroy(sr); + + //check if setting the default failed + if(!doUpdate) + { + //### if updating the default failed, here would be the place to put an error note to the user + return; // or leave + }; + + //update the item in the list + if (aServicesAndMimesArray) + { + //get the string + TDesC* string; + if(iSimplifiedView) + string = GetMediaTaskStringLC(*iTasks[aServiceAndMimeIndex], ETrue); + else + string = GetServiceAndMimeStringLC(*iServMimes[aServiceAndMimeIndex], ETrue); + aServicesAndMimesArray->Delete(aServiceAndMimeIndex); + aServicesAndMimesArray->InsertL(aServiceAndMimeIndex,*string); + CleanupStack::PopAndDestroy(string); + } + } + +// --------------------------------------------------------------------------- +// This function creates a string that will become en element of a list box. To create the string, the function +// concatenates several sub-strings. +// --------------------------------------------------------------------------- +// +HBufC* CDefaultAppServMimeApps::GetServiceAndMimeStringLC(CServiceMime& aServMime, TBool aInsertDefaultApp) const + { + HBufC *string=NULL; + TPtr *ptr=NULL; + TInt len; + _LIT(KTab,"\t"); + + if(aInsertDefaultApp && aServMime.iDefaultApp >= 0) //it may be that we do not have a default ... + len=aServMime.iApplications[aServMime.iDefaultApp]->iName->Size(); + else + len=0; + len+= aServMime.iServiceMime->Size(); + len+= KStringMargin ; + + string=HBufC::NewLC(len); + + //build the string, add the tabs before and after + ptr=new (ELeave) TPtr(string->Des()); + CleanupStack::PushL(ptr); + + ptr->Copy(*aServMime.iServiceMime); + + if(aInsertDefaultApp) + { + ptr->Insert(0,KTab); + ptr->Append(KTab); + + //add default app + if(aServMime.iDefaultApp >= 0) //it may be that we do not have a default ... + ptr->Append(*aServMime.iApplications[aServMime.iDefaultApp]->iName); + } + + CleanupStack::PopAndDestroy(ptr); + + return string; //pass ownership, string also on the stack + + } + +// --------------------------------------------------------------------------- +// This function creates a string that will become en element of a list box. To create the string, the function +// concatenates several sub-strings. +// --------------------------------------------------------------------------- +// +HBufC* CDefaultAppServMimeApps::GetMediaTaskStringLC(CMediaTask& aMediaTask, TBool aInsertDefaultApp) const + { + TPtr *ptr=NULL; + TInt len = KStringMargin; + _LIT(KTab,"\t"); + HBufC *taskName=NULL; //not owned, not deleted at the end of function + + //compute the string length + if(aInsertDefaultApp) + { + //we insert the task list name + taskName = aMediaTask.iTaskList; + //we also insert the length od the default app (if we have it) + if(aMediaTask.iDefaultApp >= 0)//it may be that we do not have a default ... + len += aMediaTask.iApplications[aMediaTask.iDefaultApp]->iName->Size(); + } + else + { + //we should insert the task title, if we have it + taskName = aMediaTask.iTaskTitle; + //taskName = aMediaTask.iTaskList; + }; + len += taskName->Size(); + + //allocate the string + HBufC *string=HBufC::NewLC(len); + + //add the title + ptr=new (ELeave) TPtr(string->Des()); + CleanupStack::PushL(ptr); + ptr->Copy(*taskName); + + //add other stuff + if(aInsertDefaultApp) + { + ptr->Insert(0,KTab); + ptr->Append(KTab); + //add default app + if(aMediaTask.iDefaultApp >= 0) //it may be that we do not have a default ... + ptr->Append(*aMediaTask.iApplications[aMediaTask.iDefaultApp]->iName); + } + + CleanupStack::PopAndDestroy(ptr); + + return string; //pass ownership, string also on the stack + } + +// --------------------------------------------------------------------------- +// This function resets (removes) the defaults associated with a certain task, +// or it can remove all the defaults +// --------------------------------------------------------------------------- +// +TInt CDefaultAppServMimeApps::RestoreFactorySettingsL(TInt aCathegory) + { + TInt i, j; + CServiceRegistry *sr=NULL; + + if(aCathegory == -1) + { + sr=CServiceRegistry::NewL(); + + if ( iSimplifiedView ) + { + for(i=0; iiMimes.Count(); j++) + { + sr->RemoveEntry(TUid::Uid(iTasks[i]->iServicesUids[j]), TDataType(*iTasks[i]->iMimes[j])); + } + //remove the entry that identifies the default app for the task + sr->RemoveEntry(KOpenServiceUid, TDataType(*iTasks[i]->iMimeLabel)); + } + } + else + { + //we reset the defaults for all the services & MIME + for(i=0; iRemoveEntry(iServMimes[i]->iServiceUid, TDataType(*iServMimes[i]->iMime)); + //remove the entry that identifies the default app for the task + for(i=0; iRemoveEntry(KOpenServiceUid, TDataType(*iTasks[i]->iMimeLabel)); + } + } + else if(iSimplifiedView && aCathegory >= 0 && aCathegory < iTasks.Count()) + { + //we are in simplified view, restore defaults for a single task + sr=CServiceRegistry::NewL(); + for(i=0; iiMimes.Count(); i++) + sr->RemoveEntry(TUid::Uid(iTasks[aCathegory]->iServicesUids[i]), TDataType(*iTasks[aCathegory]->iMimes[i])); + //remove the entry that identifies the default app for the task + sr->RemoveEntry(KOpenServiceUid, TDataType(*iTasks[aCathegory]->iMimeLabel)); + } + else if(!iSimplifiedView && aCathegory >= 0 && aCathegory < iServMimes.Count()) + { + //we are in the advanced view, restore defaults for a single Service & MIME pair + sr=CServiceRegistry::NewL(); + sr->RemoveEntry(iServMimes[aCathegory]->iServiceUid, TDataType(*iServMimes[aCathegory]->iMime)); + } + else return -1; //wrong aCathegory range + + if(sr) delete sr; + return 0; + }