継承図

協調図

解説

SFXTCPSocket クラスは、 TCP クライアントと TCP サーバーを実装する機能を提供します。

このクラスでは、ストリームを利用したデータ送受信が可能です。

ストリームを利用しない場合は SFXTCPSocket::Write / SFXTCPSocket::Read 関数を使用してデータを送受信します。

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

TCP クライアントの実装

TCP クライアントは、 SFXTCPSocket クラスを使用して以下の手順で実装します。

例 855. NTP サーバーからの時刻取得

// コールバック関数で使用するので、_socket はクラスのメンバ変数として定義する
class NetworkTime {
private:
    SFXTCPSocket _socket;
    SFXBinaryStreamReader _reader;
    SFXTimer _timer;

public:
    Void Start(Void); // NTP サーバーとの接続を開始する
    Void Stop(Void);  // NTP サーバーとの接続を終了する
    
    // コールバック関数の宣言
    XALLBACK_DECLARE_SFXTCPSOCKET(OnConnect)
    XALLBACK_DECLARE_SFXBINARYSTREAMREADER(OnFetch)
    XALLBACK_DECLARE_SFXTIMER(OnTimer)
};

#define     NTP_SERVER              ("www.example.com:37")
#define     TIMER_INTERVAL          (5000)

// NTP サーバーへの接続を開始する（アプリ開始時またはレジューム時に呼び出す）
Void NetworkTime::Start(Void)
{
    SFCError error(SFERR_NO_ERROR);
    // NTP サーバーのドメイン名とポート番号を設定する
    SFXSocketAddress address(NTP_SERVER);

    // タイマーコールバック関数を設定する
    _timer.Set(XALLBACK_INTERNAL(OnTimer));

    // ソケットを開く
    if ((error = _socket.Open()) == SFERR_NO_ERROR) {

        // NTP サーバーに接続する
        // ※1. 接続要求の結果は、OnConnect 関数に通知される
        // ※2. ドメイン名の解決は自動的に行われる
        if ((error = _socket.Connect(address, XALLBACK_INTERNAL(OnConnect))) == SFERR_NO_ERROR) {
            
            TRACE(">> connecting...");
        }
        else {

            // エラーが発生したとき
            // ソケットを閉じる
            _socket.Close();
        }
    }
	
    if (error != SFERR_NO_ERROR) { 

        // エラーが発生したとき
        ...

        // タイマーをセットする。TIMER_INTERVAL ミリ秒後に OnTimer 関数が呼び出される
        _timer.Schedule(TIMER_INTERVAL);
    }
    return;
}

// NTP サーバーへの接続を終了する（アプリ終了時またはサスペンド時に呼び出す）
Void NetworkTime::Stop(Void)
{
    // 終了処理
    // ストリームを解放する
    _reader.Release();
    // ソケットを閉じる
    _socket.Close();
    return;
}

// 接続要求の結果が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXTCPSOCKET(NetworkTime, OnConnect, error)
{
    if (error == SFERR_NO_ERROR) {

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

            // フェッチを行う: 実際にソケットからストリームバッファに 4 バイトのデータを受信する
            // ※ データ受信（フェッチ）の結果は、OnFetch 関数に通知される
            if ((error = _reader.Fetch(4, XALLBACK_INTERNAL(OnFetch))) == SFERR_NO_ERROR) {

                TRACE(">> fetching...");
            }
            if (error != SFERR_NO_ERROR) { 

                 // エラーが発生したとき
                 // ストリームを解放する
                 _reader.Release();
            }
        }
    }
	
    if (error != SFERR_NO_ERROR) {  

        // エラーが発生したとき
        // ソケットを閉じる
        _socket.Close();
    }
    return;
}

