Ejemplos de Características Web Android Java

// Android Java HTTP Requests Examples
// Using HttpURLConnection and OkHttp for making HTTP requests

import android.content.Context;
import android.os.AsyncTask;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Map;
import java.util.HashMap;
import java.util.concurrent.TimeUnit;
import okhttp3.*;

// 1. Basic HTTP Request with HttpURLConnection
class BasicHttpURLConnection {
    private String baseUrl;

    public BasicHttpURLConnection(String baseUrl) {
        this.baseUrl = baseUrl;
    }

    // GET request
    public String get(String endpoint) throws IOException {
        URL url = new URL(baseUrl + endpoint);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        try {
            connection.setRequestMethod("GET");
            connection.setConnectTimeout(5000);
            connection.setReadTimeout(5000);

            int responseCode = connection.getResponseCode();
            System.out.println("GET Response Code: " + responseCode);

            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader reader = new BufferedReader(
                    new InputStreamReader(connection.getInputStream())
                );
                StringBuilder response = new StringBuilder();
                String line;

                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                reader.close();

                return response.toString();
            } else {
                return "GET request failed";
            }
        } finally {
            connection.disconnect();
        }
    }

    // POST request with JSON body
    public String post(String endpoint, String jsonData) throws IOException {
        URL url = new URL(baseUrl + endpoint);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        try {
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setRequestProperty("Accept", "application/json");
            connection.setDoOutput(true);

            // Write request body
            OutputStream outputStream = connection.getOutputStream();
            byte[] input = jsonData.getBytes("utf-8");
            outputStream.write(input, 0, input.length());

            int responseCode = connection.getResponseCode();
            System.out.println("POST Response Code: " + responseCode);

            if (responseCode == HttpURLConnection.HTTP_OK ||
                responseCode == HttpURLConnection.HTTP_CREATED) {

                BufferedReader reader = new BufferedReader(
                    new InputStreamReader(connection.getInputStream())
                );
                StringBuilder response = new StringBuilder();
                String line;

                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                reader.close();

                return response.toString();
            } else {
                return "POST request failed";
            }
        } finally {
            connection.disconnect();
        }
    }

    // PUT request
    public String put(String endpoint, String jsonData) throws IOException {
        URL url = new URL(baseUrl + endpoint);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        try {
            connection.setRequestMethod("PUT");
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setDoOutput(true);

            OutputStream outputStream = connection.getOutputStream();
            byte[] input = jsonData.getBytes("utf-8");
            outputStream.write(input, 0, input.length);

            int responseCode = connection.getResponseCode();
            System.out.println("PUT Response Code: " + responseCode);

            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader reader = new BufferedReader(
                    new InputStreamReader(connection.getInputStream())
                );
                StringBuilder response = new StringBuilder();
                String line;

                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                reader.close();

                return response.toString();
            } else {
                return "PUT request failed";
            }
        } finally {
            connection.disconnect();
        }
    }

    // DELETE request
    public String delete(String endpoint) throws IOException {
        URL url = new URL(baseUrl + endpoint);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        try {
            connection.setRequestMethod("DELETE");
            connection.setConnectTimeout(5000);
            connection.setReadTimeout(5000);

            int responseCode = connection.getResponseCode();
            System.out.println("DELETE Response Code: " + responseCode);

            if (responseCode == HttpURLConnection.HTTP_OK ||
                responseCode == HttpURLConnection.HTTP_NO_CONTENT) {
                BufferedReader reader = new BufferedReader(
                    new InputStreamReader(connection.getInputStream())
                );
                StringBuilder response = new StringBuilder();
                String line;

                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                reader.close();

                return response.toString();
            } else {
                return "DELETE request failed";
            }
        } finally {
            connection.disconnect();
        }
    }
}

// 2. OkHttp Helper
class OkHttpHelper {
    private OkHttpClient client;
    private String baseUrl;

    public OkHttpHelper(String baseUrl) {
        this.baseUrl = baseUrl;
        this.client = new OkHttpClient.Builder()
            .connectTimeout(10, TimeUnit.SECONDS)
            .readTimeout(10, TimeUnit.SECONDS)
            .writeTimeout(10, TimeUnit.SECONDS)
            .build();
    }

    public OkHttpHelper(String baseUrl, int timeoutSeconds) {
        this.baseUrl = baseUrl;
        this.client = new OkHttpClient.Builder()
            .connectTimeout(timeoutSeconds, TimeUnit.SECONDS)
            .readTimeout(timeoutSeconds, TimeUnit.SECONDS)
            .writeTimeout(timeoutSeconds, TimeUnit.SECONDS)
            .build();
    }

