継承図

協調図

解説

SFXTCPSocket クラスは、BREW API の ISocket インターフェースをカプセル化し、ハイレベルな TCP ソケット通信機能を提供します。

TCP ソケット通信の手順

// SFXTCPSocket クラスのインスタンス _tcp はクラスのメンバ変数として定義する
class NetworkTime {
private:
    SFXTCPSocket _tcp;
    SFXBinaryStreamReader _reader;

public:
    Void Start(Void); // NTP サーバーとの接続を開始する
    Void Stop(Void);  // 接続途中で NTP サーバーとの接続を終了する
    
    // コールバック関数の宣言
    CALLBACK_DECLARE_SFXTCPSOCKET(OnConnect)
    CALLBACK_DECLARE_SFXBINARYSTREAMREADER(OnFetch)
};

// NTP サーバーとの接続を開始する
Void NetworkTime::Start(Void)
{
    SFCError error(SFERR_NO_ERROR);
    // NTP サーバーのアドレスを設定する
    SFXSocketAddress address("www.example.com:37");

    // NTP サーバーとの接続を初期化する
    if ((error = _tcp.Open()) == SFERR_NO_ERROR) {

        // NTP サーバーに接続する ( 接続の完了は、OnConnect 関数に通知される )
        if ((error = _tcp.Connect(address,
                CALLBACK_FUNCTION(OnConnect))) == SFERR_NO_ERROR) {
            ...
        }
        else {
            // エラーが発生したとき
            _tcp.Close();
        }
    }
	
    if (error != SFERR_NO_ERROR) { 
        // エラーが発生したとき
        // エラー処理
        ...
    }
    return;
}

// 接続途中で NTP サーバーとの接続を終了する場合に呼び出す
Void NetworkTime::Stop(Void)
{
    // 終了処理
    _reader.Release();
    _tcp.Close();
    return;
}

// 接続の完了が通知されるコールバック関数
CALLBACK_IMPLEMENT_SFXTCPSOCKET(NetworkTime, OnConnect, error)
{
    if (error == SFERR_NO_ERROR) {

        // データ受信用ストリームを取得する
        if ((error = _tcp.GetStreamReader(64, &_reader)) == SFERR_NO_ERROR) {

            // 4 バイトのデータを受信する。データ受信の完了は、OnFetch 関数に通知される
            if ((error = _reader.Fetch(4, CALLBACK_FUNCTION(OnFetch)))
                == SFERR_NO_ERROR) {
                ...
            }
            if (error != SFERR_NO_ERROR) { 
                // エラーが発生したとき
                _reader.Release();
            }
        }
    }
	
    if (error != SFERR_NO_ERROR) {  
        // エラーが発生したとき
        _tcp.Close();
    }
    return;
}

// データ受信完了の通知を受け取るコールバック関数
CALLBACK_IMPLEMENT_SFXBINARYSTREAMREADER(NetworkTime, OnFetch, error)
{
    SFXDate date; // 日付クラス
    UInt32 time;

    if (error == SFERR_NO_ERROR) {

        // データをビッグ エンディアンとして読み込む設定をする
        _reader.SetEndian(SFXBinaryStreamReader::ENDIAN_BIG);
        
        // データを UInt32 型として読み込み、time 変数に格納する
        if ((error = _reader.ReadUInt32(&time)) == SFERR_NO_ERROR) {
            
            // 日付クラスに取得した時刻 ( 秒 ) を設定する
            date.Set(time);
            
            // 受信したデータは 1900 年 1 月 1 日 からの時刻なので調整する
            date -= SFXDateDuration::Offset19000101();
            
            // 時刻をローカル時刻に変換する
            date += SFXDateDuration::LocalTimeOffset();

            // 時刻を書式に合わせて出力する
            TRACE("%s", date.Format("YYYY/MM/DD hh:mm:ss").GetCString());
        }
    }
	
    if (error != SFERR_NO_ERROR) {
        // エラーが発生したとき
        // エラー処理

        ...

    }

    // 終了処理
    _reader.Release();
    _tcp.Close();
    return;
}

参照

SFXUDPSocket | SFXSSLSocket | ソケット通信

メンバ

解説

コンストラクタでは SFBNetMgr クラスと SFBSocket クラスのインスタンスは生成されません。

解説

