TUint CTupleStoreImpl::PutL(TTupleType aTupleType, const TTupleName& aTupleName, const TDesC& aSubName, const TComponentName& aComponent, const TDesC8& aSerializedData, TBBPriority aPriority, TBool aReplace, const TTime& aLeaseExpires, TBool aKeepExisting) { CALLSTACKITEM_N(_CL("CTupleStoreImpl"), _CL("PutL")); if (aTupleName.iModule.iUid == KBBAnyUidValue || aTupleName.iId == KBBAnyId || aComponent.iModule.iUid == KBBAnyUidValue || aComponent.iId == KBBAnyId) User::Leave(KErrArgument); TUint ret; { TAutomaticTransactionHolder ath(*this); TBool exists=SeekNameL(aTupleType, aTupleName, aSubName); if (exists && aKeepExisting) { UpdateL(); iTable.SetColL(ELeaseExpires, aLeaseExpires); MDBStore::PutL(); return 0; } else if (exists && aReplace) { UpdateL(); } else { InsertL(); iTable.SetColL(ETupleType, aTupleType); iTable.SetColL(ENameModule, aTupleName.iModule.iUid); iTable.SetColL(ENameId, aTupleName.iId); iTable.SetColL(ENameSubName1, aSubName); iTable.SetColL(ENameSubName2, aSubName.Left(iSubNameIndexLength)); iTable.SetColL(EPriority, aPriority); iTable.SetColL(EComponentModule, aComponent.iModule.iUid); iTable.SetColL(EComponentId, aComponent.iId); } ret=iTable.ColUint(ETupleId); if (aSerializedData.Length() > 0) { RADbColWriteStream w; w.OpenLA(iTable, EData); w.WriteUint32L(aSerializedData.Length()); w.WriteL(aSerializedData); w.CommitL(); } else { iTable.SetColNullL(EData); } iTable.SetColL(ELeaseExpires, aLeaseExpires); MDBStore::PutL(); } if (aLeaseExpires < iNextExpiry) { TTime now=GetTime(); TTimeIntervalSeconds s; aLeaseExpires.SecondsFrom(now, s); TInt wait=s.Int(); iTimer->Wait(wait); } return ret; }
// ----------------------------------------------------------------------------- // CDRMHelperServer::UpdateL(). // This function update items with a URI // ----------------------------------------------------------------------------- // void CDRMHelperServer::UpdateL( const TDesC8& aUri ) { #ifdef _DRM_TESTING WriteL(_L8("UpdateL(aUri)")); WriteL(aUri); #endif UpdateL( aUri , ContentAccess::EView); UpdateL( aUri , ContentAccess::EPlay); UpdateL( aUri , ContentAccess::EExecute); UpdateL( aUri , ContentAccess::EPrint); }
// ----------------------------------------------------------------------------- // CDRMHelperServer::UpdateL(). // This function update items with a URI and a permission type // ----------------------------------------------------------------------------- // void CDRMHelperServer::UpdateL( const TDesC8& aUri , const TUint8& aPermType ) { #ifdef _DRM_TESTING WriteL(_L8("UpdateL(aUri,aPerm)")); WriteL(aUri); #endif UpdateL( aUri , aPermType , CDRMHelperServer::EActive ); UpdateL( aUri , aPermType , CDRMHelperServer::EPassive ); }
/** Updates the listtype and favouritename. Only, these 2 properties can be modified. @param aUriPropsId Property ID which uniquely identifies the row in the URIPropertiesTbl @param aListType New Listtype @param aFavouriteName New favourite name for the URI */ void CUriListInterface::UpdateUriL ( TInt aUriPropsId, InetUriList::TListType aListType, const TDesC8& aFavouriteName ) { iDbAccessor->BeginTransactionL (); // This is not to delete the object rather to do a rollback operation incase of a failure CleanupStack::PushL ( TCleanupItem ( CUriListInterface::RollbackTrans, iDbAccessor ) ); // Only update List Type & Favourite Name. Other properties are not allowed to update. if ( UpdateL ( KUriPropsTblName(), aUriPropsId, aListType, aFavouriteName ) == 0 ) User::Leave ( InetUriList::KErrUriNotFound ); User::LeaveIfError ( UpdateL ( KViewName(), aUriPropsId, aListType, aFavouriteName ) ); iDbAccessor->CommitTransactionL (); CleanupStack::Pop (); // iDbAccessor }
void CMyLEDAgendaNotifierSubject::UpdateL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage) { RDebug::Print(_L("Plugin: LED Agenda notifier updated (asynch. call) \n")); UpdateL(aBuffer); TRAPD(err,aMessage.WriteL(aReplySlot,KUpdateAgendaLEDResponseAsync)); __ASSERT_ALWAYS(!err,User::Panic(_L("WriteL(aReplySlot,KUpdateAgendaLEDResponseAsync)"),err)); }
// ----------------------------------------------------------------------------- // CUpdateManager::RunL // // Handles an active object's timer event. // ----------------------------------------------------------------------------- void CUpdateManager::RunL() { TTime currentTime; currentTime.HomeTime(); TTimeIntervalMinutes diff; currentTime.MinutesFrom(iLastAutoUpdate,diff); if (diff.Int() < 0) { for(TInt i =0 ; i < iQueueArray.Count(); i++) { iQueueArray[i]->ResetTimers(); } } iLastAutoUpdate.HomeTime(); if (iStatus.Int() == KErrNone || iStatus.Int() == KErrAbort) { StartTimer(); if(iAutoUpdateWhileRoaming) { UpdateL(); } else { iRoamingInfo->CheckForRoaming(); } } }
// -------------------------------------------------------------------------- // CHomeMediaContainer::ConstructL // -------------------------------------------------------------------------- // void CHomeMediaContainer::ConstructL(const TRect& aRect) { CAknDoubleLargeStyleListBox* listBoxModel = new (ELeave)CAknDoubleLargeStyleListBox; BaseConstructL( aRect , listBoxModel ); UpdateL(); }
// ----------------------------------------------------------------------------- // CLandmarksInfoContainer::EditLandmarkL // // (other items were commented in a header). // ----------------------------------------------------------------------------- // void CLandmarksInfoContainer::EditLandmarkL() { // Create editor TBool isEdited = EFalse; TInt selectedLine = iListBox->View()->CurrentItemIndex(); TInt activeField = 0; if (selectedLine >= 0 && selectedLine < iFields.Count()) { activeField = iFields[selectedLine]; } CLandmarksEditDialog* editDialog = CLandmarksEditDialog::NewLC( *iLandmark, EFalse, isEdited, iEngine, activeField); TInt err = editDialog->ExecuteLD(R_LMREFAPP_EDIT_DIALOG); CleanupStack::Pop(editDialog); User::LeaveIfError(err); // Commit if edited if (isEdited) { iEngine.CommitLandmarkL(*iLandmark); UpdateL(); // move to first field iListBox->View()->SetCurrentItemIndex(0); } }
EXPORT_C void CCnaConverterList::ConvToListL(const TDataType& aMimeType,CArrayFix<SConverterInfo>* aSConverterInfoArray) /** Gets a list of converters that convert to a specified data type. @param aMimeType Target data type @param aSConverterInfoArray On return, an array of converter information objects for all suitable converters */ { ASSERT(aSConverterInfoArray->Count()==0); if (!iDoneScan) UpdateL(); TInt i; TInt count = iConverters->Count(); for (i = 0; i < count; i++) { CCnaConverter* conv = iConverters->At(i); //does converter support this type if (conv->MimeTo(aMimeType) ) { const TInt countFrom=conv->CountFrom(); for( TInt j=0; j<countFrom; j++) { SConverterInfo info; info.iTranslation=conv->MimeFromText(j); info.iUid=conv->Uid(); info.iIndex=j; aSConverterInfoArray->AppendL(info); } } } }
// ----------------------------------------------------------------------------- // CAMMSLocationControlGroup::SetCartesianL // Moves the object to the new location // (other items were commented in a header). // ----------------------------------------------------------------------------- void CAMMSLocationControlGroup::SetCartesianL(TInt aX, TInt aY, TInt aZ) { iUncommited.iLocation[ EComponentX ] = aX; iUncommited.iLocation[ EComponentY ] = aY; iUncommited.iLocation[ EComponentZ ] = aZ; UpdateL(ELocation); }
void CMyLEDPhoneNotifierSubject::UpdateL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage) { RDebug::Print(_L("Plugin: LED Phone notifier updated (asynch. call) \n")); UpdateL(aBuffer); TRAPD(err,aMessage.WriteL(aReplySlot,KUpdatePhoneLEDResponseAsync)); __ASSERT_ALWAYS(!err,User::Panic(_L("WriteL(aReplySlot,KUpdatePhoneLEDResponseAsync)"),err)); aMessage.Complete(EEikNotExtRequestCompleted); }
//-------------------------------------------------------------------- //-------------------------------------------------------------------- // void CPosLmNameIndex::UpdateL( TPosLmItemId aId, const TDesC& aName ) { HBufC* name = aName.AllocLC(); CleanupStack::Pop( name );//ownership of name is transferred in the call to UpdateL //coverity[freed_arg : FALSE] UpdateL( aId, name ); //coverity[pass_freed_arg : FALSE] }
// ----------------------------------------------------------------------------- // CAMMSDopplerControlGroup::SetVelocityCartesianL // Sets the velocity, used in calculations for the Doppler effect. // (other items were commented in a header). // ----------------------------------------------------------------------------- void CAMMSDopplerControlGroup::SetVelocityCartesianL( TInt aX, TInt aY, TInt aZ) { iUncommited.iVelocity[ EComponentX ] = aX; iUncommited.iVelocity[ EComponentY ] = aY; iUncommited.iVelocity[ EComponentZ ] = aZ; UpdateL(EVelocity); }
// ----------------------------------------------------------------------------- // CAMMSDopplerControlGroup::SetEnabledL // Specifies if this Doppler effect is active or ignored. // (other items were commented in a header). // ----------------------------------------------------------------------------- void CAMMSDopplerControlGroup::SetEnabledL(TBool aEnabled) { // If the DopplerControl was fetched from the Spectator, // this method has no effect. So only disable the value for SoundSource3D. if (aEnabled || (!aEnabled && iControlType == EAMMSSoundSource3DControl)) { iUncommited.iEnabled = aEnabled; UpdateL(EEnabled); } }
// ----------------------------------------------------------------------------- // CLandmarksInfoContainer::LoadLandmarkL // // (other items were commented in a header). // ----------------------------------------------------------------------------- // void CLandmarksInfoContainer::LoadLandmarkL(TPosLmItemId aLandmarkId) { delete iLandmark; iLandmark = NULL; iLandmark = iEngine.LandmarkLC(aLandmarkId); CleanupStack::Pop(iLandmark); UpdateL(); iListBox->View()->SetCurrentItemIndex(0); }
void CTupleStoreImpl::CleanOldTuplesL() { CALLSTACKITEM_N(_CL("CTupleStoreImpl"), _CL("CleanOldTuplesL")); SwitchIndexL(EIndexLeaseExpires); iTable.FirstL(); iTable.GetL(); TTupleName name; TBuf<KMaxTupleSubNameLength> subname; TTime expires; if (iTable.IsColNull(ELeaseExpires)) { expires=TTime(0); } else { expires=iTable.ColTime(ELeaseExpires); } TTime now=GetTime(); TInt tupletype=-1; while (now > expires) { if ( iTable.IsColNull(ELeaseExpires) ) { UpdateL(); iTable.SetColL( ELeaseExpires, Time::MaxTTime() ); MDBStore::PutL(); } else { tupletype=iTable.ColInt(ETupleType); if (tupletype == ETupleDataOrRequest) { name.iModule.iUid=iTable.ColInt(ENameModule); name.iId=iTable.ColInt(ENameId); subname=iTable.ColDes16(ENameSubName1); } MDBStore::DeleteL(); if (tupletype == ETupleDataOrRequest) { iDeleteNotification.NotifyDeleted(name, subname); } } if (! iTable.NextL() ) return; iTable.GetL(); if (iTable.IsColNull(ELeaseExpires)) { expires=TTime(0); } else { expires=iTable.ColTime(ELeaseExpires); } } if ( expires == TTime(0) || expires == Time::MaxTTime() ) return; TTimeIntervalSeconds s; TInt err=expires.SecondsFrom(now, s); if (err==KErrOverflow) return; iNextExpiry=expires; TInt wait=s.Int(); iTimer->Wait(wait); }
// ----------------------------------------------------------------------------- // CAMMSDopplerControlGroup::SetVelocitySphericalL // Sets the velocity, used in calculations for the Doppler effect. // (other items were commented in a header). // ----------------------------------------------------------------------------- void CAMMSDopplerControlGroup::SetVelocitySphericalL( TInt aAzimuth, TInt aElevation, TInt aRadius) { TInt sphericalVector[] = { aAzimuth, aElevation, aRadius }; // Convert to cartesian. AMMSUtil::FromSphericalToCartesianL(sphericalVector, iUncommited.iVelocity); UpdateL(EVelocity); }
EXPORT_C TInt CCnaConverterList::CountL() /** Gets the total number of converters. It can leave because it needs to rescan the disk to refresh the list of converters. @return Total number of converters */ { if (!iDoneScan) UpdateL(); TInt count=0; return count+iImplementationArray.Count(); }
// ----------------------------------------------------------------------------- // CAMMSLocationControlGroup::SetSphericalL // Moves the object to the new location // (other items were commented in a header). // ----------------------------------------------------------------------------- void CAMMSLocationControlGroup::SetSphericalL( TInt aAzimuth, TInt aElevation, TInt aRadius) { __ASSERT_DEBUG(aRadius >= 0, User::Invariant()); TInt sphericalVector[] = { aAzimuth, aElevation, aRadius }; // Convert to cartesian. AMMSUtil::FromSphericalToCartesianL(sphericalVector, iUncommited.iLocation); UpdateL(ELocation); }
void CSpecialLog::SpecialLogL(TInt aKey, TInt aValue) { RLogSpecial & entry = iLogSpecial[aKey]; if (ESpecialLogInt == entry.iType && aValue == entry.iInt) return; // Same, ignore. if (ESpecialLogText == entry.iType) { delete entry.iText; entry.iText = NULL; entry.iType = ESpecialLogInt; } entry.iInt = aValue; UpdateL(EFalse); }
void CSpecialLog::SpecialLogL(TInt aKey, const TDesC & aValue) { RLogSpecial & entry = iLogSpecial[aKey]; if (ESpecialLogText == entry.iType && entry.iText) { if (entry.iText->Length() == aValue.Length() && 0 == entry.iText->Compare(aValue)) return; // Same, ignore. // Reallocate for the value descriptor. delete entry.iText; entry.iText = NULL; } else { entry.iType = ESpecialLogText; } entry.iText = aValue.AllocL(); UpdateL(EFalse); }
EXPORT_C TUid CCnaConverterList::ConverterL(const TDataType& aFrom,const TDataType& aTo) /** Gets the UID of the converter that converts to and from the specified data types. @param aFrom Source data type @param aTo Target data type @return Converter UID */ { if (!iDoneScan) UpdateL(); TInt ii; TInt count=iConverters->Count(); for (ii=0; ii<count; ii++) { const CCnaConverter* conv=iConverters->At(ii); if (conv->MimeFrom(aFrom) && conv->MimeTo(aTo)) { return conv->Uid(); } } return KNullUid; }
EXPORT_C CConverterBase* CCnaConverterList::NewConverterL(TUid aUid) /** Locates the converter with the specified UID, loads its associated DLL and returns a pointer to it. @param aUid Converter UID @return Converter with the specified UID, or NULL if there is no suitable converter */ { CConverterBase* base=ConverterListUtil::UtilityConverterL(aUid); if (base) return base; if (!iDoneScan) UpdateL(); TInt i; TInt count; count = iImplementationArray.Count(); for (i = 0; i < count; i++) { if (iImplementationArray[i]->ImplementationUid()==aUid) { return LoadConverterL(iImplementationArray[i]->ImplementationUid()); } } return NULL; }
// ----------------------------------------------------------------------------- // CDRMHelperServer::HandleEventL(). // This function handle event from DRM notifier // ----------------------------------------------------------------------------- // void CDRMHelperServer::HandleEventL( MDRMEvent* aEvent ) { #ifdef _DRM_TESTING WriteL(_L8("HandleEventL")); #endif HBufC8* contentID = 0; TDRMEventType event; aEvent->GetEventType(event); #ifdef _DRM_TESTING WriteL(_L8("Notifier:"),event); #endif switch(event) { case KEventAddRemove: { #ifdef _DRM_TESTING WriteL(_L8("Notifier: EventAddRemove")); #endif contentID = REINTERPRET_CAST( CDRMEventAddRemove* , aEvent )->GetContentIDL(); CleanupStack::PushL( contentID ); #ifdef _DRM_TESTING WriteL(contentID->Des()); #endif switch( REINTERPRET_CAST( CDRMEventAddRemove* , aEvent )->Status() ) { case ERightsObjectRecieved: { #ifdef _DRM_TESTING WriteL(_L8("Notifier: RightsObjectRecieved")); #endif UpdateL( contentID->Des() ); } break; case ERightsObjectDeleted: { #ifdef _DRM_TESTING WriteL(_L8("Notifier: RightsObjectDeleted")); #endif UpdateL( contentID->Des() ); } break; case ERightsObjectDeletedAll: { #ifdef _DRM_TESTING WriteL(_L8("Notifier: RightsObjectDeletedAll")); #endif UpdateL( contentID->Des() ); } break; default: { #ifdef _DRM_TESTING WriteL(_L8("Notifier: Unknown event")); #endif } break; } CleanupStack::PopAndDestroy( contentID ); } break; case KEventModify: { #ifdef _DRM_TESTING WriteL(_L8("Notifier: EventModify")); #endif contentID = REINTERPRET_CAST( CDRMEventModify* , aEvent )->GetContentIDL(); CleanupStack::PushL( contentID ); #ifdef _DRM_TESTING WriteL(contentID->Des()); #endif UpdateL( contentID->Des() ); CleanupStack::PopAndDestroy( contentID ); } break; case KEventTimeChange: { #ifdef _DRM_TESTING WriteL(_L8("Notifier: EventTimeChange")); #endif UpdateL(); } break; default: { #ifdef _DRM_TESTING WriteL(_L8("Notifier: Unknown event")); #endif } break; } return; }
/** Add the given contact item to the database. Forward the call to CPplTableBase based classes representing the tables in the contact database. @param aItem The contact item to be added to the database. @param aSessionId The ID of the session that issued the request. Used to prevent Phonebook Synchroniser deadlock. @return Contact item ID of the contact added to the database. */ TContactItemId CPplContactItemManager::CreateL(CContactItem& aItem, TUint aSessionId) { TBool controlTransaction = !(iTransactionManager.IsTransactionActive()); TBool compressedGuid=EFalse; // If needed generate a gui for the current contact item if (aItem.Guid() == TPtrC(KNullDesC)) { iPreferencePersistor->SetGuidL(aItem, compressedGuid); } if (compressedGuid) { aItem.SetHasCompressedGuid(compressedGuid); } if (aItem.Type() == KUidContactICCEntry) { const TInt ret = iContactProperties.ContactSynchroniserL(aSessionId).ValidateWriteContact(static_cast<CContactICCEntry&>(aItem)); User::LeaveIfError(ret); } if(controlTransaction) { StartTransactionL(aSessionId); } iContactTable->CreateInDbL(aItem); iGroupTable->CreateInDbL(aItem); iCommAddrTable->CreateInDbL(aItem); TContactItemId groupId = iIccContactStore.CreateInDbL(aItem, aSessionId); if(groupId != KNullContactId) { //Every ICC entry is added to a special group, created by the Phonebook //Synchroniser server during the initial synchronisation with the Contacts Model. CContactItemViewDef* itemDef = CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields,CContactItemViewDef::EMaskHiddenFields); itemDef->AddL(KUidContactFieldMatchAll); // Add ICC entry to the group. CContactGroup* grp = static_cast<CContactGroup*>(ReadLC(groupId, *itemDef, EPlAllInfo, aSessionId)); grp->AddContactL(aItem.Id()); UpdateL(*grp, aSessionId); CleanupStack::PopAndDestroy(2, itemDef); // grp } if(controlTransaction) { CommitTransactionL(); } // Assuming success if no leaves at this point, so update // the metadata search store for this entry //CCntMetadataOperation* op = CCntMetadataOperation::NewLC(iColSession); //TRAP_IGNORE(op->SaveContactLD(aItem)); //CleanupStack::Pop(op); // Do not destroy - called LD function return aItem.Id(); }
void CTupleStoreImpl::ConstructL() { CALLSTACKITEM_N(_CL("CTupleStoreImpl"), _CL("ConstructL")); iSubNameIndexLength=40; // name: id, tupletype, TInt cols[]={ EDbColUint32, EDbColInt32, //{ Uid, Id, subname1 }, EDbColInt32, EDbColInt32, EDbColText, // priority, EDbColInt8, // { Uid, Id}, EDbColInt32, EDbColInt32, // data LeaseExpires EDbColLongBinary, EDbColDateTime, // subname2 EDbColText, -1 }; TInt col_flags[]={ TDbCol::EAutoIncrement, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // the tuple id is added to indices so that data is read in // the order it arrives TInt idxs[]={ ETupleType, ENameModule, ENameId, ENameSubName2, ETupleId, -2, ETupleId, -2, ETupleType, EComponentModule, EComponentId, EPriority, ETupleId, -2, ELeaseExpires, -1 }; MDBStore::ConstructL(cols, idxs, false, _L("TUPLES"), EFalse, col_flags); iTimer=CTimeOut::NewL(*this, CActive::EPriorityIdle); if (SeekIdL(0)) { TInt version=0; iTable.GetL(); // check version and migrate if necessary version=iTable.ColInt32(ENameId); if (version<KVersion) { SwitchIndexL(-1); // no index TBool found=iTable.FirstL(); while (found) { iTable.GetL(); TUint uid_in_table, new_uid; new_uid=uid_in_table=iTable.ColInt(ENameModule); GetBackwardsCompatibleUid(new_uid); if (new_uid != uid_in_table) { UpdateL(); iTable.SetColL(ENameModule, new_uid); MDBStore::PutL(); } found=iTable.NextL(); } } if (version<=KVersionBeforeExpires) { SwitchIndexL(-1); // no index TBool found=iTable.FirstL(); while (found) { iTable.GetL(); TInt tupletype; TTupleName tn; tn.iModule.iUid=iTable.ColInt(ENameModule); tn.iId=iTable.ColInt(ENameId); tupletype=iTable.ColInt(ETupleType); if ( (!(tn == KCLSettingsTuple)) && tupletype!=ETupleSpaceInternal ) { MDBStore::DeleteL(); } found=iTable.NextL(); } } if (version<KVersionBeforeNewUids) { TInt no_idxs[]={ -1 }; iTable.Close(); DeleteIndices(_L("TUPLES")); CC_TRAPD(err, MDBStore::ConstructL(cols, no_idxs, false, _L("TUPLES"), ETrue, col_flags)); iDb.BeginL(); TTransactionHolder th(*this); TBool found=iTable.FirstL(); while (found) { iTable.GetL(); if ( iTable.ColUint(ETupleId) == 0 ) { UpdateL(); iTable.SetColL(ENameId, KVersion); MDBStore::PutL(); } else if (! iTable.IsColNull(ENameSubName1)) { UpdateL(); iTable.SetColL(ENameSubName2, iTable.ColDes(ENameSubName1).Left(iSubNameIndexLength)); MDBStore::PutL(); } found=iTable.NextL(); } iDb.CommitL(); MDBStore::ConstructL(cols, idxs, false, _L("TUPLES"), ETrue, col_flags); } if (version>=KVersionBeforeNewUids) { CleanOldTuplesL(); } SeekIdL(0); UpdateL(); iTable.SetColL(ENameId, KVersion); MDBStore::PutL(); } else { InsertL(); iTable.SetColL(ETupleType, ETupleSpaceInternal); iTable.SetColL(ENameId, KVersion); iTable.SetColL( ELeaseExpires, Time::MaxTTime() ); MDBStore::PutL(); } }