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);
	}
Beispiel #6
0
// 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;
			}
		}
	}
Beispiel #8
0
// ---------------------------------------------------------------------------
// InsertedToScene
// ---------------------------------------------------------------------------
//
void CAlfWindow::InsertedToScene(TBool aInserted)
    {
    __ASSERT_ALWAYS( iData, USER_INVARIANT() );
    iData->iIsInScene = aInserted;
    }
Beispiel #9
0
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
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);
}
Beispiel #11
0
// ---------------------------------------------------------------------------
// 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();
}
Beispiel #15
0
// 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());
	}
Beispiel #16
0
// ---------------------------------------------------------------------------
// 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);
	}
Beispiel #18
0
const TDesC8& CINC037440::GetRawResponse(TInt aConnectionIndex, TInt aTransIndex)
	{
	__ASSERT_ALWAYS( (aTransIndex<KTransactionCount) && (aConnectionIndex < KConnectionCount), User::Invariant());

	return KTxtRawResponse();
	}
Beispiel #19
0
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();
    }
Beispiel #29
0
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();
}