// ----------------------------------------------------------------------------- // CGetPartialObject::VerifyParametersL // Verify if the parameter of the request (i.e. offset) is good. // ----------------------------------------------------------------------------- // TBool CGetPartialObject::VerifyParametersL() { PRINT( _L( "MM MTP => CGetPartialObject::VerifyParametersL" ) ); __ASSERT_DEBUG( iRequestChecker, Panic( EMmMTPDpRequestCheckNull ) ); TBool result = EFalse; iObjectHandle = Request().Uint32( TMTPTypeRequest::ERequestParameter1 ); iOffset = Request().Uint32( TMTPTypeRequest::ERequestParameter2 ); iPartialDataLength = Request().Uint32( TMTPTypeRequest::ERequestParameter3 ); PRINT3( _L( "MM MTP <> CGetPartialObject::VerifyParametersL iObjectHandle = 0x%x, iOffset = 0x%x, iMaxLength = 0x%x " ), iObjectHandle, iOffset, iPartialDataLength ); //get object info, but do not have the ownship of the object CMTPObjectMetaData* objectInfo = iRequestChecker->GetObjectInfo( iObjectHandle ); __ASSERT_DEBUG( objectInfo, Panic( EMmMTPDpObjectNull ) ); const TDesC& suid( objectInfo->DesC( CMTPObjectMetaData::ESuid ) ); PRINT1( _L( "MM MTP <> CGetPartialObject::VerifyParametersL suid = %S" ), &suid ); TEntry fileEntry; User::LeaveIfError( iFramework.Fs().Entry( suid, fileEntry ) ); if ( iOffset < fileEntry.FileSize() ) { result = ETrue; } PRINT1( _L( "MM MTP <= CGetPartialObject::VerifyParametersL result = %d" ), result ); return result; }
int main(int argc, const char * argv[]) { int x, y=1, z; if( y!=0) x=5; PRINT1(d,x); //(3.1) if(y==0) x=3; else x=5; PRINT1(d,x); //(3.2) x=1; if(y<0) if (y>0) x=3; else x=5; PRINT1(d,x); //(3.3) if (z=y<0) x=3; else if (y==0) x=5; else x=7; PRINT2(d,x,z); //(3.4) if(z =(y==0))x=5; x=3; PRINT2(d,x,z); //(3.5) if(x=z=y); x=3; PRINT2(d,x,z); //(3.6) return 0; }
// ---------------------------------------------------------------------------- // CPcsKeyMap::GetMappedString // ---------------------------------------------------------------------------- QString CPcsKeyMap::GetMappedString(QString aSource) const { #if defined(WRITE_PRED_SEARCH_LOGS) const int KLogLength = 30; TBuf<KLogLength> log(aSource.left(KLogLength).utf16()); PRINT1(_L("Enter CPcsKeyMap::GetMappedString input '%S'"), &log); #endif QString destination; TBool skipHashStar = DetermineSpecialCharBehaviour(aSource); TInt length = aSource.length(); for (int i = 0; i < length; ++i) { if (aSource[i] == KSpaceChar) { destination.append(KSeparatorChar); } else { QChar ch(0); ch = MappedKeyForChar(aSource[i]); if (!ShouldSkipChar(ch, skipHashStar)) { destination.append(ch); } } } #if defined(WRITE_PRED_SEARCH_LOGS) log = destination.left(KLogLength).utf16(); PRINT1(_L("End CPcsKeyMap::GetMappedString result '%S'"), &log); #endif return destination; }
TBool CPredictiveSearchSynchronizer::CheckIfPredSearchTableExistsL( const TDesC& aTableName) const { PRINT1(_L("CPredictiveSearchSynchronizer::CheckIfPredSearchTableExistsL table='%S'"), &aTableName); _LIT(KSelectFirstTableFormat, "SELECT name FROM sqlite_master WHERE type='table' AND name='%S';"); TInt bufSize = KSelectFirstTableFormat().Length() + aTableName.Length(); HBufC* select = HBufC::NewLC(bufSize); select->Des().AppendFormat(KSelectFirstTableFormat, &aTableName); RSqlStatement stmnt; CleanupClosePushL(stmnt); stmnt.PrepareL(iDatabase, *select); TBool tableExists = (stmnt.Next() == KSqlAtRow); CleanupStack::PopAndDestroy(&stmnt); CleanupStack::PopAndDestroy(select); PRINT1(_L("CPredictiveSearchSynchronizer::CheckIfPredSearchTablesExistL return %d"), tableExists); return tableExists; }
// ----------------------------------------------------------------------------- // CMediaMtpDataProviderEnumerator::RunL // Update the mpx db flag for round trip // ----------------------------------------------------------------------------- // void CMediaMtpDataProviderEnumerator::RunL() { PRINT1( _L( "MM MTP => CMediaMtpDataProviderEnumerator::RunL iStorages.Count() = %d" ), iStorages.Count() ); if ( iStorages.Count() > 0 ) { const CMTPStorageMetaData& storage( iFramework.StorageMgr().StorageL( iStorages[0] ) ); TPtrC root( storage.DesC( CMTPStorageMetaData::EStorageSuid ) ); GetModifiedContentL( root ); TRAPD( err, iDataProvider.GetWrapperL().UpdateMusicCollectionL( root ) ); if ( err != KErrNone ) { PRINT1( _L("MM MTP <> CMediaMtpDataProviderEnumerator::RunL, UpdateMusicCollectionL err =%d "), err ); } iStorages.Remove( 0 ); TRequestStatus* status = &iStatus; User::RequestComplete( status, iStatus.Int() ); SetActive(); } else { iStorages.Reset(); SignalCompleteL( iDataProvider ); } PRINT( _L( "MM MTP <= CMediaMtpDataProviderEnumerator::RunL" ) ); }
// ----------------------------------------------------------------------------- // CSendObject::SaveEmptyFileL // ----------------------------------------------------------------------------- // void CSendObject::SaveEmptyFileL() { PRINT( _L( "MM MTP => CSendObject::SaveEmptyFileL" ) ); if ( EMTPFormatCodeAbstractAudioVideoPlaylist == iObjectFormat ) { TInt err = iFileReceived->File().SetAtt( KEntryAttSystem | KEntryAttHidden, KEntryAttReadOnly | KEntryAttNormal ); if ( err != KErrNone ) PRINT1( _L( "MM MTP <> CSendObject::SaveEmptyFileL err = %d" ), err ); iDpConfig.GetWrapperL().AddDummyFileL( iFullPath ); } // Set subformat code to avoid MPX query for the first time to GetObjectReference, // in which case references has been kept in fw. if ( MmMtpDpUtility::HasReference( iObjectFormat ) ) iReceivedObjectInfo->SetUint( CMTPObjectMetaData::EFormatSubCode, EMTPSubFormatCodeUndefined ); // add playlist to MPX DB TRAPD( err, AddMediaToStoreL() ); if ( err != KErrNone ) iRollbackList.Append( &CSendObject::RemoveObjectFromDbL ); else iRollbackList.Reset(); PRINT1( _L( "MM MTP <= CSendObject::SaveEmptyFileL err = %d" ), err ); }
// ----------------------------------------------------------------------------- // CSendObject::ExistsL // Check if the file already exists on the storage. // ----------------------------------------------------------------------------- // TBool CSendObject::ExistsL( const TDesC& aName ) const { PRINT1( _L( "MM MTP => CSendObject::Exists aName = %S" ), &aName ); // This detects both files and folders TBool ret( EFalse ); ret = BaflUtils::FileExists( iFramework.Fs(), aName ); #ifdef MMMTPDP_REPLACE_EXIST_FILE if( ret ) { // delete the old one and replace TInt delErr = iFramework.Fs().Delete( aName ); PRINT1( _L( "MM MTP <> CSendObject::Exists delErr = %d" ), delErr ); // delete from the metadata DB TRAPD( err, iFramework.ObjectMgr().RemoveObjectL( aName ) ); PRINT1( _L( "MM MTP <> CSendObject::Exists err = %d" ), err ); if( err == KErrNone ) { // do nothing, ignore warning } // delete from video/mpx DB CMTPObjectMetaData* objectInfo = CMTPObjectMetaData::NewLC(); // + objectInfo if ( iFramework.ObjectMgr().ObjectL( aName, *objectInfo ) ) { TRAP_IGNORE( iWrapper.DeleteObjectL( aName, objectInfo->Uint( CMTPObjectMetaData::EFormatCode ) ) ); } CleanupStack::PopAndDestroy( objectInfo ); // - objectInfo ret = EFalse; } #endif PRINT1( _L( "MM MTP <= CSendObject::Exists ret = %d" ), ret ); return ret; }
// ----------------------------------------------------------------------------- // CGetObject::ServiceL // GetObject request handler // ----------------------------------------------------------------------------- // void CGetObject::ServiceL() { PRINT( _L( "MM MTP => CGetObject::ServiceL" ) ); MmMtpDpUtility::SetPSStatus(EMtpPSStatusActive); // Get the objectinfo TUint32 objectHandle = Request().Uint32( TMTPTypeRequest::ERequestParameter1 ); PRINT1( _L( "MM MTP <> CGetObject::ServiceL objectHandle = 0x%x" ), objectHandle ); // NOTE: shouldn't be deleted in destructor, don't have the ownership iObjectInfo = iRequestChecker->GetObjectInfo( objectHandle ); if ( iObjectInfo != NULL ) { // Get the file GetObjectL( iObjectInfo->DesC( CMTPObjectMetaData::ESuid ) ); // Send the data (file) SendDataL( *iFileObject ); } else { // The object handle has already been checked, so an invalid handle can // only occur if it was invalidated during a context switch between // the validation time and now. iError = EMTPRespCodeInvalidObjectHandle; } PRINT1( _L( "MM MTP <= CGetObject::ServiceL iError = 0x%x" ), iError ); }
void CacheSize(TUint aMin, TUint aMax) { SVMCacheInfo info; if (UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&info,0) != KErrNone) { return; } if (aMin > 0 || aMax > 0) { if (aMin > 0) { info.iMinSize = aMin; } if (aMax > 0) { info.iMaxSize = aMax; } UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)info.iMinSize,(TAny*)info.iMaxSize); if (UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&info,0) != KErrNone) { return; } } PRINT1(_L("Paging Cache min size %d"),info.iMinSize); PRINT1(_L(" max size %d"),info.iMaxSize); PRINT1(_L(" current size %d\n"),info.iCurrentSize); }
// ---------------------------------------------------------------------------- // C12keyKeyMap::ReadExtraCharacters // The special chars that are listed in HbKeyboardSctPortrait, but not in // HbKeyboardVirtual12Key, are mapped to key-* except the hardcoded characters // "+*#". // ---------------------------------------------------------------------------- TInt C12keyKeyMap::ReadExtraCharacters(const HbInputLanguage& aLanguage) { PRINT(_L("C12keyKeyMap::ReadExtraCharacters")); TInt count(0); // How many new keys have been mapped #if defined(NEW_KEYMAP_FACTORY_API) // Takes ownership QScopedPointer<const HbKeymap> keymap( HbKeymapFactory::instance()->keymap(aLanguage, HbKeymapFactory::NoCaching)); #else const HbKeymap* keymap = HbKeymapFactory::instance()->keymap(aLanguage, HbKeymapFactory::Default); #endif if (keymap) { TInt i(0); const HbMappedKey* mappedKey = keymap->keyForIndex(HbKeyboardSctPortrait, i); while (mappedKey) { AddNewKeyToMap(EKeyStar, mappedKey->characters(HbModifierNone), count); mappedKey = keymap->keyForIndex(HbKeyboardSctPortrait, ++i); } } else { PRINT1(_L("no keymap for language %d"), aLanguage.language()); } PRINT1(_L("End C12keyKeyMap::ReadExtraCharacters added %d chars"), count); return count; }
// ---------------------------------------------------------------------------- // CCsServer::RefreshConversations // Refresh conversations. // ---------------------------------------------------------------------------- void CCsServer::RefreshConversations() { // NOTE:- NO CHECK DONE NOW ON NUMBER OF PLUGINS TO KEEP IT SIMPLE. // NOT EXPECTED TO BE MORE THAN 1 PLUGIN FOR TB 9.2. // Delete and recreate cache. if (iConversationCache) { delete iConversationCache; iConversationCache = NULL; iCsCachingStatus = KCachingStatusUnknown; TRAPD(error, iConversationCache = CCsConversationCache:: NewL(iContactsManager, this)); if (error != KErrNone) { PRINT1 ( _L("CCsServer::RefreshConversations - Error:%d"), error ); } } // Notify client to refresh NotifySessions(NULL, KConversationEventRefresh); NotifySessions(NULL, KConversationEventListRefresh); // Read again. TRAPD(error, iConversationPlugin->GetConversationsL()); if (error != KErrNone) { PRINT1 ( _L("CCsServer::RefreshConversations - Error:%d"), error ); } }
int CHOLMOD(reallocate_factor) ( /* ---- input ---- */ size_t nznew, /* new # of entries in L */ /* ---- in/out --- */ cholmod_factor *L, /* factor to modify */ /* --------------- */ cholmod_common *Common ) { /* ---------------------------------------------------------------------- */ /* get inputs */ /* ---------------------------------------------------------------------- */ RETURN_IF_NULL_COMMON (FALSE) ; RETURN_IF_NULL (L, FALSE) ; RETURN_IF_XTYPE_INVALID (L, CHOLMOD_REAL, CHOLMOD_ZOMPLEX, FALSE) ; PRINT1 (("realloc factor: xtype %d\n", L->xtype)) ; if (L->is_super) { /* L must be simplicial, and not symbolic */ ERROR (CHOLMOD_INVALID, "L invalid") ; return (FALSE) ; } Common->status = CHOLMOD_OK ; PRINT1 (("realloc factor %g to %g\n", (double) L->nzmax, (double) nznew)) ; /* ---------------------------------------------------------------------- */ /* resize (or allocate) the L->i and L->x components of the factor */ /* ---------------------------------------------------------------------- */ CHOLMOD(realloc_multiple) (nznew, 1, L->xtype, &(L->i), NULL, &(L->x), &(L->z), &(L->nzmax), Common) ; return (Common->status == CHOLMOD_OK) ; }
TBool CPredictiveSearchSynchronizer::ReadMailAddressesL(CContactItem& aContact) { PRINT(_L("CPredictiveSearchSynchronizer::ReadMailAddressesL")); // SELECT value FROM comm_addr // WHERE contact_id = [contact id value] AND type = [type value]; _LIT(KSelectMailAddrFormat, "SELECT %S FROM %S WHERE %S = %d AND %S = %d;"); const TInt KContactIdLength = 10; const TInt KCommAddrTypeLength = 2; // CPplCommAddrTable::EEmailAddress is enum TInt bufSize = KSelectMailAddrFormat().Length() + KCommAddrValue().Length() + KSqlContactCommAddrTableName().Length() + KCommAddrContactId().Length() + KContactIdLength + KCommAddrType().Length() + KCommAddrTypeLength; HBufC* sqlStatement = HBufC::NewLC(bufSize); sqlStatement->Des().AppendFormat(KSelectMailAddrFormat, &KCommAddrValue, &KSqlContactCommAddrTableName, &KCommAddrContactId, aContact.Id(), &KCommAddrType, CPplCommAddrTable::EEmailAddress); RSqlStatement stmnt; CleanupClosePushL(stmnt); PRINT1(_L("prepare SQL statement:%S"), sqlStatement); stmnt.PrepareL(iDatabase, *sqlStatement); const TInt KValueIndex = 0; TBool foundMailAddress(EFalse); TInt err(KErrNone); while ((err = stmnt.Next()) == KSqlAtRow) { TPtrC value; if (stmnt.ColumnText(KValueIndex, value) == KErrNone) { PRINT2(_L(" id=%d, found mail address=%S"), aContact.Id(), &value); CContactItemField* field = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldEMail); CContactTextField* textfield = field->TextStorage(); textfield->SetTextL(value); aContact.AddFieldL(*field); // Takes ownership CleanupStack::Pop(field); foundMailAddress = ETrue; } } if (err != KSqlAtEnd) { PRINT1(_L("CPredictiveSearchSynchronizer::ReadMailAddressesL SQL err=%d"), err); User::Leave(err); } CleanupStack::PopAndDestroy(&stmnt); CleanupStack::PopAndDestroy(sqlStatement); PRINT1(_L("CPredictiveSearchSynchronizer::ReadMailAddressesL return %d"), foundMailAddress); return foundMailAddress; }
static void cc_process_volume_usage(struct hid_appcol *ha, struct hid_report *hr, int value) { struct hid_interface *hi; struct hid_field *hf; int i, flags, total; struct hid_key keycodes[MAX_KEYCODE]; uint16_t key; /* * HUG_VOLUME has Usage Type LC (linear control). Usually it has * value range [-Min, Max]. Positive value n increments the volume * by n. Negative value -n decrements the volumn by n. To fit in * our key press/release model, HUG_VOLUME is simulated by * pressing/releasing HUG_VOLUME_UP or HUG_VLOLUME_DOWN n times. */ hi = hid_appcol_get_parser_private(ha); assert(hi != NULL); /* Do nothing if value is 0. */ if (value == 0) return; /* The keyboard driver needs to know the total number of keys. */ total = 0; hf = NULL; while ((hf = hid_report_get_next_field(hr, hf, HID_INPUT)) != NULL) { flags = hid_field_get_flags(hf); if (flags & HIO_CONST) continue; for (i = 0; i < hf->hf_count; i++) total++; } if (total >= MAX_KEYCODE) return; if (value < 0) key = HUG_VOLUME_DOWN; else key = HUG_VOLUME_UP; value = abs(value); memset(keycodes, 0, sizeof(keycodes)); for (i = 0; i < value; i++) { /* Key press. */ keycodes[0].code = key; keycodes[0].up = HUP_CONSUMER; kbd_input(ha, 0, keycodes, total); if (verbose > 1) PRINT1("hid codes: 0x%02X (HUG_VOLUME)\n", keycodes[0].code); /* Key release. */ keycodes[0].code = 0; kbd_input(ha, 0, keycodes, total); if (verbose > 1) PRINT1("hid codes: none (HUG_VOLUME)\n"); } }
// --------------------------------------------------------------------------- // CMmMtpDpMetadataAccessWrapper::GetObjectMetadataValueL // Gets a piece of metadata from the collection // --------------------------------------------------------------------------- // EXPORT_C void CMmMtpDpMetadataAccessWrapper::GetObjectMetadataValueL( const TUint16 aPropCode, MMTPType& aNewData, const CMTPObjectMetaData& aObjectMetaData ) { PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::GetObjectMetadataValueL" ) ); TMPXGeneralCategory category = Category( aObjectMetaData ); switch ( category ) { case EMPXAbstractAlbum: if ( aPropCode == EMTPObjectPropCodeDateAdded && EMTPTypeString == aNewData.Type() ) { TBuf<KMtpMaxDateTimeStringLength> timeStr; MmMtpDpUtility::GetObjectDateModifiedL( iFs, aObjectMetaData.DesC( CMTPObjectMetaData::ESuid ), timeStr ); PRINT1( _L( "MM MTP <> CGetObjectPropList::ServiceOneObjectPropertyL Date time %S" ), &timeStr ); ( ( CMTPTypeString & ) aNewData ).SetL( timeStr ); break; } // else // Fall through on purpoe to get from mpx case EMPXPlaylist: case EMPXSong: { iMmMtpDpMetadataMpxAccess->GetObjectMetadataValueL( aPropCode, aNewData, aObjectMetaData.DesC( CMTPObjectMetaData::ESuid ), category ); } break; case EMPXVideo: if ( aPropCode == EMTPObjectPropCodeDateAdded && EMTPTypeString == aNewData.Type() ) { TBuf<KMtpMaxDateTimeStringLength> timeStr; MmMtpDpUtility::GetObjectDateModifiedL( iFs, aObjectMetaData.DesC( CMTPObjectMetaData::ESuid ), timeStr ); PRINT1( _L( "MM MTP <> CGetObjectPropList::ServiceOneObjectPropertyL Date time %S" ), &timeStr ); ( ( CMTPTypeString & ) aNewData ).SetL( timeStr ); } else { iMmMtpDpMetadataVideoAccess->GetObjectMetadataValueL( aPropCode, aNewData, aObjectMetaData ); } break; default: // do nothing break; } PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::GetObjectMetadataValueL" ) ); }
void CreateChunk(RChunk * aChunk, TUint aSize) { TESTNEXT(_L("Creating a paged chunk")); TChunkCreateInfo createInfo; PRINT1(_L("Creating chunk size 0x%08X bytes "),aSize); PRINT1(_L("at index %d\n"),gNextChunk); createInfo.SetPaging(TChunkCreateInfo::EPaged); createInfo.SetNormal(aSize,aSize); test_KErrNone(aChunk->Create(createInfo)); }
// ----------------------------------------------------------------------------- // CMediaMtpDataProvider::Supported // Defines the supported operations and formats of the data provider // ----------------------------------------------------------------------------- // void CMediaMtpDataProvider::Supported( TMTPSupportCategory aCategory, RArray<TUint>& aArray ) const { switch ( aCategory ) { case EEvents: break; case EObjectCaptureFormats: case EObjectPlaybackFormats: { TInt count = sizeof( KMediaMtpDataProviderSupportedFormats ) / sizeof( TUint16 ); for ( TInt i = 0; i < count; i++ ) { aArray.Append( KMediaMtpDataProviderSupportedFormats[i] ); } PRINT1( _L( "MM MTP <> CMediaMtpDataProvider::Supported format count = %d" ), count ); } break; case EOperations: { TInt count = sizeof( KMediaMtpDataProviderSupportedOperations ) / sizeof( TUint16 ); for ( TInt i = 0; i < count; i++ ) { aArray.Append( KMediaMtpDataProviderSupportedOperations[i] ); } PRINT1( _L( "MM MTP <> CMediaMtpDataProvider::Supported operation count = %d" ), count ); } break; case EObjectProperties: { TInt count = iSupportedPropAll.Count(); for ( TInt i = 0; i < count; i++ ) { aArray.Append( iSupportedPropAll[i] ); } PRINT1( _L( "MM MTP <> CMediaMtpDataProvider::Supported properties count = %d" ), aArray.Count() ); } break; case EStorageSystemTypes: { aArray.Append( CMTPStorageMetaData::ESystemTypeDefaultFileSystem ); } break; default: // Unrecognised category, leave aArray unmodified. break; } }
// ----------------------------------------------------------------------------- // CSendObject::MatchStoreAndParentL // ----------------------------------------------------------------------------- // TMTPResponseCode CSendObject::MatchStoreAndParentL() { TMTPResponseCode responseCode = EMTPRespCodeOK; iStorageId = Request().Uint32( TMTPTypeRequest::ERequestParameter1 ); iParentHandle = Request().Uint32( TMTPTypeRequest::ERequestParameter2 ); PRINT2( _L( "MM MTP <> CSendObject::MatchStoreAndParentL, iStorageId = 0x%x, iParentHandle = 0x%x" ), iStorageId, iParentHandle ); if ( iStorageId == KMTPStorageDefault ) { iStorageId = iDpConfig.GetDefaultStorageIdL(); PRINT1( _L( "MM MTP <> CSendObject::GetDefaultStorageIdL, iStorageId = 0x%x" ), iStorageId ); } delete iParentSuid; iParentSuid = NULL; if( iParentHandle == KMTPHandleNone ) // parentHandle is not used by initiator, set it to root { iParentHandle = KMTPHandleAll; } if ( iParentHandle == KMTPHandleAll ) // According to spec, KMTPHandleAll means initiator wish to place in the root { PRINT( _L( "MM MTP <> CSendObject::MatchStoreAndParentL, iParentSuid = KMTPHandleAll" ) ); iParentSuid = iFramework.StorageMgr().StorageL( iStorageId ).DesC( CMTPStorageMetaData::EStorageSuid ).AllocL(); PRINT1( _L( "MM MTP <> CSendObject::MatchStoreAndParentL, iParentSuid = %S" ), iParentSuid ); } else // parentHandle is specified by initiator { // does not take owernship CMTPObjectMetaData* parentObjInfo = iRequestChecker->GetObjectInfo( iParentHandle ); __ASSERT_DEBUG( parentObjInfo, Panic( EMmMTPDpObjectNull ) ); if ( parentObjInfo->Uint( CMTPObjectMetaData::EStorageId ) != iStorageId ) { responseCode = EMTPRespCodeInvalidObjectHandle; PRINT( _L( "MM MTP <> CSendObject::MatchStoreAndParentL, STORAGEID DOES NOT MATCH WITH PARENTHANDLE!" ) ); } else { iParentSuid = parentObjInfo->DesC( CMTPObjectMetaData::ESuid ).AllocL(); } } PRINT1( _L( "MM MTP <> CSendObject::MatchStoreAndParentL, iParentSuid = %S" ), iParentSuid ); if ( ( responseCode == EMTPRespCodeOK ) && !BaflUtils::PathExists( iFramework.Fs(), *iParentSuid ) ) { responseCode = EMTPRespCodeInvalidDataset; } return responseCode; }
// ----------------------------------------------------------------------------- // CSendObject::CheckSendingState // Helper Functions // Verify if the SendObject request comes after SendObjectInfo request // @return EMTPRespCodeOK if SendObject request comes after a valid SendObjectInfo request, otherwise // EMTPRespCodeNoValidObjectInfo // ----------------------------------------------------------------------------- // TMTPResponseCode CSendObject::CheckSendingStateL() { PRINT( _L( "MM MTP => CSendObject::CheckSendingState" ) ); TMTPResponseCode result = EMTPRespCodeOK; iOperationCode = Request().Uint16( TMTPTypeRequest::ERequestOperationCode ); PRINT1( _L( "MM MTP <> CSendObject iOperationCode = 0x%x" ), iOperationCode ); if ( iOperationCode == EMTPOpCodeSendObject ) { // In ParseRouter everytime SendObject gets resolved then will be removed from Registry // right away therefore we need reRegister it here again in case possible cancelRequest // against this SendObject being raised. iExpectedSendObjectRequest.SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); iFramework.RouteRequestRegisterL( iExpectedSendObjectRequest, iConnection ); } if ( iProgress == EObjectNone ) { if ( iOperationCode == EMTPOpCodeSendObject ) { PRINT( _L( "MM MTP <> CSendObject::CheckSendingState EMTPRespCodeNoValidObjectInfo" ) ); result = EMTPRespCodeNoValidObjectInfo; } } else if ( iProgress == EObjectInfoSucceed ) { if ( iOperationCode == EMTPOpCodeSendObjectInfo ) { delete iObjectInfo; iObjectInfo = NULL; Rollback(); iProgress = EObjectNone; } else if ( iOperationCode == EMTPOpCodeSendObjectPropList ) { delete iObjectPropList; iObjectPropList = NULL; Rollback(); iProgress = EObjectNone; } } else { Panic( EMmMTPDpSendObjectStateInvalid ); } PRINT1( _L( "MM MTP <= CSendObject::CheckSendingState result = 0x%x" ), result ); return result; }
// ----------------------------------------------------------------------------- // CMmMtpDpMetadataAccessWrapper::DeleteDummyFile // Delete one dummy file from dummy files array // ----------------------------------------------------------------------------- // EXPORT_C void CMmMtpDpMetadataAccessWrapper::DeleteDummyFile( const TDesC& aDummyFileName ) { PRINT1( _L( "MM MTP <> CMmMtpDpMetadataAccessWrapper::DeleteDummyFile aDummyFileName(%S)" ), &aDummyFileName ); TInt pos = 0; if ( iAbstractMediaArray->Count() > 0 ) { if ( 0 == iAbstractMediaArray->Find( aDummyFileName, pos ) ) { PRINT1( _L( "MM MTP <> CMmMtpDpMetadataAccessWrapper::DeleteDummyFile pos = %d" ), pos ); iAbstractMediaArray->Delete( pos ); } } }
void ThreadedAudioDevice::waitForThread(int waitMs) { if (!isPassive()) { assert(_thread != 0); // should not get called again! PRINT1("ThreadedAudioDevice::waitForThread: waiting for thread to finish\n"); if (pthread_join(_thread, NULL) == -1) { PRINT0("ThreadedAudioDevice::doStop: terminating thread!\n"); // JWM: pthread_cancel is not available in Android //pthread_cancel(_thread); //_thread = 0; } PRINT1("\tThreadedAudioDevice::waitForThread: thread done\n"); } }
static int allocate_simplicial_numeric ( cholmod_factor *L, cholmod_common *Common ) { Int n ; Int *Lp, *Lnz, *Lprev, *Lnext ; size_t n1, n2 ; PRINT1 (("Allocate simplicial\n")) ; ASSERT (L->xtype == CHOLMOD_PATTERN || L->is_super) ; ASSERT (L->p == NULL) ; ASSERT (L->nz == NULL) ; ASSERT (L->prev == NULL) ; ASSERT (L->next == NULL) ; n = L->n ; /* this cannot cause size_t overflow */ n1 = ((size_t) n) + 1 ; n2 = ((size_t) n) + 2 ; Lp = CHOLMOD(malloc) (n1, sizeof (Int), Common) ; Lnz = CHOLMOD(malloc) (n, sizeof (Int), Common) ; Lprev = CHOLMOD(malloc) (n2, sizeof (Int), Common) ; Lnext = CHOLMOD(malloc) (n2, sizeof (Int), Common) ; if (Common->status < CHOLMOD_OK) { CHOLMOD(free) (n1, sizeof (Int), Lp, Common) ; CHOLMOD(free) (n, sizeof (Int), Lnz, Common) ; CHOLMOD(free) (n2, sizeof (Int), Lprev, Common) ; CHOLMOD(free) (n2, sizeof (Int), Lnext, Common) ; PRINT1 (("Allocate simplicial failed\n")) ; return (FALSE) ; /* out of memory */ } /* ============================================== commit the changes to L */ L->p = Lp ; L->nz = Lnz ; L->prev = Lprev ; L->next = Lnext ; /* initialize a doubly linked list for columns in natural order */ natural_list (L) ; PRINT1 (("Allocate simplicial done\n")) ; return (TRUE) ; }
// ----------------------------------------------------------------------------- // CSendObject::SetFileProperties // ----------------------------------------------------------------------------- // void CSendObject::SetFileProperties() { PRINT1( _L( "MM MTP => CSendObject::SetFileProperties iProtectionStatus = %d" ), iProtectionStatus ); if ( iFileReceived != NULL ) { if ( iProtectionStatus == EMTPProtectionNoProtection || iProtectionStatus == EMTPProtectionReadOnly ) { TInt err = KErrNone; if ( iProtectionStatus == EMTPProtectionNoProtection ) { err = iFileReceived->File().SetAtt( KEntryAttNormal, KEntryAttReadOnly ); } else { err = iFileReceived->File().SetAtt( KEntryAttReadOnly, KEntryAttNormal ); } if ( err != KErrNone ) { PRINT1( _L( "MM MTP <> CSendObject::SetFileProperties SetAtt err = %d" ), err ); } } if( iDateMod != NULL ) { TTime modTime( 0 ); TInt err = MmMtpDpUtility::DesToTTime( *iDateMod, modTime ); if( err == KErrNone ) { err = iFileReceived->File().SetModified( modTime ); PRINT1( _L( "MM MTP <> CSendObject::SetFileProperties SetModified err = %d" ), err ); } } // Close the file after SetFileProperties to make sure other process won't open // the file successfully right at the time calling RFile::SetAtt. if ( iObjectSize > 0 ) { delete iFileReceived; iFileReceived = NULL; } else iFileReceived->File().Close(); } PRINT( _L( "MM MTP <= CSendObject::SetFileProperties" ) ); }
void ThreadedAudioDevice::waitForThread(int waitMs) { if (!isPassive()) { //f assert(_thread != 0); // should not get called again! PRINT1("ThreadedAudioDevice::waitForThread: waiting for thread to finish\n"); // if (pthread_join(_thread, NULL) == -1) { // PRINT0("ThreadedAudioDevice::doStop: terminating thread!\n"); //#ifndef OF_ANDROID // pthread_cancel(_thread); //#endif // _thread = 0; // } PRINT1("\tThreadedAudioDevice::waitForThread: thread done\n"); } }
// ----------------------------------------------------------------------------- // CMoveObject::CanMoveObjectL // Check if we can move the file to the new location // ----------------------------------------------------------------------------- // TMTPResponseCode CMoveObject::CanMoveObjectL( const TDesC& aOldName, const TDesC& aNewName ) const { PRINT2( _L( "MM MTP => CMoveObject::CanMoveObjectL aOldName = %S, aNewName = %S" ), &aOldName, &aNewName ); TMTPResponseCode result = EMTPRespCodeOK; TEntry fileEntry; User::LeaveIfError( iFramework.Fs().Entry( aOldName, fileEntry ) ); TInt drive = iFramework.StorageMgr().DriveNumber( iStorageId ); User::LeaveIfError( drive ); TVolumeInfo volumeInfo; User::LeaveIfError( iFramework.Fs().Volume( volumeInfo, drive ) ); if ( volumeInfo.iFree < fileEntry.FileSize() ) { result = EMTPRespCodeStoreFull; } else if ( BaflUtils::FileExists( iFramework.Fs(), aNewName ) ) { #ifdef MMMTPDP_REPLACE_EXIST_FILE // delete the old one and replace TInt delErr = iFramework.Fs().Delete( aNewName ); PRINT1( _L( "MM MTP <> CMoveObject::CanMoveObjectL delErr = %d" ), delErr ); // delete from the metadata DB TRAPD( err, iFramework.ObjectMgr().RemoveObjectL( aNewName ) ); PRINT1( _L( "MM MTP <> CMoveObject::CanMoveObjectL err = %d" ), err ); // delete from video/mpx DB CMTPObjectMetaData* objectInfo = CMTPObjectMetaData::NewLC(); // + objectInfo if ( iFramework.ObjectMgr().ObjectL( aNewName, *objectInfo ) ) { TRAP( err, iDpConfig.GetWrapperL().DeleteObjectL( aNewName, objectInfo->Uint( CMTPObjectMetaData::EFormatCode ) ) ); } CleanupStack::PopAndDestroy( objectInfo ); // - objectInfo if ( err ) { // do nothing } #else result = EMTPRespCodeInvalidParentObject; #endif } PRINT1( _L( "MM MTP <= CMoveObject::CanMoveObjectL result = 0x%x" ), result ); return result; }
// ---------------------------------------------------------------------------- // CPcsKeyMap::GetMappedStringL // ---------------------------------------------------------------------------- HBufC* CPcsKeyMap::GetMappedStringL(const TDesC& aSource) const { PRINT1(_L("Enter CPcsKeyMap::GetMappedStringL input '%S'"), &aSource); QString source((QChar*)aSource.Ptr(), aSource.Length()); QString result; TInt err(KErrNone); QT_TRYCATCH_ERROR(err, result = GetMappedString(source)); User::LeaveIfError(err); HBufC* destination = HBufC::NewL(result.length()); destination->Des().Copy(result.utf16()); PRINT1(_L("End CPcsKeyMap::GetMappedStringL result '%S'"), destination); return destination; }
int ThreadedAudioDevice::waitForDevice(unsigned int wTime) { int ret; unsigned waitSecs = int(wTime / 1000.0); unsigned waitUsecs = 1000 * (wTime - unsigned(waitSecs * 1000)); // Wait wTime msecs for select to return, then bail. if (!stopping()) { int nfds = _device + 1; struct timeval tv; tv.tv_sec = waitSecs; tv.tv_usec = waitUsecs; // If wTime == 0, wait forever by passing NULL as the final arg. // if (!isPlaying()) // printf("select(%d, 0x%x, 0x%x, NULL, 0x%x)...\n", // nfds, &_rfdset, &_wfdset, wTime == 0 ? NULL : &tv); int selret = ::select(nfds, &_rfdset, &_wfdset, NULL, wTime == 0 ? NULL : &tv); if (selret <= 0) { if (errno != EINTR) fprintf(stderr, "ThreadedAudioDevice::waitForDevice: select %s\n", (selret == 0) ? "timed out" : "returned error"); ret = -1; } else { setFDSet(); ret = 0; } } else { PRINT1("ThreadedAudioDevice::waitForDevice: stopping == true\n"); ret = 1; } return ret; }
// ----------------------------------------------------------------------------- // CDescriptionUtility::NewRangeFormDescriptionL // // ----------------------------------------------------------------------------- // EXPORT_C CMTPTypeObjectPropDesc* CDescriptionUtility::NewRangeFormDescriptionL( TUint16 aPropertyCode, TUint32 aMinValue, TUint32 aMaxValue, TUint32 aStepValue, TBool aIsReadOnly ) { PRINT1( _L( "MM MTP => CDescriptionUtility::NewRangeFormDescriptionL, aPropertyCode = 0x%x" ), aPropertyCode ); CMTPTypeObjectPropDescRangeForm* form = CMTPTypeObjectPropDescRangeForm::NewLC( EMTPTypeUINT32 ); // + form // Set expected values form->SetUint32L( CMTPTypeObjectPropDescRangeForm::EMinimumValue, aMinValue ); form->SetUint32L( CMTPTypeObjectPropDescRangeForm::EMaximumValue, aMaxValue ); form->SetUint32L( CMTPTypeObjectPropDescRangeForm::EStepSize, aStepValue ); CMTPTypeObjectPropDesc::TPropertyInfo propertyInfo; propertyInfo.iDataType = EMTPTypeUINT32; propertyInfo.iFormFlag = CMTPTypeObjectPropDesc::ERangeForm; propertyInfo.iGetSet = !aIsReadOnly; CMTPTypeObjectPropDesc* propertyDesc = CMTPTypeObjectPropDesc::NewL( aPropertyCode, propertyInfo, form ); // + propertyDesc CleanupStack::PopAndDestroy( form ); // - form PRINT( _L( "MM MTP <= CDescriptionUtility::NewRangeFormDescriptionL" ) ); return propertyDesc; }
// ----------------------------------------------------------------------------- // CMoveObject::MoveFileL // A helper function of MoveObjectL // ----------------------------------------------------------------------------- // void CMoveObject::MoveFileL( const TDesC& aNewFileName ) { HBufC* oldFileName = iObjectInfo->DesC( CMTPObjectMetaData::ESuid ).AllocLC(); // + oldFileName PRINT2( _L( "MM MTP => CMoveObject::MoveFileL old name = %S, aNewFileName = %S" ), oldFileName, &aNewFileName ); if ( iStorageId == iObjectInfo->Uint( CMTPObjectMetaData::EStorageId ) ) iSameStorage = ETrue; else iSameStorage = EFalse; // Move the file first no matter if it will fail in Get/SetPreviousPropertiesL // Already trapped inside GetPreviousPropertiesL( *iObjectInfo ); TRAP_IGNORE( SetPropertiesL( aNewFileName ) ); CFileMan* fileMan = CFileMan::NewL( iFramework.Fs() ); CleanupStack::PushL( fileMan ); // + fileMan TInt err = fileMan->Move( *oldFileName, aNewFileName ); PRINT1( _L( "MM MTP <> CMoveObject::MoveFileL err = %d" ), err ); User::LeaveIfError( err ); CleanupStack::PopAndDestroy( fileMan ); // - fileMan CleanupStack::PopAndDestroy( oldFileName ); // - oldFileName PRINT( _L( "MM MTP <= CMoveObject::MoveFileL" ) ); }
// ----------------------------------------------------------------------------- // CMoveObject::GetParametersL // Retrieve the parameters of the request // ----------------------------------------------------------------------------- // void CMoveObject::GetParametersL() { PRINT( _L( "MM MTP => CMoveObject::GetParametersL" ) ); __ASSERT_DEBUG( iRequestChecker, Panic( EMmMTPDpRequestCheckNull ) ); TUint32 objectHandle = Request().Uint32( TMTPTypeRequest::ERequestParameter1 ); iStorageId = Request().Uint32( TMTPTypeRequest::ERequestParameter2 ); iNewParentHandle = Request().Uint32( TMTPTypeRequest::ERequestParameter3 ); PRINT3( _L( "MM MTP <> objectHandle = 0x%x, iStorageId = 0x%x, iNewParentHandle = 0x%x" ), objectHandle, iStorageId, iNewParentHandle ); // not taking owernship iObjectInfo = iRequestChecker->GetObjectInfo( objectHandle ); __ASSERT_DEBUG( iObjectInfo, Panic( EMmMTPDpObjectNull ) ); if ( iNewParentHandle == KMTPHandleNone ) { SetDefaultParentObjectL(); } else { CMTPObjectMetaData* parentObject = iRequestChecker->GetObjectInfo( iNewParentHandle ); __ASSERT_DEBUG( parentObject, Panic( EMmMTPDpObjectNull ) ); delete iDest; iDest = NULL; iDest = parentObject->DesC( CMTPObjectMetaData::ESuid ).AllocL(); PRINT1( _L( "MM MTP <> CMoveObject::GetParametersL iDest = %S" ), iDest ); } PRINT( _L( "MM MTP <= CMoveObject::GetParametersL" ) ); }