EXPORT_C OMX_CALLBACKTYPE* COmxILComponent::GetCallbacks() const { __ASSERT_ALWAYS(ipImpl, User::Panic(KOmxILComponentPanicCategory, 1)); return ipImpl->GetCallbacks(); }
/** Provides the value of the specified element. @param aElementId The identifier of the requested element. @return The value of the element. @panic MTPDataTypes 3, if the source buffer type does not match the requested element. */ EXPORT_C TUint8 TMTPTypeFlatBase::Uint8(TInt aElementId) const { const TElementInfo& info(ElementInfo(aElementId)); __ASSERT_ALWAYS((info.iType == EMTPTypeUINT8), Panic(EMTPTypeIdMismatch)); return (static_cast<TUint8>(iBuffer[info.iOffset])); }
EXPORT_C TInt TMTPTypeFlatBase::FirstWriteChunk(TPtr8& aChunk) { __ASSERT_ALWAYS(iBuffer.MaxLength() > 0, Panic(EMTPTypeBadStorage)); aChunk.Set(&iBuffer[0], 0, iBuffer.MaxLength()); return KMTPChunkSequenceCompletion; }
// ----------------------------------------------------------------------------- // CMceMediaSink::ExternalizeFlatL // ----------------------------------------------------------------------------- // void CMceMediaSink::ExternalizeFlatL( RWriteStream& aWriteStream ) { __ASSERT_ALWAYS( iFlatData , User::Leave( KErrNotReady ) ); _FLAT_DATA->ExternalizeFlatL( aWriteStream ); }
RHTTPTransaction CTestCase10::GetTransactionL(TInt aIndex, RHTTPSession aSession, MHTTPTransactionCallback& aClient) { __ASSERT_ALWAYS(aIndex<KTransactionCount, User::Invariant()); TPtrC8 uriDes; switch(aIndex) { case 0: { uriDes.Set(_L8("http://10.29.23.12")); } break; case 1: { uriDes.Set(_L8("http://10.29.23.12/manual/index.html")); } break; case 2: { uriDes.Set(_L8("http://10.29.23.12/manual/new_features_1_3.html")); } break; case 3: { uriDes.Set(_L8("http://10.29.23.12/wap/suite-08Jun2000/")); } break; case 4: { uriDes.Set(_L8("http://10.29.23.12/wap/suite-20Jun2000/")); } break; case 5: { uriDes.Set(_L8("http://10.29.23.12/manual/upgrading_to_1_3.html")); } break; case 6: { uriDes.Set(_L8("http://10.29.23.12/manual/install.html")); } break; case 7: { uriDes.Set(_L8("http://10.29.23.12/manual/invoking.html")); } break; case 8: { uriDes.Set(_L8("http://10.29.23.12/stats.html")); } break; case 9: { uriDes.Set(_L8("http://10.29.23.12/manual/stopping.html")); } break; case 10: { uriDes.Set(_L8("http://10.29.23.12/manual/mod/directives.html")); } break; case 11: { uriDes.Set(_L8("http://10.29.23.12/manual/images/custom_errordocs.gif")); } break; case 12: { uriDes.Set(_L8("http://10.29.23.12/manual/images/home.gif")); } break; case 13: { uriDes.Set(_L8("http://10.29.23.12/manual/images/index.gif")); } break; default: // Shouldn't happen! User::Invariant(); break; } RStringF method = aSession.StringPool().StringF(HTTP::EGET,RHTTPSession::GetTable()); TUriParser8 uri; uri.Parse(uriDes); return aSession.OpenTransactionL(uri, aClient, method); }
// SendRequestL // Creates the msg from the data elements passed in the descriptor array // and sends over socket connection. // Then waits until a response is received from the slave. // Caller has to pass in empty HBufC8. TInt CSender::SendRequestL(CRpsMsg& aRpsMsg, HBufC8** aResp) { // Generate request data buf HBufC8* msg = NULL; aRpsMsg.ExternalizeL(msg); CleanupStack::PushL(msg); // Send the msg over the socket TRequestStatus sendStatus; iSendSocket.Send(*msg, 0, sendStatus); User::WaitForRequest(sendStatus); CleanupStack::PopAndDestroy(msg); if(sendStatus != KErrNone) { RDEBUGPRINTLOGGER2(_L("CSender::SendRequestL Send error [%d]"),sendStatus.Int()); return sendStatus.Int(); } // Expect a response msg back from slave synchronously. // Return an error if resp not received in time-out. // Else pass the response msg up to the caller. // Expect the msg header+length TRequestStatus recvStatus; iBufferPreRead.Delete(0, iBufferPreRead.Length()); iSendSocket.Recv(iBufferPreRead, 0, recvStatus); // ** TODO: check for error value in recvStatus (-191 returned if slave has crashed) ** TInt ret = GetRequestOrTimeOut(recvStatus, KRespFromSlaveTimeout); if (recvStatus.Int() != KErrNone) { RDEBUGPRINTLOGGER2(_L("CSender::SendRequestL Recv error [%d]"),recvStatus.Int()); } if(ret != KErrNone) { // We didn't receive a response within timelimit. return ret; } // Receive the rest of the msg. // Get msg length from pre-read TUint msgLen(0); TLex8 lex(iBufferPreRead.Right(KMaxMsgLenChars)); lex.Val(msgLen); __ASSERT_ALWAYS(msgLen > KRespSocketPreReadSize, User::Panic(KPanicMsgFormat, 303)); // TODO - panic number? // Now read the rest of msg iBuffer.Close(); iBuffer.CreateL(msgLen - KReqstSocketPreReadSize); // Recv operation should complete immediately if msg has been formatted correctly iSendSocket.Recv(iBuffer, 0, recvStatus); ret = GetRequestOrTimeOut(recvStatus, KRespFromSlaveTimeout); if(ret != KErrNone) { // We didn't receive a response within timelimit. return ret; } // Check status of Recv operation if(recvStatus != KErrNone) { return recvStatus.Int(); } iBufferAll.Close(); iBufferAll.CreateL(msgLen); // Give HandleRequestL the entire msg iBufferAll += iBufferPreRead; iBufferAll += iBuffer; // For debug ... RBuf16 buf; buf.CreateL(iBufferAll.Length()); buf.Copy(iBufferAll); buf.Close(); // Passing entire response msg to caller // Caller owns memory *aResp = iBufferAll.AllocL(); iBufferPreRead.Delete(0, iBufferPreRead.Length()); iBuffer.Close(); iBufferAll.Close(); return KErrNone; }
// --------------------------------------------------------------------------- // Handles an active object's request completion event. // --------------------------------------------------------------------------- // void COMASuplPositionTest::RunL() { switch(iNextInSeq) { case EStartTest: { iLogger->GetRequestStartTime(); TRAPD( err, iSessionBase = iPosHandler.CreateNewSessionL(this)); if( KErrNone != err ) { iError++; iLogger->WriteLine(KCreatingSessionFail, iTestNo); User::Leave(err); } iInfo++; iLogger->LogExecutionTime(KExecCreateNewSessionL); iInfo++; iLogger->WriteLine(KSessionCreated, iTestNo); __ASSERT_ALWAYS(!IsActive(),User::Panic(KPanicSetActive, KErrAlreadyExists)); iNextInSeq = EGetPositionBeforeInitialize; DummyRequest(iStatus); SetActive(); break; } case EGetPositionBeforeInitialize: { iNextInSeq = EGetPositionCompleteBeforeInitialize; iInfo++; iLogger->WriteLine(KGetPositionLInfo, iTestNo); RequestForPositionL(); break; } case EGetPositionCompleteBeforeInitialize: { iNextInSeq = EInitializeSession; if(iStatus == KErrOMASuplPosInActive) { iInfo++; iLogger->WriteStatus( _L8("Info: GetPositionL completed with ") , iStatus.Int(), iTestNo); } else { iWarning++; iLogger->WriteStatus( _L8("Warning: GetPositionL completed with ") , iStatus.Int(), iTestNo); } __ASSERT_ALWAYS(!IsActive(),User::Panic(KPanicSetActive, KErrAlreadyExists)); DummyRequest(iStatus); SetActive(); break; } case EInitializeSession: { __ASSERT_ALWAYS(!IsActive(),User::Panic(KPanicSetActive, KErrAlreadyExists)); iNextInSeq = EGetPositionAfterInitialize; iInfo++; iLogger->WriteLine(KInitializingSession); iSessionBase->InitializeL(iRequestID, iStatus); SetActive(); break; } case EGetPositionAfterInitialize: { if(iStatus != KErrNone) { iError++; iLogger->WriteStatus(KError, iStatus.Int(), iTestNo, &KReqCompWith()); TestingAborted(KPositionTestAborted); return; } else { iInfo++; iLogger->WriteStatus(KInfo, KErrNone, iTestNo, &KReqCompWith()); } iNextInSeq = EGetPositionCompleteAfterInitialize; iInfo++; iLogger->WriteLine(KGetPositionLSessionInitInfo, iTestNo); RequestForPositionL(); break; } case EGetPositionCompleteAfterInitialize: { iNextInSeq = EEndSessionAndGetPosition; if(iStatus != KErrNone) { iWarning++; iLogger->WriteStatus( _L8("Warning: GetPositionL completed with ") , iStatus.Int(), iTestNo); } else { iInfo++; iLogger->WriteStatus( _L8("Info: GetPositionL completed with ") , iStatus.Int(), iTestNo); } iLogger->LogSuplPosition(iPosition); __ASSERT_ALWAYS(!IsActive(),User::Panic(KPanicSetActive, KErrAlreadyExists)); DummyRequest(iStatus); SetActive(); break; } case EEndSessionAndGetPosition: { iNextInSeq = EGetPositionCompleteAfterEndSession; iInfo++; iLogger->WriteLine(KEndingSession, iTestNo); iSessionBase->SessionEnd(); iInfo++; iLogger->WriteLine(KGetPositionLSessionEndInfo, iTestNo); RequestForPositionL(); break; } case EGetPositionCompleteAfterEndSession: { if(iStatus == KErrOMASuplPosInActive) { iInfo++; iLogger->WriteStatus(KAfterEndSessionI, iStatus.Int() , iTestNo); } else { iWarning++; iLogger->WriteStatus(KAfterEndSessionW, iStatus.Int() , iTestNo); } iLogger->LogSuplPosition(iPosition); TestingComplete(KPositionTestComplete); break; } } }
// --------------------------------------------------------------------------- // InsertedToScene // --------------------------------------------------------------------------- // void CAlfWindow::InsertedToScene(TBool aInserted) { __ASSERT_ALWAYS( iData, USER_INVARIANT() ); iData->iIsInScene = aInserted; }
// --------------------------------------------------------------------------- // // --------------------------------------------------------------------------- // TBool CAlfWindow::ShouldBeDeactivated() { __ASSERT_ALWAYS( iData, USER_INVARIANT() ); return iData->iFlags & TAlfWindowData::EShouldInactivate; }
EXPORT_C TInt COmxILComponent::AddPort(const COmxILPort* aPort, OMX_DIRTYPE aDirection) { __ASSERT_ALWAYS(ipImpl, User::Panic(KOmxILComponentPanicCategory, 1)); return ipImpl->AddPort(aPort, aDirection); }
// --------------------------------------------------------------------------- // IsInsertedToScene // --------------------------------------------------------------------------- // TBool CAlfWindow::IsInsertedToScene() { __ASSERT_ALWAYS( iData, USER_INVARIANT() ); return iData->iIsInScene; }
EXPORT_C MOmxILCallbackNotificationIf* COmxILComponent::CreateCallbackManagerL(TCallbackManagerType aCallbackManagerType) { __ASSERT_ALWAYS(ipImpl, User::Panic(KOmxILComponentPanicCategory, 1)); return ipImpl->CreateCallbackManagerL(aCallbackManagerType); }
EXPORT_C COmxILProcessingFunction* COmxILComponent::GetProcessingFunction() const { __ASSERT_ALWAYS(ipImpl, User::Panic(KOmxILComponentPanicCategory, 1)); return ipImpl->GetProcessingFunction(); }
EXPORT_C COmxILConfigManager* COmxILComponent::GetConfigManager() const { __ASSERT_ALWAYS(ipImpl, User::Panic(KOmxILComponentPanicCategory, 1)); return ipImpl->GetConfigManager(); }
// Full name of the test resource file when installed. void ResFileFullName(TFileName& aFileName, TTErrorResFile aFile) { __ASSERT_ALWAYS(aFile >= EResFile1 && aFile <= EResFile5, Panic(ETestUnknownResFile)); aFileName.Format(KErrorResFileFmt, aFile); aFileName.Insert(0, KLitV2ResFilePath()); }
// --------------------------------------------------------------------------- // NSPUtil::RejectL // --------------------------------------------------------------------------- // void NSPUtil::RejectL( CSdpMediaField& aField ) { __ASSERT_ALWAYS( &aField, User::Leave( KErrArgument ) ); aField.SetPortL( KRejectPort ); }
OMX_BOOL COmxILTestMD5SinkProcessingFunction::BufferRemovalIndication(OMX_BUFFERHEADERTYPE* apBufferHeader, OMX_DIRTYPE aDirection) { __ASSERT_ALWAYS(aDirection == OMX_DirInput, User::Invariant()); return iMD5Active->RemoveBuffer(apBufferHeader); }
const TDesC8& CINC037440::GetRawResponse(TInt aConnectionIndex, TInt aTransIndex) { __ASSERT_ALWAYS( (aTransIndex<KTransactionCount) && (aConnectionIndex < KConnectionCount), User::Invariant()); return KTxtRawResponse(); }
TInt CImapIO::GetReply(TRequestStatus& aStatus, const TInt aFetchSize, const TBool aPartialReturn) { DBG((LogText(_L8("CImapIO::GetReply (aFetchSize=%d, aPartialReturn=%d)"),aFetchSize,aPartialReturn))); // Disconnected? if (iState==EIOStateDisconnected) return(KErrDisconnected); // Have to be connected & not busy __ASSERT_ALWAYS(iState==EIOStateConnected,gPanic(EIOWhenNotReady)); // Queue request Queue(aStatus); // Save max number of bytes to read in next request iBytesToRead=aFetchSize; // Partial return required? (ie return tree in as-is state when read // completes) iReturnPartialLine=aPartialReturn; // Still busy (last request cancelled?), or still building tree? if (iBytesRead) { // Carry on with this one, return it when ready } else { // New line // Blank output buffer iBuffer->Des().Zero(); // Delete existing tree if (iRootAtom!=NULL) { // remove atoms from atom tree iAtomArray.ResetAndDestroy(); delete iRootAtom; iRootAtom=NULL; } // Reset (empty) atom stack iAtomStack.Reset(); // Reset state iParserState=EIOStateAtomWait; // First created atom will be child of root iRootAtom=new CImapAtom(); iAtom=iRootAtom; iNextIsChild=ETrue; } // Anything in receive buffer? Deal with it if we can TRAPD(err,ProcessBufferL()); if (err!=KErrNone) { // An error has occurred: return this DBG((LogText(_L8("CImapIO::ProcessBuffer: Complete in GetReply err %d"),err))); Complete(KErrGeneral); } return(KErrNone); }
void CCamcTestClient_2::RunLTrappedL() { TBool prepare = EFalse; if ( iOpenReady ) { iOpenReady = EFalse; // Set default parameters. They can be overwritten depending on the test case. iCamc->SetVideoFrameSizeL(TSize(176,144)); iCamc->SetVideoFrameRateL(TReal32(15)); iCamc->SetVideoBitRateL(TInt(50000)); iCamc->SetAudioEnabledL(ETrue); switch ( iAction ) { case KcloseWhenControllerReady: { iCamc->Close(); iClosed = 1; break; } case KprepareWhenControllerReady: { prepare = ETrue; break; } case KrecordWhenControllerReady: { iCamc->Record(); break; } case KSetPriorityLWhenControllerReady : { iCamc->SetPriorityL(EMdaPriorityNormal,EMdaPriorityPreferenceTime ); prepare = ETrue; break; } case KSetVideoFrameRateLWhenControllerReady : { iCamc->SetVideoFrameRateL( TReal32(TC2_VIDEO_FRAME_RATE) ); prepare = ETrue; break; } case KSetVideoFrameSizeLWhenControllerReady : { iCamc->SetVideoFrameSizeL( TC2_VIDEO_FRAME_SIZE ); prepare = ETrue; break; } case KSetVideoFrameSizeLWhenControllerReady_MPEG4 : { iCamc->SetVideoFrameSizeL( TC2_CIF_VIDEO_FRAME_SIZE ); prepare = ETrue; break; } case KSetVideoBitRateLWhenControllerReady : { iCamc->SetVideoBitRateL( TC2_VIDEO_BIT_RATE ); prepare = ETrue; break; } case KSetAudioBitRateLWhenControllerReady : { iCamc->SetAudioBitRateL( TC2_AUDIO_BIT_RATE ); prepare = ETrue; break; } case KSetAudioEnabledLWhenControllerReady : { iCamc->SetAudioEnabledL( TC2_AUDIO_ENABLED ); prepare = ETrue; break; } case KSetMaxClipSizeLWhenControllerReady : { iCamc->SetMaxClipSizeL( 10000 ); prepare = ETrue; break; } case KSetVideoTypeLWhenControllerReady : { iCamc->SetVideoTypeL( TC2_VIDEO_TYPE ); prepare = ETrue; break; } case KSetAudioTypeLWhenControllerReady : { iCamc->SetAudioTypeL( TC2_AUDIO_TYPE ); prepare = ETrue; break; } default: { prepare = ETrue; break; } } if ( prepare ) { iCamc->Prepare(); } } else if ( iPrepareReady ) { TBool record = EFalse; switch ( iAction ) { case KcloseWhenPrepareReady: { iCamc->Close(); iClosed = 1; break; } case KcloseWhenPrepareReadyUsingAACandMPEG4: { iCamc->Close(); iClosed = 1; break; } case KprepareWhenPrepareReady: { iAction = Knone; iPrepareReady = EFalse; iCamc->Prepare(); break; } case KprepareWhenPrepareReadySetVideoAttributes: { iAction = Knone; iPrepareReady = EFalse; iCamc->SetVideoFrameSizeL( TSize(176,144) ); iCamc->SetVideoFrameRateL( TReal32(15) ); iCamc->SetVideoBitRateL( TInt(50000) ); iCamc->SetAudioEnabledL( EFalse ); iCamc->Prepare(); break; } case KrecordWhenPrepareReady: { record = ETrue; break; } case KSetPriorityLWhenPrepareReady : { if (!iSecondTime) { iCamc->SetPriorityL(EMdaPriorityNormal,EMdaPriorityPreferenceTime ); record = EFalse; iCamc->Prepare(); iSecondTime = ETrue; } else { record= ETrue; } break; } case KSetVideoFrameRateLWhenPrepareReady : { iCamc->SetVideoFrameRateL( TReal32(TC2_VIDEO_FRAME_RATE) ); record = ETrue; break; } case KSetVideoFrameSizeLWhenPrepareReady : { iCamc->SetVideoFrameSizeL( TC2_VIDEO_FRAME_SIZE ); record = ETrue; break; } case KSetVideoBitRateLWhenPrepareReady : { iCamc->SetVideoBitRateL( TC2_VIDEO_BIT_RATE ); record = ETrue; break; } case KSetAudioBitRateLWhenPrepareReady : { iCamc->SetAudioBitRateL( TC2_AUDIO_BIT_RATE ); record = EFalse; iCamc->Prepare(); iAction = Knone; break; } case KSetAudioEnabledLWhenPrepareReady : { iCamc->SetAudioEnabledL( TC2_AUDIO_ENABLED ); record = ETrue; break; } case KSetMaxClipSizeLWhenPrepareReady : { iCamc->SetMaxClipSizeL( 10000 ); record = ETrue; break; } case KSetVideoTypeLWhenPrepareReady : { iCamc->SetVideoTypeL( TC2_VIDEO_TYPE ); record = ETrue; break; } case KSetAudioTypeLWhenPrepareReady : { iCamc->SetAudioTypeL( TC2_AUDIO_TYPE ); record = ETrue; break; } case KSetMaxClipSizeLWhenControllerReady : { record = ETrue; iTimeout = 40 * 1E6; // Wait for 10 seconds. break; } default: { record = ETrue; break; } } if ( record ) { iPrepareReady = EFalse; iCamc->Record(); CTimer::After( iTimeout ); } } else if ( iRecordingReady ) { TBool closeCam = ETrue; switch ( iAction ) { case KcloseWhenRecordingReady: { iAction = Knone; iCamc->Close(); closeCam = EFalse; // False because we want to stop the Active scheduler // yet CTimer::After( 10000 ); break; } case KprepareWhenRecordingReady: { iAction = Knone; iRecordingReady = EFalse; iCamc->Prepare(); closeCam = EFalse; // Should start a new recording break; } case KrecordWhenRecordingReady: { iAction = Knone; iRecordingReady = EFalse; iCamc->Record(); closeCam = EFalse; CTimer::After( (TInt) (10*1E6) ); // Starts a new recording break; } default: break; } // //////////////////////////////////////////////////////////////// // Check here if the settings were taken into use // (For functions with a get) switch ( iSavedAction ) { case KSetPriorityLWhenPrepareReady : case KSetPriorityLWhenRecording: case KSetPriorityLWhenControllerReady : { TInt priority; TMdaPriorityPreference pref; iCamc->GetPriorityL(priority, pref); __ASSERT_ALWAYS( priority == EMdaPriorityNormal, User::Leave( KErrGetNotEqualToValuePreviouslySet )); __ASSERT_ALWAYS( pref == EMdaPriorityPreferenceTime, User::Leave( KErrGetNotEqualToValuePreviouslySet )); break; } case KSetVideoFrameRateLWhenPrepareReady : case KSetVideoFrameRateLWhenRecording: case KSetVideoFrameRateLWhenControllerReady : { TReal32 frameRate; frameRate = iCamc->VideoFrameRateL(); __ASSERT_ALWAYS( frameRate == TC2_VIDEO_FRAME_RATE , User::Leave( KErrGetNotEqualToValuePreviouslySet )); break; } case KSetVideoFrameSizeLWhenPrepareReady : // Should have left already case KSetVideoFrameSizeLWhenRecording: // Should have left already User::Panic(_L("Should never come here"),0); break; case KSetVideoFrameSizeLWhenControllerReady : { TSize frameSize; iCamc->GetVideoFrameSizeL( frameSize ); __ASSERT_ALWAYS( frameSize== TC2_VIDEO_FRAME_SIZE , User::Leave( KErrGetNotEqualToValuePreviouslySet )); break; } case KSetVideoFrameSizeLWhenControllerReady_MPEG4 : { TSize cifFrameSize; iCamc->GetVideoFrameSizeL( cifFrameSize ); __ASSERT_ALWAYS( cifFrameSize== TC2_CIF_VIDEO_FRAME_SIZE , User::Leave( KErrGetNotEqualToValuePreviouslySet )); break; } case KSetVideoBitRateLWhenPrepareReady : case KSetVideoBitRateLWhenRecording: case KSetVideoBitRateLWhenControllerReady : { TInt bitRate; bitRate = iCamc->VideoBitRateL(); __ASSERT_ALWAYS( bitRate == TC2_VIDEO_BIT_RATE , User::Leave( KErrGetNotEqualToValuePreviouslySet )); break; } case KSetAudioBitRateLWhenPrepareReady : case KSetAudioBitRateLWhenControllerReady : { TInt bitRate; bitRate = iCamc->AudioBitRateL(); __ASSERT_ALWAYS( bitRate == TC2_AUDIO_BIT_RATE , User::Leave( KErrGetNotEqualToValuePreviouslySet )); break; } case KSetVideoTypeLWhenPrepareReady : // Should have left already case KSetVideoTypeLWhenRecording: // Should have left already User::Panic(_L("Should never come here"),0); break; case KSetVideoTypeLWhenControllerReady : { TPtrC8 videoType = iCamc->VideoFormatMimeType(); TPtrC8 expectedVideoType[TC2_VIDEO_TYPES_ARRAY_LENGTH] = TC2_VIDEO_TYPES_ARRAY ; TBool found = 0; for (TInt i=0; i<TC2_VIDEO_TYPES_ARRAY_LENGTH ; i++) { if ( expectedVideoType[i] == videoType) { found = 1; } } __ASSERT_ALWAYS( found, User::Leave( KErrGetNotEqualToValuePreviouslySet )); break; } case KSetAudioTypeLWhenPrepareReady : // Should have left already case KSetAudioTypeLWhenRecording: // Should have left already User::Panic(_L("Should never come here"),0); break; case KSetAudioTypeLWhenControllerReady : { TFourCC audioType; audioType = iCamc->AudioTypeL(); __ASSERT_ALWAYS( audioType == TC2_AUDIO_TYPE , User::Leave( KErrGetNotEqualToValuePreviouslySet )); break; } default: break; } if (closeCam) { iRecordingReady = EFalse; // Close will panic if called here... iCamc->Close(); CActiveScheduler::Stop(); } } else if ( iPaused ) //resume { iPaused = EFalse; iCamc->Record(); } else //timer { switch ( iAction ) { case KcloseWhenRecording: { iCamc->Close(); iClosed = 1; break; } case KprepareWhenRecording: { // Should leave. iAction = Knone; iCamc->Prepare(); break; } case KrecordWhenRecording: { // Should be ignored iAction = Knone; iCamc->Record(); CTimer::After ( (TInt) 1E6 ); // Wait 1 Second break; } case KSetPriorityLWhenRecording : { iAction = Knone; iCamc->SetPriorityL( EMdaPriorityNormal,EMdaPriorityPreferenceTime ); CTimer::After( iTimeout ); break; } case KSetVideoFrameRateLWhenRecording: { iAction = Knone; iCamc->SetVideoFrameRateL( TReal32( TC2_VIDEO_FRAME_RATE ) ); CTimer::After( iTimeout ); break; } case KSetVideoFrameSizeLWhenRecording : { iCamc->SetVideoFrameSizeL( TC2_VIDEO_FRAME_SIZE ); break; } case KSetVideoBitRateLWhenRecording : { iAction = Knone; iCamc->SetVideoBitRateL( TC2_VIDEO_BIT_RATE ); CTimer::After( iTimeout ); break; } case KSetAudioBitRateLWhenRecording : { iAction = Knone; // Should leave iCamc->SetAudioBitRateL( TC2_AUDIO_BIT_RATE ); // If it has left yet, problem ! User::Leave(KErrCorrupt); CTimer::After( iTimeout ); break; } case KSetAudioEnabledLWhenRecording : { iAction = Knone; iCamc->SetAudioEnabledL( TC2_AUDIO_ENABLED ); CTimer::After( iTimeout ); break; } case KSetMaxClipSizeLWhenRecording: { iAction = Knone; iCamc->SetMaxClipSizeL( 10000 ); CTimer::After( iTimeout ); break; } case KSetVideoTypeLWhenRecording: { iAction = Knone; // Should leave iCamc->SetVideoTypeL( TC2_VIDEO_TYPE ); // If it has left yet, problem ! User::Leave(KErrCorrupt); CTimer::After( iTimeout ); break; } case KSetAudioTypeLWhenRecording: { iAction = Knone; // Should leave iCamc->SetAudioTypeL( TC2_AUDIO_TYPE ); // If it has left yet, problem ! User::Leave(KErrCorrupt); CTimer::After( iTimeout ); break; } default: { iCamc->Stop(); // Simulates that iRecording has been completed through the // MvruoRecordComplete callback iRecordingReady=ETrue; CTimer::After( 1000 ); break; } } } if ( iClosed ) { iCamc->Stop(); CActiveScheduler::Stop(); } }
// ----------------------------------------------------------------------------- // CMceMediaSink::InternalizeFlatL // ----------------------------------------------------------------------------- // void CMceMediaSink::InternalizeFlatL( RReadStream& aReadStream ) { __ASSERT_ALWAYS( iFlatData , User::Leave( KErrNotReady ) ); _FLAT_DATA->InternalizeFlatL( aReadStream ); }
void CSendAsSender::FinalProgress(TMsvSendOperationProgress& aProgress) { __ASSERT_ALWAYS( iState == ESenderDone, User::Invariant() ); aProgress = iFinalProgress; }
// ----------------------------------------------------------------------------- // CSIPProfileRegistryBase::ProfileItemL // ----------------------------------------------------------------------------- // CSIPProfileItem* CSIPProfileRegistryBase::ProfileItemL(TUint aProfileId) { TInt index = ProfileIndex (aProfileId); __ASSERT_ALWAYS (index != KErrNotFound, User::Leave (KErrNotFound)); return ProfileItemByIndex(index); }
EXPORT_C RArray<OMX_IMAGE_CODINGTYPE>& COmxILImagePort::GetSupportedImageFormats() { __ASSERT_ALWAYS(ipImagePortImpl, User::Panic(KOmxILImagePortPanicCategory, 1)); return ipImagePortImpl->GetSupportedImageFormats(); }
void CTestBase::RestartScript() { __ASSERT_ALWAYS(iRestartReqStat!=NULL,User::Panic(_L("T_TsyLb Panic"),1)); TRequestStatus* reqStatus=iRestartReqStat; iScriptThread.RequestComplete(reqStatus,KErrNone); }
EXPORT_C RArray<OMX_COLOR_FORMATTYPE>& COmxILImagePort::GetSupportedColorFormats() { __ASSERT_ALWAYS(ipImagePortImpl, User::Panic(KOmxILImagePortPanicCategory, 1)); return ipImagePortImpl->GetSupportedColorFormats(); }
EXPORT_C TInt TMTPTypeFlatBase::FirstReadChunk(TPtrC8& aChunk) const { __ASSERT_ALWAYS(iBuffer.MaxLength() > 0, Panic(EMTPTypeBadStorage)); aChunk.Set(iBuffer); return KMTPChunkSequenceCompletion; }
EXPORT_C OMX_IMAGE_PARAM_PORTFORMATTYPE& COmxILImagePort::GetParamImagePortFormat() { __ASSERT_ALWAYS(ipImagePortImpl, User::Panic(KOmxILImagePortPanicCategory, 1)); return ipImagePortImpl->GetParamImagePortFormat(); }
const TDesC8& CTestCase9::GetRawRequest(TInt aConnectionIndex, TInt aTransIndex) { __ASSERT_ALWAYS( (aTransIndex<KTransactionCount) && (aConnectionIndex<KConnectionCount), User::Invariant()); return KTxtRawRequest(); }
EXPORT_C OMX_PTR COmxILComponent::GetAppData() const { __ASSERT_ALWAYS(ipImpl, User::Panic(KOmxILComponentPanicCategory, 1)); return ipImpl->GetAppData(); }