    // GET request
    public String get(String endpoint) throws IOException {
        Request request = new Request.Builder()
            .url(baseUrl + endpoint)
            .get()
            .build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                return response.body().string();
            } else {
                return "GET request failed: " + response.code();
            }
        }
    }

    // GET with query parameters
    public String get(String endpoint, Map<String, String> queryParams) throws IOException {
        HttpUrl.Builder urlBuilder = HttpUrl.parse(baseUrl + endpoint).newBuilder();

        if (queryParams != null) {
            for (Map.Entry<String, String> entry : queryParams.entrySet()) {
                urlBuilder.addQueryParameter(entry.getKey(), entry.getValue());
            }
        }

        Request request = new Request.Builder()
            .url(urlBuilder.build())
            .get()
            .build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                return response.body().string();
            } else {
                return "GET request failed: " + response.code();
            }
        }
    }

    // POST request with JSON body
    public String post(String endpoint, String jsonData) throws IOException {
        MediaType JSON = MediaType.parse("application/json; charset=utf-8");
        RequestBody body = RequestBody.create(JSON, jsonData);

        Request request = new Request.Builder()
            .url(baseUrl + endpoint)
            .post(body)
            .build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                return response.body().string();
            } else {
                return "POST request failed: " + response.code();
            }
        }
    }

    // POST with form data
    public String postForm(String endpoint, Map<String, String> formData) throws IOException {
        FormBody.Builder formBuilder = new FormBody.Builder();

        if (formData != null) {
            for (Map.Entry<String, String> entry : formData.entrySet()) {
                formBuilder.add(entry.getKey(), entry.getValue());
            }
        }

        RequestBody body = formBuilder.build();
        Request request = new Request.Builder()
            .url(baseUrl + endpoint)
            .post(body)
            .build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                return response.body().string();
            } else {
                return "POST form request failed: " + response.code();
            }
        }
    }

    // PUT request
    public String put(String endpoint, String jsonData) throws IOException {
        MediaType JSON = MediaType.parse("application/json; charset=utf-8");
        RequestBody body = RequestBody.create(JSON, jsonData);

        Request request = new Request.Builder()
            .url(baseUrl + endpoint)
            .put(body)
            .build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                return response.body().string();
            } else {
                return "PUT request failed: " + response.code();
            }
        }
    }

    // DELETE request
    public String delete(String endpoint) throws IOException {
        Request request = new Request.Builder()
            .url(baseUrl + endpoint)
            .delete()
            .build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                return response.body().string();
            } else {
                return "DELETE request failed: " + response.code();
            }
        }
    }

    // Add headers
    public String getWithHeaders(String endpoint, Map<String, String> headers) throws IOException {
        Request.Builder requestBuilder = new Request.Builder()
            .url(baseUrl + endpoint)
            .get();

        if (headers != null) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                requestBuilder.addHeader(entry.getKey(), entry.getValue());
            }
        }

        Request request = requestBuilder.build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                return response.body().string();
            } else {
                return "GET request failed: " + response.code();
            }
        }
    }

    // Upload file
    public String uploadFile(String endpoint, File file, String contentType) throws IOException {
        MediaType MEDIA_TYPE = MediaType.parse(contentType);
        RequestBody requestBody = RequestBody.create(MEDIA_TYPE, file);

        Request request = new Request.Builder()
            .url(baseUrl + endpoint)
            .post(requestBody)
            .build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                return response.body().string();
            } else {
                return "File upload failed: " + response.code();
            }
        }
    }

    // Download file
    public boolean downloadFile(String endpoint, File destFile) throws IOException {
        Request request = new Request.Builder()
            .url(baseUrl + endpoint)
            .get()
            .build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                InputStream inputStream = response.body().byteStream();
                FileOutputStream outputStream = new FileOutputStream(destFile);

                byte[] buffer = new byte[4096];
                int bytesRead;

                while ((bytesRead = inputStream.read(buffer)) != -1) {
                    outputStream.write(buffer, 0, bytesRead);
                }

                outputStream.close();
                inputStream.close();

                return true;
            } else {
                return false;
            }
        }
    }
}

// 3. API Response Handler
class ApiResponseHandler {
    public interface ResponseCallback {
        void onSuccess(String response);
        void onError(String errorMessage);
    }

    // Execute HTTP request asynchronously (using AsyncTask)
    public void executeAsync(final String url, final ResponseCallback callback) {
        new AsyncTask<Void, Void, String>() {
            private Exception exception;

            @Override
            protected String doInBackground(Void... voids) {
                try {
                    URL requestUrl = new URL(url);
                    HttpURLConnection connection = (HttpURLConnection) requestUrl.openConnection();
                    connection.setRequestMethod("GET");
                    connection.setConnectTimeout(5000);
                    connection.setReadTimeout(5000);

                    int responseCode = connection.getResponseCode();

                    if (responseCode == HttpURLConnection.HTTP_OK) {
                        BufferedReader reader = new BufferedReader(
                            new InputStreamReader(connection.getInputStream())
                        );
                        StringBuilder response = new StringBuilder();
                        String line;

                        while ((line = reader.readLine()) != null) {
                            response.append(line);
                        }
                        reader.close();

                        return response.toString();
                    } else {
                        return null;
                    }
                } catch (Exception e) {
                    exception = e;
                    return null;
                }
            }

            @Override
            protected void onPostExecute(String response) {
                if (exception != null) {
                    callback.onError(exception.getMessage());
                } else if (response != null) {
                    callback.onSuccess(response);
                } else {
                    callback.onError("Request failed");
                }
            }
        }.execute();
    }
}

// 4. REST API Client
class RestClient {
    private OkHttpHelper httpClient;
    private String apiToken;

    public RestClient(String baseUrl) {
        this.httpClient = new OkHttpHelper(baseUrl);
    }

    public RestClient(String baseUrl, String apiToken) {
        this.httpClient = new OkHttpHelper(baseUrl);
        this.apiToken = apiToken;
    }

    // Set authentication token
    public void setAuthToken(String token) {
        this.apiToken = token;
    }

    // Get with auth
    public String getAuth(String endpoint) throws IOException {
        Map<String, String> headers = new HashMap<>();
        headers.put("Authorization", "Bearer " + apiToken);
        return httpClient.getWithHeaders(endpoint, headers);
    }