デストラクタでは SFXTCPSocket::Close 関数が呼び出されます。

参照

SFXTCPSocket::Close

戻り値

解説

SFXTCPSocket::Accept 関数の戻り値が AEE_NET_WOULDBLOCK の場合は SFXTCPSocket::ScheduleAccept 関数でコールバック関数を登録し、コールバック関数の中で再度 SFXTCPSocket::Accept 関数を呼び出す必要があります。

参照

SFXTCPSocket::ScheduleAccept

戻り値

参照

SFBSocket | SFBAStream

戻り値

解説

SFXTCPSocket::AsSFBSource 関数は内部で SFBSourceUtil クラスのインスタンスを生成し、解放します。

参照

SFBSocket | SFBSource

戻り値

解説

SFXTCPSocket::Bind 関数の戻り値が AEE_NET_WOULDBLOCK のときは SFXTCPSocket::ScheduleBind 関数でコールバックを登録し、コールバック関数の中で再度 SFXTCPSocket::Bind 関数を呼び出す必要があります。

参照

SFXTCPSocket::ScheduleBind

解説

TCP ソケット通信をキャンセルし、内部で使っている ISocket インターフェースや INetMgr インターフェースを解放します。

BREW アプリのサスペンド時は、SFXTCPSocket::Close 関数を呼び出してリソースを解放します。

引数

戻り値

解説

接続が確立されると、登録したコールバック関数に通知されます。

	接続時のエラー取得
	接続に関するエラーは、戻り値では取得できません。コールバック関数に通知されます。

使用例

// SFXTCPSocket クラスのインスタンス _tcp はクラスのメンバ変数として定義する
class TcpSample {
private:
    SFXTCPSocket _tcp;
public:
    Void Start(Void);                       
    CALLBACK_DECLARE_SFXTCPSOCKET(OnConnect) 
};

// TCP 接続を開始する
Void TcpSample::Start(Void)
{
    SFCError error(SFERR_NO_ERROR);

    // TCP サーバーのアドレスを設定する
    SFXSocketAddress address("www.example.com:37");

    // TCP ソケットをオープンする
    if ((error = _tcp.Open()) == SFERR_NO_ERROR) {
        
        // TCP サーバーに接続する
        if ((error = _tcp.Connect(address,CALLBACK_FUNCTION(OnConnect))) == SFERR_NO_ERROR) {
            ...
        }else {
            // エラーが発生したとき
            _tcp.Close();
        }
    }
	
    if (error != SFERR_NO_ERROR) { 
        // エラーが発生したとき
        // エラー処理
        ...
    }    
}

// 接続の完了が通知されるコールバック関数
CALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnConnect, error)
{
    if (error == SFERR_NO_ERROR) {
        ...
    }
}

戻り値

解説

	ローカルの IP アドレスの変化
	TCP ソケット接続の前後で、ローカルの IP アドレスは変化する可能性があります。

参照

SFXInetAddress::LocalInetAddress

戻り値

解説

	リモートの IP アドレスの変化
	TCP ソケット接続の前後で、リモートの IP アドレスは変化する可能性があります。

解説

内部で管理するソケット ( SFBSocket 型 ) を取得します。

戻り値

解説

データ受信用ストリームのバッファ サイズを指定することも可能です。 データ受信用ストリームは、受信するデータのタイプに応じて SFXBinaryStreamReader、SFXAnsiStringStreamReader、または SFXWideStringStreamReader クラスを使い分けます。

使用例

SFXBinaryStreamReader を使ってデータ受信用ストリームを取得します。

// TCP ソケット 通信に必要な SFXTCPSocket クラスのインスタンス _tcp はクラスのメンバ変数として定義する
class NetworkTime {
private:
    SFXTCPSocket _tcp;
    SFXBinaryStreamReader _reader;
public:
    // コールバック関数の宣言
    CALLBACK_DECLARE_SFXTCPSOCKET(OnConnect)
};

// 接続の完了が通知されるコールバック関数
CALLBACK_IMPLEMENT_SFXTCPSOCKET(NetworkTime, OnConnect, error)
{
    if (error == SFERR_NO_ERROR) {

        // データ受信用ストリームを取得する
        if ((error = _tcp.GetStreamReader(64, &_reader)) == SFERR_NO_ERROR) {
            ...
        }
    }
    return;
}

参照

