//------------------------------------------------------------------------------ // CAddBuffer::Find //------------------------------------------------------------------------------ CConnMoNodeElement* CAddBuffer::CacheFind( const TDesC8& aUri ) { OstTraceExt1( TRACE_NORMAL, CADDBUFFER_CACHEFIND_ENTRY, "ENTRY: CAddBuffer::CacheFind;aUri=%s", aUri ); CConnMoNodeElement* resultNode = NULL; for ( TInt i = 0; i < iCache.Count(); ++i ) { if ( iCache[i]->iUri.Match( aUri ) != KErrNotFound ) { OstTrace0( TRACE_NORMAL, CADDBUFFER_CACHEFIND_MATCH_FOUND, "CAddBuffer::CacheFind; Matching URI found."); resultNode = iCache[i]; OstTraceExt1( TRACE_NORMAL, CADDBUFFER_CACHEFIND_RESULT_NODE, "CAddBuffer::CacheFind; resultNode=%s", resultNode->iUri ); break; } } OstTrace0( TRACE_NORMAL, CADDBUFFER_CACHEFIND_EXIT, "EXIT: CAddBuffer::CacheFind"); return resultNode; }
//------------------------------------------------------------------------------ // CAddBuffer::FindDynamicNode //------------------------------------------------------------------------------ CConnMoNodeElement* CAddBuffer::CacheFindDynamicNode( const TDesC8& aUri ) { OstTraceExt1( TRACE_NORMAL, CADDBUFFER_CACHEFINDDYNAMICNODE_ENTRY, "ENTRY: CAddBuffer::CacheFindDynamicNode;aUri=%s", aUri ); CConnMoNodeElement* resultNode = NULL; for ( TInt i = 0; i < iCache.Count(); ++i ) { if ( iCache[i]->iUri.Match( aUri ) != KErrNotFound ) { // TBuf8<KMaxFieldLength> dynamicNodeChildUri( aUri ); dynamicNodeChildUri.Append( KChildNodeWildCardPattern ); if ( iCache[i]->iUri.Match(dynamicNodeChildUri) == KErrNotFound ) { // Correct dynamic node found. OstTrace0( TRACE_NORMAL, CADDBUFFER_CACHEFINDDYNAMICNODE_MATCH_FOUND, "CAddBuffer::CacheFindDynamicNode; Matching node found."); resultNode = iCache[i]; break; } } } if ( resultNode != NULL ) { OstTraceExt1( TRACE_NORMAL, CADDBUFFER_CACHEFINDDYNAMICNODE_EXIT, "EXIT: CAddBuffer::CacheFindDynamicNode;resultNode=%s", resultNode->iUri ); } return resultNode; }
void CCdcDataInterface::CancelWrite() /** * Cancel an outstanding write request */ { OstTraceFunctionEntry0( CCDCDATAINTERFACE_CANCELWRITE_ENTRY ); if (!iWriter) { OstTraceExt1( TRACE_FATAL, CCDCDATAINTERFACE_CANCELWRITE, "CCdcDataInterface::CancelWrite;iWriter=%p", iWriter ); __ASSERT_DEBUG( EFalse, User::Panic(KAcmPanicCat, EPanicInternalError) ); } iWriter->Cancel(); iWriteObserver = NULL; OstTraceFunctionExit0( CCDCDATAINTERFACE_CANCELWRITE_EXIT ); }
/** Set the object properties after moving */ void CMTPMoveObject::SetPreviousPropertiesL(const TDesC& aFileName) { OstTraceFunctionEntry0( CMTPMOVEOBJECT_SETPREVIOUSPROPERTIESL_ENTRY ); LEAVEIFERROR(iFramework.Fs().SetModified(aFileName, iPreviousModifiedTime), OstTraceExt1( TRACE_ERROR, CMTPMOVEOBJECT_SETPREVIOUSPROPERTIESL, "Sets the date and time for %S failed", aFileName)); if ( iIsFolder && iIsHidden ) { TEntry fileEntry; User::LeaveIfError(iFramework.Fs().Entry( aFileName, fileEntry )); fileEntry.iAtt &= ~KEntryAttHidden; fileEntry.iAtt |= KEntryAttHidden; User::LeaveIfError(iFramework.Fs().SetAtt( aFileName, fileEntry.iAtt, ~fileEntry.iAtt)); } OstTraceFunctionExit0( CMTPMOVEOBJECT_SETPREVIOUSPROPERTIESL_EXIT ); }
/** Print a report at the end of a test run of all PASSED tests, Note: If a test fails, the framework gets Panic'd */ void CTestEngine::Report() { TBuf<KTestCaseIdLength> aTestCaseId; test.Printf(_L("============================\n")); OstTrace0(TRACE_NORMAL, CTESTENGINE_REPORT, "============================\n"); test.Printf(_L("PASSED TESTS:\n")); OstTrace0(TRACE_NORMAL, CTESTENGINE_REPORT_DUP01, "PASSED TESTS:\n"); // itterate our list of tests to perform ResetTestCaseIndex(); while (KErrNone == NextTestCaseId(aTestCaseId)) { test.Printf(_L("%S\n"), &aTestCaseId); OstTraceExt1(TRACE_NORMAL, CTESTENGINE_REPORT_DUP02, "%S\n", aTestCaseId); } }
void CCdcDataInterface::CancelRead() /** * Cancel an outstanding read request */ { OstTraceFunctionEntry0( CCDCDATAINTERFACE_CANCELREAD_ENTRY ); if (!iReader) { OstTraceExt1( TRACE_FATAL, CCDCDATAINTERFACE_CANCELREAD, "CCdcDataInterface::CancelRead;iReader=%p", iReader ); __ASSERT_DEBUG( EFalse, User::Panic(KAcmPanicCat, EPanicInternalError) ); } if (!iReadOneOrMoreReader) { OstTraceExt1( TRACE_FATAL, CCDCDATAINTERFACE_CANCELREAD_DUP1, "CCdcDataInterface::CancelRead;iReadOneOrMoreReader=%p", iReadOneOrMoreReader ); __ASSERT_DEBUG( EFalse, User::Panic(KAcmPanicCat, EPanicInternalError) ); } iReader->Cancel(); iReadOneOrMoreReader->Cancel(); iReadObserver = NULL; iReadOneOrMoreObserver = NULL; OstTraceFunctionExit0( CCDCDATAINTERFACE_CANCELREAD_EXIT ); }
// ----------------------------------------------------------------------------- // CDpPn2Rx::UpDate // Pipe state has been changed. // ----------------------------------------------------------------------------- // void CDpPn2Rx::UpDate( CDpSubject* /*aChangedSubject*/ ) { OstTrace0( TRACE_NORMAL, CDPPN2RX_UPDATE, "CDpPn2Rx::UpDate" ); LOGM("CDpPn2Rx::UpDate"); TInt r( KErrNone ); // DCS PIF state changed switch ( iPifDcs.PipeState() ) { case CDpPif::EDpPipeEnabled: { // start read but beware double read if ( iState == EElementWait ) { r = Read(); if ( r != KErrNone ) { LOG(" ERROR, CDpPn2Rx::UpDate, Read() failed"); OstTrace0( TRACE_NORMAL, DUP1_CDPPN2RX_UPDATE, "ERROR, CDpPn2Rx::UpDate, Read() failed" ); } //no else } //no else break; } case CDpPif::EDpPipeDisabled: // Fall through case CDpPif::EDpPipeDisconnected: { if ( IsActive() ) { Cancel(); } //no else break; } default: { // Pipe is in state that is not regonized LOG1(" ERROR, CDpPn2Rx::UpDate, Unrecognized pipe state: %d", iPifDcs.PipeState() ); OstTraceExt1( TRACE_NORMAL, DUP2_CDPPN2RX_UPDATE, "ERROR, CDpPn2Rx::UpDate, Unrecognized pipe state: %s", iPifDcs.PipeState() ); Cancel(); break; } } }
void CCdcDataInterface::CancelNotifyDataAvailable() /** * Cancel notification of arrival of data. */ { OstTraceFunctionEntry0( CCDCDATAINTERFACE_CANCELNOTIFYDATAAVAILABLE_ENTRY ); if (!iDataAvailableNotifier) { OstTraceExt1( TRACE_FATAL, CCDCDATAINTERFACE_CANCELNOTIFYDATAAVAILABLE, "CCdcDataInterface::CancelNotifyDataAvailable;iDataAvailableNotifier=%p", iDataAvailableNotifier ); __ASSERT_DEBUG( EFalse, User::Panic(KAcmPanicCat, EPanicInternalError) ); } iDataAvailableNotifier->Cancel(); iNotifyDataAvailableObserver = NULL; OstTraceFunctionExit0( CCDCDATAINTERFACE_CANCELNOTIFYDATAAVAILABLE_EXIT ); }
//------------------------------------------------------------------------------ // CAddBuffer::AddNodeToBuffer() //------------------------------------------------------------------------------ void CAddBuffer::AddNodeToBufferL( const TDesC8& aUri, const TDesC8& aParentLUID, const TInt aStatusRef ) { OstTraceExt1( TRACE_NORMAL, CADDBUFFER_ADDNODETOBUFFERL_ENTRY, "ENTRY: CAddBuffer::AddNodeToBufferL;aUri=%s", aUri ); CConnMoNodeElement* newNode = new (ELeave) CConnMoNodeElement(); newNode->iUri.Copy( aUri ); newNode->iParentLUID.Copy( aParentLUID ); newNode->iStatusRef = aStatusRef; newNode->iProcessed = EFalse; newNode->iLeaf = EFalse; iBuffer.AppendL( newNode ); OstTrace0( TRACE_NORMAL, CADDBUFFER_ADDNODETOBUFFERL_EXIT, "EXIT: CAddBuffer::AddNodeToBufferL"); }
/*! This function handles urlChanged signal from QGraphicsWebView @param [in] newUrl New URL */ void WlanLoginView::handleUrlChanged(const QUrl& newUrl ) { OstTraceFunctionEntry0(WLANLOGINVIEW_HANDLEURLCHANGED_ENTRY); #ifdef OST_TRACE_COMPILER_IN_USE QString url = newUrl.toString(); TPtrC tmp(url.utf16(),url.length() ); OstTraceExt1( TRACE_NORMAL, WLANLOGINVIEW_HANDLEURLCHANGED_URL_TRACE, "WlanLoginEngine::handleUrlChanged;newUrl=%S", tmp); #endif OstTraceFunctionExit0(WLANLOGINVIEW_HANDLEURLCHANGED_EXIT); }
//------------------------------------------------------------------------------ // CAddBuffer::AddNodeToBuffer() //------------------------------------------------------------------------------ TInt CAddBuffer::GetGroup( const TDesC8& aRoot, RPointerArray<CConnMoNodeElement>* aGroup ) { OstTraceExt1( TRACE_NORMAL, CADDBUFFER_GETGROUP_ENTRY, "ENTRY: CAddBuffer::GetGroup;aRoot=%s", aRoot ); iCache.Reset(); TInt retval( KErrNotFound ); TBool first = ETrue; TBuf8<KSmlMaxURISegLen> groupTag; groupTag.Copy( aRoot ); groupTag.Append( KChildNodeWildCardPattern ); for ( TInt i = 0; i < iBuffer.Count(); ++i ) { if ( iBuffer[i]->iUri.Match( groupTag ) != KErrNotFound && !iBuffer[i]->iProcessed ) { if ( first ) { groupTag.Insert( aRoot.Length(), KNodeSeparator ); groupTag.Insert( aRoot.Length() + 1, CUtils::GetSecondURISeg( iBuffer[i]->iUri ) ); first = EFalse; retval = 0; } TInt err = KErrNone; TRAP(err,aGroup->AppendL(iBuffer[i])); if(err != KErrNone) { retval = err; break; } TRAP(err,iCache.AppendL(iBuffer[i])); if(err != KErrNone) { TInt indx = aGroup->Find(iBuffer[i]); if(indx != KErrNotFound) aGroup->Remove(indx); retval = err; break; } retval++; } } OstTrace1( TRACE_NORMAL, CADDBUFFER_GETGROUP_EXIT, "EXIT: CAddBuffer::GetGroup;retval=%d", retval ); return retval; }
TMTPResponseCode CMTPMoveObject::CheckRequestL() { OstTraceFunctionEntry0( CMTPMOVEOBJECT_CHECKREQUESTL_ENTRY ); TMTPResponseCode result = CMTPRequestProcessor::CheckRequestL(); if (EMTPRespCodeOK != result) { OstTraceFunctionExit0( CMTPMOVEOBJECT_CHECKREQUESTL_EXIT ); return result; } const TUint32 KObjectHandle = Request().Uint32(TMTPTypeRequest::ERequestParameter1); //not taking owernship iObjectInfo = iRequestChecker->GetObjectInfo(KObjectHandle); __ASSERT_DEBUG(iObjectInfo, Panic(EMTPDpObjectNull)); if(!iSingletons.StorageMgr().IsReadWriteStorage(iObjectInfo->Uint(CMTPObjectMetaData::EStorageId))) { result = EMTPRespCodeStoreReadOnly; } if ( (EMTPRespCodeOK == result) && (!iSingletons.StorageMgr().IsReadWriteStorage(Request().Uint32(TMTPTypeRequest::ERequestParameter2))) ) { result = EMTPRespCodeStoreReadOnly; } if(result == EMTPRespCodeOK) { const TDesC& suid(iObjectInfo->DesC(CMTPObjectMetaData::ESuid)); iIsFolder = EFalse; LEAVEIFERROR(BaflUtils::IsFolder(iFramework.Fs(), suid, iIsFolder), OstTraceExt1( TRACE_ERROR, DUP1_CMTPMOVEOBJECT_CHECKREQUESTL, "can't judge whether %S is folder", suid)); if(!iIsFolder) { if(iDpSingletons.MovingBigFileCache().IsOnGoing()) { OstTrace0( TRACE_NORMAL, CMTPMOVEOBJECT_CHECKREQUESTL, "CheckRequestL - A big file moving is ongoing, respond with access denied" ); result = EMTPRespCodeAccessDenied; } } } OstTraceFunctionExit0( DUP1_CMTPMOVEOBJECT_CHECKREQUESTL_EXIT ); return result; }
CCdcDataInterface* CCdcDataInterface::NewL(const TDesC16& aIfcName) /** * Create a new CCdcDataInterface object and construct it using interface name * This call will return an object with a valid USB configuration * * @param aParent Observer. * @param aIfcName Contains the interface name * @return A pointer to the new object */ { OstTraceFunctionEntry0( CCDCDATAINTERFACE_NEWL_ENTRY ); OstTraceExt1( TRACE_NORMAL, CCDCDATAINTERFACE_NEWL, "CCdcDataInterface::NewL;\tData Ifc Name = %S", aIfcName ); CCdcDataInterface* self = new (ELeave) CCdcDataInterface(aIfcName); CleanupStack::PushL(self); self->ConstructL(); CLEANUPSTACK_POP(self); OstTraceFunctionExit0( CCDCDATAINTERFACE_NEWL_EXIT ); return self; }
/** Add a file entry to the object store @param aEntry The file Entry to be added @param aPath The full path name of the entry @return MTP object handle, or KMTPHandleNone if entry was not accepted */ void CMTPFSEnumerator::AddEntryL(const TDesC& aPath, TUint32 &aHandle, TMTPFormatCode format, TUint32 aDPId, const TEntry& aEntry, TUint32 aStorageId, TUint32 aParentHandle) { OstTraceFunctionEntry0( CMTPFSENUMERATOR_ADDENTRYL_ENTRY ); #ifdef OST_TRACE_COMPILER_IN_USE TBuf8<KMaxFileName> tmp; tmp.Copy(aPath); OstTraceExt1( TRACE_NORMAL, CMTPFSENUMERATOR_ADDENTRYL, "entry: %s", tmp ); #endif // OST_TRACE_COMPILER_IN_USE TUint16 assoc; TPtrC name; if (format == EMTPFormatCodeAssociation) { assoc = EMTPAssociationTypeGenericFolder; TParsePtrC pathParser(aPath.Left(aPath.Length() - 1)); // Ignore the trailing "\". name.Set(aEntry.iName); } else { assoc = EMTPAssociationTypeUndefined; TParsePtrC pathParser(aPath); name.Set(pathParser.Name()); } //if(iExclusionMgr.IsFormatValid(format)) { aHandle = KMTPHandleNone; iObject->SetUint(CMTPObjectMetaData::EDataProviderId, aDPId); iObject->SetUint(CMTPObjectMetaData::EFormatCode, format); iObject->SetUint(CMTPObjectMetaData::EStorageId, aStorageId); iObject->SetDesCL(CMTPObjectMetaData::ESuid, aPath); iObject->SetUint(CMTPObjectMetaData::EFormatSubCode, assoc); iObject->SetUint(CMTPObjectMetaData::EParentHandle, aParentHandle); iObject->SetUint(CMTPObjectMetaData::ENonConsumable, EMTPConsumable); iObject->SetDesCL(CMTPObjectMetaData::EName, name); iFramework.ObjectMgr().InsertObjectL(*iObject); aHandle = iObject->Uint(CMTPObjectMetaData::EHandle); } OstTraceFunctionExit0( CMTPFSENUMERATOR_ADDENTRYL_EXIT ); }
/*! Process SSID validation. @param [in] ssid to be validated. @return Following values are possible - SsidStatusOk - SsidStatusInvalidLength */ WlanWizardUtils::SsidStatus WlanWizardUtils::validateSsid(const QString &ssid) { OstTraceFunctionEntry0( WLANWIZARDUTILS_VALIDATESSID_ENTRY ); TPtrC tmp(ssid.utf16(), ssid.length() ); OstTraceExt1( TRACE_NORMAL, WLANWIZARDUTILS_VALIDATESSID, "WlanWizardUtils::validateSsid;ssid=%S", tmp ); SsidStatus ret = SsidStatusOk; int len = ssid.length(); if (len < SsidMinLength || len > SsidMaxLength) { ret = SsidStatusInvalidLength; } OstTrace1( TRACE_NORMAL, WLANWIZARDUTILS_VALIDATESSID_RETURN, "WlanWizardUtils::validateSsid - Return;ret=%{SsidStatus}", ret ); OstTraceFunctionExit0( WLANWIZARDUTILS_VALIDATESSID_EXIT ); return ret; }
TBool CMTPProxyDpConfigMgr::GetFileName(const TDesC& aFileName,TInt& aIndex) { OstTraceFunctionEntry0( CMTPPROXYDPCONFIGMGR_GETFILENAME_ENTRY ); OstTraceExt1( TRACE_NORMAL, CMTPPROXYDPCONFIGMGR_GETFILENAME, "aFileName = %S", aFileName); TInt count = iMappingStruct.Count(); OstTrace1( TRACE_NORMAL, DUP1_CMTPPROXYDPCONFIGMGR_GETFILENAME, "count = %d", count ); for(TInt i=0 ; i<count ; i++) { TInt err=iMappingStruct[i].iFileArray->Find(aFileName,aIndex); if(err == KErrNone) { aIndex=i; OstTrace1( TRACE_NORMAL, DUP2_CMTPPROXYDPCONFIGMGR_GETFILENAME, "aIndex = %d", aIndex ); OstTraceFunctionExit0( CMTPPROXYDPCONFIGMGR_GETFILENAME_EXIT ); return ETrue; } } OstTraceFunctionExit0( DUP1_CMTPPROXYDPCONFIGMGR_GETFILENAME_EXIT ); return EFalse; }
/** Opens the specified database configuration file and executes those operations that are specified in it which are currently supported (currently only 'CREATE INDEX' operations are supported and will be executed). @param aFs The server's file server session @param aConfigFilePath The configuration file path @param aDbName Logical database name: "main" for the main database or attached database name @leave KErrNoMemory, if an out of memory condition occurs. One of the other system-wide error codes if the configuration file fails to be opened or read @panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object). */ void TSqlDbSysSettings::DoExecuteDbConfigFileOpsL(RFs& aFs, const TDesC& aConfigFilePath, const TDesC& aDbName) { __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj)); //Open the config file and read it into a buffer RFile64 file; __SQLLEAVE_IF_ERROR(file.Open(aFs, aConfigFilePath, EFileRead)); CleanupClosePushL(file); TInt64 size = 0; __SQLLEAVE_IF_ERROR(file.Size(size)); if(size == 0) { //Config file is empty so just return SQL_TRACE_INTERNALS(OstTraceExt1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_DOEXECUTEDBCONFIGFILEOPSL, "0;TSqlDbSysSettings::DoExecuteDbConfigFileOpsL();Config file %S is empty", __SQLPRNSTR(aConfigFilePath))); CleanupStack::PopAndDestroy(); // file return; } HBufC8* buffer = HBufC8::NewLC(size); TPtr8 bufPtr = buffer->Des(); __SQLLEAVE_IF_ERROR(file.Read(bufPtr)); //Convert buffer to Unicode for processing (the configuration file is expected to be ASCII or UTF-8) HBufC16* buf16 = CnvUtfConverter::ConvertToUnicodeFromUtf8L(bufPtr); CleanupStack::PushL(buf16); TPtrC16 ptr16 = buf16->Des(); //Skip the BOM (byte ordering mark) at the start if there is one if((ptr16.Locate(TChar(0xFEFF)) == 0) || (ptr16.Locate(TChar(0xFFFE)) == 0)) { ptr16.Set(ptr16.Mid(1)); } //Parse the file contents and execute the specified //config statements that are supported ParseFileL(ptr16, aDbName); CleanupStack::PopAndDestroy(3); // buf16, buffer, file }
void CMTPMoveObject::DoOnTimeoutL() { OstTraceFunctionEntry0( CMTPMOVEOBJECT_DOONTIMEOUTL_ENTRY ); if (iTimer) { if (iTimer->IsActive()) { iTimer->Cancel(); } delete iTimer; iTimer = NULL; } const TDesC& suid(iObjectInfo->DesC(CMTPObjectMetaData::ESuid)); TEntry fileEntry; LEAVEIFERROR(iFramework.Fs().Entry(suid, fileEntry), OstTraceExt1( TRACE_ERROR, DUP1_CMTPMOVEOBJECT_DOONTIMEOUTL, "Gets the entry details for %S failed!", suid)); TUint32 handle = iObjectInfo->Uint(CMTPObjectMetaData::EHandle); iObjectInfo->SetDesCL(CMTPObjectMetaData::ESuid, *iNewFileName); iObjectInfo->SetUint(CMTPObjectMetaData::EStorageId, iStorageId); iObjectInfo->SetUint(CMTPObjectMetaData::EParentHandle, iNewParentHandle); iFramework.ObjectMgr().ModifyObjectL(*iObjectInfo); CMTPFSEntryCache& aCache = iDpSingletons.MovingBigFileCache(); // Cache the target file entry info, which is used to send response to getobjectproplist and getobjectinfo aCache.SetOnGoing(ETrue); aCache.SetTargetHandle(handle); aCache.SetFileEntry(fileEntry); OstTrace0( TRACE_NORMAL, CMTPMOVEOBJECT_DOONTIMEOUTL, "UpdateFSEntryCache, sending response with respond code OK for a big file move" ); SendResponseL(EMTPRespCodeOK); OstTraceFunctionExit0( CMTPMOVEOBJECT_DOONTIMEOUTL_EXIT ); }
void CTestEngine::GetNumericInput(TInt &aNumber) { TUint value(0); TUint digits(0); TKeyCode key = (TKeyCode) 0; aNumber = -1; while ( key != EKeyEnter ) { key = test.Getch(); if ( ( key >= '0' ) && ( key <= '9' ) ) { test.Printf(_L("%c"),key); OstTraceExt1(TRACE_NORMAL, CTESTENGINE_GETNUMERICINPUT, "%c",key); value = ( 10 * value ) + ( key - '0' ); digits++; } else { // very basic keyboard processing, backspace if (key == EKeyBackspace) { value = value/10; digits--; test.Printf(_L("\r \r%d"), value); OstTrace1(TRACE_NORMAL, CTESTENGINE_GETNUMERICINPUT_DUP01, "\r \r%d", value); } } } if (digits > 0) { aNumber = value; } test.Printf(_L("\n")); OstTrace0(TRACE_NORMAL, CTESTENGINE_GETNUMERICINPUT_DUP02, "\n"); }
/** Check the GetPartialObject reqeust @return EMTPRespCodeOK if the request is good, otherwise, one of the error response codes */ TMTPResponseCode CMTPGetPartialObject::CheckRequestL() { OstTraceFunctionEntry0( CMTPGETPARTIALOBJECT_CHECKREQUESTL_ENTRY ); TMTPResponseCode result = CMTPRequestProcessor::CheckRequestL(); if(result == EMTPRespCodeOK) { TUint32 objectHandle = Request().Uint32(TMTPTypeRequest::ERequestParameter1); iOffset = Request().Uint32(TMTPTypeRequest::ERequestParameter2); iLength = Request().Uint32(TMTPTypeRequest::ERequestParameter3); //does not take ownership iObjectInfo = iRequestChecker->GetObjectInfo(objectHandle); if (!iObjectInfo) { // 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. result = EMTPRespCodeInvalidObjectHandle; } else { TEntry fileEntry; LEAVEIFERROR(iFramework.Fs().Entry(iObjectInfo->DesC(CMTPObjectMetaData::ESuid), fileEntry), OstTraceExt1(TRACE_ERROR, CMTPGETPARTIALOBJECT_CHECKREQUESTL, "can't get entry details for %S!", iObjectInfo->DesC(CMTPObjectMetaData::ESuid))); if((iOffset >= fileEntry.FileSize())) { result = EMTPRespCodeInvalidParameter; } } } OstTraceFunctionExit0( CMTPGETPARTIALOBJECT_CHECKREQUESTL_EXIT ); return result; }
void CMTPDeviceDataProvider::AddFolderRecursiveL( const TMTPNotificationParamsFolderChange& aFolder ) { OstTraceFunctionEntry0( CMTPDEVICEDATAPROVIDER_ADDFOLDERRECURSIVEL_ENTRY ); TPtrC folderRight( aFolder.iFolderChanged ); OstTraceExt1(TRACE_NORMAL, CMTPDEVICEDATAPROVIDER_ADDFOLDERRECURSIVEL, "Folder Addition - DriveAndFullPath:%S", folderRight); if ( !BaflUtils::FolderExists( Framework().Fs(), folderRight )) { OstTrace0(TRACE_NORMAL, DUP1_CMTPDEVICEDATAPROVIDER_ADDFOLDERRECURSIVEL, "Folder not exist in file system"); User::Leave( KErrArgument ); } TUint32 parentHandle( KMTPHandleNoParent ); TUint32 handle( KMTPHandleNoParent ); TInt pos( KErrNotFound ); TInt lengthOfRight( folderRight.Length()); TFileName folderLeft; // get root path of storage TInt driveNumber; User::LeaveIfError(Framework().Fs().CharToDrive(folderRight[0], driveNumber)); RBuf rootDirPath; rootDirPath.CreateL(KMaxFileName); rootDirPath.CleanupClosePushL(); iDevDpSingletons.ConfigMgr().GetRootDirPathL(driveNumber, rootDirPath); rootDirPath.Insert(0, folderRight.Mid(0, 2));// get drive: /* Go through from beginning. when this while end, folderLeft keeps the top layer folder which has no handle */ do { pos = folderRight.Locate( KPathDelimiter ); if ( KErrNotFound == pos ) { break; } folderLeft.Append( folderRight.Left( pos + 1 )); lengthOfRight = folderRight.Length()-pos -1; folderRight.Set( folderRight.Right( lengthOfRight )); if ( rootDirPath.FindF(folderLeft) != KErrNotFound) { //first time, root folder //continue continue; } parentHandle = handle; handle = Framework().ObjectMgr().HandleL( folderLeft ); } while( KMTPHandleNone != handle ); CleanupStack::PopAndDestroy(&rootDirPath); if ( KMTPHandleNone == handle ) { OstTrace0(TRACE_NORMAL, DUP2_CMTPDEVICEDATAPROVIDER_ADDFOLDERRECURSIVEL, "need to add entry into mtp database"); CMTPObjectMetaData* folderObject = CMTPObjectMetaData::NewL(); TUint32 storageId = GetStorageIdL( folderLeft ); while( 1 ) { parentHandle = AddEntryL( folderLeft, parentHandle, storageId, *folderObject ); OnDeviceFolderChangedL( EMTPEventCodeObjectAdded, *folderObject ); pos = folderRight.Locate( KPathDelimiter ); lengthOfRight = folderRight.Length()-pos -1; if ( KErrNotFound == pos ) { break; } folderLeft.Append( folderRight.Left( pos + 1 )); folderRight.Set( folderRight.Right( lengthOfRight )); } delete folderObject; } OstTraceFunctionExit0( CMTPDEVICEDATAPROVIDER_ADDFOLDERRECURSIVEL_EXIT ); }
// --------------------------------------------------------- // CDpMif::SendNameAddReqL // This method sends name add request to Name Service. // --------------------------------------------------------- // void CDpMif::SendNameAddReqL( const TUint aUnit ) { OstTrace0( TRACE_NORMAL, CDPMIF_SENDNAMEADDREQL, "CDpMif::SendNameAddReqL" ); LOGM(" CDpMif::SendNameAddReq"); __ASSERT_ALWAYS( aUnit <= KDataPortCommHighUnit, User::Leave( KErrNotSupported ) ); TBuf8<SIZE_PNS_NAME_ADD_REQ> messageData; // Add reserved bytes messageData.Append( KDpPadding ); messageData.Append( KDpPadding ); // Add 32bit name (Big-endian) switch ( aUnit ) { case KDpCsdPort: case KDpPort6: { messageData.Append( aUnit ); //name messageData.Append( PN_PEP_SUB_TYPE_SYMBIAN_INTERNAL ); //name messageData.Append( PN_PEP_TYPE_COMM ); //name messageData.Append( PN_PIPE ); //name break; } case KDpDialUpPort: case KDpPort4: case KDpPort5: { messageData.Append( aUnit ); //name messageData.Append( KDpPadding ); //name messageData.Append( PN_PEP_TYPE_COMM ); //name messageData.Append( PN_PIPE ); //name break; } case KDpBtAccHfPort: { messageData.Append( KDpPadding ); //name messageData.Append( PN_PEP_SUB_TYPE_BT_ACC_HF ); //name messageData.Append( PN_PEP_TYPE_BT_ACC ); //name messageData.Append( PN_PIPE ); //name break; } case KDpBtAccHsPort: { messageData.Append( KDpPadding ); //name messageData.Append( PN_PEP_SUB_TYPE_BT_ACC_HS ); //name messageData.Append( PN_PEP_TYPE_BT_ACC ); //name messageData.Append( PN_PIPE ); //name break; } default: { User::Leave( KErrGeneral ); } } // Add Device id messageData.Append( THIS_DEVICE ); // Create Object id TUint8 channelId( 0 ); switch ( aUnit ) { case KDpCsdPort: { channelId = EIscNokiaDataport1; break; } case KDpDialUpPort: { channelId = EIscNokiaDataport2; break; } case KDpBtAccHfPort: case KDpBtAccHsPort: { channelId = EIscNokiaBtAppl; break; } case KDpPort4: { channelId = EIscNokiaDataport3; break; } case KDpPort5: { channelId = EIscNokiaDataport4; break; } case KDpPort6: { channelId = EIscNokiaDataport5; break; } default: { //Do nothing break; } } TBuf8<2> data; TInt ret( iDataPort.ISAHandle().GetChannelInfo( channelId, data ) ); _LIT(KPanicStr, "Dataport::SendNameAddReqL"); __ASSERT_ALWAYS( KErrNone == ret, User::Panic( KPanicStr, 0 ) ); // Set obj id TUint16 obj( static_cast<TUint16>( ( static_cast<TUint16>( data[0] ) << 8 ) + data[1] ) ); LOG1(" Dataport::SendNameAddReqL obj = 0x%x", obj ); OstTraceExt1( TRACE_NORMAL, DUP1_CDPMIF_SENDNAMEADDREQL, "CDpMif:: obj = 0x%hx", obj ); // Add Object id messageData.Append( obj ); // Add Record flags messageData.Append( PN_NAME_UNDEF/**PN_NAME_CLEARED**/ ); //fill messageData.Append( KDpPadding ); #if defined(_DEBUG) ret = #endif SendMessage( PN_NAMESERVICE, iDataPort.CreateTransactionId(), PNS_NAME_ADD_REQ, messageData ); LOG1(" <== PNS_NAME_ADD_REQ req sent, obj id: %x", obj ); OstTraceExt1( TRACE_NORMAL, DUP2_CDPMIF_SENDNAMEADDREQL, "CDpMif:: <== PNS_NAME_ADD_REQ req sent, obj id: %hx", obj ); #if defined(_DEBUG) if (KErrNone != ret ) { LOG1(" Error isc api send %d", ret ); OstTrace1( TRACE_NORMAL, DUP3_CDPMIF_SENDNAMEADDREQL, "CDpMif:: Error isc api send %d", ret ); } //no else #endif }
// ----------------------------------------------------------------------------- // CMmConferenceCallMessHandler::CallControlInd // Breaks a CALL_CONTROL_IND ISI-message. Completes failed // CreateConference, AddCall or Swap API request if there is a cause sub // block in this response. In case that this message contains Split operation // sub block, inform ConferenceCallTsy that GoOneToOne handling has started // ----------------------------------------------------------------------------- // void CMmConferenceCallMessHandler::CallControlInd( const TIsiReceiveC& aIsiMsg ) { TFLOGSTRING("TSY: CMmConferenceCallMessHandler::CallControlInd"); OstTrace0( TRACE_NORMAL, CMMCONFERENCECALLMESSHANDLER_CALLCONTROLIND_TD, "CMmConferenceCallMessHandler::CallControlInd" ); TUint sbStartOffSet( 0 ); // Try to find CALL_MODEM_SB_CAUSE subblock. If found something has gone wrong if( KErrNone == aIsiMsg.FindSubBlockOffsetById( ISI_HEADER_SIZE + SIZE_CALL_MODEM_CONTROL_IND, CALL_MODEM_SB_CAUSE, EIsiSubBlockTypeId8Len8, sbStartOffSet ) ) { // CALL_MODEM_SB_CAUSE sub block found, something has gone wrong. // Get cause type TUint8 causeType( aIsiMsg.Get8bit( sbStartOffSet + CALL_MODEM_SB_CAUSE_OFFSET_CAUSETYPE ) ); // Get cause value TUint8 causeValue( aIsiMsg.Get8bit( sbStartOffSet + CALL_MODEM_SB_CAUSE_OFFSET_CAUSE ) ); // Get Symbian OS error value TInt result( CMmStaticUtility::CSCauseToEpocError( PN_MODEM_CALL, causeType, causeValue ) ); // If last operation was build, CreateConference or AddCall was asked if ( CALL_MODEM_OP_CONFERENCE_BUILD == iLastOperation ) { // Has CreateConference been requested last. if ( iIsCreateConference ) { // Complete with error iMessageRouter->Complete( EMobileConferenceCallCreateConference, result); // Reset flag iIsCreateConference = EFalse; } else { // Must be response to AddCall request iMessageRouter->Complete( EMobileConferenceCallAddCall, result ); } iLastOperation = 0; } // if last operation was hold or retrieve else if ( CALL_MODEM_OP_HOLD == iLastOperation || CALL_MODEM_OP_RETRIEVE == iLastOperation ) { // Complete swap with error iMessageRouter->Complete( EMobileConferenceCallSwap, result ); } // No else } // Successful operation handling for operations // Initiated bypassing the ETel (ghost operetion). else if ( !iIsCreateConference && 0 == iLastOperation ) { TUint8 callOperation( 0 ); // Get call Id (three bits (1-3) contain unique call ID) TInt uniqueCallId( static_cast<TInt>( aIsiMsg.Get8bit( ISI_HEADER_SIZE + CALL_MODEM_CONTROL_IND_OFFSET_CALLID ) & KMaskBits1to3 ) ); // Get call operation sub block if ( KErrNone == aIsiMsg.FindSubBlockOffsetById( ISI_HEADER_SIZE + CALL_MODEM_CONTROL_IND_OFFSET_OPERATION, CALL_MODEM_SB_OPERATION, EIsiSubBlockTypeId8Len8, sbStartOffSet ) ) { TInt symbianConferenceEvent( -1 ); // Get call operation callOperation = aIsiMsg.Get8bit( sbStartOffSet + CALL_MODEM_SB_OPERATION_OFFSET_OPERATION ); TFLOGSTRING2("TSY: CMmConferenceCallMessHandler::CallControlInd - Call operation: %d", callOperation); OstTraceExt1( TRACE_NORMAL, DUP1_CMMCONFERENCECALLMESSHANDLER_CALLCONTROLIND_TD, "CMmConferenceCallMessHandler::CallControlInd;callOperation=%hhu", callOperation ); // Purpose of this case is to prepare handling of externally // controlled conference call switch ( callOperation ) { case CALL_MODEM_OP_CONFERENCE_BUILD: { symbianConferenceEvent = RMobileConferenceCall::EConferenceBuilt; break; } case CALL_MODEM_OP_HOLD: case CALL_MODEM_OP_SWAP: { symbianConferenceEvent = RMobileConferenceCall::EConferenceSwapped; break; } case CALL_MODEM_OP_CONFERENCE_SPLIT: { symbianConferenceEvent = RMobileConferenceCall::EConferenceSplit; break; } default: { // Nothing to do break; } } // Update the information to Conference call if ( 0 <= symbianConferenceEvent ) { // Create call package CCallDataPackage callData; // Pack the data for sending to the manager callData.SetCallIdAndMode( uniqueCallId, RMobilePhone::EVoiceService ); // Pack conference event callData.PackData( &symbianConferenceEvent ); // Pass call information to the Symbian OS layer // complete mobile call info change iMessageRouter->Complete( EMobileConferenceCallNotifyConferenceEvent, &callData, KErrNone ); } // No else } // No else } // No else iIsCreateConference = EFalse; iLastOperation = 0; }
// --------------------------------------------------------- // CDpMif::RunL // This method handles received message from Isc Api and // renews read from Isc Api. // --------------------------------------------------------- // void CDpMif::RunL() { OstTrace0( TRACE_NORMAL, CDPMIF_RUNL, "CDpMif::RunL" ); LOGM1("CDpMif::RunL - Port %d", iDataPort.PortUnit() ); // we are always signaled from PhoNet ReceiveMessage if ( KErrNoMemory == iStatus.Int() ) { LOGM(" ==> KErrNoMemory"); OstTrace0( TRACE_NORMAL, DUP1_CDPMIF_RUNL, "CDpMif:: ==> KErrNoMemory" ); // deallocate current message if ( iMsgReceiveBuffer ) { delete iMsgReceiveBuffer; iMsgReceiveBuffer = NULL; iReceiveMessage.Set( NULL, 0, 0 ); } //no else // ISA Handle receive // Trying to allocate a new message iMsgReceiveBuffer = HBufC8::NewL( ISI_HEADER_SIZE + iLen ); _LIT( KPanicStr, "Dataport - CDpMif::RunL" ); __ASSERT_ALWAYS( iMsgReceiveBuffer, User::Panic( KPanicStr, KErrNoMemory ) ); iReceiveMessage.Set( iMsgReceiveBuffer->Des() ); iLen = 0; if ( !IsActive() ) { iDataPort.ISAHandle().Receive( iStatus, iReceiveMessage, iLen ); SetActive(); } //no else } else { OstTrace0( TRACE_NORMAL, DUP2_CDPMIF_RUNL, "CDpMif:: ==> ISI-message received" ); OstPrintIsiMessage( iReceiveMessage ); LOGM(" ==> ISI-message received"); LOGMESSAGE( iReceiveMessage ); TIsiReceiveC receivedMsg( iReceiveMessage ); TUint8 resource_id( receivedMsg.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) ); TUint8 message_id( receivedMsg.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) ); switch ( resource_id ) { case PN_NAMESERVICE: { switch ( message_id ) { case PNS_NAME_ADD_RESP: { LOG(" ==> PNS_NAME_ADD_RESP received"); OstTrace0( TRACE_NORMAL, DUP4_CDPMIF_RUNL, "CDpMif:: ==> PNS_NAME_ADD_RESP received" ); TUint8 reason( receivedMsg.Get8bit( ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_REASON ) ); TInt error( KErrNone ); switch ( reason ) { case PN_NAME_OK: { LOG(" ==> PN_NAME_OK"); OstTrace0( TRACE_NORMAL, DUP5_CDPMIF_RUNL, "CDpMif:: ==> PN_NAME_OK" ); error = KErrNone; break; } default: { LOG1(" ==> reason: %d", reason ); OstTraceExt1( TRACE_NORMAL, DUP6_CDPMIF_RUNL, "CDpMif:: ==> reason: %hhu", reason ); error = KErrGeneral; } } iDataPort.SignalPif( error ); break; } case PNS_NAME_REMOVE_RESP: { LOG(" ==> PNS_NAME_REMOVE_RESP received"); OstTrace0( TRACE_NORMAL, DUP7_CDPMIF_RUNL, "CDpMif:: ==> PNS_NAME_REMOVE_RESP received" ); break; } default: { LOG1(" ==> Unknown message received. ID: %d", message_id ); OstTraceExt1( TRACE_NORMAL, DUP8_CDPMIF_RUNL, "CDpMif:: ==> Unknown message received. ID: %hhu", message_id ); } } break; } case PN_PIPE: { switch ( message_id ) { case PNS_PEP_CTRL_REQ: { LOG(" ==> PNS_PEP_CTRL_REQ received"); OstTrace0( TRACE_NORMAL, DUP9_CDPMIF_RUNL, "CDpMif:: ==> PNS_PEP_CTRL_REQ received" ); HandlePepCtrlReq( receivedMsg ); break; } case PNS_PEP_STATUS_IND: { LOG(" ==> PNS_PEP_STATUS_IND received"); OstTrace0( TRACE_NORMAL, DUP10_CDPMIF_RUNL, "CDpMif:: ==> PNS_PEP_STATUS_IND received" ); HandlePepStatusInd( receivedMsg ); break; } default: { LOG1(" ==> Unknown message received. ID: %d", message_id ); OstTraceExt1( TRACE_NORMAL, DUP11_CDPMIF_RUNL, "CDpMif:: ==> Unknown message received. ID: %hhu", message_id ); } } break; } default: { LOG1(" ==> Unknown message received. ID: %d", message_id ); OstTraceExt1( TRACE_NORMAL, DUP12_CDPMIF_RUNL, "CDpMif:: ==> Unknown message received. ID: %hhu", message_id ); } } iReceiveMessage.Zero(); // Check if pipe is removed if ( PNS_NAME_REMOVE_RESP == message_id && CDpPif::EDpPipeDisconnected == iPifDcs.PipeState() ) { // Check if DataPort is ready to be deleted if ( iDataPort.IsReadyToDestruct() ) { iDataPort.DeleteDataPort(); } //no else } else { // Renew read User::LeaveIfError( Read() ); } } }
// --------------------------------------------------------- // CDpMif::HandlePepCtrlReq // Handles PepCtrlReq messages // --------------------------------------------------------- // void CDpMif::HandlePepCtrlReq( TIsiReceiveC& aIsiMessage ) { OstTrace0( TRACE_NORMAL, CDPMIF_HANDLEPEPCTRLREQ, "CDpMif::HandlePepCtrlReq" ); LOGM(" CDpMif::HandlePepCtrlReq"); // Transaction id TUint8 transactionId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ) ); // Pipe Handle if ( PN_PIPE_INVALID_HANDLE == iPifDcs.PipeHandle() ) { TUint8 pipeHandle( aIsiMessage.Get8bit( ISI_HEADER_SIZE + PNS_PEP_CTRL_REQ_OFFSET_PIPEHANDLE) ); iPifDcs.SetPipeHandle( pipeHandle ); } // PEP Type TUint8 pepType( aIsiMessage.Get8bit( ISI_HEADER_SIZE + PNS_PEP_CTRL_REQ_OFFSET_PEPTYPE ) ); // PEP Control ID TUint8 ctrlId( aIsiMessage.Get8bit( ISI_HEADER_SIZE + PNS_PEP_CTRL_REQ_OFFSET_PEPCTRLID ) ); // PEP Control Data TPtrC8 ctrlData; // Check if there is data (there is no data for all control id's) if ( ( ISI_HEADER_SIZE + SIZE_PNS_PEP_CTRL_REQ ) <= aIsiMessage.GetBuffer().Length() ) { // Control Data length is 1 byte TInt ctrlDataLen( 1 ); ctrlData.Set( aIsiMessage.GetData( ISI_HEADER_SIZE + PNS_PEP_CTRL_REQ_OFFSET_PEPCTRLDATA, ctrlDataLen ) ); } // Get sender device TUint8 senderDevice( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_SENDERDEVICE ) ); // Get sender object TUint8 senderObject( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_SENDEROBJECT ) ); #ifdef PIPECAMP_DATAPORT_PNS_PEP_STATUS_IND_PHONET_ADDRESS_FROM_PNS_PEP_CTRL_REQ iPifDcs.SetPipeControllerDeviceIdentifier( senderDevice ); iPifDcs.SetPipeControllerObjectIdentifier( senderObject ); #endif // E32 return value TInt return_E32( KErrNone ); // PN_PIPE return value TInt ret( KErrNone ); switch ( pepType ) { case PN_PEP_TYPE_COMM: case PN_PEP_TYPE_BT_ACC: { // comm_pep handles ctrl_req // Something can go wrong in here. Leaving is not the best case in here. // We can send an response message with error value to NOS side and // hope for the best. return_E32 = iCommPep.HandlePepCtrlReq( ctrlId, ctrlData ); break; } default: // Not supported pepType { LOG1(" ERROR - Unsupported pep type: %d", pepType ); OstTraceExt1( TRACE_NORMAL, DUP1_CDPMIF_HANDLEPEPCTRLREQ, "CDpMif:: ERROR - Unsupported pep type: %hhu", pepType ); return_E32 = KErrArgument; break; } } // do mapping from E32 error codes => PN_PIPE error codes switch ( return_E32 ) { case KErrNone: { ret = PN_PIPE_NO_ERROR; break; } case KErrNotSupported: { // this error code should NOT be used according to specification LOG(" ERROR - Unsupported config (KErrNotSupported)"); OstTrace0( TRACE_NORMAL, DUP2_CDPMIF_HANDLEPEPCTRLREQ, "CDpMif:: ERROR - Unsupported config (KErrNotSupported)" ); ret = PN_PIPE_ERR_NOT_SUPPORTED; break; } case KErrArgument: { // this error code should NOT be used according to specification LOG(" ERROR - Invalid argument (KErrArgument)"); OstTrace0( TRACE_NORMAL, DUP3_CDPMIF_HANDLEPEPCTRLREQ, "CDpMif:: ERROR - Invalid argument (KErrArgument)" ); ret = PN_PIPE_ERR_INVALID_PARAM; break; } case KErrGeneral: { LOG(" ERROR - Invalid parameter (KErrGeneral)"); OstTrace0( TRACE_NORMAL, DUP4_CDPMIF_HANDLEPEPCTRLREQ, "CDpMif:: ERROR - Invalid parameter (KErrGeneral)" ); ret = PN_PIPE_ERR_INVALID_CTRL_ID; break; } default: { // this error code should NOT be used according to specification LOG1(" ERROR - Other error: %d", return_E32 ); OstTrace1( TRACE_NORMAL, DUP5_CDPMIF_HANDLEPEPCTRLREQ, "CDpMif:: ERROR - Other error: %d", return_E32 ); ret = PN_PIPE_ERR_GENERAL; break; } } // Create PNS_PEP_CTRL_RESP response TBuf8<SIZE_PNS_PEP_CTRL_RESP> messageData; // Pipe Handle messageData.Append( iPifDcs.PipeHandle() ); // PEP Control ID messageData.Append( ctrlId ); // PEP Type messageData.Append( pepType ); // Error Code messageData.Append( static_cast<TUint8>( ret ) ); // Filler bytes messageData.Append( KDpPadding ); messageData.Append( KDpPadding ); // Send message, respond to sender return_E32 = SendMessage( senderDevice, senderObject, PN_PIPE, transactionId, PNS_PEP_CTRL_RESP, messageData ); LOG1(" <== PNS_PEP_CTRL_RESP resp sent, error code = %d", ret ); OstTrace1( TRACE_NORMAL, DUP6_CDPMIF_HANDLEPEPCTRLREQ, "CDpMif:: <== PNS_PEP_CTRL_RESP resp sent, error code = %d", ret ); #if defined(_DEBUG) if (KErrNone != return_E32 ) { LOG1(" Error isc api send %d", return_E32 ); OstTrace1( TRACE_NORMAL, DUP7_CDPMIF_HANDLEPEPCTRLREQ, "CDpMif:: Error isc api send %d", return_E32 ); } //no else #endif }
// ----------------------------------------------------------------------------- // CSatTimer::Tick // Static callback method for CPeriodic timer. // (other items were commented in a header). // ----------------------------------------------------------------------------- // TInt CSatTimer::Tick ( TAny* aSatTimer ) { // Logging omitted to avoid excessive log output // This is a static method, we need a pointer to parent class in // order to utilize it's method and members CSatTimer* satTimer = static_cast<CSatTimer*>( aSatTimer ); // Invert boolean value of half second boolean satTimer->iHalfSecondTick = !satTimer->iHalfSecondTick; // Update second counter and check timers only when there are active // timers and whole second has passed since last update. TInt tableSize( satTimer->iTimerTable->Count() ); if ( KZero != tableSize && !satTimer->iHalfSecondTick ) { satTimer->iSecondsPassed++; TFLOGSTRING2("TSY: CSatTimer::Tick, seconds %d", satTimer->iSecondsPassed ); OstTrace1( TRACE_INTERNALS, CSATTIMER_TICK_TD, "CSatTimer::Tick, seconds %u", satTimer->iSecondsPassed ); for( TInt i = tableSize - 1; KZero <= i; i-- ) { // Get reference to a timer in TimerTable TTimer& timer = ( *satTimer->iTimerTable )[i]; // Send timer expiration envelope if: // 1) Enough time has passed // 2) Timer is active // 3) Proactive command is not ongoing if ( timer.TimeStamp() <= satTimer->iSecondsPassed && TTimer::ETicking == timer.State() ) { // Deactive timer to avoid multiple envelopes timer.SetState( TTimer::EBeingSent); // Elapsed time TInt time( satTimer->iSecondsPassed - timer.StartTime() ); satTimer->iSatMessaging->TimerExpiration( timer.Id(), time ); } } } // Handle the stored envelopes. Look for envelopes activated for resending. // Resend the oldest envelope if delay criteria has been met. tableSize = satTimer->iEnvelopeTable->Count(); TBool done( EFalse ); if ( KZero != tableSize ) { for ( TInt i = 0 ; i < tableSize && done == EFalse ; i++ ) { TSatEnvelope& current = ( *satTimer->iEnvelopeTable )[i]; if ( current.iActive ) { // Active envelope found. Decrease delay and send envelope // if zero. current.iDelay--; if ( KZero >= current.iDelay ) { TFLOGSTRING2("TSY: CSatTimer::Tick: \ Resending type %x envelope", current.iType ); OstTraceExt1( TRACE_INTERNALS, DUP1_CSATTIMER_TICK_TD, "CSatTimer::Tick Resending type %hhu envelope", current.iType ); // Deactivate envelope just in case. Get new transaction // if for envelope and resend it. Finally remove the // envelope from table. current.iActive = EFalse; satTimer->iSatMessHandler->UiccCatReqEnvelope( current.iTId, current.iEnvelope, EFalse ); satTimer->RemoveEnvelope( current.iTId ); tableSize = satTimer->iEnvelopeTable->Count(); // Exit resending loop, only one resent envelope per tick done = ETrue; } } // If active } // For-loop
TBool CheckAttribute (CConsoleBase* iConsole, ConfigPtrsPtr cpPtr,TInt aKeyIndex, TPtrC aDes) { TBool retValue = ETrue; TBuf<50> attrib = aDes; TInt typePos; TInt dirPos; TInt typeLen; TInt dirLen; TUint epType = 0; TUint epDir = 0; TUint ifNumber = 0; _LIT (KQuote,"\""); switch (aKeyIndex) { // level 0 index LDD case ExiLdd : if (attrib.Find(KAttributeName) == 0) { attrib.Delete(0,((TDesC&)KAttributeName).Length()); if (attrib[0] == ((TDesC&)KQuote)[0] && attrib[attrib.Length()-1] == ((TDesC&)KQuote)[0]) { TUSB_VERBOSE_PRINT1 ("LDD with attribute name %s",attrib.PtrZ()); if(gVerbose) { OstTraceExt1 (TRACE_VERBOSE, CONFIGPTRS_CONFIGPTRS_DUP17, "LDD with attribute name %s",attrib); } cpPtr->iThisLDDPtr = new LDDConfig (attrib.MidTPtr(1,attrib.Length()-2)); *cpPtr->iNextLDDPtrPtr = cpPtr->iThisLDDPtr; cpPtr->iNextLDDPtrPtr = &(cpPtr->iThisLDDPtr->iPtrNext); cpPtr->iNextIFPtrPtr = &(cpPtr->iThisLDDPtr->iIFPtr); } else retValue = EFalse; } else { retValue = EFalse; } break; // level 1 index INTERFACE case ExiInterface : if (attrib.Find(KAttributeNumber) == 0) { attrib.Delete(0,((TDesC&)KAttributeNumber).Length()); if (attrib[0] == ((TDesC&)KQuote)[0] && attrib[attrib.Length()-1] == ((TDesC&)KQuote)[0]) { if (TDesToTUint(attrib.MidTPtr(1,attrib.Length()-2), &ifNumber)) { if (cpPtr->iThisLDDPtr == NULL) { TUSB_PRINT ("No LDD container for interface"); OstTrace0 (TRACE_NORMAL, CONFIGPTRS_CONFIGPTRS_DUP18, "No LDD container for interface"); retValue = EFalse; } } else { TUSB_PRINT2 ("Number conversion error %s %d",attrib.PtrZ(),ifNumber); OstTraceExt2 (TRACE_NORMAL, CONFIGPTRS_CONFIGPTRS_DUP19, "Number conversion error %S %u",attrib,ifNumber); retValue = EFalse; } } else { TUSB_PRINT1 ("Attribute number not in \"\" %s",attrib.PtrZ()); OstTraceExt1 (TRACE_NORMAL, CONFIGPTRS_CONFIGPTRS_DUP20, "Attribute number not in \"\" %s",attrib); retValue = EFalse; } } if (retValue) { TUSB_VERBOSE_PRINT1 ("Interface number %d",ifNumber); if(gVerbose) { OstTrace1 (TRACE_VERBOSE, CONFIGPTRS_CONFIGPTRS_DUP21, "Interface number %d",ifNumber); } cpPtr->iThisIFPtr = new IFConfig ((TUint8)ifNumber); * cpPtr->iNextIFPtrPtr = cpPtr->iThisIFPtr; cpPtr->iNextIFPtrPtr = &cpPtr->iThisIFPtr->iPtrNext; cpPtr->iThisLDDPtr->iNumChannels++; } break; // level 1 index Setting case ExiSetting : if (aDes.Length() != 0) { retValue = EFalse; } else { if (cpPtr->iThisLDDPtr == NULL) { TUSB_PRINT ("No LDD container for interface"); OstTrace0 (TRACE_NORMAL, CONFIGPTRS_CONFIGPTRS_DUP22, "No LDD container for interface"); retValue = EFalse; } else { TUSB_VERBOSE_PRINT ("Alternate Interface Setting"); if(gVerbose) { OstTrace0 (TRACE_VERBOSE, CONFIGPTRS_CONFIGPTRS_DUP23, "Alternate Interface Setting"); } cpPtr->iThisIFPtr = new IFConfig (0); * cpPtr->iNextIFPtrPtr = cpPtr->iThisIFPtr; cpPtr->iNextIFPtrPtr = &cpPtr->iThisIFPtr->iPtrNext; cpPtr->iThisIFPtr->iAlternateSetting = ETrue; } } break; // level 2 index ENDPOINT case ExiEndpoint : typePos = attrib.Find(KAttributeType); dirPos = attrib.Find(KAttributeDirection); if (typePos == KErrNotFound || dirPos == KErrNotFound) { retValue = EFalse; } else { if (typePos < dirPos) { typePos += ((TDesC&)KAttributeType).Length(); typeLen = dirPos - typePos; dirPos += ((TDesC&)KAttributeDirection).Length(); dirLen = attrib.Length() - dirPos; } else { dirPos += ((TDesC&)KAttributeDirection).Length(); dirLen = typePos - dirPos; typePos += ((TDesC&)KAttributeType).Length(); typeLen = attrib.Length() - typePos; } TPtr attribPtr = attrib.MidTPtr(typePos,typeLen); attribPtr.UpperCase(); attribPtr.TrimAll(); if (attribPtr == KEpBulk) { epType = KUsbEpTypeBulk; } else { if (attribPtr == KEpInterrupt) { epType = KUsbEpTypeInterrupt; } else { if (attribPtr == KEpIsochronous) { epType = KUsbEpTypeIsochronous; } else { retValue = EFalse; } } } attribPtr = attrib.MidTPtr(dirPos,dirLen); attribPtr.UpperCase(); attribPtr.TrimAll(); if (attribPtr == KEpIn) { epDir = KUsbEpDirIn; } else { if (attribPtr == KEpOut) { epDir = KUsbEpDirOut; } else { retValue = EFalse; } } if (retValue) { if (cpPtr->iThisIFPtr == NULL) { TUSB_PRINT ("No Interface container for Endpoint"); OstTrace0 (TRACE_NORMAL, CONFIGPTRS_CONFIGPTRS_DUP24, "No Interface container for Endpoint"); retValue = EFalse; } else { TUint epIndex = cpPtr->iThisIFPtr->iInfoPtr->iTotalEndpointsUsed; TUSB_VERBOSE_PRINT2 ("Endpoint with type %d %d",epType,epDir); if(gVerbose) { OstTraceExt2 (TRACE_VERBOSE, CONFIGPTRS_CONFIGPTRS_DUP25, "Endpoint with type %u %u",(TUint32)epType,(TUint32)epDir); } cpPtr->iThisIFPtr->iInfoPtr->iEndpointData[epIndex].iType = epType; cpPtr->iThisIFPtr->iInfoPtr->iEndpointData[epIndex].iDir = epDir; #ifdef USB_SC cpPtr->iThisIFPtr->iInfoPtr->iEndpointData[epIndex].iBufferSize = 65536; cpPtr->iThisIFPtr->iInfoPtr->iEndpointData[epIndex].iReadSize = 4096; #endif cpPtr->iThisIFPtr->iEpDMA[epIndex] = EFalse; cpPtr->iThisIFPtr->iEpDoubleBuff[epIndex] = EFalse; cpPtr->iThisIFPtr->iInfoPtr->iTotalEndpointsUsed++; } } } break; default : if (aDes.Length() != 0) { retValue = EFalse; } } return retValue; }
void CMTPFSEnumerator::ProcessEntriesL() { // Start looping through entries at where we left off TInt count = iEntries.Count() - iFirstUnprocessed; // Process no more than KProcessLimit entries count = Min(count, iProcessLimit); iFirstUnprocessed += count; for (TInt i = (iFirstUnprocessed - count); i < iFirstUnprocessed; ++i) { const TEntry& entry = iEntries[i]; TInt len = entry.iName.Length(); if(iCurrentPath.Length() + len > KMaxFileName) { OstTrace0( TRACE_WARNING, CMTPFSENUMERATOR_PROCESSENTRIESL, "Full name exceeds KMaxFileName, ignored." ); continue; } iCurrentPath.Append(entry.iName); OstTraceExt2( TRACE_NORMAL, DUP1_CMTPFSENUMERATOR_PROCESSENTRIESL, "Process path %S name %S", iCurrentPath, entry.iName ); #ifdef OST_TRACE_COMPILER_IN_USE TBuf8<KMTPMaxFullFileName> tmp; tmp.Copy(iCurrentPath); TInt pathLen=iCurrentPath.Length(); if(pathLen > KLogBufferSize) { TBuf8<KLogBufferSize> tmp1; tmp1.Copy(tmp.Ptr(),KLogBufferSize); OstTrace0( TRACE_NORMAL, DUP2_CMTPFSENUMERATOR_PROCESSENTRIESL, "Entry - " ); OstTraceExt1( TRACE_NORMAL, DUP3_CMTPFSENUMERATOR_PROCESSENTRIESL, "%s", tmp1); tmp1.Copy(tmp.Ptr()+KLogBufferSize, pathLen-KLogBufferSize); OstTraceExt1( TRACE_NORMAL, DUP4_CMTPFSENUMERATOR_PROCESSENTRIESL, "%s", tmp1); } else { OstTrace0( TRACE_NORMAL, DUP5_CMTPFSENUMERATOR_PROCESSENTRIESL, "Entry - " ); OstTraceExt1( TRACE_NORMAL, DUP6_CMTPFSENUMERATOR_PROCESSENTRIESL, "%s", tmp); } #endif // OST_TRACE_COMPILER_IN_USE TUint32 handle = 0; TMTPFormatCode format; if(-- iObjectNeedToScan <=0 && iAllRootScaned) { iSkipCurrentStorage = ETrue; return; } if (entry.IsDir()) { if (iExclusionMgr.IsFolderAcceptedL(iCurrentPath, iStorages[iScanPos])) { iCurrentPath.Append('\\'); ++len; format = EMTPFormatCodeAssociation; AddEntryL(iCurrentPath, handle, format, KMTPDeviceDPID, entry, iStorages[iScanPos], iParentHandle); iDirStack.AppendL(TStackItem(iCurrentPath, handle)); } } else { if ( iExclusionMgr.IsFileAcceptedL(iCurrentPath,iStorages[iScanPos]) ) { format = EMTPFormatCodeUndefined; AddEntryL(iCurrentPath, handle, format, iDpID, entry, iStorages[iScanPos], iParentHandle); } else { TParsePtrC parse(iCurrentPath); if ( parse.ExtPresent() ) { switch(iDpSingletons.MTPUtility().GetEnumerationFlag(parse.Ext().Mid(1))) { case MISSED_FILES_OWNED_BY_FILE_DP: if (KMTPHandleNone == iFramework.ObjectMgr().HandleL(iCurrentPath)) { format = EMTPFormatCodeUndefined; AddEntryL(iCurrentPath, handle, format, iDpID, entry, iStorages[iScanPos], iParentHandle); } break; case MISSED_FILES_OWNED_BY_OTHER_DP: if (KMTPHandleNone == iFramework.ObjectMgr().HandleL(iCurrentPath)) { format = iDpSingletons.MTPUtility().GetFormatByExtension(parse.Ext().Mid(1)); TUint32 DpId = iDpSingletons.MTPUtility().GetDpIdL(parse.Ext().Mid(1), KNullDesC); AddFileEntryForOtherDpL(iCurrentPath, handle, format, DpId, entry, iStorages[iScanPos], iParentHandle); } break; case FILES_OWNED_BY_OTHER_DP: { _LIT( KTxtExtensionODF, ".odf" ); TUint32 DpId = iFramework.DataProviderId(); if (parse.Ext().CompareF(KTxtExtensionODF)==0) { HBufC* mime = iDpSingletons.MTPUtility().ContainerMimeType(iCurrentPath); CleanupStack::PushL(mime); if ( mime != NULL ) { OstTraceExt1( TRACE_NORMAL, DUP7_CMTPFSENUMERATOR_PROCESSENTRIESL, "mime %S", *mime ); DpId = iDpSingletons.MTPUtility().GetDpIdL(parse.Ext().Mid(1),*mime); OstTrace1( TRACE_NORMAL, DUP8_CMTPFSENUMERATOR_PROCESSENTRIESL, "DpId find %d", DpId ); format = iDpSingletons.MTPUtility().GetFormatCodeByMimeTypeL(parse.Ext().Mid(1),*mime); AddFileEntryForOtherDpL(iCurrentPath, handle, format, DpId, entry, iStorages[iScanPos], iParentHandle, iDpSingletons.MTPUtility().GetSubFormatCodeL(parse.Ext().Mid(1),*mime)); } else { AddEntryL(iCurrentPath, handle, EMTPFormatCodeUndefined, iDpID, entry, iStorages[iScanPos], iParentHandle); } CleanupStack::PopAndDestroy(mime); } else { format = iDpSingletons.MTPUtility().GetFormatByExtension(parse.Ext().Mid(1)); TUint32 DpId = iDpSingletons.MTPUtility().GetDpIdL(parse.Ext().Mid(1), KNullDesC); AddFileEntryForOtherDpL(iCurrentPath, handle, format, DpId, entry, iStorages[iScanPos], iParentHandle); } } break; // case FILES_OWNED_BY_NONE: default: //nothing to do break; } } } } // Remove filename part iCurrentPath.SetLength(iCurrentPath.Length() - len); } }
// ----------------------------------------------------------------------------- // CDpPn2Rx::Read // Reserves space from rx buffer and makes new PipeReceive // to Isc Api. Checks if flow control high water mark is reached. // Extracts paritybits if 7-bit data.Signals Rx2Dte. // ----------------------------------------------------------------------------- // TInt CDpPn2Rx::Read() { OstTrace0( TRACE_NORMAL, CDPPN2RX_READ, "CDpPn2Rx::Read" ); OstTrace1( TRACE_NORMAL, DUP1_CDPPN2RX_READ, "CDpPn2Rx::Read %x", &iDataPort ); OstTraceExt2( TRACE_NORMAL, DUP2_CDPPN2RX_READ, "CDpPn2Rx:: (Read from ISC) - Port: %u, iRx.Length: %d", iDataPort.PortUnit(), iRx.Length() ); LOGM1("CDpPn2Rx::Read %x", &iDataPort); LOGM2("CDpPn2Rx::Read (Read from ISC) - Port %d, iRx.Length: %d", iDataPort.PortUnit(), iRx.Length() ); TInt ret( KErrNone ); // We've been listening pn_pipe if ( EDpReadWait == iState ) { LOGHEX(iRx, EFalse); OstTraceExt1( TRACE_NORMAL, DUP10_CDPPN2RX_READ, "CDpPn2Rx:: RX = %s", iRx ); ret = iBufferRx.WriteElement().Release( iRx.Length() ); if ( KErrNone == ret ) { #ifdef USE_FILE_SERIAL_TRUST_DEBUG iDataPort.DebugBytesFromPn( iRx.Length() ); #endif if ( 0 < iRx.Length() ) { // 7-bit data extract parity bits if ( EData7 == iDataConfig.DataBits() ) { iParityHandler.ExtractParityBits( iRx ); } //no else if ( iDataPort.IsRx2DteReadPending() ) { // Signal RX2DTE iDataPort.SignalRx2Dte(); } //no else // New data is available. is client interested about that if ( iInBufHasDataNotify ) { // We should notify client iInBufHasDataNotify = EFalse; iDataPort.NotifyDataAvailableCompleted( KErrNone ); } //no else } //no else } //no else } //no else // Check pipe state if ( KErrNone == ret && CDpPif::EDpPipeEnabled != iPifDcs.PipeState() ) { ret = KErrNotReady; } else if ( KErrNone == ret ) { // Try reserve element for writing TPtr8 nullPtr( 0, 0 ); // Check if reserved buffer was too small // => override MaxReservationSize for next read request. if ( KErrNoMemory == iStatus.Int() && iLen > iBufferRx.MaxReservationSize() ) { OstTrace0( TRACE_NORMAL, DUP4_CDPPN2RX_READ, "CDpPn2Rx::KErrNoMemory from ISC =>" ); OstTraceExt1( TRACE_NORMAL, DUP5_CDPPN2RX_READ, "CDpPn2Rx:: -- Try to read more than MaxReservationSize, %hu --", iLen ); LOG(" CDpPn2Rx::Read, KErrNoMemory from ISC =>"); LOG1(" -- Try to read more than MaxReservationSize, %d --", iLen ); ret = iBufferRx.WriteElement().Reserve( iLen, iRx, nullPtr, ETrue ); // Set iLen to zero (required buffer lenght for read, // received from ISC if buffer was too small) iLen = 0; } else { ret = iBufferRx.WriteElement().Reserve( iBufferRx.MaxReservationSize(), iRx, nullPtr ); } // Is flowctrl off and rx "high watermark" reached if ( EFlowControlOff == iFlowCtrl.FlowCtrlDcs2Dp() ) { if ( IsHighWaterMarkReached() ) { // Buffer is almost full set flowcontrol on LOG(" CDpPn2Rx::Read, Rx High WaterMarkReached"); OstTrace0( TRACE_NORMAL, DUP6_CDPPN2RX_READ, "CDpPn2Rx:: Rx High WaterMark reached" ); iFlowCtrl.WaterMarkHighReached(); } //no else } //no else switch ( ret ) { // Reservation successed case KErrNone: { LOG1(" CDpPn2Rx::Read, ISAHandle Pipe Receive. iRx.MaxLength: %d", iRx.MaxLength() ); OstTrace1( TRACE_NORMAL, DUP7_CDPPN2RX_READ, "CDpPn2Rx:: ISAHandle Pipe Receive. iRx.MaxLength: %d", iRx.MaxLength() ); // Set pipe receive if ( !IsActive() ) { iDataPort.ISAHandle().DataReceive( iStatus, iRx, iLen ); iRequestActive = ETrue; // Change state iState = EDpReadWait; SetActive(); } //no else break; } // Reservation failed case KErrNotReady: { LOG(" ERROR, CDpPn2Rx::Read, Element reservation failed (KErrNotReady)."); OstTrace0( TRACE_NORMAL, DUP8_CDPPN2RX_READ, "ERROR, CDpPn2Rx::Read, Element reservation failed (KErrNotReady)" ); // Change state iState = EElementWait; // Better done here if ( !IsActive() ) { iStatus = KRequestPending; SetActive(); } //no else iRequestActive = ETrue; ret = KErrNone; break; } default: { // An error value returned LOG1(" ERROR, CDpPn2Rx::Read, Fail to reserve Element, error code: %d", ret ); OstTrace1( TRACE_NORMAL, DUP9_CDPPN2RX_READ, "CDpPn2Rx:: ERROR, CDpPn2Rx::Read, Fail to reserve Element, error code: %d", ret ); } } } //no else return ret; }
/** * Callback function for Trace Activation * * @param aComponentId * @param aGroupId */ void DTraceCompilerTesterAdvanced::TraceActivated( TUint32 aComponentId, TUint16 aGroupId ) { Kern::Printf( "DTraceCompilerTesterAdvanced::TraceActivated - ComponentId = 0x%x, GroupId = 0x%x", aComponentId, aGroupId ); if (aGroupId == POINTER_PARAMETER_TEST) { // Print out pointer values of two NTimers by using %p tag Kern::Printf( "--------------TraceCompilerTesterAdvanced Pointer Parameter Test START----------------" ); NTimer* myNTimer1 = new NTimer(); NTimer* myNTimer2 = new NTimer(); const NTimer* myNTimer3 = new NTimer(); OstTraceExt2( POINTER_PARAMETER_TEST, POINTER_PARAMETER_TRACE1, "Print out pointer values of two NTimers;myNTimer1=%p;myNTimer2=%p", myNTimer1, myNTimer2 ); OstTraceExt1( POINTER_PARAMETER_TEST, POINTER_PARAMETER_TRACE2, "Print out pointer values of one const NTimers;myNTimer3=%p", myNTimer3 ); delete myNTimer1; delete myNTimer2; delete myNTimer3; Kern::Printf( "--------------TraceCompilerTesterAdvanced Pointer Parameter Test END----------------" ); } else if (aGroupId == LONG_TRACE_TEST) { // Print out n times traces those lengths are 60, 300, 512 and 600 characters. // Print out also some traces those parameter total length is more than 512 Kern::Printf( "--------------TraceCompilerTesterAdvanced Long Trace Test START----------------" ); TInt i=0; TUint numberOfTraces = 1; TInt32 freq = NKern::FastCounterFrequency(); TUint32 startTime; TUint32 endTime; TUint32 time; TUint timeTestNumber1 = 0; TUint timeTestNumber2 = 0; TUint timeTestNumber3 = 0; TUint timeTestNumber4 = 0; TUint timeTestNumber5 = 0; TUint timeTestNumber6 = 0; TUint timeTestNumber7 = 0; // ---------------------------- Ascii60 ---------------------------- startTime = NKern::FastCounter(); Kern::Printf( "--------------TraceCompilerTesterAdvanced Long Trace Test : Ascii60----------------" ); for (i=0; i < numberOfTraces; i++) { OstTraceExt1( LONG_TRACE_TEST, ASCII60, "Ascii60: %s", buf60); } endTime = NKern::FastCounter(); time = (endTime - startTime) * 1000 / freq; timeTestNumber1 = time; // ---------------------------- Ascii60 ---------------------------- // ---------------------------- Ascii300 ---------------------------- startTime = NKern::FastCounter(); Kern::Printf( "--------------TraceCompilerTesterAdvanced Long Trace Test : Ascii300----------------" ); for (i=0; i < numberOfTraces; i++) { OstTraceExt1( LONG_TRACE_TEST, ASCII300, "Ascii300: %s", buf300); } endTime = NKern::FastCounter(); time = (endTime - startTime) * 1000 / freq; timeTestNumber2 = time; // ---------------------------- Ascii300 ---------------------------- // ---------------------------- Ascii512 ---------------------------- startTime = NKern::FastCounter(); Kern::Printf( "--------------TraceCompilerTesterAdvanced Long Trace Test : Ascii512----------------" ); for (i=0; i < numberOfTraces; i++) { OstTraceExt1( LONG_TRACE_TEST, ASCII512, "Ascii512: %s", buf512); } endTime = NKern::FastCounter(); time = (endTime - startTime) * 1000 / freq; timeTestNumber3 = time; // ---------------------------- Ascii512 ---------------------------- // ---------------------------- Ascii600 ---------------------------- startTime = NKern::FastCounter(); Kern::Printf( "--------------TraceCompilerTesterAdvanced Long Trace Test : Ascii600----------------" ); for (i=0; i < numberOfTraces; i++) { OstTraceExt1( LONG_TRACE_TEST, ASCII600, "Ascii600: %s", buf600); } endTime = NKern::FastCounter(); time = (endTime - startTime) * 1000 / freq; timeTestNumber4 = time; // ---------------------------- Ascii600 ---------------------------- // ---------------------------- Ascii300 + Ascii512 ---------------------------- startTime = NKern::FastCounter(); Kern::Printf( "--------------TraceCompilerTesterAdvanced Long Trace Test : Ascii300 + Ascii512----------------" ); for (i=0; i < numberOfTraces; i++) { OstTraceExt2( LONG_TRACE_TEST, ASCII300_ASCII512, "Ascii300: %s Ascii512: %s", buf300, buf512); } endTime = NKern::FastCounter(); time = (endTime - startTime) * 1000 / freq; timeTestNumber5 = time; // ---------------------------- Ascii300 + Ascii512 ---------------------------- // ---------------------------- Ascii600 + Ascii300 ---------------------------- startTime = NKern::FastCounter(); Kern::Printf( "--------------TraceCompilerTesterAdvanced Long Trace Test : Ascii600 + Ascii300----------------" ); for (i=0; i < numberOfTraces; i++) { OstTraceExt2( LONG_TRACE_TEST, ASCII600_ASCII300, "Ascii600: %s Ascii300: %s", buf600, buf300); } endTime = NKern::FastCounter(); time = (endTime - startTime) * 1000 / freq; timeTestNumber6 = time; // ---------------------------- Ascii600 + Ascii300 ---------------------------- // ---------------------------- Ascii333 + Ascii333 ---------------------------- startTime = NKern::FastCounter(); Kern::Printf( "--------------TraceCompilerTesterAdvanced Long Trace Test : Ascii333 + Ascii333----------------" ); for (i=0; i < numberOfTraces; i++) { OstTraceExt2( LONG_TRACE_TEST, ASCII333_ASCII333, "Ascii333: %s Ascii333: %s", buf333, buf333); } endTime = NKern::FastCounter(); time = (endTime - startTime) * 1000 / freq; timeTestNumber7 = time; // ---------------------------- Ascii333 + Ascii333 ---------------------------- Kern::Printf( "--------------TraceCompilerTesterAdvanced----------------" ); Kern::Printf( "Ascii60: %d", timeTestNumber1 ); Kern::Printf( "Ascii300: %d", timeTestNumber2 ); Kern::Printf( "Ascii512: %d", timeTestNumber3 ); Kern::Printf( "Ascii600: %d", timeTestNumber4 ); Kern::Printf( "Ascii300 + Ascii512: %d", timeTestNumber5 ); Kern::Printf( "Ascii600 + Ascii300: %d", timeTestNumber6 ); Kern::Printf( "Ascii333 + Ascii333: %d", timeTestNumber7 ); Kern::Printf( "--------------TraceCompilerTesterAdvanced----------------" ); Kern::Printf( "--------------TraceCompilerTesterAdvanced Long Trace Test END----------------" ); } else if (aGroupId == SHORT_TRACE_TEST) { Kern::Printf( "--------------TraceCompilerTesterAdvanced Short Trace Test START----------------" ); Kern::Printf( "--------------TraceCompilerTesterAdvanced Short Trace Test : Ascii1----------------" ); OstTraceExt1( SHORT_TRACE_TEST, ASCII1, "Ascii1: %s", buf1); Kern::Printf( "--------------TraceCompilerTesterAdvanced Short Trace Test : Ascii2----------------" ); OstTraceExt1( SHORT_TRACE_TEST, ASCII2, "Ascii2: %s", buf2); Kern::Printf( "--------------TraceCompilerTesterAdvanced Short Trace Test : Ascii3----------------" ); OstTraceExt1( SHORT_TRACE_TEST, ASCII3, "Ascii3: %s", buf3); Kern::Printf( "--------------TraceCompilerTesterAdvanced Short Trace Test : Ascii4----------------" ); OstTraceExt1( SHORT_TRACE_TEST, ASCII4, "Ascii4: %s", buf4); Kern::Printf( "--------------TraceCompilerTesterAdvanced Short Trace Test : Ascii1 + Acii2----------------" ); OstTraceExt2( SHORT_TRACE_TEST, ASCII5, "Ascii1: %s Ascii2: %s", buf1, buf2); Kern::Printf( "--------------TraceCompilerTesterAdvanced Short Trace Test END----------------" ); } else if (aGroupId == INCLUDED_NON_SOURCE_FILE_TEST) { // Print out traces from included non-source file that is defined in trace.properties file Kern::Printf( "--------------TraceCompilerTesterAdvanced Included Non-Source File Test START----------------" ); this->HelloWorld(); this->HelloMoon(); TUint32 value3 = GetBigValue1000(); TUint32 value4 = GetBigValue2000(); Kern::Printf( "--------------TraceCompilerTesterAdvanced Included Non-Source File Test END----------------" ); } else if (aGroupId == TRACE_FLOW) { OstTrace0(TRACE_FLOW, TEST_TRACE_2, "Test OLD TraceCompiler"); // This test can also use to test function parameters Kern::Printf( "--------------TraceCompilerTesterAdvanced Common Source File Test START----------------"); DTraceCompilerTesterCommon1* common1 = new DTraceCompilerTesterCommon1(); TInt32 sum = common1->SumValues(-1, -2, 100, 200); delete common1; Kern::Printf( "--------------TraceCompilerTesterAdvanced Common Source File Test END----------------"); } else if (aGroupId == KEKKONEN) { Kern::Printf( "--------------TraceCompilerTesterAdvanced Kekkonen START----------------"); DTraceCompilerTesterCommon2* common2 = new DTraceCompilerTesterCommon2(); common2->Kekkonen(); delete common2; Kern::Printf( "--------------TraceCompilerTesterAdvanced Kekkonen END----------------"); } else if (aGroupId == TRACE_STATE) { Kern::Printf( "--------------TraceCompilerTesterAdvanced State Trace Test START----------------"); OstTraceState0(STATE_TRACE_0, "Kone1", "Running"); OstTraceState1(STATE_TRACE_1, "Kone2", "Stopped", this); Kern::Printf( "--------------TraceCompilerTesterAdvanced State Trace Test END----------------"); } else if (aGroupId == TRACE_DATA) { Kern::Printf( "--------------TraceCompilerTesterAdvanced Data Trace Test START----------------"); TBuf8<601> data(buf600); OstTraceData( TRACE_DATA, TRACE_DATA_TRACE, "DTraceCoreXtiIf::DebugPrintMsg - Msg via XTI IF 0x%{hex8[]}", data.Ptr(), data.Size() ); Kern::Printf( "--------------TraceCompilerTesterAdvanced Data Trace Test END----------------"); } else if (aGroupId == POST_CODE_TEST) { Kern::Printf( "--------------TraceCompilerTesterAdvanced POST Code Trace Test START----------------"); OstTrace0(POST_CODE_TEST, POST1, "Print some POST code traces"); Kern::Printf("[POST][X-Loader][Started][OK]"); Kern::Printf("[POST][BootUp][Reset reason][PowerOn]"); Kern::NanoWait(50000000); Kern::Printf("[POST][X-Loader][Authenticate][OK]"); Kern::NanoWait(100000000); Kern::Printf("[POST][X-Loader][load][OK]"); Kern::NanoWait(100000000); Kern::Printf("[POST][X-Loader][Authenticate][OK]"); Kern::NanoWait(700000000); Kern::Printf("[POST][X-Loader][load][OK]"); Kern::NanoWait(50000000); Kern::Printf("[POST][X-Loader][load][OK]"); Kern::NanoWait(50000000); Kern::Printf("[POST][X-Loader][load][OK]"); Kern::NanoWait(50000000); Kern::Printf("[POST][X-Loader][Authenticate][OK]"); Kern::NanoWait(200000000); Kern::Printf("[POST][Boot strap][Started][OK]"); Kern::NanoWait(10000000); Kern::Printf("[POST][Estart][started][OK]"); Kern::NanoWait(10000000); Kern::Printf("[POST][Estart][CompositeFileSys.][OK]"); Kern::NanoWait(500000000); Kern::Printf("[POST][Mount][Drive][OK]"); Kern::NanoWait(200000000); Kern::Printf("[POST][Mount][Drive][OK]"); Kern::NanoWait(200000000); Kern::Printf("[POST][Estart][ISC API start][OK]"); Kern::NanoWait(300000000); Kern::Printf("[POST][Estart][userdisk format][No]"); Kern::NanoWait(10000000); Kern::Printf("[POST][Estart][secenv start][OK]"); Kern::NanoWait(20000000); Kern::Printf("[POST][Estart][startup mode][Local]"); Kern::NanoWait(10000000); Kern::Printf("[POST][Estart][Language selection][OK]"); Kern::NanoWait(200000000); Kern::Printf("[POST][SelfTest][Started][FAIL][KErrOutOfMemory]"); Kern::NanoWait(200000000); Kern::Printf("[POST][BT][Started][OK]"); Kern::NanoWait(800000000); Kern::Printf("[POST][WLAN][Started][OK]"); Kern::NanoWait(800000000); Kern::Printf("[POST][Display][Started][OK]"); Kern::NanoWait(800000000); Kern::Printf("[POST][Camera][Started][OK]"); Kern::NanoWait(80000000); Kern::Printf("[POST][mc_kernelagent][ExtensionInit0][OK]"); Kern::NanoWait(100000000); Kern::Printf("[POST][mc_sender][Pre-init][OK]"); Kern::NanoWait(100000000); Kern::Printf("[POST][mc_useragent][MobileCrashWriter init][OK]"); Kern::Printf( "--------------TraceCompilerTesterAdvanced POST Code Trace Test END----------------"); } }