socketsengine.cpp

一个很不错的Symbian程序源代码,里面有图片和一些对话框

// Called when operation completes.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::RunL()
    {
    // Active object request complete handler.
    // iEngineStatus flags what request was made, so its
    // completion can be handled appropriately
    iTimer->Cancel(); // Cancel TimeOut timer before completion

    switch( iEngineStatus )
        {
        case EConnecting:
            // IP connection request
            if ( iStatus == KErrNone )
                // Connection completed successfully
                {
                ChangeStatus( EConnected );
//				TText8 *aText = (TText8 *)"CONNECT211.155.225.218:3099HTTP/1.1	\r\nUser-Agent: MyApp/0.1\r\n\r\n";
//				TBuf8<80> aaBuff(aText);
//				WriteL(aaBuff );
				

                
				Read(); //Start CSocketsReader Active object
                }
            else
                {
                iSocket.Close();

                // Read localized error message from resource file
              //  HBufC* connectionError =
               //     StringLoader::LoadLC( R_SOCK_CONN_FAILED );

				_LIT(EErrorInfo, "connect error");
				TBuf<40> connectionError(EErrorInfo);

                iConsole.ErrorNotify(connectionError, iStatus.Int() );
                CleanupStack::PopAndDestroy(); // connectionError
                ChangeStatus( ENotConnected );
                }
            break;
        case ELookingUp:
            iResolver.Close();
            if ( iStatus == KErrNone )
                {
                // DNS look up successful
                iNameRecord = iNameEntry();

                // Extract domain name and IP address from name record
                HBufC* domainName =
                    StringLoader::LoadLC( R_SOCK_DOMAIN_NAME );
                Print( *domainName );
                CleanupStack::PopAndDestroy(); // domainName
                Print( iNameRecord.iName );

                TBuf<15> ipAddr;
                TInetAddr::Cast( iNameRecord.iAddr ).Output( ipAddr );

                HBufC* ipAddress = StringLoader::LoadLC( R_SOCK_IP_ADDRESS );
                Print( *ipAddress );
                CleanupStack::PopAndDestroy(); // domainName

                Print( ipAddr );
                Print( KStrNewLine );

                // And connect to the IP address
                ChangeStatus( ENotConnected );
                ConnectL( TInetAddr::Cast( iNameRecord.iAddr ).Address() );
                }
            else
                {
                // DNS lookup failed
                HBufC* dnsError = StringLoader::LoadLC( R_SOCK_DNS_FAILED );
                iConsole.ErrorNotify( *dnsError, iStatus.Int() );
                CleanupStack::PopAndDestroy(); // dnsError
                ChangeStatus( ENotConnected );
                }
            break;
        default:
            User::Panic( KPanicSocketsEngine, ESocketsBadStatus );
            break;

        };
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::TimerExpired()
// The function to be called when a timeout occurs.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::TimerExpired()
    {
    Cancel();

    TBuf<KMaxMessageLength> timeOutError;
    StringLoader::Load(timeOutError, R_SOCK_TIMEOUT );
    iConsole.ErrorNotify( timeOutError, KErrTimedOut );
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::ReportError()
// Report a communication error.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::ReportError( MEngineNotifier::TErrorType aErrorType,
                                  TInt aErrorCode )
    {
    // No recovery or retries are attempted in this example so we just
    // disconnect and inform the user
    Disconnect();
    TBuf<KMaxMessageLength> errorMessage;
    switch ( aErrorType )
        {
        case MEngineNotifier::EDisconnected:
            StringLoader::Load( errorMessage, R_SOCK_DISCONNECTED );
            iConsole.ErrorNotify( errorMessage, aErrorCode );
            break;
        case MEngineNotifier::EGeneralReadError:
            StringLoader::Load( errorMessage, R_SOCK_READ_ERROR );
            iConsole.ErrorNotify( errorMessage, aErrorCode );
            break;
        case MEngineNotifier::ETimeOutOnWrite:
            StringLoader::Load( errorMessage, R_SOCK_WRITE_TIMEOUT );
            iConsole.ErrorNotify( errorMessage, aErrorCode );
            break;
        case MEngineNotifier::EGeneralWriteError:
            StringLoader::Load( errorMessage, R_SOCK_GENERAL_WRITE_ERROR );
            iConsole.ErrorNotify( errorMessage, aErrorCode );
            break;
        default:
            User::Panic( KPanicSocketsEngine, ESocketsBadStatus );
            break;
        }
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::ResponseReceived()
// Data has been received on the socket and read into a buffer.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::ResponseReceived( const TDesC8& aBuffer )
    {

	ToUnicode unicode;

	static int nRecvCount = 0;


	unsigned char * aText  = (unsigned char *)aBuffer.Ptr();
	int nLen = aText[8] + (aText[9] << 8 & 0xFF00);
	
	TPtrC8 tpr = aBuffer.Right(aBuffer.Length() -16);
	if(tpr.Length() == nLen)
	{
		HBufC16 * aa = unicode.ConvertL( (TText8 *) tpr.Ptr());
	//	iConsole.PrintNotify(*aa);

		nRecvCount++;
		TBuf8<30> aOutBuff;
		aOutBuff.Format(_L8("Receive (%03d); success!\n"), nRecvCount);
		iConsole.PrintNotify(aOutBuff);
	}
	else
		iConsole.PrintNotify( aBuffer );
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::ChangeStatus()
// Handles a change in this object's status.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::ChangeStatus( TSocketsEngineState aNewStatus )
    {
    TBuf<KMaxMessageLength> statusInfo;
    // Update the status ( and the status display )

    switch ( aNewStatus )
        {
        case ENotConnected:
            StringLoader::Load( statusInfo, R_SOCK_NOT_CONNECTED );
			_LIT(EStatus1, "NO_CONNECT");
			statusInfo.Copy(EStatus1);
            iConsole.SetStatus( statusInfo );
            break;
        case EConnecting:
            StringLoader::Load( statusInfo, R_SOCK_CONNECTING );
			_LIT(EStatus2, "CONNECTING");
			statusInfo.Copy(EStatus2);
            iConsole.SetStatus( statusInfo );
            break;
        case EConnected:
            StringLoader::Load( statusInfo, R_SOCK_CONNECTED );
			_LIT(EStatus3, "CONNECTED");
			statusInfo.Copy(EStatus3);
            iConsole.SetStatus( statusInfo );
            break;
        case ELookingUp:
            StringLoader::Load( statusInfo, R_SOCK_LOOKING_UP );
			_LIT(EStatus4, "R_LOOKINGUP");
			statusInfo.Copy(EStatus4);
            iConsole.SetStatus( statusInfo );
            break;
        default:
            User::Panic( KPanicSocketsEngine, ESocketsBadStatus );
            break;
        }
iEngineStatus = aNewStatus;
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::Print()
// Displays text on the console.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::Print( const TDesC& aDes )
    {
    iConsole.PrintNotify( aDes, CEikGlobalTextEditor::EItalic );
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::SetServerName()
// Sets name of server to connect to.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::SetServerName( const TDesC& aName )
    {
    iServerName.Copy( aName );
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::ServerName()
// Gets server name.
// -----------------------------------------------------------------------------
//
const TDesC& CSocketsEngine::ServerName() const
    {
    return iServerName;
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::SetPort()
// Sets port number to connect to.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::SetPort( TInt aPort )
    {
    iPort = aPort;
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::Port()
// Gets port number.
// -----------------------------------------------------------------------------
//
TInt CSocketsEngine::Port() const
    {
    return iPort;
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::Connected()
// Checks if socket is fully connected.
// -----------------------------------------------------------------------------
//
TBool CSocketsEngine::Connected() const
    {
    return ( iEngineStatus == EConnected );
    }

// End of File