    // Post with auth
    public String postAuth(String endpoint, String jsonData) throws IOException {
        Map<String, String> headers = new HashMap<>();
        headers.put("Authorization", "Bearer " + apiToken);

        MediaType JSON = MediaType.parse("application/json; charset=utf-8");
        RequestBody body = RequestBody.create(JSON, jsonData);

        Request request = new Request.Builder()
            .url(httpClient.baseUrl + endpoint)
            .post(body)
            .addHeader("Authorization", "Bearer " + apiToken)
            .build();

        try (Response response = httpClient.client.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                return response.body().string();
            } else {
                return "Request failed: " + response.code();
            }
        }
    }
}

// 5. Request Interceptor
class RequestInterceptor implements Interceptor {
    private String authToken;

    public RequestInterceptor(String authToken) {
        this.authToken = authToken;
    }

    @Override
    public Response intercept(Chain chain) throws IOException {
        Request originalRequest = chain.request();

        Request.Builder requestBuilder = originalRequest.newBuilder()
            .header("Accept", "application/json")
            .header("Content-Type", "application/json");

        if (authToken != null) {
            requestBuilder.header("Authorization", "Bearer " + authToken);
        }

        Request newRequest = requestBuilder.build();
        return chain.proceed(newRequest);
    }
}

// 6. Retry Interceptor
class RetryInterceptor implements Interceptor {
    private int maxRetries;

    public RetryInterceptor(int maxRetries) {
        this.maxRetries = maxRetries;
    }

    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Response response = null;
        IOException exception = null;

        for (int i = 0; i < maxRetries; i++) {
            try {
                response = chain.proceed(request);

                if (response.isSuccessful()) {
                    return response;
                }
            } catch (IOException e) {
                exception = e;

                if (i == maxRetries - 1) {
                    throw e;
                }

                try {
                    Thread.sleep(1000 * (i + 1));
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw e;
                }
            }
        }

        if (response != null) {
            return response;
        }

        throw exception;
    }
}

// Main demonstration
class HttpRequestDemo {
    public static void demonstrateHttpRequests() {
        System.out.println("=== Android Java HTTP Requests Examples ===\n");

        String baseUrl = "https://jsonplaceholder.typicode.com";

        // 1. HttpURLConnection
        System.out.println("--- 1. HttpURLConnection GET ---");
        try {
            BasicHttpURLConnection httpConnection = new BasicHttpURLConnection(baseUrl);
            String response = httpConnection.get("/posts/1");
            System.out.println("Response: " + response);
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }

        // 2. OkHttp GET
        System.out.println("\n--- 2. OkHttp GET ---");
        try {
            OkHttpHelper okHttp = new OkHttpHelper(baseUrl);
            String response = okHttp.get("/posts/1");
            System.out.println("Response: " + response);
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }

        // 3. POST request
        System.out.println("\n--- 3. POST Request ---");
        try {
            OkHttpHelper okHttp = new OkHttpHelper(baseUrl);
            String jsonData = "{\"title\": \"Test\", \"body\": \"Test body\", \"userId\": 1}";
            String response = okHttp.post("/posts", jsonData);
            System.out.println("Response: " + response);
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }

        // 4. GET with query parameters
        System.out.println("\n--- 4. GET with Query Parameters ---");
        try {
            OkHttpHelper okHttp = new OkHttpHelper(baseUrl);
            Map<String, String> params = new HashMap<>();
            params.put("userId", "1");
            String response = okHttp.get("/posts", params);
            System.out.println("Response: " + response);
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }

        // 5. PUT request
        System.out.println("\n--- 5. PUT Request ---");
        try {
            OkHttpHelper okHttp = new OkHttpHelper(baseUrl);
            String jsonData = "{\"id\": 1, \"title\": \"Updated Title\", \"body\": \"Updated body\", \"userId\": 1}";
            String response = okHttp.put("/posts/1", jsonData);
            System.out.println("Response: " + response);
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }

        // 6. DELETE request
        System.out.println("\n--- 6. DELETE Request ---");
        try {
            OkHttpHelper okHttp = new OkHttpHelper(baseUrl);
            String response = okHttp.delete("/posts/1");
            System.out.println("Response: " + response);
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }

        // 7. POST with form data
        System.out.println("\n--- 7. POST with Form Data ---");
        try {
            OkHttpHelper okHttp = new OkHttpHelper(baseUrl);
            Map<String, String> formData = new HashMap<>();
            formData.put("username", "testuser");
            formData.put("password", "testpass");
            String response = okHttp.postForm("/posts", formData);
            System.out.println("Response: " + response);
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }

        System.out.println("\n=== All HTTP Request Examples Completed ===");
    }
}

// Android Java URL Handling Examples
// URL parsing, building, encoding, and decoding

import android.net.Uri;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

// 1. Basic URL Parsing
class UrlParser {
    private String urlString;
    private URL url;
    private Uri uri;

    public UrlParser(String urlString) {
        this.urlString = urlString;
        try {
            this.url = new URL(urlString);
            this.uri = Uri.parse(urlString);
        } catch (Exception e) {
            System.out.println("Invalid URL: " + e.getMessage());
        }
    }

    // Get protocol/scheme
    public String getProtocol() {
        if (url != null) {
            return url.getProtocol();
        }
        return uri != null ? uri.getScheme() : null;
    }

    // Get host
    public String getHost() {
        if (url != null) {
            return url.getHost();
        }
        return uri != null ? uri.getHost() : null;
    }

