Android TCP通信 inputStream.readにタイムアウトを設定したい

Question

前提・実現したいこと

こちらのKotlinのコードを参考に、スマホアプリをクライアントとしてTCP通信を行うプログラムを作成しています。
socket接続とサーバーとの電文のやり取りはできたのですが、outputStreamで送信してから〇秒以内に返信がない場合、というタイムアウトを設定することができません。
socket.soTimeoutを用いればタイムアウトを設定できるそうなのですが、動作してないように見えます。（java.net.SocketTimeoutExceptionに引っ掛かりません）
どのようにすればAndroidのKotlinでTCP通信のリードタイムアウトを設定できるのでしょうか？
socket.soTimeoutを使えるようにするのでも、何かタイマーを設けるものでも、タイムアウトの判定ができればいいです。

参考（setSoTimeout）

該当のソースコード

whileで連続してサーバーに送信し続け、途中でサーバーを落とし、タイムアウト（もしくは切断）を検知できるか、という風にしています。

MainActivity

import android.os.Bundle
import android.os.Handler
import android.util.Log
import android.widget.Button
import androidx.appcompat.app.AppCompatActivity
import kotlinx.coroutines.channels.Channel
import java.nio.ByteBuffer


const val MSG_CONNECTION_SUCCESS = 111 // 接続成功
const val MSG_CONNECTION_FAILED = 222  // 接続失敗
const val MSG_IOEXCEPTION = 333        // 例外発生

class MainActivity : AppCompatActivity() {
    private var tcpcom: ComTcpClient? = null
    val ip = "10.0.2.2"
    val port = "2001"
    private val TAG = MainActivity::class.java.simpleName
    val handler = Handler()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        connect()

        val runnable = object: Runnable{
            override fun run(){
                val sendArray = ByteBuffer.allocate(30)
                sendArray.putInt(0x01020304)
                val byteArray = ByteBuffer.allocate(30)

                try {
                    tcpcom?.sendOrReceive { outputStream, inputStream ->
                        println("output")
                        outputStream.write(sendArray.array())
                        try{
                            println("input")
                            inputStream.read(byteArray.array())

                        } catch(e: Exception){
                            println("error")
                        }
                    }
                } catch(e: Exception){
                    Log.d(TAG,"Failed...")
                }
                handler.postDelayed(this,5000)
            }
        }
        handler.post(runnable)
   
    }

    fun connect(){
        val channel = Channel<Int>()
        if (!ip.isEmpty() && !port.isEmpty()) {
            tcpcom = ComTcpClient(ip, port.toInt(), channel)
            tcpcom?.connect()
        }
    }
}

ComTCPClient
サーバー切断後もjava.net.SocketTimeoutExceptionにもIOExceptionにも引っ掛かりません……。なんならExceptionにも引っ掛かりません。

import android.util.Log
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.launch
import java.io.IOException
import java.io.InputStream
import java.io.OutputStream
import java.net.Socket
import java.net.UnknownHostException

class ComTcpClient(val ip: String, val port: Int, val channel: Channel<Int>) {
    private var socket: Socket? = null
    private val TAG = ComTcpClient::class.java.simpleName

    fun connect() {
        GlobalScope.launch(Dispatchers.Default) {
            Log.d(TAG, "接続開始...")
            try {
                socket = Socket(ip, port)
                channel.send(MSG_CONNECTION_SUCCESS)

            } catch (e: IOException) {
                Log.e(TAG, "IOException", e)
                channel.send(MSG_IOEXCEPTION)

            } catch (e: UnknownHostException) {
                Log.e(TAG, "UnknownHostException", e)
                channel.send(MSG_CONNECTION_FAILED)
            }
        }
    }

    fun sendOrReceive(callback: (OutputStream, InputStream) -> Unit) {
        socket?.soTimeout = 1000
        if (socket == null) throw java.lang.IllegalStateException()
        socket?.also { socket ->
            GlobalScope.launch(Dispatchers.Default) {
                try {
                    if (socket.isConnected) {
                        println("SOCKET!")
                        callback(socket.outputStream, socket.inputStream)
                    } else {
                        channel.send(MSG_CONNECTION_FAILED)
                        println("disconnect...")
                    }
                } catch(e: java.net.SocketTimeoutException){
                    println("Timeout!!")
                } catch (e: IOException) {
                    channel.send(MSG_IOEXCEPTION)
                    println("socket error")
                }
            }
        }
    }

    fun close() {
        if (socket == null) throw java.lang.IllegalStateException()
        socket?.also { socket ->
            GlobalScope.launch(Dispatchers.Default) {
                try {
                    if (socket.isConnected) socket.close()
                } catch (e: IOException) {
                    channel.send(MSG_IOEXCEPTION)
                }
            }
        }
    }
}

一応サーバー側も記載しておきます。両者はローカルループバックで接続しています。

import socketserver

class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        while(True):
            self.data = self.request.recv(1024).strip()
            print("{} wrote:".format(self.client_address[0]))
            print(self.data)
            
            send_array = (0x01020304).to_bytes(4,byteorder="big",signed="true")
                  
            self.request.sendall(send_array) 

if __name__ == "__main__":
    HOST, PORT = '127.0.0.1', 2001

    with socketserver.TCPServer((HOST, PORT), MyTCPHandler) as server:
        server.serve_forever()
        

Answer 1

サーバ側は Python が分からないので java で(タイムアウトが出るように)作りましたが、ご提示のクライアントコードでタイムアウトは発生しています。

