Transport Providers

/**
 * Check if the Netty channel provider is available
 * @return true if Netty transport is available
 */
public boolean isAvailable();

/**
 * Get the priority of this provider (higher values have higher priority)
 * @return Provider priority value
 */
public int priority();

/**
 * Create a channel builder for the specified address
 * @param name Host name
 * @param port Port number
 * @return NettyChannelBuilder for the address
 */
public NettyChannelBuilder builderForAddress(String name, int port);

/**
 * Create a channel builder for the specified target
 * @param target Target string (e.g., "dns:///service.com:443")
 * @return NettyChannelBuilder for the target
 */
public NettyChannelBuilder builderForTarget(String target);

/**
 * Create a new channel builder with credentials
 * @param target Target string
 * @param creds Channel credentials
 * @return Result containing the channel builder
 */
public NewChannelBuilderResult newChannelBuilder(String target, ChannelCredentials creds);

import io.grpc.netty.shaded.io.grpc.netty.NettyChannelProvider;

NettyChannelProvider provider = new NettyChannelProvider();

if (provider.isAvailable()) {
    NettyChannelBuilder builder = provider.builderForAddress("localhost", 9090);
    ManagedChannel channel = builder.build();
}

/**
 * Check if the Netty server provider is available
 * @return true if Netty server transport is available
 */
protected boolean isAvailable();

/**
 * Get the priority of this provider (higher values have higher priority)
 * @return Provider priority value
 */
protected int priority();

/**
 * Create a server builder for the specified port
 * @param port Port number to listen on
 * @return NettyServerBuilder for the port
 */
protected NettyServerBuilder builderForPort(int port);

/**
 * Create a new server builder with credentials
 * @param port Port number to listen on
 * @param creds Server credentials
 * @return Result containing the server builder
 */
protected NewServerBuilderResult newServerBuilderForPort(int port, ServerCredentials creds);

import io.grpc.netty.shaded.io.grpc.netty.NettyServerProvider;

NettyServerProvider provider = new NettyServerProvider();

if (provider.isAvailable()) {
    NettyServerBuilder builder = provider.builderForPort(9090);
    Server server = builder.addService(new MyServiceImpl()).build();
}

/**
 * Check if Unix Domain Socket transport is available
 * @return true if UDS transport is available
 */
public boolean isAvailable();

/**
 * Get the priority of this provider
 * @return Provider priority value
 */
public int priority();

/**
 * Create a channel builder for the specified address (UDS specific)
 * @param name Socket path or identifier
 * @param port Port number (may be ignored for UDS)
 * @return NettyChannelBuilder configured for UDS
 */
public NettyChannelBuilder builderForAddress(String name, int port);

/**
 * Create a channel builder for the specified target (UDS specific)
 * @param target Target string (e.g., "unix:///path/to/socket")
 * @return NettyChannelBuilder configured for UDS
 */
public NettyChannelBuilder builderForTarget(String target);

/**
 * Create a new UDS channel builder with credentials
 * @param target Target string
 * @param creds Channel credentials
 * @return Result containing the channel builder
 */
public NewChannelBuilderResult newChannelBuilder(String target, ChannelCredentials creds);

import io.grpc.netty.shaded.io.grpc.netty.UdsNettyChannelProvider;

UdsNettyChannelProvider udsProvider = new UdsNettyChannelProvider();

if (udsProvider.isAvailable()) {
    NettyChannelBuilder builder = udsProvider.builderForTarget("unix:///tmp/grpc.sock");
    ManagedChannel channel = builder.build();
}

/**
 * Check if UDS name resolution is available
 * @return true if UDS name resolution is supported
 */
public boolean isAvailable();

/**
 * Get the priority of this name resolver provider
 * @return Provider priority value
 */
public int priority();

/**
 * Get the default URI scheme for UDS
 * @return Default scheme string (typically "unix")
 */
public String getDefaultScheme();

/**
 * Create a name resolver for the given URI
 * @param targetUri Target URI to resolve
 * @param args Name resolver arguments
 * @return NameResolver for the URI or null if not supported
 */
public NameResolver newNameResolver(URI targetUri, NameResolver.Args args);

import io.grpc.netty.shaded.io.grpc.netty.UdsNameResolverProvider;
import java.net.URI;

UdsNameResolverProvider resolver = new UdsNameResolverProvider();

if (resolver.isAvailable()) {
    URI uri = URI.create("unix:///tmp/grpc.sock");
    NameResolver nameResolver = resolver.newNameResolver(uri, args);
}

/**
 * Disable authority checking for the channel
 * @param builder The NettyChannelBuilder to configure
 */
public static void disableCheckAuthority(NettyChannelBuilder builder);

/**
 * Enable authority checking for the channel
 * @param builder The NettyChannelBuilder to configure
 */
public static void enableCheckAuthority(NettyChannelBuilder builder);

/**
 * Set a protocol negotiator factory
 * @param builder The NettyChannelBuilder to configure
 * @param protocolNegotiator The protocol negotiator factory
 */
public static void setProtocolNegotiatorFactory(
    NettyChannelBuilder builder, 
    ProtocolNegotiatorFactory protocolNegotiator);

/**
 * Set statistics collection enabled/disabled
 * @param builder The NettyChannelBuilder to configure
 * @param value Whether to enable stats collection
 */
public static void setStatsEnabled(NettyChannelBuilder builder, boolean value);

/**
 * Set tracing enabled/disabled
 * @param builder The NettyChannelBuilder to configure
 * @param value Whether to enable tracing
 */
public static void setTracingEnabled(NettyChannelBuilder builder, boolean value);

/**
 * Build the underlying transport factory
 * @param builder The configured NettyChannelBuilder
 * @return ClientTransportFactory for the configuration
 */
public static ClientTransportFactory buildTransportFactory(NettyChannelBuilder builder);

// Various internal configuration methods for advanced server setup
// (specific methods vary based on internal gRPC requirements)

/**
 * Create channel credentials from a protocol negotiator factory
 * @param factory The protocol negotiator factory
 * @return ChannelCredentials using the factory
 */
public static ChannelCredentials create(ProtocolNegotiator.ClientFactory factory);

/**
 * Create server credentials from a protocol negotiator factory
 * @param factory The protocol negotiator factory
 * @return ServerCredentials using the factory
 */
public static ServerCredentials create(ProtocolNegotiator.ServerFactory factory);

import io.grpc.Grpc;
import io.grpc.InsecureChannelCredentials;
import io.grpc.InsecureServerCredentials;

// gRPC automatically selects the best available transport provider
// (will use Netty if available due to higher priority)

ManagedChannel channel = Grpc.newChannelBuilder(
    "localhost:9090", 
    InsecureChannelCredentials.create()
).build(); // Automatically uses NettyChannelBuilder

Server server = Grpc.newServerBuilderForPort(
    9090, 
    InsecureServerCredentials.create()
).build(); // Automatically uses NettyServerBuilder

/**
 * Result of creating a new channel builder
 */
public static class NewChannelBuilderResult {
    private final ManagedChannelBuilder<?> channelBuilder;
    private final boolean intercepted;
    
    // Getters and construction methods
}

/**
 * Result of creating a new server builder  
 */
public static class NewServerBuilderResult {
    private final ServerBuilder<?> serverBuilder;
    private final boolean intercepted;
    
    // Getters and construction methods
}