    // Get port
    public int getPort() {
        if (url != null) {
            int port = url.getPort();
            return port == -1 ? url.getDefaultPort() : port;
        }
        return uri != null ? uri.getPort() : -1;
    }

    // Get path
    public String getPath() {
        if (url != null) {
            return url.getPath();
        }
        return uri != null ? uri.getPath() : null;
    }

    // Get query string
    public String getQuery() {
        if (url != null) {
            return url.getQuery();
        }
        return uri != null ? uri.getQuery() : null;
    }

    // Get reference/fragment
    public String getFragment() {
        if (url != null) {
            return url.getRef();
        }
        return uri != null ? uri.getFragment() : null;
    }

    // Print all URL components
    public void printComponents() {
        System.out.println("=== URL Components ===");
        System.out.println("Protocol: " + getProtocol());
        System.out.println("Host: " + getHost());
        System.out.println("Port: " + getPort());
        System.out.println("Path: " + getPath());
        System.out.println("Query: " + getQuery());
        System.out.println("Fragment: " + getFragment());
    }
}

// 2. URL Builder
class UrlBuilder {
    private String scheme;
    private String authority;
    private String path;
    private Map<String, String> queryParams = new HashMap<>();
    private String fragment;

    public UrlBuilder() {
    }

    public UrlBuilder scheme(String scheme) {
        this.scheme = scheme;
        return this;
    }

    public UrlBuilder authority(String authority) {
        this.authority = authority;
        return this;
    }

    public UrlBuilder host(String host) {
        this.authority = host;
        return this;
    }

    public UrlBuilder host(String host, int port) {
        this.authority = host + ":" + port;
        return this;
    }

    public UrlBuilder path(String path) {
        this.path = path;
        return this;
    }

    public UrlBuilder appendPath(String segment) {
        if (this.path == null) {
            this.path = segment;
        } else {
            if (!this.path.endsWith("/")) {
                this.path += "/";
            }
            this.path += segment;
        }
        return this;
    }

    public UrlBuilder queryParam(String key, String value) {
        this.queryParams.put(key, value);
        return this;
    }

    public UrlBuilder queryParams(Map<String, String> params) {
        if (params != null) {
            this.queryParams.putAll(params);
        }
        return this;
    }

    public UrlBuilder fragment(String fragment) {
        this.fragment = fragment;
        return this;
    }

    // Build Uri (Android)
    public Uri buildUri() {
        Uri.Builder builder = new Uri.Builder();
        builder.scheme(scheme);
        builder.authority(authority);
        builder.path(path);

        for (Map.Entry<String, String> entry : queryParams.entrySet()) {
            builder.appendQueryParameter(entry.getKey(), entry.getValue());
        }

        builder.fragment(fragment);

        return builder.build();
    }

    // Build URL string
    public String build() {
        return buildUri().toString();
    }

    // Build with encoded values
    public String buildEncoded() {
        Uri uri = buildUri();
        return uri.toString();
    }
}

// 3. URL Encoding and Decoding
class UrlCodec {

