grpc流式調用--android

github鏈接：

https://github.com/grpc/grpc-java

 

python\node\java 其功能都是一樣的，可以單向流式調用，也可以雙向，以下是我的單向調用類，使用非阻塞式方式。

 

implementation 'io.grpc:grpc-okhttp:1.26.0'
implementation 'io.grpc:grpc-protobuf-lite:1.26.0'
implementation 'io.grpc:grpc-stub:1.26.0'

 

使用：

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;

import com.alpha.aiservice.App;
import com.alpha.aiservice.CommonServiceGrpc;
import com.alpha.aiservice.ControlProto;
import com.alpha.aiservice.HandProto;
import com.alpha.aiservice.ImageProto;
import com.alpha.aiservice.data.bean.NanoVersion;
import com.alpha.libcommon.utils.GsonUtil;

import java.util.concurrent.TimeUnit;

import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.stub.StreamObserver;


/**
 * GrpcClient 連接client
 */

public class GrpcClient {

    private String Tag = this.getClass().getSimpleName();
    public static GrpcClient grpcManager;

    public static synchronized GrpcClient instance() {
        if (grpcManager == null) {
            grpcManager = new GrpcClient();
        }
        return grpcManager;
    }

    private long lastPreviewTime = 0;
    private GrpcConnectListener grpcConnectListener;
    private ManagedChannel channel;
    private CommonServiceGrpc.CommonServiceStub serviceBlockingStub;

    private long delayTime = 10 * 1000;
    private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if (System.currentTimeMillis() - lastPreviewTime > delayTime * 2) {
                Log.e(Tag, "grpc connect timeout!");
                GrpcClient.instance().reConnect();
            } else {
                sendCmd();
            }
            handler.sendEmptyMessageDelayed(0, delayTime);
        }
    };

    public GrpcConnectListener getGrpcConnectListener() {
        return grpcConnectListener;
    }

    public void setGrpcConnectListener(GrpcConnectListener grpcConnectListener) {
        this.grpcConnectListener = grpcConnectListener;
    }

    public void startConnect() {
        Runnable runable = new Runnable() {
            @Override
            public void run() {
                try {
                    channel = ManagedChannelBuilder.forAddress(Const.Grpc.host, Const.Grpc.port).usePlaintext().build();
                    serviceBlockingStub = CommonServiceGrpc.newStub(channel);
                    sendCmd();
                    getHand();
                    statusListener();
                } catch (Exception e) {
                    Log.e(Tag, "grpc connect Exception: " + e.toString());
                }
            }
        };
        new Thread(runable).start();
    }

    //監聽狀態
    private void statusListener() {
        // 監聽連接狀態
        handler.removeMessages(0);
        handler.sendEmptyMessageDelayed(0, delayTime);
    }

    //手勢
    private void getHand() {
        HandProto.HandRequest handRequest = HandProto.HandRequest.newBuilder().build();
        serviceBlockingStub.getHand(handRequest, new StreamObserver<HandProto.HandResponse>() {
            @Override
            public void onNext(HandProto.HandResponse response) {
                if (grpcConnectListener != null) {
                    grpcConnectListener.handCallBack(response);
                }
            }

            @Override
            public void onError(Throwable t) {

            }

            @Override
            public void onCompleted() {

            }
        });
    }

    private void sendCmd() {
        ControlProto.ControlRequest request = ControlProto.ControlRequest.newBuilder().setCmdId(1).build();
        serviceBlockingStub.putControl(request, new StreamObserver<ControlProto.ControlResponse>() {
            @Override
            public void onNext(ControlProto.ControlResponse response) {
                String responseMsg = response.getMsg();
                Log.e(Tag, "sendCmd back:" + responseMsg);
                lastPreviewTime = System.currentTimeMillis();
//                try {
//                    NanoVersion version = GsonUtil.gsonToBean(responseMsg, NanoVersion.class);
//                    int nanoVersionCode = Integer.parseInt(version.getVersion().replace(".", ""));
//                    if (Const.NanoMsg.versionCode > nanoVersionCode) {
//                        NanoUpdateUtils.update(App.mContext);
//                    }
//                } catch (Exception ex) {
//                    ex.printStackTrace();
//                    NanoUpdateUtils.update(App.mContext);
//                }
            }

            @Override
            public void onError(Throwable t) {

            }

            @Override
            public void onCompleted() {

            }
        });
    }

    public void reConnect() {
        handler.removeMessages(0);
        Log.e(Tag, "reConnect()");
        if (channel != null) {
            channel.shutdownNow();
        }
        channel = null;
        serviceBlockingStub = null;
        startConnect();
    }

    public void shutdown() {
        try {
            channel.shutdown().awaitTermination(1, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}