SFXTCPSocket::GetStreamWriter | SFXBinaryStreamReader | SFXAnsiStringStreamReader | SFXWideStringStreamReader

戻り値

解説

データ送信用ストリームのバッファ サイズを指定することも可能です。 データ送信用ストリームは、送信するデータのタイプに応じて SFXBinaryStreamWriter、SFXAnsiStringStreamWriter、または SFXWideStringStreamWriter クラスを使い分けます。

使用例

SFXBinaryStreamwriter を使ってデータ送信用ストリームを取得します。

// TCP ソケット 通信に必要な SFXTCPSocket クラスのインスタンス _tcp はクラスのメンバ変数として定義する
class NetworkTime {
private:
    SFXTCPSocket _tcp;
    SFXBinaryStreamwriter _writer;
public:
    // コールバック関数の宣言
    CALLBACK_DECLARE_SFXTCPSOCKET(OnConnect)
};
    
// 接続の完了が通知されるコールバック関数
CALLBACK_IMPLEMENT_SFXTCPSOCKET(NetworkTime, OnConnect, error)
{
    if (error == SFERR_NO_ERROR) {

        // データ送信用ストリームを取得する
        if ((error = _tcp.GetStreamWriter(64, &_writer)) == SFERR_NO_ERROR) {
            ...
        }
    }
    return;
}

参照

SFXTCPSocket::GetStreamReader | SFXBinaryStreamWriter | SFXAnsiStringStreamWriter | SFXWideStringStreamWriter

戻り値

解説

SFXTCPSocket::Listen 関数の戻り値が AEE_NET_WOULDBLOCK の場合は SFXTCPSocket::ScheduleListen 関数でコールバック関数を登録し、コールバック関数の中で再度 SFXTCPSocket::Listen 関数を呼び出す必要があります。

参照

SFXTCPSocket::ScheduleListen

戻り値

解説

SFBNetMgr クラスのインスタンスを生成し、TCP ソケット ( SFBSocket クラスのインスタンス ) を開きます。

使用例

// TCP ソケット 通信に必要な SFXTCPSocket クラスのインスタンス _tcp はクラスのメンバ変数として定義する
class TcpSample {
private:
    SFXTCPSocket _tcp;
public:
    Void Start(Void); 
    CALLBACK_DECLARE_SFXTCPSOCKET(OnConnect)
};

// TCP接続を開始する
Void TcpSample::Start(Void)
{
    SFCError error(SFERR_NO_ERROR);

    // TCP サーバーのアドレスを設定する
    SFXSocketAddress address("www.example.com:37");

    // TCP サーバーと接続を初期化する
    if ((error = _tcp.Open()) == SFERR_NO_ERROR) { 
        
        // TCP サーバーに接続する
        if ((error = _tcp.Connect(address,CALLBACK_FUNCTION(OnConnect))) == SFERR_NO_ERROR) { 
            ...
        }else {
            // エラーが発生したとき
            _tcp.Close();
        }
    }
	
    if (error != SFERR_NO_ERROR) {
        // エラーが発生したとき
        // エラー処理
        ...
    }    
}

// 接続の完了が通知されるコールバック関数
CALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnConnect, error)
{
    if (error == SFERR_NO_ERROR) {
        ...
    }
}

引数

戻り値

解説

	注意
	SFXTCPSocket::Read 関数が AEE_NET_WOULDBLOCK を返す場合、SFXTCPSocket::ScheduleRead 関数でコールバック関数を登録し、 コールバック関数の中で再度 SFXTCPSocket::Read 関数をスケジュールする必要があります。

使用例

// TCP ソケット 通信に必要な SFXTCPSocket クラスのインスタンス _tcp はクラスのメンバ変数として定義する   
class TcpSample {
private:
    SFXTCPSocket _tcp;
public:
    // コールバック関数の宣言
    CALLBACK_DECLARE_SFXTCPSOCKET(OnWrite)  
    CALLBACK_DECLARE_SFXTCPSOCKET(OnRead)  
};