// データ受信（フェッチ）の結果が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXBINARYSTREAMREADER(NetworkTime, OnFetch, error)
{
    SFXDate date; // 日付クラス
    UInt32 time;

    if (error == SFERR_NO_ERROR) {

        // ビッグエンディアンとしてデータを読み込む
        _reader.SetEndian(SFXBinaryStreamReader::ENDIAN_BIG);
        
        // ストリームバッファから time 変数に UInt32 型データを読み込む
        if ((error = _reader.ReadUInt32(&time)) == SFERR_NO_ERROR) {
            
            // time の値を SFXDate インスタンスに設定する
            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();
    // ソケットを閉じる
    _socket.Close();
    return;
}


// タイマーコールバック関数
XALLBACK_IMPLEMENT_SFXTIMER(NetworkTime, OnTimer)
{
    Start();
    return;
}

	注意
	サスペンドとレジュームに対応した networktime アプリのサンプルコードが、 SophiaFramework UNIVERSE パッケージの Example/networktime フォルダにあります。

TCP サーバーの実装

TCP サーバーは、 SFXTCPSocket クラスを使用して以下の手順で実装します。

参照

SFXUDPSocket | SFXSSLSocket | SFXSocketAddress | TCP ソケット通信 | BREW API ISocket

メンバ

解説

このコンストラクタは、何も行いません。

解説

このデストラクタは、 SFXTCPSocket::Close 関数を呼び出します。

	注意
	登録されていたコールバックはキャンセルされます。

参照

SFXTCPSocket::Close

戻り値

解説

この関数は、Accept（待機中の接続リクエストを 1 つ取り出し、クライアントとの接続を確立する操作）を行います。

この関数は、 Listen 中であるこのソケットのバックログのキューから最初の接続リクエストを取り出し、 接続を確立し、接続状態にある新しいソケットを作成し、result 引数に返します。 クライアントとの通信は、このソケットを使用して行います。

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

	注意
	この関数は、 内部で SFBSocket::Accept 関数を呼び出します。

	前提条件
	この関数を呼び出す前に、 このソケットは SFXTCPSocket::Listen 関数を呼び出して Listen 中である必要があります 。

参照

SFXTCPSocket::ScheduleAccept | SFXTCPSocket::Listen | SFXTCPSocket::Bind | SFBSocket::Accept | BREW API ISOCKET_Accept | BREW API ISOCKET_GetLastError

引数

戻り値

解説

この関数は、 このストレージが内部で管理する SFBSocket インスタンスを SFBAStream インスタンスに変換します。

result 引数には、変換結果である SFBAStream インスタンスへのポインタが返ります。

	注意
	この関数により、 このストレージを SFBAStream インスタンスとして扱えます。

参照

SFBSocket | SFBAStream

引数

戻り値

解説

この関数は、 このストレージが内部で管理する SFBSocket インスタンスを SFBSource インスタンスに変換します。

result 引数には、変換結果である SFBSource インスタンスへのポインタが返ります。

	注意
	この関数は、内部で BREW API の BREW API ISOURCEUTIL_SourceFromSocket 関数を呼び出します。

	注意
	この関数により、 このストレージを SFBSource インスタンスとして扱えます。

参照

SFBSocket | SFBSource | BREW API ISOURCEUTIL_SourceFromSocket

戻り値

解説

この関数は、Bind （ソケットに端末のローカル IP アドレスとポート番号を関連付ける操作）を行います。

ローカル IP アドレスは、 携帯端末内部でループバック通信するときは SFXInetAddress::LoopbackInetAddress 関数の戻り値、 外部と通信するときは SFXInetAddress::AnyInetAddress 関数の戻り値を指定します。 BREW SDK の制約により、これら以外の値はサポートされません。

端末をサーバーとして利用する場合は、 この関数を実行した後に、 SFXTCPSocket::Listen 関数を呼び出して、 サーバー側で接続の待ち受けを開始します。

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

	ポート番号のバインド
	クライアント側ではこの関数の呼び出しを省略できますが、 Bind を省略した場合、デフォルトのポート番号がソケットに Bind されます。

	注意
	この関数は、 内部で SFBSocket::Bind 関数を呼び出します。

	前提条件
	この関数を呼び出す前に、 このソケットは SFXTCPSocket::Open 関数を呼び出して 開いている必要があります 。

参照

SFXTCPSocket::Open | SFXTCPSocket::Listen | SFXTCPSocket::Accept | SFXTCPSocket::ScheduleBind | SFXInetAddress::LoopbackInetAddress | SFXInetAddress::AnyInetAddress | SFXSocketAddress | SFBSocket::Bind | BREW API ISOCKET_Bind | BREW API ISOCKET_GetLastError | BREW API AEE_BREW_LOOPBACK | BREW API AEE_INADDR_LOOPBACK | BREW API AEE_INADDR_ANY

解説

この関数は、ソケット通信における各種操作をキャンセルします。

具体的には、 キャンセル対象となる操作で登録したコールバックをキャンセルし、 その操作を行う直前の状態（1 つ前の状態）に戻します。

キャンセルの対象となる操作とキャンセル内容は、以下の表の通りです。

	注意
	この関数は、SFXTCPSocket::Close 関数から呼び出されます。

参照

SFXTCPSocket::Open | SFXTCPSocket::Connect | SFXTCPSocket::ScheduleBind | SFXTCPSocket::ScheduleListen | SFXTCPSocket::ScheduleAccept | SFXTCPSocket::ScheduleRead | SFXTCPSocket::ScheduleWrite | SFXTCPSocket::Close

解説

この関数は、このソケットを閉じます（このソケットを終了します）。

具体的には、 SFXTCPSocket::Cancel 関数を呼び出してソケット通信の各種操作をキャンセルし、 内部で管理している SFBNetMgr インスタンスと SFBSocket インスタンスを解放します。

	注意
	登録されていたコールバックはキャンセルされます。

	注意
	この関数は、SFXTCPSocket::~SFXTCPSocket デストラクタから呼び出されます。

	Tip
	サスペンド時は、この関数を呼び出してリソースを解放します。

参照

SFXTCPSocket::Open | SFXTCPSocket::Cancel | SFXTCPSocket::~SFXTCPSocket | SFBNetMgr | SFBSocket | BREW API INetMgr | BREW API ISocket

引数

戻り値

解説

この関数は、引数に指定されたサーバーに接続リクエストを送信して、接続を確立します。 接続確立後は、このソケットを使用してサーバーと通信を行います。

接続確立についての結果（エラー値）は、この関数の戻り値では取得できません。 以下のエラー値が、引数に指定したコールバック関数の第 1 引数に通知されます。

コールバック関数が呼び出されるまでは、「Connect 中の状態」になります。 コールバック関数が呼び出されたとき、 接続が確立している場合は、「接続確立の状態」になり、 失敗した場合は、この関数を呼び出す直前の状態（ソケットが開いている状態）に戻ります。

コールバック関数に接続確立の通知が行われる前に、 SFXTCPSocket::Cancel 関数を呼び出すと、 接続の確立はキャンセルされ、この関数を呼び出す直前の状態（ソケットが開いている状態）に戻ります。

なお、この関数の戻り値がエラー（SFERR_NO_ERROR 以外の値）の場合、コールバック関数は呼び出されません。

	注意
	この関数は、 内部で SFBSocket::Connect 関数を呼び出します。

	前提条件
	このソケットは SFXTCPSocket::Open 関数を呼び出した直後の開いた状態である必要があります。

使用例

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

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

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

    // TCP ソケットを開く
    if ((error = _socket.Open()) == SFERR_NO_ERROR) {
        
        // サーバーに接続する
        if ((error = _socket.Connect(address,XALLBACK_INTERNAL(OnConnect))) == SFERR_NO_ERROR) {

            ...
        }else {

            // エラーが発生したとき
            _socket.Close();
        }
    }
	
    if (error != SFERR_NO_ERROR) { 

        // エラーが発生したとき
        ...
    }    
}

// 接続要求の結果が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnConnect, error)
{
    if (error == SFERR_NO_ERROR) {

        ...
    }
}

参照

SFXTCPSocket::Open | SFXTCPSocket::Cancel | SFBSocket::Connect | SFXSocketAddress | SFBNetMgr | SFXStorage::CallbackSPP | BREW API INetMgr | BREW API ISOCKET_Connect | BREW API ISOCKET_GetLastError | BREW API ネットワークエラーコード

戻り値

解説

この関数は、このソケットのローカル IP アドレスとポートを取得します。

実際の物理的な IP アドレスは、接続確立後のデータ送受信用ソケットから取得できます。 それまでの間は、SFXTCPSocket::Bind 関数で設定した値が返ります。

	Tip
	実際の物理的なローカル IP アドレスは、 SFXInetAddress::LocalInetAddress 関数を呼び出して取得することも可能です。

	前提条件
	ローカル IP アドレスとポートを取得するには、 このソケットが SFXTCPSocket::Bind 関数を呼び出してバインドしている、 または このソケットが SFXTCPSocket::Connect 関数により接続を確立している必要があります。

参照

SFXTCPSocket::Bind | SFXTCPSocket::Connect | SFXInetAddress::LocalInetAddress | SFXSocketAddress | BREW API ISOCKET_GetLastError

戻り値

解説

この関数は、このソケットに接続されたピアのリモート IP アドレスとポートを取得します。

	注意
	この関数は、 内部で SFBSocket::GetPeerName 関数を呼び出します。

	前提条件
	リモート IP アドレスとポートを取得するには、 このソケットが SFXTCPSocket::Accept 関数で返される接続確立済みである、 または このソケットが SFXTCPSocket::Connect 関数により接続を確立している必要があります。

参照

SFBSocket::GetPeerName | SFXTCPSocket::Accept | SFXTCPSocket::Connect | SFXSocketAddress | BREW API ISOCKET_GetPeerName | BREW API ISOCKET_GetLastError

戻り値

このソケットが内部で管理する SFBNetMgr インスタンス

解説

この関数は、 このソケットが内部で管理する SFBNetMgr インスタンスを取得します。

参照

SFBNetMgr | BREW API INetMgr

戻り値

このソケットが内部で管理する SFBSocket インスタンス

解説

この関数は、 このソケットが内部で管理する SFBSocket インスタンスを取得します。

参照

SFBSocket

戻り値

解説

この関数は、データ受信用ストリームを取得します。

size 引数を指定する場合、ストリームバッファは指定したサイズで固定です。 指定しない場合は、ストリームバッファは可変長になり、 内部的に SFXElasticStreamReader クラスが利用されます。

	Tip
	データ受信用ストリームは、受信するデータの種類に応じて SFXBinaryStreamReader、 SFXAnsiStringStreamReader、または SFXWideStringStreamReader クラスを使い分けます。

	前提条件
	データ受信用ストリームを取得するには、 このソケットが SFXTCPSocket::Accept 関数で返される接続確立済みのソケットである、 または このソケットが SFXTCPSocket::Connect 関数により接続を確立している必要があります。

使用例

以下は、SFXBinaryStreamReader クラスを使用してデータ受信用ストリームを取得するコードです。

// SFXTCPSocket インスタンス (_socket) はクラスのメンバ変数として定義する
class NetworkTime {
private:
    SFXTCPSocket _socket;
    SFXBinaryStreamReader _reader;
public:
    // コールバック関数の宣言
    XALLBACK_DECLARE_SFXTCPSOCKET(OnConnect)
};

// 接続要求の結果が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXTCPSOCKET(NetworkTime, OnConnect, error)
{
    if (error == SFERR_NO_ERROR) {

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

参照

SFXTCPSocket::GetStreamWriter | SFXBinaryStreamReader | SFXAnsiStringStreamReader | SFXWideStringStreamReader | SFXTCPSocket::Accept | SFXTCPSocket::Connect | ストリームバッファ

戻り値

解説

この関数は、データ送信用ストリームを取得します。

size 引数を指定する場合、ストリームバッファは指定したサイズで固定です。 指定しない場合は、ストリームバッファは可変長になり、 内部的に SFXElasticStreamWriter クラスが利用されます。

	Tip
	データ送信用ストリームは、送信するデータの種類に応じて SFXBinaryStreamWriter、 SFXAnsiStringStreamWriter、または SFXWideStringStreamWriter クラスを使い分けます。

	前提条件
	データ受信用ストリームを取得するには、 このソケットが SFXTCPSocket::Accept 関数で返される接続確立済みのソケットである、 または このソケットが SFXTCPSocket::Connect 関数により接続を確立している必要があります。

使用例

以下は、SFXBinaryStreamWriter クラスを使用してデータ送信用ストリームを取得するコードです。

// SFXTCPSocket インスタンス (_socket) はクラスのメンバ変数として定義する
class NetworkTime {
private:
    SFXTCPSocket _socket;
    SFXBinaryStreamwriter _writer;
public:
    // コールバック関数の宣言
    XALLBACK_DECLARE_SFXTCPSOCKET(OnConnect)
};
    
// 接続要求の結果が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXTCPSOCKET(NetworkTime, OnConnect, error)
{
    if (error == SFERR_NO_ERROR) {

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

参照

SFXTCPSocket::GetStreamReader | SFXBinaryStreamWriter | SFXAnsiStringStreamWriter | SFXWideStringStreamWriter | SFXTCPSocket::Accept | SFXTCPSocket::Connect | ストリームバッファ

戻り値

解説

この関数は、Listen （サーバー側で接続リクエストの待ち受けを開始する操作）を行います。

引数に待機中の接続リクエストが格納されるキューの大きさ(バックログのキューの長さ)を設定することが可能です。 省略時は、1 が設定されます。システムの最大値よりも大きな値が指定された場合は、 システムの最大値が設定されます。

この関数を実行した後に、 SFXTCPSocket::Accept 関数を呼び出して待機中の接続リクエストを 1 つ取り出し、 接続を確立します。

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

	注意
	この関数は、 内部で SFBSocket::Listen 関数を呼び出します。

	前提条件
	この関数を呼び出す前に、 このソケットは SFXTCPSocket::Bind 関数を呼び出して Bind されている必要があります 。

参照

SFXTCPSocket::Bind | SFXTCPSocket::Accept | SFXTCPSocket::ScheduleListen | SFBSocket::Listen | BREW API ISOCKET_Listen | BREW API ISOCKET_GetLastError

戻り値

解説

この関数は、このソケットを開きます（このソケットを初期化します）。

具体的には、 SFXTCPSocket クラスが内部で管理する SFBNetMgr インスタンスを生成し、 BREW API INETMGR_OpenSocket 関数を呼び出して AEE_SOCK_STREAM タイプのソケット(SFBSocket インスタンス)を生成します。

SFBNetMgr / SFBSocket インスタンスは、 SFXTCPSocket::GetSFBNetMgr / SFXTCPSocket::GetSFBSocket 関数で取得することが可能です。 これらのインスタンスを利用して、詳細な設定が可能です。

	リンガー時間(ネットワーク接続の待機時間)
	BREW API INETMGR_SetLinger 関数で設定するリンガー時間(ネットワーク接続の待機時間)は、この関数の linger 引数で指定できます。 デフォルト値は -1 ですが、このときはリンガー時間は設定されません。 UINT16_MAXIMUM よりも大きなリンガー時間を設定すると、SFERR_INVALID_PARAM エラーが返ります。 リンガー時間の設定についての詳細は、 BREW API INETMGR_SetLinger 関数を参照してください。

	Tip
	SFXTCPSocket::Close 関数を呼び出すと、 このソケットは閉じます。

使用例

// TCP ソケット _socket はクラスのメンバ変数として定義する
class TcpSample {
private:
    SFXTCPSocket _socket;  // TCP ソケット
public:
    Void Start(Void); 
    XALLBACK_DECLARE_SFXTCPSOCKET(OnConnect)
};

// TCP ソケット通信を開始する
Void TcpSample::Start(Void)
{
    SFCError error(SFERR_NO_ERROR);

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

    // TCP サーバーと接続を初期化する
    if ((error = _socket.Open()) == SFERR_NO_ERROR) { 
        
        // サーバーに接続する（接続の完了は OnConnect 関数に通知される）
        // ※ ドメイン名の解決は自動的に行われる
        if ((error = _socket.Connect(address, XALLBACK_INTERNAL(OnConnect))) == SFERR_NO_ERROR) { 

            ...

        }else {

            // エラーが発生したとき
            _socket.Close();
        }
    }
	
    if (error != SFERR_NO_ERROR) {

        // エラーが発生したとき
        ...
    }    
}

// 接続要求の結果が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnConnect, error)
{
    if (error == SFERR_NO_ERROR) {

        ...
    }
}

参照

SFXTCPSocket::Close | SFXTCPSocket::GetSFBNetMgr | SFXTCPSocket::GetSFBSocket | SFBNetMgr | SFBSocket | BREW API INetMgr | BREW API ISocket | BREW API INETMGR_SetLinger | BREW API INETMGR_OpenSocket

引数

戻り値

解説

この関数は、Read（ストリームを使用しないソケットからのデータ受信）を行います。

ピアが接続を切断した場合、 この関数は SFERR_NO_ERROR を返し、かつ、 size 引数のポインタが指す場所に 0 が戻ります。

※ この関数が AEE_NET_WOULDBLOCK を返す場合、 SFXTCPSocket::ScheduleRead 関数でコールバック関数を登録し、 コールバック関数の中で再度この関数を呼び出して Read を行う必要があります。

	注意
	この関数は、 内部で SFBAStream::Read 関数を呼び出します。

	前提条件
	この関数を呼び出す前に、 このソケットは SFXTCPSocket::Connect 関数を呼び出して 接続を確立している必要があります 。 もしくは、 このソケットは SFXTCPSocket::Accept 関数が result 引数に返した「接続確立済みのソケット」である必要があります。

使用例

// SFXTCPSocket インスタンス (_socket) はクラスのメンバ変数として定義する   
class TcpSample {
private:
    SFXTCPSocket _socket;
public:
    // コールバック関数の宣言
    XALLBACK_DECLARE_SFXTCPSOCKET(OnWrite)  
    XALLBACK_DECLARE_SFXTCPSOCKET(OnRead)  
};

// Write（データ送信）可能が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnWrite, error)
{
    UInt32 size;
    static ACharConst data[] = "GET / HTTP/1.0\n\n";
    
    // データを書き込む
    size = sizeof(data) - 1;

    switch (error = _socket.Write(data, &size)) {

        case SFERR_NO_ERROR:

            // Read をスケジュールする: コールバック関数を登録する
            // ※ Read 可能になれば、OnRead コールバック関数が呼び出される
            _socket.ScheduleRead(XALLBACK_INTERNAL(OnRead));
            break;

        case AEE_NET_WOULDBLOCK:

            // Write をスケジュールする: コールバック関数を登録する
            // ※ Write 可能になれば、OnWrite コールバック関数が呼び出される
            _socket.ScheduleWrite(XALLBACK_INTERNAL(OnWrite));
            break;
    }
}

// Read（データ受信）可能が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnRead, error)
{
    SFXBuffer buffer;
    UInt32 size;

    // データを読み込む
    buffer.SetSize(32);
    size = buffer.GetSize();

    switch (_socket.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());
                
               // 接続を閉じる
                _socket.Close();
            }
            else {

                ...

            }
            break;

        case AEE_NET_WOULDBLOCK:

            // Read をスケジュールする: コールバック関数を登録する
            // ※ Read 可能になれば、OnRead コールバック関数が呼び出される
            _socket.ScheduleRead(XALLBACK_INTERNAL(OnRead));
            break;
    }
    return;
}

参照

SFXTCPSocket::ScheduleRead | SFXTCPSocket::Accept | SFBAStream::Read | BREW API ISOCKET_Read

戻り値

解説

この関数は、Accept（待機中の接続リクエストを 1 つ取り出し、クライアントとの接続を確立する操作）をスケジュールします。

具体的には、 SFXTCPSocket::Accept 関数を使用して Accept を行うコールバック関数を登録します。 登録されたコールバック関数は、Accept が可能になると BREW AEE により呼び出されます。

コールバック関数が呼び出されるまでは、「Accept スケジュール中の状態」になります。 コールバック関数が呼び出されると、この関数を呼び出す直前の状態（ソケットが Listen している状態）に戻ります。

コールバック関数が呼び出される前に、 SFXTCPSocket::Cancel 関数を呼び出すと、 Accept のスケジュールはキャンセルされ、この関数を呼び出す直前の状態（ソケットが Listen している状態）に戻ります。

なお、この関数の戻り値がエラー（SFERR_NO_ERROR 以外の値）の場合、コールバック関数は呼び出されません。

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

	注意
	この関数は、 内部で SFBAStream::Readable 関数を呼び出します。

	前提条件
	この関数を呼び出す前に、 このソケットは SFXTCPSocket::Listen 関数を呼び出して Listen（サーバー側で接続リクエストの待ち受けを開始する操作）を行っている必要があります 。 また、既に Accept がスケジュールされている場合は、SFERR_INVALID_STATE エラーが返ります。

参照

SFXTCPSocket::Accept | SFXTCPSocket::Listen | SFBAStream::Readable | SFXStorage::CallbackSPP | BREW API ISOCKET_Readable

戻り値

解説

この関数は、Bind（ソケットに端末のローカル IP アドレスとポート番号を関連付ける操作）をスケジュールします。

具体的には、 SFXTCPSocket::Bind 関数を使用して Bind を行うコールバック関数を登録します。 登録されたコールバック関数は、Bind が可能になると BREW AEE により呼び出されます。

コールバック関数が呼び出されるまでは、「Bind スケジュール中の状態」になります。 コールバック関数が呼び出されると、この関数を呼び出す直前の状態（ソケットが開いている状態）に戻ります。

コールバック関数が呼び出される前に、 SFXTCPSocket::Cancel 関数を呼び出すと、 Bind のスケジュールはキャンセルされ、この関数を呼び出す直前の状態（ソケットが開いている状態）に戻ります。

なお、この関数の戻り値がエラー（SFERR_NO_ERROR 以外の値）の場合、コールバック関数は呼び出されません。

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

	注意
	この関数は、 内部で SFBSocket::Writeable 関数を呼び出します。

	前提条件
	この関数を呼び出す前に、 このソケットは SFXTCPSocket::Open 関数を呼び出して 開いている必要があります。 但し、接続が確立されている、もしくは、確立中の場合は、 SFERR_INVALID_STATE エラーが返ります。 また、既に Bind がスケジュールされている場合も、SFERR_INVALID_STATE エラーが返ります。

参照

SFXTCPSocket::Bind | SFBSocket::Writeable | SFXStorage::CallbackSPP | BREW API ISOCKET_Writeable

戻り値

解説

この関数は、Listen（サーバー側で接続リクエストの待ち受けを開始する操作）をスケジュールします。

具体的には、 SFXTCPSocket::Listen 関数を使用して Listen を行うコールバック関数を登録します。 登録されたコールバック関数は、Listen が可能になると BREW AEE により呼び出されます。

コールバック関数が呼び出されるまでは、「Listen スケジュール中の状態」になります。 コールバック関数が呼び出されると、この関数を呼び出す直前の状態（ソケットが Bind している状態）に戻ります。

コールバック関数が呼び出される前に、 SFXTCPSocket::Cancel 関数を呼び出すと、 Listen のスケジュールはキャンセルされ、この関数を呼び出す直前の状態（ソケットが Bind している状態）に戻ります。

なお、この関数の戻り値がエラー（SFERR_NO_ERROR 以外の値）の場合、コールバック関数は呼び出されません。

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

	注意
	この関数は、 内部で SFBSocket::Writeable 関数を呼び出します。

	前提条件
	この関数を呼び出す前に、 このソケットは SFXTCPSocket::Bind 関数を呼び出して Bind（ソケットに端末のローカル IP アドレスとポート番号を関連付ける操作）している必要があります 。 また、既に Listen がスケジュールされている場合は、SFERR_INVALID_STATE エラーが返ります。

参照

SFXTCPSocket::Listen | SFBSocket::Writeable | SFXStorage::CallbackSPP | BREW API ISOCKET_Writeable

戻り値

解説

この関数は、Read（ストリームを使用しないソケットからのデータ受信）をスケジュールします。

具体的には、 SFXTCPSocket::Read 関数による Read を行うコールバック関数を登録します。 登録されたコールバック関数は、Read が可能になると BREW AEE により呼び出されます。

コールバック関数が呼び出されるまでは、「Read スケジュール中の状態」になります。 コールバック関数が呼び出されると、この関数を呼び出す直前の状態（接続が確立している状態）に戻ります。

コールバック関数が呼び出される前に、 SFXTCPSocket::Cancel 関数を呼び出すと、 Read のスケジュールはキャンセルされ、この関数を呼び出す直前の状態（接続が確立している状態）に戻ります。

なお、この関数の戻り値がエラー（SFERR_NO_ERROR 以外の値）の場合、コールバック関数は呼び出されません。

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

	注意
	この関数は、 内部で SFBAStream::Readable 関数を呼び出します。

	前提条件
	この関数を呼び出す前に、 このソケットは SFXTCPSocket::Connect 関数を呼び出して 接続を確立している必要があります 。 もしくは、 このソケットは SFXTCPSocket::Accept 関数が result 引数に返した「接続確立済みのソケット」である必要があります。 また、既に Read がスケジュールされている場合は、SFERR_INVALID_STATE エラーが返ります。

使用例

// SFXTCPSocket インスタンス (_socket) はクラスのメンバ変数として定義する   
class TcpSample {
private:
    SFXTCPSocket _socket;
public:
    // コールバック関数の宣言
    XALLBACK_DECLARE_SFXTCPSOCKET(OnWrite)  
    XALLBACK_DECLARE_SFXTCPSOCKET(OnRead)  
};

// Write（データ送信）可能が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnWrite, error)
{
    UInt32 size;
    static ACharConst data[] = "GET / HTTP/1.0\n\n";
    
    // データを書き込む
    size = sizeof(data) - 1;
    switch (error = _socket.Write(data, &size)) {

        case SFERR_NO_ERROR:

            // Read をスケジュールする: コールバック関数を登録する
            // ※ Read 可能になれば、OnRead コールバック関数が呼び出される
            _socket.ScheduleRead(XALLBACK_INTERNAL(OnRead));
            break;

        case AEE_NET_WOULDBLOCK:

            // Write をスケジュールする: コールバック関数を登録する
            // ※ Write 可能になれば、OnWrite コールバック関数が呼び出される
            _socket.ScheduleWrite(XALLBACK_INTERNAL(OnWrite));
            break;
    }
}

// Read（データ受信）可能が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnRead, error)
{
    SFXBuffer buffer;
    UInt32 size;

    // データを読み込む
    buffer.SetSize(32);
    size = buffer.GetSize();
    switch (_socket.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());
                
                _socket.Close();  // 接続を閉じる
            }
            else {
                ...
            }
            break;

        case AEE_NET_WOULDBLOCK:

            // Read をスケジュールする: コールバック関数を登録する
            // ※ Read 可能になれば、OnRead コールバック関数が呼び出される
            _socket.ScheduleRead(XALLBACK_INTERNAL(OnRead));
            break;
    }
    return;
}

参照

SFXTCPSocket::Read | SFXTCPSocket::Accept | SFBAStream::Readable | SFXStorage::CallbackSPP | BREW API ISOCKET_Readable

戻り値

解説

この関数は、Write（ストリームを使用しないソケットへのデータ送信）をスケジュールします。

具体的には、 SFXTCPSocket::Write 関数による Write を行うコールバック関数を登録します。 登録されたコールバック関数は、Write が可能になると BREW AEE により呼び出されます。

コールバック関数が呼び出されるまでは、「Write スケジュール中の状態」になります。 コールバック関数が呼び出されると、この関数を呼び出す直前の状態（接続が確立している状態）に戻ります。

コールバック関数が呼び出される前に、 SFXTCPSocket::Cancel 関数を呼び出すと、 Write のスケジュールはキャンセルされ、この関数を呼び出す直前の状態（接続が確立している状態）に戻ります。

なお、この関数の戻り値がエラー（SFERR_NO_ERROR 以外の値）の場合、コールバック関数は呼び出されません。

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

	注意
	この関数は、 内部で SFBSocket::Writeable 関数を呼び出します。

	前提条件
	この関数を呼び出す前に、 このソケットは SFXTCPSocket::Connect 関数を呼び出して 接続を確立している必要があります 。 もしくは、 このソケットは SFXTCPSocket::Accept 関数が result 引数に返した「接続確立済みのソケット」である必要があります。 また、既に Write がスケジュールされている場合は、SFERR_INVALID_STATE エラーが返ります。

使用例

// SFXTCPSocket インスタンス (_socket) はクラスのメンバ変数として定義する   
class TcpSample {
private:

    SFXTCPSocket _socket;

public:

    // コールバック関数の宣言
    XALLBACK_DECLARE_SFXTCPSOCKET(OnConnect)  
    XALLBACK_DECLARE_SFXTCPSOCKET(OnWrite)  
};

// 接続要求の結果が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnConnect, error)
{
    if (error == SFERR_NO_ERROR) {

        // Write をスケジュールする: コールバック関数を登録する
        // ※ Write 可能になれば、OnWrite コールバック関数が呼び出される
        _socket.ScheduleWrite(XALLBACK_INTERNAL(OnWrite));
    }
}

// Write（データ送信）可能が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnWrite, error)
{
    UInt32 size;
    static ACharConst data[] = "GET / HTTP/1.0\n\n";
    
    // データを書き込む
    size = sizeof(data) - 1;

    switch (error = _socket.Write(data, &size)) {

        case SFERR_NO_ERROR:

            ...
            break;

        case AEE_NET_WOULDBLOCK:

            // Write をスケジュールする: コールバック関数を登録する
            // ※ Write 可能になれば、OnWrite コールバック関数が呼び出される
            _socket.ScheduleWrite(XALLBACK_INTERNAL(OnWrite));
            break;
    }
}

参照

SFXTCPSocket::Write | SFBSocket::Writeable | SFXTCPSocket::Accept | SFXStorage::CallbackSPP | BREW API ISOCKET_Writeable

引数

戻り値

解説

この関数は、Write（ストリームを使用しないソケットへのデータ送信）を行います。

※ この関数が AEE_NET_WOULDBLOCK を返す場合、 SFXTCPSocket::ScheduleWrite 関数でコールバック関数を登録し、 コールバック関数の中で再度この関数を呼び出して Write を行う必要があります。

	注意
	この関数は、 内部で SFBSocket::Write 関数を呼び出します。

	前提条件
	この関数を呼び出す前に、 このソケットは SFXTCPSocket::Connect 関数を呼び出して 接続を確立している必要があります 。 もしくは、 このソケットは SFXTCPSocket::Accept 関数が result 引数に返した「接続確立済みのソケット」である必要があります。

使用例

// SFXTCPSocket インスタンス (_socket) はクラスのメンバ変数として定義する   
class TcpSample {
private:

    SFXTCPSocket _socket;

public:

    // コールバック関数の宣言
    XALLBACK_DECLARE_SFXTCPSOCKET(OnConnect)  
    XALLBACK_DECLARE_SFXTCPSOCKET(OnWrite)  
};

// 接続要求の結果が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnConnect, error)
{
    if (error == SFERR_NO_ERROR) {

        // Write をスケジュールする: コールバック関数を登録する
        // ※ Write 可能になれば、OnWrite コールバック関数が呼び出される
        _socket.ScheduleWrite(XALLBACK_INTERNAL(OnWrite));
    }
}

// Write（データ送信）可能が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXTCPSOCKET(TcpSample, OnWrite, error)
{
    UInt32 size;
    static ACharConst data[] = "GET / HTTP/1.0\n\n";
    
    // データを書き込む
    size = sizeof(data) - 1;

    switch (error = _socket.Write(data, &size)) {

        case SFERR_NO_ERROR:

            ...
            break;

        case AEE_NET_WOULDBLOCK:

            // Write をスケジュールする: コールバック関数を登録する
            // ※ Write 可能になれば、OnWrite コールバック関数が呼び出される
            _socket.ScheduleWrite(XALLBACK_INTERNAL(OnWrite));
            break;
    }
}

参照

SFXTCPSocket::ScheduleWrite | SFXTCPSocket::Accept | SFBSocket::Write | BREW API ISOCKET_Write