TBool CLinePaginatorTest::ReadTestFile(TPageLine& aLine)
{
TLex8 lex;
TBuf8<128> textBuffer;
TBuf8<128> numBuffer;
TInt startNum;
iTestFile.Read(iFilePos,textBuffer,128);
if (textBuffer.Locate('X') != KErrNotFound && textBuffer.Locate('X') < textBuffer.Locate('\r'))
{
startNum=textBuffer.Locate('\n')+1;
textBuffer.Delete(0,startNum);
iFilePos+=startNum;
lex=textBuffer;
lex.Val(aLine.iDocPos);
TBuf<254> buf;
buf.AppendFormat(_L("%d\tX\n"), aLine.iDocPos);
TESTPRINT(buf);
return EFalse;
}
startNum=textBuffer.Locate('\n')+1;
textBuffer.Delete(0,startNum);
iFilePos+=startNum;
lex=textBuffer;
lex.Val(aLine.iDocPos);
startNum=textBuffer.Locate('\t')+1;
textBuffer.Delete(0,startNum);
iFilePos+=startNum;
lex=textBuffer;
lex.Val(aLine.iLineHeight);
startNum=textBuffer.Locate('\t')+1;
textBuffer.Delete(0,startNum);
iFilePos+=startNum;
lex=textBuffer;
lex.Val(aLine.iKeepWithNext);
startNum=textBuffer.Locate('\t')+1;
textBuffer.Delete(0,startNum);
iFilePos+=startNum;
lex=textBuffer;
lex.Val(aLine.iStartNewPage);
if (textBuffer.Locate('\t')<textBuffer.Locate('\r')
&& textBuffer.Locate('B')!=KErrNotFound
&& textBuffer.Locate('B')<textBuffer.Locate('\r'))
iTestPageBreak=ETrue;
else
iTestPageBreak=EFalse;
iFilePos+=textBuffer.Locate('\r')+1;
return ETrue;
}
/**
* Convert a string to Hexadecimal
*
* @param aData String descriptor
* @param aDes Descriptor where Hex value is stored
*
* @return N/A
*
* @leave System wide error
*/
void CT_DataVerify::ConvertString2HexL( const TDesC8& aData, TDes8& aDes )
{
TBuf8<DataVerify::KCharlength> charBuf;
// Check that buffer is even number
if( ( aData.Length() % DataVerify::KCharlength ) != 0 )
{
User::Leave( KErrBadDescriptor );
}
// Go through the data and convert it two characters at a time
// buffer overflow does not occur because buffer is checked to be even number first
for( TInt i = 0, limit = aData.Length()-DataVerify::KCharlength; i <= limit; i+=DataVerify::KCharlength )
{
// Clean char buffer first
charBuf.Delete( 0, charBuf.Length() );
// Add KCharlength characters into buffer
for ( TInt j = 0; j < DataVerify::KCharlength; j++ )
{
charBuf.Append( aData[i+j] );
}
TUint number;
TLex8 converter = TLex8( charBuf );
// Two characters together represent a hex number in MD5 checksum
User::LeaveIfError( converter.Val( number, EHex ) );
aDes.Append( number );
}
}
// ----------------------------------------------------------------------------------------
// CTerminalControlServer::FindLocalProcessInfoL
// ----------------------------------------------------------------------------------------
CTerminalControlServer::TTcProcessInfo CTerminalControlServer::FindLocalProcessInfoL ( const TDesC8 &aProcessName )
{
RDEBUG("CTerminalControlServer::FindLocalProcessInfoL");
TInt processCount = iProcessInfoArray->Count();
if(processCount == 0)
{
User::Leave( KErrNotFound );
}
if(aProcessName.Length() < KFormatProcessNamePrefix().Length()+1)
{
User::Leave(KErrNotFound);
}
if(aProcessName.Left( KFormatProcessNamePrefix().Length() ).Compare(KFormatProcessNamePrefix) != KErrNone)
{
User::Leave(KErrNotFound);
}
//
// Get process index from the name
//
TInt index;
TLex8 lex;
lex.Assign( aProcessName );
lex.Inc( KFormatProcessNamePrefix().Length() );
User::LeaveIfError( lex.Val(index) );
index --;
if(index < 0 || index >= processCount)
{
User::Leave( KErrNotFound );
}
return iProcessInfoArray->At(index);
}
void CSenBaseIdentityManager::CleanupUnusedIdentityDBL()
{
TInt count(0);
RPointerArray<CSenElement> elemList;
CleanupClosePushL(elemList);
CSenElement& element = iIdentity->AsElement();
element.ElementsL(elemList, KIdentityProvider);
count = elemList.Count();
// There can be many Identity Provider elements within Identity element
for(TInt i = 0; i < count; i++)
{
CSenElement* elem = elemList[i];
const TDesC8* attrValue = elem->AttrValue(KTouch());
if(attrValue != NULL)
{
TUint32 current_tick(0);
TUint32 db_ticks(0);
TUint32 diff_ticks(0);
TLex8 lex;
lex.Assign(*attrValue);
lex.Val(db_ticks, EDecimal);
current_tick = User::NTickCount();
diff_ticks = current_tick - db_ticks;
if(KMaxTicks <= diff_ticks || current_tick < db_ticks)
{
TInt endpointCount(0);
_LIT8(KEndpoint, "Endpoint");
RPointerArray<CSenElement> endpointElemList;
CleanupClosePushL(endpointElemList);
elem->ElementsL(endpointElemList, KEndpoint);
endpointCount = endpointElemList.Count();
if(endpointCount > 0)
{
CSenIdentityProvider* pMatch = NULL;
CSenElement* endpointElem = endpointElemList[0];
TPtrC8 endpoint = endpointElem->Content();
pMatch = IdentityProviderL(endpoint);
if(pMatch != NULL)
{
// Ownership ?
UnregisterIdentityProviderL(*pMatch);
}
}
CleanupStack::PopAndDestroy(&endpointElemList);
}
}
}
CleanupStack::PopAndDestroy(&elemList);
}
// ----------------------------------------------------------------------------------------
// CTerminalControlServer::StartProcessByUidL
// ----------------------------------------------------------------------------------------
void CTerminalControlServer::StartProcessByUidL ( const TDesC8& aUID )
{
RDEBUG("CTerminalControlServer::StartProcessByUidL2");
TLex8 lex;
lex.Assign( aUID );
TInt64 uid_value;
User::LeaveIfError( lex.Val( uid_value) );
StartProcessByUidL( TUid::Uid( uid_value ) );
}
TBool CSmfCredMgrClientSymbian::isPluginAuthenticatedL(QString PluginID)
{
CBufFlat* buf = CBufFlat::NewL(KMinBufSize);
CleanupStack::PushL(buf);
RBufWriteStream stream(*buf);
CleanupClosePushL(stream);
TPtr idPtr(qt_QString2HBufC(PluginID)->Des());
SmfUtils::ExternalizeDesL(idPtr, stream);
stream.CommitL();
// to get the data from server, we create a space.
HBufC8* retBuf = HBufC8::NewL(32);
CleanupStack::PushL(retBuf);
TPtr8 bufPtr = buf->Ptr(0);
TPtr8 flag(retBuf->Des());
TIpcArgs args;
args.Set(0, &bufPtr);
args.Set(1, &flag);
iSession.RequestService(ECheckPluginAuthentication, args);
TLex8 iLex = TLex8(flag);
TInt value = 0;
iLex.Val(value);
CleanupStack::PopAndDestroy(retBuf);
CleanupStack::PopAndDestroy(&stream);
CleanupStack::PopAndDestroy(buf);
if (value)
{
RDebug::Printf("flag returned is ETrue");
return ETrue;
}
else
{
RDebug::Printf("flag returned is EFalse");
return EFalse;
}
}
OMX_ERRORTYPE
CBellagioOpenMaxSymbianLoader::GetRolesOfComponent(OMX_STRING compName,
OMX_U32 *pNumRoles,
OMX_U8 **roles)
{
TInt index = 0;
index = GetInfoIndex(compName);
if (index < 0)
{
return OMX_ErrorComponentNotFound;
}
TLex8 lexer = TLex8((componentInfos[index])->OpaqueData());
lexer.Val((TUint32 &)(*pNumRoles), EDecimal);
if((*pNumRoles) == 0)
{
return OMX_ErrorNone;
}
// check if client is asking only for the number of roles
if (roles == NULL)
{
return OMX_ErrorNone;
}
// TODO We copy only one role here and there might be several of those
TBuf8<257> role;
TBufC8<1> endOfString((TText8*)"\0");
role.Append((componentInfos[index])->DataType());
role.Append(endOfString);
strcpy((char*)roles[0], (char*)role.Ptr());
return OMX_ErrorNone;
}
// -----------------------------------------------------------------------------
// CMccCodecInformation::ParseFmtpAttr
// Parses the fmtp attribute
// -----------------------------------------------------------------------------
//
TBool CMccCodecRed::ParseFmtpAttrL( const TDesC8& aFmtp )
{
// Parse codecs used for primary and secondary etc. codecs from the
// fmtp attribute
// example fmtp attribute:
// a=fmtp:99 0/103
// 99 is the redundancy format payload type
// 0 is the primary codecs payload type
// 103 is the secondary codecs payload type
// NOTE: currently redundancy is allowed only for single payload type
TBool updated( EFalse );
TInt nextIndex = 0;
TInt prevIndex = 0;
TUint8 prevPayloadFormat = KMccPayloadTypeMax;
HBufC8* modifyBuf = HBufC8::NewLC( aFmtp.Length() );
TPtr8 pFmtpValue( modifyBuf->Des() );
pFmtpValue = aFmtp;
if( aFmtp.Length() > 0 )
{
// Search for all the slashes and convert number strings between them
// to integers
TBool found = ETrue;
while( EFalse != found )
{
pFmtpValue = modifyBuf->Mid( nextIndex );
nextIndex = pFmtpValue.Locate( KCharSlash );
if( ( KErrNotFound == nextIndex ) )
{
found = EFalse;
if( 0 != pFmtpValue.Length() )
{
nextIndex = pFmtpValue.Length(); // Handle last payload value
}
}
if( 0 != pFmtpValue.Length() )
{
TLex8 lex = pFmtpValue.Mid( prevIndex, (nextIndex - prevIndex) );
TUint8 payloadFormat;
TInt err = lex.Val( payloadFormat, EDecimal );
if( KErrNone == err )
{
if ( prevPayloadFormat != KMccPayloadTypeMax &&
prevPayloadFormat != payloadFormat )
{
iRedPayloads.Reset();
User::Leave( KErrNotSupported );
}
iRedPayloads.AppendL( static_cast<TUint>( payloadFormat ) );
updated = ETrue;
prevPayloadFormat = payloadFormat;
}
nextIndex++;
prevIndex = 0;
}
}
}
CleanupStack::PopAndDestroy( modifyBuf );
return updated;
}
inline void CPppMsChap::ProcessFailureMessageL(
const TDesC8& aFailureMessage,
TUint& aErrorCode,
TUint8& aRetryFlag,
TBool& aHasNewChallenge,
TDes8& aChallenge,
TUint8& aPasswordProtoVersion)
/**
Processes a MS-CHAP Failure Message.
@param aFailureMessage [in] A MS-CHAP Failure Message. The Failure
Message needs to be in the format specified in RFC 2433:
"E=eeeeeeeeee R=r C=cccccccccccccccc V=vvvvvvvvvv".
@param aErrorCode [out] The MS-CHAP Failure error code.
@param aRetryFlag [out] The retry flag. The flag will be set to
"1" if a retry is allowed, and "0" if not. When the authenticator
sets this flag to "1" it disables short timeouts, expecting the
peer to prompt the user for new credentials and resubmit the
response.
@param aHasNewChallenge [out] The flag that indicates if the
Failure Message contains a new Challenge Value.
@param aChallenge [out] The new Challenge Value, if the Failure
Message contains a one.
@param aPasswordProtoVersion [out] The password changing protocol
supported by the peer.
@internalComponent
*/
{
ASSERT(aChallenge.Length() == KPppMsChapChallengeSize);
TLex8 input(aFailureMessage);
if (input.Get() != 'E')
User::Leave(KErrGeneral);
if (input.Get() != '=')
User::Leave(KErrGeneral);
// RFC 2433: ""eeeeeeeeee" is the ASCII representation of a decimal
// error code (need not be 10 digits) corresponding to one of those
// listed below, though implementations should deal with codes not on
// this list gracefully."
TInt ret;
if ((ret = input.Val(aErrorCode)) != KErrNone)
if (ret != KErrOverflow)
User::Leave(KErrGeneral);
else
// Gracefully handle unusually large, yet valid, MS-CHAP specific
// error code values. This code only handles the MS-CHAP specific
// error code values specified in RFC 2433.
aErrorCode=0;
input.SkipSpace();
if (input.Get() != 'R')
User::Leave(KErrGeneral);
if (input.Get() != '=')
User::Leave(KErrGeneral);
if (input.Val(aRetryFlag, EDecimal)!=KErrNone)
User::Leave(KErrGeneral);
input.SkipSpace();
switch (input.Get())
{
case 'C':
{
if (input.Get() != '=')
User::Leave(KErrGeneral);
TPtrC8 token(input.NextToken());
// This field is 16 hexadecimal digits representing an ASCII
// representation of a new challenge value. Each octet is represented
// in 2 hexadecimal digits.
if (token.Length() != KPppMsChapChallengeSize*2)
User::Leave(KErrGeneral);
TLex8 lex;
TUint8 octet;
TUint8* pChallengeOctet =
const_cast<TUint8*>(aChallenge.Ptr());
TUint8 i = 0;
do
{
lex.Assign(token.Mid(i*2, 2));
if (lex.Val(octet, EHex) != KErrNone)
User::Leave(KErrGeneral);
*(pChallengeOctet + i) = octet;
}
while (++i < KPppMsChapChallengeSize);
aHasNewChallenge = ETrue;
input.SkipSpace();
if (input.Get()!='V')
{
aPasswordProtoVersion = 1;
User::Leave(KErrGeneral);
}
}
// As specified in RFC 2433, the field containing the ASCII
// representation of a new challenge value is optional, so fall
// through.
case 'V':
// RFC 2433: "The "vvvvvvvvvv" is the decimal version code (need not
// be 10 digits) indicating the MS-CHAP protocol version supported on
// the server. Currently, this is interesting only in selecting a
// Change Password packet type. If the field is not present the
// version should be assumed to be 1; since use of the version 1
// Change Password packet has been deprecated, this field SHOULD
// always contain a value greater than or equal to 2."
aHasNewChallenge = EFalse;
if (input.Get() != '=')
User::Leave(KErrGeneral);
if ((ret=input.Val(aPasswordProtoVersion,
EDecimal)) != KErrNone)
if (ret!= KErrOverflow)
User::Leave(KErrGeneral);
else
// Gracefully handle unusually large, yet valid, password changing
// protocol version values. This code only handles the password
// changing protocol version codes values specified in RFC 2433.
aPasswordProtoVersion = 0;
break;
default:
aHasNewChallenge = EFalse;
aPasswordProtoVersion = 1;
}
}
// ---------------------------------------------------------------------------
// Received a response header
// ---------------------------------------------------------------------------
//
void CCatalogsHttpTransaction::ResponseHeaderReceived( const TDesC8& aHeader,
const TDesC8& aValue )
{
DLTRACEIN( ("") );
DASSERT( iObserver );
TRAPD( err, iResponseHeaders->AddHeaderL( aHeader, aValue ) );
if ( err != KErrNone )
{
HandleHttpError( ECatalogsHttpErrorGeneral, err );
return;
}
iState.iOperationState = ECatalogsHttpOpInProgress;
iState.iProgressState = ECatalogsHttpResponseHeaderReceived;
if ( aHeader.CompareF( KHttpContentRangeHeader ) == 0 )
{
//
// Content-Range, bytes x-y/z
// Extract 'z' and use it as the total content length
//
TPtrC8 ptr( aValue );
TInt offset = ptr.Locate( '/' );
if ( offset != KErrNotFound )
{
TLex8 val;
val.Assign( ptr.Mid( offset + 1 ) );
TInt value;
TInt err = val.Val( value );
if ( err == KErrNone )
{
iContentLength = value;
DLTRACE(( "Content length: %i", iContentLength ));
}
}
}
else if ( aHeader.CompareF( KHttpContentLengthHeader ) == 0 )
{
//
// If content length for this request has not been already set
// e.g. from a Content-Range header, extract from Content-Length header
//
if ( iContentLength == 0 )
{
TLex8 val;
val.Assign( aValue );
TInt value;
TInt err = val.Val( value );
if ( err == KErrNone )
{
iContentLength = value;
DLTRACE(( "Content length: %i", iContentLength ));
}
}
else
{
DLTRACE(( "-> ContentLength set, ignoring" ));
}
}
else if ( aHeader.CompareF( KHttpContentTypeHeader ) == 0 )
{
// Content type from the header
DLTRACE( ( "Content type received" ) );
TRAPD( err, SetContentTypeL( aValue ) );
if ( err != KErrNone )
{
DLTRACE( ( "Content type setting failed with err: %i",
err ) );
HandleHttpError( ECatalogsHttpErrorGeneral, err );
return;
}
else
{
iState.iProgressState = ECatalogsHttpContentTypeReceived;
}
}
// Report the observer that a header has been received
NotifyObserver();
}
inline void CPppMsChap2::ProcessFailureMessageL(
const TDesC8& aFailureMessage,
TUint& aErrorCode,
TUint8& aRetryFlag,
TDes8& aAuthChallenge,
TUint8& aPasswordProtoVersion,
TPtrC8& aMessage)
/**
Processes a MS-CHAP-V2 Failure Message.
@param aFailureMessage [in] A MS-CHAP-V2 Failure Message. The
Failure Message needs to be in the format specified in RFC 2759:
"E=eeeeeeeeee R=r C=cccccccccccccccccccccccccccccccc V=vvvvvvvvvv
M=<msg>".
@param aErrorCode [out] The MS-CHAP-V2 Failure error code.
@param aRetryFlag [out] The retry flag. The flag will be set to
"1" if a retry is allowed, and "0" if not. When the authenticator
sets this flag to "1" it disables short timeouts, expecting the
peer to prompt the user for new credentials and resubmit the
response.
@param aAuthChallenge [out] The new Authenticator Challenge Value.
@param aPasswordProtoVersion [out] The password changing protocol
supported by the peer.
@param aMessage [out] A failure text message.
@internalComponent
*/
{
ASSERT(aAuthChallenge.Length() ==
KPppMsChap2AuthenticatorChallengeSize);
TLex8 input(aFailureMessage);
if (input.Get() != 'E')
User::Leave(KErrGeneral);
if (input.Get() != '=')
User::Leave(KErrGeneral);
// RFC 2759: ""eeeeeeeeee" is the ASCII representation of a decimal
// error code (need not be 10 digits) corresponding to one of those
// listed below, though implementations should deal with codes not on
// this list gracefully."
TInt ret;
if ((ret = input.Val(aErrorCode))!=KErrNone)
if (ret!= KErrOverflow)
User::Leave(KErrGeneral);
else
// Gracefully handle unusually large, yet valid, MS-CHAP-V2 specific
// error code values. This code only handles the MS-CHAP-V2 specific
// error code values specified in RFC 2759.
aErrorCode=0;
input.SkipSpace();
if (input.Get() != 'R')
User::Leave(KErrGeneral);
if (input.Get() != '=')
User::Leave(KErrGeneral);
if (input.Val(aRetryFlag, EDecimal)!=KErrNone)
User::Leave(KErrGeneral);
input.SkipSpace();
if (input.Get() != 'C')
User::Leave(KErrGeneral);
if (input.Get() != '=')
User::Leave(KErrGeneral);
TPtrC8 token(input.NextToken());
// This field is 32 hexadecimal digits representing an ASCII
// representation of a new challenge value. Each octet is represented
// in 2 hexadecimal digits.
if (token.Length() != KPppMsChap2AuthenticatorChallengeSize*2)
User::Leave(KErrGeneral);
TLex8 lex;
TUint8 octet;
TUint8* pChallengeOctet =
const_cast<TUint8*>(aAuthChallenge.Ptr());
TUint8 i = 0;
do
{
lex.Assign(token.Mid(i*2, 2));
if (lex.Val(octet, EHex) != KErrNone)
User::Leave(KErrGeneral);
*(pChallengeOctet + i) = octet;
}
while (++i < KPppMsChap2AuthenticatorChallengeSize);
input.SkipSpace();
if (input.Get() != 'V')
User::Leave(KErrGeneral);
if (input.Get() != '=')
User::Leave(KErrGeneral);
// RFC 2759: "The "vvvvvvvvvv" is the ASCII representation of a
// decimal version code (need not be 10 digits) indicating the
// password changing protocol version supported on the server. For
// MS-CHAP-V2, this value SHOULD always be 3."
if ((ret = input.Val(aPasswordProtoVersion, EDecimal)) !=
KErrNone)
if (ret != KErrOverflow)
User::Leave(KErrGeneral);
else
// Gracefully handle unusually large, yet valid, password changing
// protocol version values. This code only handles the password
// changing protocol version values specified in RFC 2759.
aPasswordProtoVersion=0;
input.SkipSpace();
switch (input.Get())
{
case 'M':
if (input.Get() != '=')
User::Leave(KErrGeneral);
aMessage.Set(input.NextToken());
break;
case 0:
break;
default:
User::Leave(KErrGeneral);
}
ASSERT(aAuthChallenge.Length() ==
KPppMsChap2AuthenticatorChallengeSize);
}
// -----------------------------------------------------------------------------
// CSeiForwardPlugin::HandleNotifyL
//
// -----------------------------------------------------------------------------
//
void CSeiForwardPlugin::HandleNotifyL( const CEcmtMessageEvent& aEvent )
{
const TPtrC8 m = iMessaging->Message( aEvent );
TLex8 lexer( m );
TPtrC8 type = lexer.NextToken();
TPtrC8 channelStr = lexer.NextToken();
TLex8 num ( channelStr );
TInt channel;
// Check message type
if ( ( type != KConnect ) &&
( type != KListen ) &&
( type != KMsg ) )
{
RDebug::Print( _L( "EcmtSeiForwardPlugin: Invalid message" ) );
return;
}
// Get channel number
if ( num.Val( channel ) )
{
RDebug::Print( _L( "EcmtSeiForwardPlugin: Invalid channel" ) );
return;
}
// Process message
if ( type == KConnect )
{
TPtrC8 portStr = lexer.NextToken();
TInt port;
num.Assign ( portStr );
// Get port number
if ( num.Val( port ) )
{
RDebug::Print( _L( "EcmtSeiForwardPlugin: Invalid port" ) );
return;
}
ConnectL( channel, port );
}
else if ( type == KListen )
{
ListenL( channel );
}
else if ( type == KMsg )
{
// Now this just sends the message back to the Java plug-in.
// Instead, should cancel the appropriate socket read and write
// the message to the socket.
TPtrC8 msg = lexer.Remainder();
SendMessageL( channel, msg );
}
}
/**
* After the player has received the update after the last iteration of the game.
* We want to display the current game status, if there is only one player remaining then
* the game has finished.
*/
void CScabbyQueenPlayer::ReceiveNextRole()
{
if (iPlayerUpdate == iGameOverBuffer)
{
iConsole.Printf(_L("\nDealer Says: GAME OVER"));
}
else
{
// Break down the update descriptor and display the result
TBufC<20> buffer;
buffer.Des().Copy(iPlayerUpdate);
iConsole.Printf(_L("\n\nUpdate from the dealer...%S\n"), &buffer);
TInt position;
TPtrC8 ptr(iPlayerUpdate);
TLex8 lex;
TInt player;
TBool stillIn = EFalse;
iConsole.Printf(_L("\n Number of players: %d\n"), iPlayerUpdate.Length()-1);
TInt stillInCount = 0;
for (TInt i=0; i<iPlayerUpdate.Length();i++)
{
TChar inspect = ptr[i];
if (inspect != 'F')
{
TBuf8<2> buff;
buff.Append(inspect);
lex.Assign(buff);
lex.Val(player);
if (stillIn)
{
TBufC16<2> buff;
buff.Des().Append(inspect);
iConsole.Printf(_L("\n Player %S still in play"), &buff);
stillInCount++;
}
else
{
position = i+1;
if (i == 0)
{
iConsole.Printf(_L("\n The winner is player %d"), player);
}
else
{
iConsole.Printf(_L("\n In position %d is player %d"), position, player);
}
}
}
else
{
stillIn = ETrue;
}
}
if (stillInCount == 1)
{
// If there is only one player left the game is over.
iGameOver = ETrue;
iConsole.Printf(_L("\nThe loser is player %d, give them a smack"), player);
iConsole.Printf(_L("\n\nDealer Says: GAME OVER"));
}
iGameStatus = EReadyForToken;
iSendMode = ESendReadyForToken;
BaseSendTo(iGameStatus, KDealerIpAddr);
}
}
TInt CReceiveStoredSms::SendSms(TBool aQuiet, RMobileSmsMessaging& aSms)
/**
* SendSms test.
*/
{
if(!aQuiet)
INFO_PRINTF1(_L("Sending SMS."));
// Create message PDU and convert to binary
TBuf8<400> msgData;
TLex8 lex;
TUint8 val;
TInt i;
TInt ret;
msgData.Zero();
const TInt count_before((&KMsgDataBeforeTargetAddress)->Length()/2); // Assume length of pdu is always even
for(i=0;i<count_before;++i)
{
lex=(&KMsgDataBeforeTargetAddress)->Mid(i*2,2);
ret = lex.Val(val,EHex);
if(ret) return ret;
msgData.Append(TChar(val));
}
TBuf8<20> targetAddressAscii;
targetAddressAscii.Zero();
RMobilePhone::TMobileAddress targetAddress;
targetAddress.iTypeOfNumber=RMobilePhone::EInternationalNumber;
targetAddress.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
targetAddress.iTelNumber.Copy(iTelNumber);
ret = CATSmsUtils::AppendAddressToAscii(targetAddressAscii,targetAddress);
if(ret) return ret;
const TInt count_address(targetAddressAscii.Length()/2); // Assume length is always even
for(i=0;i<count_address;++i)
{
lex=targetAddressAscii.Mid(i*2,2);
ret = lex.Val(val,EHex);
if(ret) return ret;
msgData.Append(TChar(val));
}
const TInt count_after((&KMsgDataAfterTargetAddress)->Length()/2); // Assume length of pdu is always even
for(i=0;i<count_after;++i)
{
lex=(&KMsgDataAfterTargetAddress)->Mid(i*2,2);
ret = lex.Val(val,EHex);
if(ret) return ret;
msgData.Append(TChar(val));
}
// Create message attibutes
RMobileSmsMessaging::TMobileSmsSendAttributesV1 msgAttr;
msgAttr.iFlags=0x184;
msgAttr.iDataFormat=RMobileSmsMessaging::EFormatGsmTpdu;
msgAttr.iGsmServiceCentre.iTypeOfNumber=RMobilePhone::EInternationalNumber;
msgAttr.iGsmServiceCentre.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
msgAttr.iGsmServiceCentre.iTelNumber.Copy(iSCANumber);
// Package up data ready for sending to etel
RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg msgAttrPkg(msgAttr);
// Send the message, try upto 3 times if phone is not ready
TRequestStatus status;
INFO_PRINTF1(_L(".."));
TSmsPdu smsPduSent;
smsPduSent.Copy(KTestSendPduA,sizeof(KTestSendPduA));
aSms.SendMessage(status,smsPduSent,msgAttrPkg);
User::WaitForRequest(status);
if(status==KErrGsmSMSFailureInME || status==KErrGeneral || status==KErrGsmSMSUnknownError)
{
INFO_PRINTF1(_L(".."));
aSms.SendMessage(status,smsPduSent,msgAttrPkg);
User::WaitForRequest(status);
if(status==KErrGsmSMSFailureInME || status==KErrGeneral || status==KErrGsmSMSUnknownError)
{
INFO_PRINTF1(_L(".."));
aSms.SendMessage(status,smsPduSent,msgAttrPkg);
User::WaitForRequest(status);
}
}
ret = status.Int();
if(ret) return ret;
// Validate message reference number has changed
if(!(msgAttr.iFlags&RMobileSmsMessaging::KMessageReference))
{
return(KErrCorrupt);
}
if(!aQuiet)
{
INFO_PRINTF1(_L("test(s) passed"));
}
return(KErrNone);
}
TVerdict CSendSmsAndCancel::doTestStepL( void )
{
TInt i;
TRequestStatus status;
INFO_PRINTF1(_L("Sending SMS and cancelling."));
// Create message PDU and convert to binary
_LIT8(KMsgDataBeforeTargetAddress,"1d00");
_LIT8(KMsgDataAfterTargetAddress,"01A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A001A0");
TBuf8<400> msgData;
TLex8 lex;
TUint8 val;
msgData.Zero();
const TInt count_before((&KMsgDataBeforeTargetAddress)->Length()/2); // Assume length of pdu is always even
for(i=0;i<count_before;++i)
{
lex=(&KMsgDataBeforeTargetAddress)->Mid(i*2,2);
TESTL(KErrNone == lex.Val(val,EHex));
msgData.Append(TChar(val));
}
TBuf8<20> targetAddressAscii;
targetAddressAscii.Zero();
RMobilePhone::TMobileAddress targetAddress;
targetAddress.iTypeOfNumber=RMobilePhone::EInternationalNumber;
targetAddress.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
targetAddress.iTelNumber.Copy(iTelNumber);
TInt ret = CATSmsUtils::AppendAddressToAscii(targetAddressAscii,targetAddress);
if(ret) return(EFail);
const TInt count_address(targetAddressAscii.Length()/2); // Assume length is always even
for(i=0;i<count_address;++i)
{
lex=targetAddressAscii.Mid(i*2,2);
lex.Val(val,EHex);
msgData.Append(TChar(val));
}
const TInt count_after((&KMsgDataAfterTargetAddress)->Length()/2); // Assume length of pdu is always even
for(i=0;i<count_after;++i)
{
lex=(&KMsgDataAfterTargetAddress)->Mid(i*2,2);
lex.Val(val,EHex);
msgData.Append(TChar(val));
}
// Create message attibutes
RMobileSmsMessaging::TMobileSmsSendAttributesV1 msgAttr;
msgAttr.iFlags=0x184;
msgAttr.iDataFormat=RMobileSmsMessaging::EFormatGsmTpdu;
msgAttr.iGsmServiceCentre.iTypeOfNumber=RMobilePhone::EInternationalNumber;
msgAttr.iGsmServiceCentre.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
msgAttr.iGsmServiceCentre.iTelNumber.Copy(iSCANumber);
// Package up data ready for sending to etel
RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg msgAttrPkg(msgAttr);
// Send the message
INFO_PRINTF1(_L(".."));
TSmsPdu smsPduSent;
smsPduSent.Copy(KTestSendPduA,sizeof(KTestSendPduA));
iSms.SendMessage(status,smsPduSent,msgAttrPkg);
// Wait for a bit
User::After(KOneSecond*2);
// Cancel sending, then wait for sending operation to complete
iSms.CancelAsyncRequest(EMobileSmsMessagingSendMessage);
//if(status==KRequestPending)
User::WaitForRequest(status);
ret=KErrNone;
if(status!=KErrCancel && status!=KErrNone)
ret=status.Int();
else
INFO_PRINTF1(_L("TESTL(s) passed")); // If we don't cause a panic or leave the test has passed
/* iSms.Close();
iPhone->Close();
User::After(500000L);
iPhone.Open(iTelServer,GSM_NAME);
iSms.Open(iPhone);
*/
return TestStepResult();
}
TInt CProfilerPowerListener::StartL(const TDesC8& aBuf)
{
LOGTEXT(_L("CProfilerPowerListener::StartL() - entry"));
// get the property value
TInt r = RProperty::Get(KGppPropertyCat, EGppPropertySyncSampleNumber, iSampleStartTime);
if(r != KErrNone)
{
LOGSTRING2("CProfilerPowerListener::StartL() - getting iSyncOffset failed, error %d", r);
}
// check if given sampling period is valid
if(aBuf.CompareF(KNullDesC8)!= 0)
{
TLex8* lex = new TLex8(aBuf);
lex->Val(iPwrSamplingPeriod);
delete lex;
}
else
{
// set default period
iPwrSamplingPeriod = 250;
}
// Check that sampling period is in allowed range
if (KMinSampleInterval > 0 && iPwrSamplingPeriod < KMinSampleInterval)
{
iPwrSamplingPeriod = KMinSampleInterval;
}
LOGSTRING2("CProfilerPowerListener::StartL() - Sampling period %d", iPwrSamplingPeriod);
// Start monitoring voltage and current
iPowerAPI = CHWRMPower::NewL();
iPowerAPI->SetPowerReportObserver(this);
// Read HWRM reporting settings from central repository
CRepository* centRep = CRepository::NewL(KCRUidPowerSettings);
TInt baseInterval(0);
User::LeaveIfError(centRep->Get(KPowerBaseTimeInterval, baseInterval));
User::LeaveIfError(centRep->Get(KPowerMaxReportingPeriod, iOriginalReportingPeriod));
LOGSTRING2("CProfilerPowerListener::StartL() - HWRM base power report interval: %d", baseInterval);
LOGSTRING2("CProfilerPowerListener::StartL() - Original HWRM max power reporting period: %d", iOriginalReportingPeriod);
User::LeaveIfError(centRep->Set(KPowerMaxReportingPeriod, KReportingPeriodInfinite));
// Power reporting interval reading may return too low value sometimes. Minimum value expected to be 250ms.
if ( baseInterval < KMinSampleInterval )
{
baseInterval = KMinSampleInterval;
LOGSTRING2("CProfilerPowerListener::StartL() - Power report interval too low. Changed to: %d", baseInterval);
}
// Power reporting period is multiplier of HWRM base period
TInt intervalMultiplier = iPwrSamplingPeriod / baseInterval;
if (intervalMultiplier < 1)
{
intervalMultiplier = 1;
}
LOGSTRING2("CProfilerPowerListener::StartL() - Reporting period multiplier: %d", intervalMultiplier);
TRequestStatus status(KRequestPending);
iPowerAPI->StartAveragePowerReporting(status, intervalMultiplier);
User::WaitForRequest(status);
if (status.Int() != KErrNone)
{
LOGTEXT(_L("CProfilerPowerListener::StartL() - Failed to initialize power reporting"));
DisplayNotifierL(KPowerTextLine1, KPowerTextLine2, KButtonOk, KNullDesC);
return status.Int();
}
#ifdef PWR_SAMPLER_BACKLIGHT
// Start monitoring backlight status
iLightAPI = CHWRMLight::NewL(this);
#endif
LOGTEXT(_L("CProfilerPowerListener::StartL() - exit"));
return KErrNone;
}