// データ送信の完了が通知されるコールバック関数
CALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnWrite, error)
{
    UInt32 size;
    static ACharConst data[] = "GET / HTTP/1.0\n\n";
    
    // データを書き込む
    size = sizeof(data) - 1;
    switch (error = _tcp.Write(data, &size)) {
        case SFERR_NO_ERROR:
             // コールバックを登録する
            _tcp.ScheduleRead(CALLBACK_FUNCTION(OnRead));
            break;
        case AEE_NET_WOULDBLOCK:
            // コールバックを登録する
            _tcp.ScheduleWrite(CALLBACK_FUNCTION(OnWrite));
            break;
    }
}

// データ受信の完了が通知されるコールバック関数
CALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnRead, error)
{
    SFXBuffer buffer;
    UInt32 size;

    // データを読み込む
    buffer.SetSize(32);
    size = buffer.GetSize();
    switch (_tcp.Read(buffer.GetBuffer(), &size)) {
        case SFERR_NO_ERROR:

           // 指定したサイズのデータが読み込まれたかチェックする
           if (size == buffer.GetSize()) {

                // 読み込んだデータを表示する
                buffer.SetSize(buffer.GetSize() + 1);
                buffer[buffer.GetSize() - 1] = '\0';
                TRACE("%s", SFXAnsiString(buffer).GetCString());
                
               // 接続を閉じる
                _tcp.Close();
            }
            else {
                ...
            }
            break;

        case AEE_NET_WOULDBLOCK:
            // コールバックを登録する
            _tcp.ScheduleRead(CALLBACK_FUNCTION(OnRead));
            break;
    }
    return;
}

参照

SFXTCPSocket::ScheduleRead

戻り値

解説

SFXTCPSocket::ScheduleAccept 関数は、SFXTCPSocket::Accept 関数を使って TCP サーバーとの接続を待機するコールバック関数を登録するために使います。

※ SFXTCPSocket::Accept 関数の戻り値が AEE_NET_WOULDBLOCK である場合、SFXTCPSocket::ScheduleAccept 関数でコールバック関数を登録して、再び TCP サーバーとの接続待機を試みます。

参照

SFXTCPSocket::Accept

戻り値

解説

SFXTCPSocket::ScheduleBind 関数は、SFXTCPSocket::Bind 関数を使って Bind するコールバック関数を登録するために使います。

※ SFXTCPSocket::Bind 関数の戻り値が AEE_NET_WOULDBLOCK である場合、SFXTCPSocket::ScheduleBind 関数でコールバック関数を登録して、再び Bind を試みます。

参照

SFXTCPSocket::Bind

戻り値

解説

SFXTCPSocket::ScheduleListen 関数は、SFXTCPSocket::Listen 関数を使って TCP 接続の待ち受け ( Listen ) をするコールバック関数を登録するために使います。

※ SFXTCPSocket::Listen 関数の戻り値が AEE_NET_WOULDBLOCK である場合、SFXTCPSocket::ScheduleListen 関数でコールバック関数を登録して、再び TCP 接続の待ち受け ( Listen ) を試みます。

参照

SFXTCPSocket::Listen

戻り値

解説

SFXTCPSocket::ScheduleRead 関数は、SFXTCPSocket::Read 関数を使ってデータ受信するコールバック関数を登録するために使います。

※ SFXTCPSocket::Read 関数の戻り値が AEE_NET_WOULDBLOCK である場合、SFXTCPSocket::ScheduleRead 関数でコールバック関数を登録して、再びデータ受信を試みます。

使用例

// TCP ソケット 通信に必要な SFXTCPSocket クラスのインスタンス _tcp はクラスのメンバ変数として定義する   
class TcpSample {
private:
    SFXTCPSocket _tcp;
public:
    // コールバック関数の宣言
    CALLBACK_DECLARE_SFXTCPSOCKET(OnWrite)  
    CALLBACK_DECLARE_SFXTCPSOCKET(OnRead)  
};

//データ送信の完了が通知されるコールバック関数
CALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnWrite, error)
{
    UInt32 size;
    static ACharConst data[] = "GET / HTTP/1.0\n\n";
    
    // データを書き込む
    size = sizeof(data) - 1;
    switch (error = _tcp.Write(data, &size)) {
        case SFERR_NO_ERROR:
             // コールバックを登録する
            _tcp.ScheduleRead(CALLBACK_FUNCTION(OnRead));
            break;
        case AEE_NET_WOULDBLOCK:
            // コールバックを登録する
            _tcp.ScheduleWrite(CALLBACK_FUNCTION(OnWrite));
            break;
    }
}