    // Encode URL component
    public static String encode(String value) {
        try {
            return URLEncoder.encode(value, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            return value;
        }
    }

    // Decode URL component
    public static String decode(String encoded) {
        try {
            return URLDecoder.decode(encoded, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            return encoded;
        }
    }

    // Encode URL parameter
    public static String encodeParam(String param) {
        return encode(param).replace("+", "%20");
    }

    // Build query string
    public static String buildQueryString(Map<String, String> params) {
        StringBuilder query = new StringBuilder();

        for (Map.Entry<String, String> entry : params.entrySet()) {
            if (query.length() > 0) {
                query.append("&");
            }
            query.append(encodeParam(entry.getKey()));
            query.append("=");
            query.append(encodeParam(entry.getValue()));
        }

        return query.toString();
    }

    // Parse query string
    public static Map<String, String> parseQueryString(String query) {
        Map<String, String> params = new HashMap<>();

        if (query == null || query.isEmpty()) {
            return params;
        }

        String[] pairs = query.split("&");
        for (String pair : pairs) {
            String[] keyValue = pair.split("=", 2);
            if (keyValue.length == 2) {
                params.put(decode(keyValue[0]), decode(keyValue[1]));
            } else if (keyValue.length == 1) {
                params.put(decode(keyValue[0]), "");
            }
        }

        return params;
    }
}

// 4. Query Parameter Helper
class QueryParamHelper {
    private Uri uri;

    public QueryParamHelper(String urlString) {
        this.uri = Uri.parse(urlString);
    }

    public QueryParamHelper(Uri uri) {
        this.uri = uri;
    }

    // Get query parameter
    public String getParam(String key) {
        return uri.getQueryParameter(key);
    }

    // Get query parameter with default value
    public String getParam(String key, String defaultValue) {
        String value = uri.getQueryParameter(key);
        return value != null ? value : defaultValue;
    }

    // Get boolean parameter
    public boolean getBooleanParam(String key, boolean defaultValue) {
        String value = uri.getQueryParameter(key);
        if (value == null) {
            return defaultValue;
        }
        return Boolean.parseBoolean(value);
    }

    // Get integer parameter
    public int getIntParam(String key, int defaultValue) {
        String value = uri.getQueryParameter(key);
        if (value == null) {
            return defaultValue;
        }
        try {
            return Integer.parseInt(value);
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }

    // Get all query parameters
    public Map<String, String> getAllParams() {
        Map<String, String> params = new HashMap<>();
        Set<String> paramNames = uri.getQueryParameterNames();

        for (String name : paramNames) {
            params.put(name, uri.getQueryParameter(name));
        }

        return params;
    }

    // Check if parameter exists
    public boolean hasParam(String key) {
        return uri.getQueryParameter(key) != null;
    }

    // Print all parameters
    public void printAllParams() {
        System.out.println("=== Query Parameters ===");
        Set<String> paramNames = uri.getQueryParameterNames();

        for (String name : paramNames) {
            System.out.println(name + " = " + uri.getQueryParameter(name));
        }
    }
}

// 5. URL Validation
class UrlValidator {

    // Check if string is valid URL
    public static boolean isValidUrl(String urlString) {
        try {
            URL url = new URL(urlString);
            url.toURI();
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    // Check if using HTTPS
    public static boolean isHttps(String urlString) {
        try {
            URL url = new URL(urlString);
            return "https".equalsIgnoreCase(url.getProtocol());
        } catch (Exception e) {
            return false;
        }
    }

    // Get domain from URL
    public static String getDomain(String urlString) {
        try {
            URL url = new URL(urlString);
            return url.getHost();
        } catch (Exception e) {
            return null;
        }
    }

    // Check if same domain
    public static boolean isSameDomain(String url1, String url2) {
        String domain1 = getDomain(url1);
        String domain2 = getDomain(url2);

        if (domain1 == null || domain2 == null) {
            return false;
        }

        return domain1.equalsIgnoreCase(domain2);
    }
}

// 6. URL Manipulation
class UrlManipulator {
    private Uri uri;

    public UrlManipulator(String urlString) {
        this.uri = Uri.parse(urlString);
    }

    // Add query parameter
    public String addQueryParam(String key, String value) {
        Uri.Builder builder = uri.buildUpon();
        builder.appendQueryParameter(key, value);
        return builder.build().toString();
    }

    // Remove query parameter
    public String removeQueryParam(String key) {
        String newUrl = uri.getScheme() + "://" + uri.getAuthority() + uri.getPath();

        Map<String, String> params = new HashMap<>();
        Set<String> paramNames = uri.getQueryParameterNames();

        for (String name : paramNames) {
            if (!name.equals(key)) {
                params.put(name, uri.getQueryParameter(name));
            }
        }

        if (!params.isEmpty()) {
            newUrl += "?" + UrlCodec.buildQueryString(params);
        }

        if (uri.getFragment() != null) {
            newUrl += "#" + uri.getFragment();
        }

        return newUrl;
    }

    // Replace path
    public String replacePath(String newPath) {
        Uri.Builder builder = uri.buildUpon();
        builder.path(newPath);
        return builder.build().toString();
    }

    // Add path segment
    public String appendPath(String segment) {
        Uri.Builder builder = uri.buildUpon();
        builder.appendPath(segment);
        return builder.build().toString();
    }

    // Set fragment
    public String setFragment(String fragment) {
        Uri.Builder builder = uri.buildUpon();
        builder.fragment(fragment);
        return builder.build().toString();
    }
}

// 7. Deep Link Handler
class DeepLinkHandler {
    private Uri uri;

    public DeepLinkHandler(String deepLink) {
        this.uri = Uri.parse(deepLink);
    }

    // Get action from deep link
    public String getAction() {
        // Extract action from path, e.g., myapp://action/params
        List<String> pathSegments = uri.getPathSegments();
        if (!pathSegments.isEmpty()) {
            return pathSegments.get(0);
        }
        return null;
    }

    // Get parameter from deep link
    public String getParam(String key) {
        return uri.getQueryParameter(key);
    }

    // Check if matches scheme
    public boolean matchesScheme(String scheme) {
        return scheme.equals(uri.getScheme());
    }

    // Check if matches host
    public boolean matchesHost(String host) {
        return host.equals(uri.getHost());
    }

    // Print deep link info
    public void printInfo() {
        System.out.println("=== Deep Link Information ===");
        System.out.println("Scheme: " + uri.getScheme());
        System.out.println("Host: " + uri.getHost());
        System.out.println("Path: " + uri.getPath());
        System.out.println("Action: " + getAction());

        Set<String> paramNames = uri.getQueryParameterNames();
        if (!paramNames.isEmpty()) {
            System.out.println("Parameters:");
            for (String name : paramNames) {
                System.out.println("  " + name + " = " + uri.getQueryParameter(name));
            }
        }
    }
}

// Main demonstration
class UrlHandlingDemo {
    public static void demonstrateUrlHandling() {
        System.out.println("=== Android Java URL Handling Examples ===\n");

        String testUrl = "https://example.com:8080/path/to/resource?key1=value1&key2=value2#fragment";

        // 1. URL parsing
        System.out.println("--- 1. URL Parsing ---");
        UrlParser parser = new UrlParser(testUrl);
        parser.printComponents();

        // 2. URL building
        System.out.println("\n--- 2. URL Building ---");
        UrlBuilder builder = new UrlBuilder()
            .scheme("https")
            .host("api.example.com")
            .appendPath("v1")
            .appendPath("users")
            .queryParam("page", "1")
            .queryParam("limit", "10");

        String builtUrl = builder.build();
        System.out.println("Built URL: " + builtUrl);

        // 3. URL encoding and decoding
        System.out.println("\n--- 3. URL Encoding/Decoding ---");
        String original = "Hello World! @#$";
        String encoded = UrlCodec.encode(original);
        String decoded = UrlCodec.decode(encoded);

        System.out.println("Original: " + original);
        System.out.println("Encoded: " + encoded);
        System.out.println("Decoded: " + decoded);

        // 4. Query parameter handling
        System.out.println("\n--- 4. Query Parameters ---");
        QueryParamHelper paramHelper = new QueryParamHelper(testUrl);
        paramHelper.printAllParams();

        System.out.println("key1 = " + paramHelper.getParam("key1"));
        System.out.println("page = " + paramHelper.getIntParam("page", 1));
        System.out.println("active = " + paramHelper.getBooleanParam("active", false));

        // 5. Build query string
        System.out.println("\n--- 5. Build Query String ---");
        Map<String, String> params = new HashMap<>();
        params.put("search", "java programming");
        params.put("filter", "recent");
        params.put("sort", "desc");

        String queryString = UrlCodec.buildQueryString(params);
        System.out.println("Query String: " + queryString);

        // 6. Parse query string
        System.out.println("\n--- 6. Parse Query String ---");
        Map<String, String> parsedParams = UrlCodec.parseQueryString(queryString);
        for (Map.Entry<String, String> entry : parsedParams.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }

        // 7. URL validation
        System.out.println("\n--- 7. URL Validation ---");
        System.out.println("Valid URL: " + UrlValidator.isValidUrl(testUrl));
        System.out.println("Is HTTPS: " + UrlValidator.isHttps(testUrl));
        System.out.println("Domain: " + UrlValidator.getDomain(testUrl));

        String invalidUrl = "not-a-valid-url";
        System.out.println("Valid URL: " + UrlValidator.isValidUrl(invalidUrl));

        // 8. URL manipulation
        System.out.println("\n--- 8. URL Manipulation ---");
        UrlManipulator manipulator = new UrlManipulator(testUrl);

        String modifiedUrl = manipulator
            .addQueryParam("newParam", "newValue")
            .appendPath("additional")
            .setFragment("newFragment");

        System.out.println("Modified URL: " + modifiedUrl);

        // 9. Deep link handling
        System.out.println("\n--- 9. Deep Link Handling ---");
        String deepLink = "myapp://open/product?id=123&ref=share";

        DeepLinkHandler deepLinkHandler = new DeepLinkHandler(deepLink);
        deepLinkHandler.printInfo();

        System.out.println("Matches scheme 'myapp': " + deepLinkHandler.matchesScheme("myapp"));
        System.out.println("Action: " + deepLinkHandler.getAction());
        System.out.println("Product ID: " + deepLinkHandler.getParam("id"));

        System.out.println("\n=== All URL Handling Examples Completed ===");
    }
}

// Android Java WebView Integration Examples
// Using WebView to display web content and enable JavaScript communication

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.view.View;
import android.webkit.*;
import java.util.ArrayList;
import java.util.List;

// 1. Basic WebView Setup
class BasicWebViewHelper {
    private Activity activity;
    private WebView webView;

    public BasicWebViewHelper(Activity activity) {
        this.activity = activity;
        this.webView = new WebView(activity);
        setupWebView();
    }

    public BasicWebViewHelper(Activity activity, WebView webView) {
        this.activity = activity;
        this.webView = webView;
        setupWebView();
    }

    private void setupWebView() {
        // Enable JavaScript
        webView.getSettings().setJavaScriptEnabled(true);

        // Enable DOM storage
        webView.getSettings().setDomStorageEnabled(true);

        // Enable zoom
        webView.getSettings().setSupportZoom(true);
        webView.getSettings().setBuiltInZoomControls(true);
        webView.getSettings().setDisplayZoomControls(false);

        // Improve rendering
        webView.getSettings().setRenderPriority(WebSettings.RenderPriority.HIGH);
        webView.getSettings().setCacheMode(WebSettings.LOAD_DEFAULT);

        // Enable mixed content (for HTTPS pages with HTTP resources)
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
            webView.getSettings().setMixedContentMode(WebSettings.MIXED_CONTENT_ALWAYS_ALLOW);
        }

        // Set WebViewClient
        webView.setWebViewClient(new WebViewClient());

        // Set WebChromeClient
        webView.setWebChromeClient(new WebChromeClient());
    }

    public WebView getWebView() {
        return webView;
    }

    // Load URL
    public void loadUrl(String url) {
        webView.loadUrl(url);
    }

    // Load HTML string
    public void loadData(String htmlData) {
        webView.loadDataWithBaseURL(null, htmlData, "text/html", "UTF-8", null);
    }

    // Load file from assets
    public void loadFileFromAssets(String fileName) {
        webView.loadUrl("file:///android_asset/" + fileName);
    }

    // Go back
    public void goBack() {
        if (webView.canGoBack()) {
            webView.goBack();
        }
    }

    // Go forward
    public void goForward() {
        if (webView.canGoForward()) {
            webView.goForward();
        }
    }

    // Reload
    public void reload() {
        webView.reload();
    }

    // Stop loading
    public void stopLoading() {
        webView.stopLoading();
    }

    // Clear cache
    public void clearCache() {
        webView.clearCache(true);
    }

    // Clear history
    public void clearHistory() {
        webView.clearHistory();
    }
}

// 2. Custom WebViewClient
class CustomWebViewClient extends WebViewClient {
    private PageLoadListener pageLoadListener;

    public interface PageLoadListener {
        void onPageStarted(String url);
        void onPageFinished(String url);
        void onPageLoadError(String url, int errorCode);
    }

    public void setPageLoadListener(PageLoadListener listener) {
        this.pageLoadListener = listener;
    }

    @Override
    public void onPageStarted(WebView view, String url, Bitmap favicon) {
        super.onPageStarted(view, url, favicon);
        if (pageLoadListener != null) {
            pageLoadListener.onPageStarted(url);
        }
    }

    @Override
    public void onPageFinished(WebView view, String url) {
        super.onPageFinished(view, url);
        if (pageLoadListener != null) {
            pageLoadListener.onPageFinished(url);
        }
    }

    @Override
    public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
        super.onReceivedError(view, request, error);
        if (pageLoadListener != null && android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
            pageLoadListener.onPageLoadError(request.getUrl().toString(), error.getErrorCode());
        }
    }

    @Override
    public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
            String url = request.getUrl().toString();

            // Handle special URLs
            if (url.startsWith("tel:")) {
                // Handle phone number
                Intent intent = new Intent(Intent.ACTION_DIAL, Uri.parse(url));
                view.getContext().startActivity(intent);
                return true;
            } else if (url.startsWith("mailto:")) {
                // Handle email
                Intent intent = new Intent(Intent.ACTION_SENDTO, Uri.parse(url));
                view.getContext().startActivity(intent);
                return true;
            } else if (url.startsWith("myapp://")) {
                // Handle deep links
                handleDeepLink(url);
                return true;
            }
        }

        return super.shouldOverrideUrlLoading(view, request);
    }

    @Override
    public boolean shouldOverrideUrlLoading(WebView view, String url) {
        // Fallback for older API levels
        if (url.startsWith("tel:") || url.startsWith("mailto:") || url.startsWith("myapp://")) {
            return shouldOverrideUrlLoading(view,
                android.webkit.WebResourceRequest.builder().url(Uri.parse(url)).build());
        }
        return false;
    }

    private void handleDeepLink(String deepLink) {
        // Handle app-specific deep links
        System.out.println("Deep link: " + deepLink);
    }
}

// 3. Custom WebChromeClient
class CustomWebChromeClient extends WebChromeClient {
    private ProgressListener progressListener;
    private TitleListener titleListener;

