gRPC and HTTP 1 call on single port, with out using TLS in goLang

I have recently started working in <b>golang</b> for a project, where I have to use gRPC for push notification on my server to connect to an Android device.
I have created a simple multiplexer mux := http.NewServeMux() which is working fine with my server code:

  serverWeb := http.Server{
	Addr:	constants.ServerIPWeb,
	//Handler: grpcHandlerFunc(grpcServer, mux),
	Handler: mux,
}

serverWeb.ListenAndServe()

As from the examples on <a href="https://grpc.io/">gRPC.io</a> I have also created a simple gRPC client/server as a standalone project connected to my android device, with out any TLS configuration and its working fine.

type server struct{}

func (s *server) DeviceData(ctx context.Context,req *pb.GetDeviceRequest) (*pb.SetDeviceResponse, error){
    util.P("Device is: ",req) // simple fmt.PrintF(a ... interface)
    return  &pb.SetDeviceResponse{Message:"Success"}, nil
}

func main(){
    lis, err := net.Listen("tcp", ":8080")
    if err!=nil{
	log.Fatalf("Failed to listen: %v", err)
	}
	s := grpc.NewServer()
	pb.RegisterDeviceInfoServer(s,&server{})
    reflection.Register(s)
    if err := s.Serve(lis); err != nil{
	    log.Fatalf("Falied to server: %v", err)
    }
}

The <b>problem</b> is I could not connect my current gRPC server to my serverStruct above. I have tried to add Handler: grpcHandlerFunc(grpcServer, mux) that will connect my server to the following code, as explained here (<a href="https://grpc.io/blog/coreos"> gRPC with open API </a>)

func grpcHandlerFunc(grpcServer *grpc.Server, otherHandler http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
	// TODO(tamird): point to merged gRPC code rather than a PR.
	// This is a partial recreation of gRPC's internal checks https://github.com/grpc/grpc-go/pull/514/files#diff-95e9a25b738459a2d3030e1e6fa2a718R61
	util.P("ResponseFunction: GRPC: ",r.URL) // simple fmt.PrintF(a ... interface)
	if r.ProtoMajor == 2 && strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
		grpcServer.ServeHTTP(w, r)
	} else {
		otherHandler.ServeHTTP(w, r)
	}
})
}

The above code will run my Service running from my mux i.e connecting to http, but it won't run services from gRPC, i.e is connecting to my Android Device.

I believe it requires, TLS connection, but I don't want to get into the implementation of securing my web and Android side code, as that would require me to change all the code at my Android Side and Web, which I want to avoid.

So I am looking for a way to connect this grpcServer to my current serverStruct without using any TLS configuration.

<b>More Over myResearcH:</b>
I have also searched there is a repo called cmux (<a href="https://github.com/soheilhy/cmux">Connection Mux</a>) which will do the same job, but I don't understand how would I use it with my current serverStruct, as I have a fully functional web app running on this, and I just need to add gRPC with my current code.

gRPC Service can be achieved with out the implementation of TLS by using go routines.<br /><br />
<b>Create a Function, Serving your gRPC</b>

func RunGRPC()  {
    grpcServer := grpc.NewServer()
	pb.RegisterGlassInfoServer(grpcServer,&GlassApkBean{})
    pb.RegisterDeviceInfoServer(grpcServer, &DeviceInfoBean{}) // for multiple services
	lis, err := net.Listen("tcp", ":50051")
    if err !=nil{
	    log.Fatalf("Error: %v\n" , err.Error())
    }
	grpcServer.Serve(lis)
}

<b> use this function, to recive client request</b>

func main(){
    .
    . // Your Code
    .
    go RunGRPC() // code to run grpc server in go routine. 
    serverWeb := http.Server{
        Addr:   "localhost:8080",
        Handler: mux,
}

serverWeb.ListenAndServe()
}