//データ受信の完了が通知されるコールバック関数
CALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnRead, error)
{
    SFXBuffer buffer;
    UInt32 size;

    // データを読み込む
    buffer.SetSize(32);
    size = buffer.GetSize();
    switch (_tcp.Read(buffer.GetBuffer(), &size)) {
        case SFERR_NO_ERROR:

           // 指定したサイズのデータが読み込まれたかチェックする
           if (size == buffer.GetSize()) {

                // 読み込んだデータを表示する
                buffer.SetSize(buffer.GetSize() + 1);
                buffer[buffer.GetSize() - 1] = '\0';
                TRACE("%s", SFXAnsiString(buffer).GetCString());
                
                _tcp.Close();  // 接続を閉じる
            }
            else {
                ...
            }
            break;

        case AEE_NET_WOULDBLOCK:
            // コールバックを登録する
            _tcp.ScheduleRead(CALLBACK_FUNCTION(OnRead));
            break;
    }
    return;
}

参照

SFXTCPSocket::Read

戻り値

解説

SFXTCPSocket::ScheduleWrite 関数は、SFXTCPSocket::Write 関数を使ってデータ送信するコールバック関数を登録するために使います。

※ SFXTCPSocket::Write 関数の戻り値が AEE_NET_WOULDBLOCK である場合、SFXTCPSocket::ScheduleWrite 関数でコールバック関数を登録して、再びデータ送信を試みます。

使用例

 // TCP ソケット 通信に必要な SFXTCPSocket クラスのインスタンス _tcp はクラスのメンバ変数として定義する   
class TcpSample {
private:
    SFXTCPSocket _tcp;
public:
    // コールバック関数の宣言
    CALLBACK_DECLARE_SFXTCPSOCKET(OnConnect)  
    CALLBACK_DECLARE_SFXTCPSOCKET(OnWrite)  
};

// 接続の完了が通知されるコールバック関数
CALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnConnect, error)
{
    if (error == SFERR_NO_ERROR) {
       _tcp.ScheduleWrite(CALLBACK_FUNCTION(OnWrite));
    }
}

//データ送信の完了が通知されるコールバック関数
CALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnWrite, error)
{
    UInt32 size;
    static ACharConst data[] = "GET / HTTP/1.0\n\n";
    
    // データを書き込む
    size = sizeof(data) - 1;
    switch (error = _tcp.Write(data, &size)) {
        case SFERR_NO_ERROR:
            ...
            break;
        case AEE_NET_WOULDBLOCK:
            // コールバックを登録する
            _tcp.ScheduleWrite(CALLBACK_FUNCTION(OnWrite));
            break;
    }
}

参照

SFXTCPSocket::Write

引数

戻り値

解説

	注意
	SFXTCPSocket::Write 関数が AEE_NET_WOULDBLOCK を返す場合、SFXTCPSocket::ScheduleWrite 関数でコールバック関数を登録し、 そのコールバック関数の中で再度 SFXTCPSocket::Write 関数をスケジュールする必要があります。

使用例

 // TCP ソケット 通信に必要な SFXTCPSocket クラスのインスタンス _tcp はクラスのメンバ変数として定義する   
class TcpSample {
private:
    SFXTCPSocket _tcp;
public:
    // コールバック関数の宣言
    CALLBACK_DECLARE_SFXTCPSOCKET(OnConnect)  
    CALLBACK_DECLARE_SFXTCPSOCKET(OnWrite)  
};

// 接続の完了が通知されるコールバック関数
CALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnConnect, error)
{
    if (error == SFERR_NO_ERROR) {
        _tcp.ScheduleWrite(CALLBACK_FUNCTION(OnWrite));
    }
}

//データ送信の完了が通知されるコールバック関数
CALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnWrite, error)
{
    UInt32 size;
    static ACharConst data[] = "GET / HTTP/1.0\n\n";
    
    // データを書き込む
    size = sizeof(data) - 1;
    switch (error = _tcp.Write(data, &size)) {
        case SFERR_NO_ERROR:
            ...
            break;
        case AEE_NET_WOULDBLOCK:
            // コールバックを登録する
            _tcp.ScheduleWrite(CALLBACK_FUNCTION(OnWrite));
            break;
    }
}

参照

SFXTCPSocket::ScheduleWrite