    public interface ProgressListener {
        void onProgressChanged(int progress);
    }

    public interface TitleListener {
        void onTitleChanged(String title);
    }

    public void setProgressListener(ProgressListener listener) {
        this.progressListener = listener;
    }

    public void setTitleListener(TitleListener listener) {
        this.titleListener = listener;
    }

    @Override
    public void onProgressChanged(WebView view, int newProgress) {
        super.onProgressChanged(view, newProgress);
        if (progressListener != null) {
            progressListener.onProgressChanged(newProgress);
        }
    }

    @Override
    public void onReceivedTitle(WebView view, String title) {
        super.onReceivedTitle(view, title);
        if (titleListener != null) {
            titleListener.onTitleChanged(title);
        }
    }

    @Override
    public boolean onJsAlert(WebView view, String url, String message, JsResult result) {
        // Handle JavaScript alert
        showAlertDialog(message, result);
        return true;
    }

    @Override
    public boolean onJsConfirm(WebView view, String url, String message, JsResult result) {
        // Handle JavaScript confirm
        showConfirmDialog(message, result);
        return true;
    }

    private void showAlertDialog(String message, final JsResult result) {
        // Show alert dialog
        new android.app.AlertDialog.Builder(view.getContext())
            .setMessage(message)
            .setPositiveButton("OK", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    result.confirm();
                }
            })
            .setCancelable(false)
            .show();
    }

    private void showConfirmDialog(String message, final JsResult result) {
        // Show confirm dialog
        new android.app.AlertDialog.Builder(view.getContext())
            .setMessage(message)
            .setPositiveButton("OK", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    result.confirm();
                }
            })
            .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    result.cancel();
                }
            })
            .setCancelable(false)
            .show();
    }
}

