android - 如何有效地将流式数据从服务传递到 Activity ？

Question

我正在开发一个与外部服务器应用程序交互的产品。我无法更改外部服务器或传入数据的协议(protocol)或格式。

我的应用程序(主要)作为一项服务运行，该服务通过网络从外部服务接收数据包。许多这些数据包都是信息性的，但是外部服务可以选择发送我的应用程序“视频”数据。此数据采用专有格式，并作为单独编码的数据“帧”出现。我的服务将专有格式解码为位图数据并将其(作为单独的帧)发送到我的“显示视频” Activity 。

由于这些帧每秒可以出现多次，我希望流式传输尽可能没有“卡顿”。我正在寻找将每一帧从我的服务传递到显示 Activity 的最有效方法。我提出了三种方法，但我的问题是哪种方法最有效(如果有的话)，以及您是否有任何建议。

我将解释每种方法，并为每种方法展示一些示例代码。注意:我包含的代码是简化的，但代表“现有功能代码”我已经在各种应用程序中使用了这些方法中的每一种，但希望就最适合这个特定应用程序的方法提出一些意见。我知道意见就像背后。每个人都有一个...

方法一:“绑定(bind)服务消息”

当“显示视频” Activity 启动时，它会绑定(bind)到服务并设置 MessageHandler。服务使用此处理程序将每个“帧”发送到 Activity ， Activity 又将帧绘制到表面 View 。

代码:

我的 Activity 绑定(bind)到 onResume() 中的服务

 void doBindService()
 {
     bindService(new Intent( this, com.myservice.class ), mConnection, Context.BIND_AUTO_CREATE );
 }

在 onServiceConnected() 中，我向服务发送对我的 Messenger 的引用。

public void onServiceConnected( ComponentName className, Ibinder service )
{
    m_service = new Messenger( service );
    Message msg = Message.obtain(null, MyService.MSG_REGISTER_CLIENT );
    msg.replyTo = mMessenger;
    msg.arg1 = getServiceClientType(); 
    m_service.send(msg);
}

当服务消息处理程序收到 MSG_REGISTER_CLIENT 消息时，它会存储连接 Activity 的“replyTo”。

protected class IncomingHandler extends Handler 
{
    @Override
    public void handleMessage(Message msg)
    {
        MessageParcel p = null;
        Bundle b = msg.getData();
        switch ( msg.what )
        {
             case MSG_REGISTER_CLIENT:
             {
                 m_client_messenger = msg.replyTo;
                 break;
             }

             .....

        }
    }

}

当我从服务器收到视频帧时，我使用存储的 Messenger 将帧发送到 Activity。

protected void sendClientFrame( byte[] frameData )
{
    Message message = Message.obtain();
    Bundle b = new Bundle();
    b.putByteArray( "frame_data", frameData );
    message.setData(b);
    message.what = MyActivity.MSG_FRAME_DATA;
    message.replyTo( mMessenger );
    if ( m_client_messenger != null )
        m_client_messenger.send(message);
}

当 Activity 收到此消息时，它会绘制:

class IncomingServiceMessageHandler extends Handler
{
    @Override
    public void handleMessage( Mesasge msg )
    {
        super.handleMessage( msg );
        switch ( msg.what )
        {
            case MyActivity.MSG_FRAME_DATA:
                Bundle b = msg.getData();
                b.setClassLoader( getClassLoader() );
                byte[] frame_data = b.getByteArray( "frame_data" );
                if ( frame_data != null )
                     decode_and_paint_frame_data( frame_data );
                break;

             case ....:
        }

    }

}

方法二:“Intent 框架”

此方法将每个传入的帧打包到一个 Intent 中，并将该 Intent 发送到 View Activity 。

代码:

当服务接收到视频帧时，它会创建一个 Intent 并将帧数据打包到 Intent 中并将其触发到 Activity 。

public void sendShowVideoActivityFrame( byte[] framedata )
{
    Intent frame_intent = new Intent( this, MyActivity.class );
    frame_intent.setFlags( Intent.FLAG_ACTIVITY_RENDER_TO_FRONT );
    frame_intent.setAction( MyActivity.ACTION_SEND_FRAME );
    frame_intent.startActivity( );
    frame_intent.putExtra( "frame_data", framedata );

    startActivity( frame_intent );

}

当 Activity 接收到 Intent 时，它解码并绘制帧数据:

@Override
protected void onNewIntent( Intent intent )
{
    super.onNewIntent(intent);

    if ( intent.getAction().compareTo( MyActivity.ACTION_SEND_FRAME ) == 0 )
    {
        byte[] frame_data = intent.getByteArrayExtra( "frame_data" );
        if ( frame_data != null )
            decode_and_paint_frame_data( frame_data );

    }
}

方法三:“通过本地socket发送”

当服务接收到视频帧时，它通过本地套接字连接到“显示视频” Activity 。然后使用此套接字将每个帧“流”到服务接收到的 Activity 。

代码:

服务创建套接字并连接到 Activity :

protected Socket m_activity_socket = null;
protected InputStream m_nis = null;
protected OutputStrea m_nos = null;

protected void sendClientFrame( byte[] frameData )
{
    if ( m_activity_socket == null )
    {
         m_activity_socket = new Socket()
         SocketAddress sockaddr = new InetSocketAddress("127.0.0.1", 12345 );
         m_activity_socket.connect( sockaddr, 5000 );
                if (m_activity_socket.isConnected()) { 
                    m_nis = m_activity_socket.getInputStream();
                    m_nos = m_activity_socket.getOutputStream();
    }

    if ( m_nos != null )
    {
         // the header describes the frame data (type, width, height, length)
         // frame width and heigth have been previously decoded
         byte[] header = new byte[16];
         build_header( 1, width, height, frameData.length, header, 1 );
         m_nos.write( header );  // message header
         m_nos.write( frameData );  // message data
    }
}

当客户端从套接字接收到消息时，它会解码帧数据并绘制它。

public class SocketServerListener implements Runnable
{
    private boolean _run = false;

    public void run()
    {
         Socket s = null;
         _run = true;
         serverSocket = new ServerSocket( 12345 );

         while( _run )
         {
             s = serverSocket.accept();

             handleSocket( s );
         }

         serverSocket.close();
    }

    public void handleSocket( Socket s )
    {
        InputStream in = s.getInputStream();
        OutputStream out = s.getOutputStream();
        int bytes_read = 0;

        byte[] header = new byte[16];
        bytes_read = in.read( buffer, 0, header.length );

        // the header contains the number of bytes in the frame data
        int data_len = header_get_frame_length( );

        byte[] frame_data = new byte[data_len];
        bytes_read = in.read( frame_data, 0, frame_data.length );
        if ( bytes_read == data_len ) // we got the full frame
             decode_and_paint_frame_data( frame_data );    
    }

}

提前感谢您的建设性意见。

Answer 1

经过数小时的研究和数天的实验、反复试验，我决定采用所描述的最后一种方法。我的服务发送一个 Intent 来启动我的 Activity ，然后等待 Activity 启动一个 ServerSocket 监听给定的本地非特权端口。 Activity 准备就绪后，它会启动一个线程，并在指定端口上监听一个套接字。然后该服务使用 Socket 连接到该端口并发送帧数据。在上面的示例代码中，似乎我正在为每一帧重新连接。实际代码中并非如此。一旦服务连接到套接字，它只是保持它打开并发送从内容服务器接收到的每一帧数据。

之所以选择这种方法，是因为它看起来效率最高，而且我对套接字编程也很熟悉。通过服务消息或 Intent 发送帧似乎非常低效，并且在我无法控制的地方引入了延迟。