恐らく原因はそのテスト方法とコードの不備と思います。
「途中でサーバーを落とし、タイムアウト（もしくは切断）を検知できるか」と言われていますが、クライアントが read 中にソケットを切断した場合、タイムアウト(等の例外の発生)では無く read (のブロック) が戻るだけです。
必要なのはその時の read の戻り値から何が起きたのかを判断するのであり、ご提示のコードでは判断どころか戻り値の取得もしていません。

read でタイムアウトを発生させるのであれば、ソケットは繋いだままでサーバからの送信を遅らせる形でテストするべきと思います。

なお、参考とされているドキュメントは ORACLE のもので、つまり PC 用 Java のものです。
基本同じとはいえ、Android のドキュメント を参考にされたほうが良いと思います。

---

ハンドラでコルーチンという構造が良く分からなかったので、 java から変換する形でハンドラだけのものを作ってみました。
ByteBuffer 使用部分も素直に配列にしています。

MainActivity.kt

package com.teratail.a363500

import android.os.Bundle
import android.os.Handler
import android.os.HandlerThread
import android.util.Log
import android.widget.Button
import androidx.appcompat.app.AppCompatActivity
import java.io.IOException
import java.io.InputStream
import java.io.OutputStream
import java.net.InetSocketAddress
import java.net.Socket
import java.net.SocketAddress

class MainActivity : AppCompatActivity() {
  private lateinit var ht: HandlerThread
  private lateinit var pinger: Pinger

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    ht = HandlerThread("PingerThread")
    ht.start()

    val endpoint = InetSocketAddress("10.0.2.2", 2001) //エミュレータ → ホストPC
    pinger = Pinger(endpoint, 5000, 500, 1000)

    val button = findViewById<Button>(R.id.button) //ボタンを押すと開始
    button.setOnClickListener { pinger.start(Handler(ht.looper)) }
  }

  override fun onDestroy() {
    super.onDestroy()
    ht.quit()
    pinger.stop()
  }
}

class Pinger(val endpoint: SocketAddress, val interval: Long, val timeoutOfConnect: Int, val timeoutOfRead: Int) {
  companion object {
    private const val TAG = "Pinger"
  }

  private var s: Socket? = null

  fun start(handler: Handler) {
    handler.post {
      try {
        s = Socket().also {
          it.connect(endpoint, timeoutOfConnect)
          it.soTimeout = timeoutOfRead
          val output = it.getOutputStream()
          val input = it.getInputStream()

          if (ping(output, input)) next(handler, output, input)
        }
      } catch (e: Exception) {
        e.printStackTrace()
      }
    }
  }

  private fun next(handler: Handler, output: OutputStream, input: InputStream) {
    handler.postDelayed({
      if (ping(output, input)) next(handler, output, input)
    }, interval)
  }

  private fun ping(output: OutputStream, input: InputStream): Boolean {
    try {
      Log.d(TAG, "write")
      output.write(byteArrayOf(1,2,3,4))

      Log.d(TAG, "read")
      val buf = ByteArray(4);
      val len = input.read(buf)
      Log.d(TAG, "len=$len")
      if (len < buf.size) {
        Log.d(TAG, "切断")
        stop()
        return false
      }
      if (buf.contentEquals(byteArrayOf(1,2,3,4))) {
        Log.d(TAG, "OK")
      } else {
        Log.d(TAG, "data error");
      }
    } catch (e: Exception) {
      e.printStackTrace()
      stop()
      return false
    }
    return true
  }

  fun stop() {
    Log.d(TAG, "stop")
    try {
      s?.close()
    } catch (ignore: IOException) {
    }
    s = null
  }
}

レイアウト: activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivityJ">

  <Button
      android:id="@+id/button"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="START"
      app:layout_constraintBottom_toBottomOf="parent"
      app:layout_constraintLeft_toLeftOf="parent"
      app:layout_constraintRight_toRightOf="parent"
      app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Comments

[RgrayLemon]

サーバーのプログラムを電文を受信してから送信するまで一定時間遅らせるように変えて試したところ、タイムアウトが生じていることが確認できました。ずっと勘違いしていたようです……ありがとうございます！
ただ、このタイムアウトの目的は、電文の応答がないことによってサーバーとの接続が切れたと判断することだったので、別の方法を考える必要がありそうです。
切断に関してはjava.net.SocketExceptionなどで拾う必要があるのでしょうか？

[jimbe]

回答にも書いていますが、ソケット切断時は(例外は発生せず)ブロックしていた read が受信用に指定したパラメータの配列の大きさ未満の値を返します。(1バイトも受信していなければ -1 となります。)
ですので、read の戻り値をチェックして、必要なデータ数分受信した=正常応答か、必要数に達していない( or -1 )=切断かを判断してください。

read していない状態( 5 秒の delay 中 等 ) で切断した場合、次の write → read のタイミングで read が -1 を返して切断が分かるということになると思いますので、テストしてみてください。

[RgrayLemon]

readの戻り値を取得して-1が返るかどうかで切断を判断することもできました！ありがとうございます！
Javaも似たようなものだろうとJavaのドキュメントを見ていたのですが、Androidのドキュメントに記載があったのですね。きちんと読もうと思います。streamに関してもいろいろ間違っている点がありそうなので、もう少し調べようと思います。
何はともあれ目的は達成できました。ご丁寧に詳しくありがとうございました！