// 4. JavaScript Interface
class JavaScriptInterface {
    private Context context;
    private WebCallback callback;

    public JavaScriptInterface(Context context) {
        this.context = context;
    }

    public void setCallback(WebCallback callback) {
        this.callback = callback;
    }

    // Method callable from JavaScript
    @android.webkit.JavascriptInterface
    public void showToast(String message) {
        android.widget.Toast.makeText(context, message, android.widget.Toast.LENGTH_SHORT).show();
    }

    @android.webkit.JavascriptInterface
    public void sendMessage(String message) {
        System.out.println("Message from JavaScript: " + message);
        if (callback != null) {
            callback.onMessage(message);
        }
    }

    @android.webkit.JavascriptInterface
    public String getData() {
        return "Data from Android";
    }

    @android.webkit.JavascriptInterface
    public int add(int a, int b) {
        return a + b;
    }

    public interface WebCallback {
        void onMessage(String message);
    }
}

// 5. WebView Communication Helper
class WebViewCommunicationHelper {
    private WebView webView;

    public WebViewCommunicationHelper(WebView webView) {
        this.webView = webView;
    }

    // Add JavaScript interface
    public void addJavaScriptInterface(Object object, String name) {
        webView.addJavascriptInterface(object, name);
    }

    // Execute JavaScript
    public void executeJavaScript(String script) {
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.KITKAT) {
            webView.evaluateJavascript(script, new ValueCallback<String>() {
                @Override
                public void onReceiveValue(String value) {
                    System.out.println("JavaScript result: " + value);
                }
            });
        } else {
            webView.loadUrl("javascript:" + script);
        }
    }

    // Call JavaScript function
    public void callJavaScriptFunction(String functionName, Object... args) {
        StringBuilder script = new StringBuilder();
        script.append(functionName).append("(");

        for (int i = 0; i < args.length; i++) {
            if (i > 0) {
                script.append(", ");
            }

            Object arg = args[i];
            if (arg instanceof String) {
                script.append("'").append(arg).append("'");
            } else {
                script.append(arg);
            }
        }

        script.append(")");
        executeJavaScript(script.toString());
    }

    // Inject JavaScript
    public void injectJavaScript(String jsCode) {
        executeJavaScript("(function(){" + jsCode + "})()");
    }
}

// 6. Cookie Manager
class WebViewCookieManager {
    private CookieManager cookieManager;

    public WebViewCookieManager() {
        this.cookieManager = CookieManager.getInstance();
        setupCookieManager();
    }

    private void setupCookieManager() {
        cookieManager.setAcceptCookie(true);

        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
            cookieManager.setAcceptThirdPartyCookies(webView, true);
        }
    }

    // Set cookie
    public void setCookie(String url, String cookieValue) {
        cookieManager.setCookie(url, cookieValue);
    }

    // Get cookie
    public String getCookie(String url) {
        return cookieManager.getCookie(url);
    }

    // Clear all cookies
    public void clearAllCookies() {
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
            cookieManager.removeAllCookies(null);
        } else {
            cookieManager.removeAllCookie();
        }
    }

    // Clear session cookies
    public void clearSessionCookies() {
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
            cookieManager.removeSessionCookies(null);
        } else {
            cookieManager.removeSessionCookie();
        }
    }
}

// 7. WebView Cache Manager
class WebViewCacheManager {
    private WebView webView;

    public WebViewCacheManager(WebView webView) {
        this.webView = webView;
    }

    // Enable cache
    public void enableCache() {
        webView.getSettings().setCacheMode(WebSettings.LOAD_DEFAULT);
        webView.getSettings().setDomStorageEnabled(true);
        webView.getSettings().setDatabaseEnabled(true);
    }

    // Disable cache
    public void disableCache() {
        webView.getSettings().setCacheMode(WebSettings.LOAD_NO_CACHE);
    }

    // Load from cache only
    public void loadFromCacheOnly() {
        webView.getSettings().setCacheMode(WebSettings.LOAD_CACHE_ONLY);
    }

    // Clear all cache
    public void clearAllCache() {
        webView.clearCache(true);
    }

    // Clear cache for specific URL
    public void clearCacheForUrl(String url) {
        // This would require more complex implementation
        webView.clearCache(true);
    }
}

// Main demonstration
class WebViewIntegrationDemo {
    public static void demonstrateWebViewIntegration(Activity activity) {
        System.out.println("=== Android Java WebView Integration Examples ===\n");

        // 1. Basic WebView setup
        System.out.println("--- 1. Basic WebView Setup ---");
        BasicWebViewHelper webViewHelper = new BasicWebViewHelper(activity);
        WebView webView = webViewHelper.getWebView();

        // 2. Load URL
        System.out.println("\n--- 2. Load URL ---");
        webViewHelper.loadUrl("https://www.example.com");

        // 3. Load HTML data
        System.out.println("\n--- 3. Load HTML Data ---");
        String htmlContent = "<html><body><h1>Hello WebView!</h1></body></html>";
        webViewHelper.loadData(htmlContent);

        // 4. Custom WebViewClient
        System.out.println("\n--- 4. Custom WebViewClient ---");
        CustomWebViewClient customClient = new CustomWebViewClient();
        customClient.setPageLoadListener(new CustomWebViewClient.PageLoadListener() {
            @Override
            public void onPageStarted(String url) {
                System.out.println("Page started loading: " + url);
            }

            @Override
            public void onPageFinished(String url) {
                System.out.println("Page finished loading: " + url);
            }

            @Override
            public void onPageLoadError(String url, int errorCode) {
                System.out.println("Page load error: " + url + " (" + errorCode + ")");
            }
        });

        webView.setWebViewClient(customClient);

        // 5. JavaScript interface
        System.out.println("\n--- 5. JavaScript Interface ---");
        JavaScriptInterface jsInterface = new JavaScriptInterface(activity);
        webView.addJavascriptInterface(jsInterface, "Android");

        // Call JavaScript from Android
        WebViewCommunicationHelper commHelper = new WebViewCommunicationHelper(webView);
        commHelper.executeJavaScript("alert('Hello from Android!')");

        // Call JavaScript function
        commHelper.callJavaScriptFunction("updateContent", "New Content");

        // 6. Inject JavaScript
        System.out.println("\n--- 6. Inject JavaScript ---");
        String jsCode = "document.body.style.backgroundColor = 'lightgray';";
        commHelper.injectJavaScript(jsCode);

        // 7. Cookie management
        System.out.println("\n--- 7. Cookie Management ---");
        WebViewCookieManager cookieManager = new WebViewCookieManager();
        cookieManager.setCookie("https://www.example.com", "user=JohnDoe; max-age=3600");

        String cookie = cookieManager.getCookie("https://www.example.com");
        System.out.println("Cookie: " + cookie);

        // 8. Cache management
        System.out.println("\n--- 8. Cache Management ---");
        WebViewCacheManager cacheManager = new WebViewCacheManager(webView);
        cacheManager.enableCache();

        // 9. WebView history
        System.out.println("\n--- 9. WebView History ---");
        System.out.println("Can go back: " + webView.canGoBack());
        System.out.println("Can go forward: " + webView.canGoForward());

        webViewHelper.goBack();
        webViewHelper.goForward();

        System.out.println("\n=== All WebView Integration Examples Completed ===");
    }
}