Android Java 移动功能示例

// Android Java Device Information Examples
// Getting various device information and system properties

import android.app.Activity;
import android.content.Context;
import android.content.res.Configuration;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.StatFs;
import android.provider.Settings;
import android.telephony.TelephonyManager;
import android.view.Display;
import android.view.WindowManager;
import android.webkit.WebSettings;
import android.text.TextUtils;
import java.io.File;
import java.util.Locale;

// 1. Basic Device Info
public class DeviceInfoHelper {
    private Context context;

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

    // Get device manufacturer
    public String getManufacturer() {
        return Build.MANUFACTURER;
    }

    // Get device model
    public String getModel() {
        return Build.MODEL;
    }

    // Get device name
    public String getDeviceName() {
        String manufacturer = Build.MANUFACTURER;
        String model = Build.MODEL;
        if (model.startsWith(manufacturer)) {
            return capitalize(model);
        }
        return capitalize(manufacturer) + " " + model;
    }

    private String capitalize(String str) {
        if (str == null || str.isEmpty()) {
            return str;
        }
        char first = str.charAt(0);
        if (Character.isUpperCase(first)) {
            return str;
        }
        return Character.toUpperCase(first) + str.substring(1);
    }

    // Get Android version
    public String getAndroidVersion() {
        return "Android " + Build.VERSION.RELEASE + " (API " + Build.VERSION.SDK_INT + ")";
    }

    // Get Android SDK version
    public int getSdkVersion() {
        return Build.VERSION.SDK_INT;
    }

    // Get device serial
    public String getSerialNumber() {
        return Build.SERIAL;
    }

    // Get device ID (requires permission)
    public String getDeviceId() {
        String androidId = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);
        return androidId;
    }

    // Get bootloader version
    public String getBootloaderVersion() {
        return Build.BOOTLOADER;
    }

    // Get hardware info
    public String getHardware() {
        return Build.HARDWARE;
    }

    // Get radio firmware version
    public String getRadioVersion() {
        return Build.getRadioVersion();
    }

    // Get build fingerprint
    public String getBuildFingerprint() {
        return Build.FINGERPRINT;
    }

    // Print all device info
    public void printAllDeviceInfo() {
        System.out.println("=== Device Information ===");
        System.out.println("Manufacturer: " + getManufacturer());
        System.out.println("Model: " + getModel());
        System.out.println("Device Name: " + getDeviceName());
        System.out.println("Android Version: " + getAndroidVersion());
        System.out.println("SDK Version: " + getSdkVersion());
        System.out.println("Serial: " + getSerialNumber());
        System.out.println("Device ID: " + getDeviceId());
        System.out.println("Bootloader: " + getBootloaderVersion());
        System.out.println("Hardware: " + getHardware());
        System.out.println("Build Fingerprint: " + getBuildFingerprint());
    }
}

// 2. Screen Information
public class ScreenInfoHelper {
    private Context context;

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

    // Get screen width
    public int getScreenWidth() {
        WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        Display display = wm.getDefaultDisplay();
        android.graphics.Point point = new android.graphics.Point();
        display.getSize(point);
        return point.x;
    }

    // Get screen height
    public int getScreenHeight() {
        WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        Display display = wm.getDefaultDisplay();
        android.graphics.Point point = new android.graphics.Point();
        display.getSize(point);
        return point.y;
    }

    // Get screen density
    public float getScreenDensity() {
        return context.getResources().getDisplayMetrics().density;
    }

    // Get screen density DPI
    public int getScreenDensityDpi() {
        return context.getResources().getDisplayMetrics().densityDpi;
    }

    // Get screen resolution
    public String getScreenResolution() {
        return getScreenWidth() + "x" + getScreenHeight();
    }

    // Check if tablet
    public boolean isTablet() {
        return (context.getResources().getConfiguration().screenLayout
                & Configuration.SCREENLAYOUT_SIZE_MASK)
                >= Configuration.SCREENLAYOUT_SIZE_LARGE;
    }

    // Get screen orientation
    public String getScreenOrientation() {
        int orientation = context.getResources().getConfiguration().orientation;
        switch (orientation) {
            case Configuration.ORIENTATION_LANDSCAPE:
                return "Landscape";
            case Configuration.ORIENTATION_PORTRAIT:
                return "Portrait";
            default:
                return "Undefined";
        }
    }

    // Print all screen info
    public void printAllScreenInfo() {
        System.out.println("=== Screen Information ===");
        System.out.println("Resolution: " + getScreenResolution());
        System.out.println("Width: " + getScreenWidth());
        System.out.println("Height: " + getScreenHeight());
        System.out.println("Density: " + getScreenDensity());
        System.out.println("Density DPI: " + getScreenDensityDpi());
        System.out.println("Is Tablet: " + isTablet());
        System.out.println("Orientation: " + getScreenOrientation());
    }
}

// 3. Battery Information
public class BatteryInfoHelper {
    private Context context;

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

    // Get battery level percentage
    public int getBatteryLevel() {
        android.content.IntentFilter ifilter = new android.content.IntentFilter(android.content.Intent.ACTION_BATTERY_CHANGED);
        android.content.Intent batteryStatus = context.registerReceiver(null, ifilter);

        int level = batteryStatus.getIntExtra(android.os.BatteryManager.EXTRA_LEVEL, -1);
        int scale = batteryStatus.getIntExtra(android.os.BatteryManager.EXTRA_SCALE, -1);

        return (int) ((level / (double) scale) * 100);
    }

    // Check if device is charging
    public boolean isCharging() {
        android.content.IntentFilter ifilter = new android.content.IntentFilter(android.content.Intent.ACTION_BATTERY_CHANGED);
        android.content.Intent batteryStatus = context.registerReceiver(null, ifilter);

        int chargePlug = batteryStatus.getIntExtra(android.os.BatteryManager.EXTRA_PLUGGED, -1);
        return chargePlug == android.os.BatteryManager.BATTERY_PLUGGED_AC
                || chargePlug == android.os.BatteryManager.BATTERY_PLUGGED_USB
                || chargePlug == android.os.BatteryManager.BATTERY_PLUGGED_WIRELESS;
    }

    // Get battery health
    public String getBatteryHealth() {
        android.content.IntentFilter ifilter = new android.content.IntentFilter(android.content.Intent.ACTION_BATTERY_CHANGED);
        android.content.Intent batteryStatus = context.registerReceiver(null, ifilter);

        int health = batteryStatus.getIntExtra(android.os.BatteryManager.EXTRA_HEALTH, 0);
        switch (health) {
            case android.os.BatteryManager.BATTERY_HEALTH_COLD:
                return "Cold";
            case android.os.BatteryManager.BATTERY_HEALTH_DEAD:
                return "Dead";
            case android.os.BatteryManager.BATTERY_HEALTH_GOOD:
                return "Good";
            case android.os.BatteryManager.BATTERY_HEALTH_OVERHEAT:
                return "Overheat";
            case android.os.BatteryManager.BATTERY_HEALTH_OVER_VOLTAGE:
                return "Over Voltage";
            case android.os.BatteryManager.BATTERY_HEALTH_UNKNOWN:
            default:
                return "Unknown";
            case android.os.BatteryManager.BATTERY_HEALTH_UNSPECIFIED_FAILURE:
                return "Unspecified Failure";
        }
    }

    // Get battery technology
    public String getBatteryTechnology() {
        android.content.IntentFilter ifilter = new android.content.IntentFilter(android.content.Intent.ACTION_BATTERY_CHANGED);
        android.content.Intent batteryStatus = context.registerReceiver(null, ifilter);
        return batteryStatus.getStringExtra(android.os.BatteryManager.EXTRA_TECHNOLOGY);
    }

    // Get battery temperature
    public float getBatteryTemperature() {
        android.content.IntentFilter ifilter = new android.content.IntentFilter(android.content.Intent.ACTION_BATTERY_CHANGED);
        android.content.Intent batteryStatus = context.registerReceiver(null, ifilter);
        int temperature = batteryStatus.getIntExtra(android.os.BatteryManager.EXTRA_TEMPERATURE, 0);
        return temperature / 10.0f; // Convert to Celsius
    }

    // Get battery voltage
    public int getBatteryVoltage() {
        android.content.IntentFilter ifilter = new android.content.IntentFilter(android.content.Intent.ACTION_BATTERY_CHANGED);
        android.content.Intent batteryStatus = context.registerReceiver(null, ifilter);
        return batteryStatus.getIntExtra(android.os.BatteryManager.EXTRA_VOLTAGE, 0);
    }

    // Print all battery info
    public void printAllBatteryInfo() {
        System.out.println("=== Battery Information ===");
        System.out.println("Level: " + getBatteryLevel() + "%");
        System.out.println("Charging: " + (isCharging() ? "Yes" : "No"));
        System.out.println("Health: " + getBatteryHealth());
        System.out.println("Technology: " + getBatteryTechnology());
        System.out.println("Temperature: " + getBatteryTemperature() + "°C");
        System.out.println("Voltage: " + getBatteryVoltage() + " mV");
    }
}

// 4. Storage Information
public class StorageInfoHelper {
    private Context context;

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

    // Get internal storage total size
    public long getInternalStorageTotalSize() {
        StatFs stat = new StatFs(Environment.getDataDirectory().getPath());
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2) {
            return stat.getTotalBytes();
        }
        return (long) stat.getBlockCount() * stat.getBlockSize();
    }

    // Get internal storage available size
    public long getInternalStorageAvailableSize() {
        StatFs stat = new StatFs(Environment.getDataDirectory().getPath());
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2) {
            return stat.getAvailableBytes();
        }
        return (long) stat.getAvailableBlocks() * stat.getBlockSize();
    }

    // Get internal storage used size
    public long getInternalStorageUsedSize() {
        return getInternalStorageTotalSize() - getInternalStorageAvailableSize();
    }

    // Get external storage state
    public String getExternalStorageState() {
        return Environment.getExternalStorageState();
    }

    // Check if external storage is available
    public boolean isExternalStorageAvailable() {
        return Environment.MEDIA_MOUNTED.equals(getExternalStorageState());
    }

    // Check if external storage is read-only
    public boolean isExternalStorageReadOnly() {
        return Environment.MEDIA_MOUNTED_READ_ONLY.equals(getExternalStorageState());
    }

    // Get external storage total size
    public long getExternalStorageTotalSize() {
        if (isExternalStorageAvailable()) {
            StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());
            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2) {
                return stat.getTotalBytes();
            }
            return (long) stat.getBlockCount() * stat.getBlockSize();
        }
        return 0;
    }

    // Get external storage available size
    public long getExternalStorageAvailableSize() {
        if (isExternalStorageAvailable()) {
            StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());
            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2) {
                return stat.getAvailableBytes();
            }
            return (long) stat.getAvailableBlocks() * stat.getBlockSize();
        }
        return 0;
    }

    // Format bytes to readable format
    public String formatBytes(long bytes) {
        double kb = bytes / 1024.0;
        double mb = kb / 1024;
        double gb = mb / 1024;

        if (gb >= 1) {
            return String.format("%.2f GB", gb);
        } else if (mb >= 1) {
            return String.format("%.2f MB", mb);
        } else if (kb >= 1) {
            return String.format("%.2f KB", kb);
        } else {
            return bytes + " bytes";
        }
    }

    // Print all storage info
    public void printAllStorageInfo() {
        System.out.println("=== Storage Information ===");
        System.out.println("Internal Storage:");
        System.out.println("  Total: " + formatBytes(getInternalStorageTotalSize()));
        System.out.println("  Available: " + formatBytes(getInternalStorageAvailableSize()));
        System.out.println("  Used: " + formatBytes(getInternalStorageUsedSize()));
        System.out.println("External Storage:");
        System.out.println("  Available: " + isExternalStorageAvailable());
        System.out.println("  Total: " + formatBytes(getExternalStorageTotalSize()));
        System.out.println("  Free: " + formatBytes(getExternalStorageAvailableSize()));
    }
}

// 5. Network Information
public class NetworkInfoHelper {
    private Context context;

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

    // Get network operator name
    public String getNetworkOperatorName() {
        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        if (telephonyManager != null) {
            return telephonyManager.getNetworkOperatorName();
        }
        return "Unknown";
    }

    // Get SIM operator name
    public String getSimOperatorName() {
        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        if (telephonyManager != null) {
            return telephonyManager.getSimOperatorName();
        }
        return "Unknown";
    }

    // Get network type
    public String getNetworkType() {
        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        if (telephonyManager != null) {
            int networkType = telephonyManager.getNetworkType();
            switch (networkType) {
                case TelephonyManager.NETWORK_TYPE_GPRS:
                    return "GPRS";
                case TelephonyManager.NETWORK_TYPE_EDGE:
                    return "EDGE";
                case TelephonyManager.NETWORK_TYPE_UMTS:
                    return "UMTS";
                case TelephonyManager.NETWORK_TYPE_HSDPA:
                    return "HSDPA";
                case TelephonyManager.NETWORK_TYPE_HSUPA:
                    return "HSUPA";
                case TelephonyManager.NETWORK_TYPE_HSPA:
                    return "HSPA";
                case TelephonyManager.NETWORK_TYPE_LTE:
                    return "LTE";
                default:
                    return "Unknown";
            }
        }
        return "Unknown";
    }

    // Get phone type
    public String getPhoneType() {
        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        if (telephonyManager != null) {
            int phoneType = telephonyManager.getPhoneType();
            switch (phoneType) {
                case TelephonyManager.PHONE_TYPE_NONE:
                    return "None";
                case TelephonyManager.PHONE_TYPE_GSM:
                    return "GSM";
                case TelephonyManager.PHONE_TYPE_CDMA:
                    return "CDMA";
                case TelephonyManager.PHONE_TYPE_SIP:
                    return "SIP";
                default:
                    return "Unknown";
            }
        }
        return "Unknown";
    }

    // Get SIM serial number
    public String getSimSerialNumber() {
        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        if (telephonyManager != null) {
            return telephonyManager.getSimSerialNumber();
        }
        return "Unknown";
    }

    // Get SIM country ISO
    public String getSimCountryIso() {
        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        if (telephonyManager != null) {
            return telephonyManager.getSimCountryIso();
        }
        return "Unknown";
    }

    // Print all network info
    public void printAllNetworkInfo() {
        System.out.println("=== Network Information ===");
        System.out.println("Network Operator: " + getNetworkOperatorName());
        System.out.println("SIM Operator: " + getSimOperatorName());
        System.out.println("Network Type: " + getNetworkType());
        System.out.println("Phone Type: " + getPhoneType());
        System.out.println("SIM Serial: " + getSimSerialNumber());
        System.out.println("SIM Country: " + getSimCountryIso());
    }
}

// 6. Locale and Language Information
public class LocaleInfoHelper {
    private Context context;

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

    // Get current language
    public String getCurrentLanguage() {
        return Locale.getDefault().getLanguage();
    }

    // Get current display language
    public String getDisplayLanguage() {
        return Locale.getDefault().getDisplayLanguage();
    }

    // Get current country
    public String getCurrentCountry() {
        return Locale.getDefault().getCountry();
    }

    // Get current display country
    public String getDisplayCountry() {
        return Locale.getDefault().getDisplayCountry();
    }

    // Get device locale
    public String getDeviceLocale() {
        return Locale.getDefault().toString();
    }

    // Get timezone
    public String getTimezone() {
        return java.util.TimeZone.getDefault().getID();
    }

    // Get default timezone name
    public String getTimezoneName() {
        return java.util.TimeZone.getDefault().getDisplayName();
    }

    // Print all locale info
    public void printAllLocaleInfo() {
        System.out.println("=== Locale Information ===");
        System.out.println("Language Code: " + getCurrentLanguage());
        System.out.println("Language: " + getDisplayLanguage());
        System.out.println("Country Code: " + getCurrentCountry());
        System.out.println("Country: " + getDisplayCountry());
        System.out.println("Locale: " + getDeviceLocale());
        System.out.println("Timezone ID: " + getTimezone());
        System.out.println("Timezone Name: " + getTimezoneName());
    }
}

// 7. App Information
public class AppInfoHelper {
    private Context context;

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

    // Get app version name
    public String getAppVersionName() {
        try {
            return context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName;
        } catch (Exception e) {
            return "Unknown";
        }
    }

    // Get app version code
    public int getAppVersionCode() {
        try {
            return context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionCode;
        } catch (Exception e) {
            return 0;
        }
    }

    // Get package name
    public String getPackageName() {
        return context.getPackageName();
    }

    // Get install time
    public long getInstallTime() {
        try {
            return context.getPackageManager().getPackageInfo(context.getPackageName(), 0).firstInstallTime;
        } catch (Exception e) {
            return 0;
        }
    }

    // Get last update time
    public long getLastUpdateTime() {
        try {
            return context.getPackageManager().getPackageInfo(context.getPackageName(), 0).lastUpdateTime;
        } catch (Exception e) {
            return 0;
        }
    }

    // Print all app info
    public void printAllAppInfo() {
        System.out.println("=== App Information ===");
        System.out.println("Package Name: " + getPackageName());
        System.out.println("Version Name: " + getAppVersionName());
        System.out.println("Version Code: " + getAppVersionCode());
        System.out.println("Install Time: " + new java.util.Date(getInstallTime()));
        System.out.println("Last Update: " + new java.util.Date(getLastUpdateTime()));
    }
}

// Main demonstration
public class DeviceInfoDemo {
    public static void demonstrateDeviceInfo(Context context) {
        System.out.println("=== Android Java Device Information Examples ===\n");

        // 1. Basic device info
        System.out.println("--- 1. Basic Device Info ---");
        DeviceInfoHelper deviceInfo = new DeviceInfoHelper(context);
        deviceInfo.printAllDeviceInfo();

        // 2. Screen info
        System.out.println("\n--- 2. Screen Information ---");
        ScreenInfoHelper screenInfo = new ScreenInfoHelper(context);
        screenInfo.printAllScreenInfo();

        // 3. Battery info
        System.out.println("\n--- 3. Battery Information ---");
        BatteryInfoHelper batteryInfo = new BatteryInfoHelper(context);
        batteryInfo.printAllBatteryInfo();

        // 4. Storage info
        System.out.println("\n--- 4. Storage Information ---");
        StorageInfoHelper storageInfo = new StorageInfoHelper(context);
        storageInfo.printAllStorageInfo();

        // 5. Network info
        System.out.println("\n--- 5. Network Information ---");
        NetworkInfoHelper networkInfo = new NetworkInfoHelper(context);
        networkInfo.printAllNetworkInfo();

        // 6. Locale info
        System.out.println("\n--- 6. Locale Information ---");
        LocaleInfoHelper localeInfo = new LocaleInfoHelper(context);
        localeInfo.printAllLocaleInfo();

        // 7. App info
        System.out.println("\n--- 7. App Information ---");
        AppInfoHelper appInfo = new AppInfoHelper(context);
        appInfo.printAllAppInfo();

        System.out.println("\n=== All Device Information Examples Completed ===");
    }
}

// Android Java Network Status Examples
// Checking network connectivity, type, and monitoring changes

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkInfo;
import android.net.NetworkRequest;
import android.os.Build;
import androidx.net.ConnectivityManagerCompat;
import android.content.BroadcastReceiver;
import android.content.Intent;
import android.content.IntentFilter;
import android.telephony.TelephonyManager;

// 1. Basic Network Connectivity
public class NetworkConnectivityHelper {
    private Context context;
    private ConnectivityManager connectivityManager;

    public NetworkConnectivityHelper(Context context) {
        this.context = context;
        this.connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    }

    // Check if network is available
    public boolean isNetworkAvailable() {
        if (connectivityManager == null) {
            return false;
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            android.net.Network network = connectivityManager.getActiveNetwork();
            if (network == null) {
                return false;
            }

            NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(network);
            return capabilities != null
                    && capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                    && capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
        } else {
            NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
            return networkInfo != null && networkInfo.isConnected();
        }
    }

    // Check if WiFi is connected
    public boolean isWifiConnected() {
        if (connectivityManager == null) {
            return false;
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            android.net.Network network = connectivityManager.getActiveNetwork();
            if (network == null) {
                return false;
            }

            NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(network);
            return capabilities != null
                    && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI);
        } else {
            NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
            return networkInfo != null
                    && networkInfo.getType() == ConnectivityManager.TYPE_WIFI
                    && networkInfo.isConnected();
        }
    }

    // Check if mobile data is connected
    public boolean isMobileDataConnected() {
        if (connectivityManager == null) {
            return false;
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            android.net.Network network = connectivityManager.getActiveNetwork();
            if (network == null) {
                return false;
            }

            NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(network);
            return capabilities != null
                    && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR);
        } else {
            NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
            return networkInfo != null
                    && networkInfo.getType() == ConnectivityManager.TYPE_MOBILE
                    && networkInfo.isConnected();
        }
    }

    // Check if VPN is connected
    public boolean isVpnConnected() {
        if (connectivityManager == null) {
            return false;
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            android.net.Network network = connectivityManager.getActiveNetwork();
            if (network == null) {
                return false;
            }

            NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(network);
            return capabilities != null
                    && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN);
        }
        return false;
    }

    // Get network type
    public String getNetworkType() {
        if (!isNetworkAvailable()) {
            return "No Network";
        }

        if (isWifiConnected()) {
            return "WiFi";
        } else if (isMobileDataConnected()) {
            return "Mobile Data";
        } else if (isVpnConnected()) {
            return "VPN";
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            android.net.Network network = connectivityManager.getActiveNetwork();
            NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(network);
            if (capabilities != null) {
                if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)) {
                    return "Ethernet";
                } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_BLUETOOTH)) {
                    return "Bluetooth";
                }
            }
        }

        return "Unknown";
    }

    // Check if network is metered
    public boolean isNetworkMetered() {
        if (connectivityManager == null) {
            return false;
        }
        return ConnectivityManagerCompat.isActiveNetworkMetered(connectivityManager);
    }

    // Print network status
    public void printNetworkStatus() {
        System.out.println("=== Network Status ===");
        System.out.println("Network Available: " + isNetworkAvailable());
        System.out.println("WiFi Connected: " + isWifiConnected());
        System.out.println("Mobile Data Connected: " + isMobileDataConnected());
        System.out.println("VPN Connected: " + isVpnConnected());
        System.out.println("Network Type: " + getNetworkType());
        System.out.println("Network Metered: " + isNetworkMetered());
    }
}

// 2. Mobile Network Type Details
public class MobileNetworkHelper {
    private Context context;

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

    // Get mobile network type
    public String getMobileNetworkType() {
        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        if (telephonyManager == null) {
            return "Unknown";
        }

        int networkType = telephonyManager.getNetworkType();
        switch (networkType) {
            case TelephonyManager.NETWORK_TYPE_GPRS:
                return "2G - GPRS (General Packet Radio Service)";
            case TelephonyManager.NETWORK_TYPE_EDGE:
                return "2G - EDGE (Enhanced Data rates for GSM Evolution)";
            case TelephonyManager.NETWORK_TYPE_CDMA:
                return "2G - CDMA (Code Division Multiple Access)";
            case TelephonyManager.NETWORK_TYPE_1xRTT:
                return "2G - 1xRTT (Single Carrier Radio Transmission Technology)";
            case TelephonyManager.NETWORK_TYPE_IDEN:
                return "2G - iDEN (Integrated Digital Enhanced Network)";
            case TelephonyManager.NETWORK_TYPE_UMTS:
                return "3G - UMTS (Universal Mobile Telecommunications System)";
            case TelephonyManager.NETWORK_TYPE_EVDO_0:
                return "3G - EVDO Rev. 0 (Evolution-Data Optimized)";
            case TelephonyManager.NETWORK_TYPE_EVDO_A:
                return "3G - EVDO Rev. A";
            case TelephonyManager.NETWORK_TYPE_HSDPA:
                return "3G - HSDPA (High Speed Downlink Packet Access)";
            case TelephonyManager.NETWORK_TYPE_HSUPA:
                return "3G - HSUPA (High Speed Uplink Packet Access)";
            case TelephonyManager.NETWORK_TYPE_HSPA:
                return "3G - HSPA (High Speed Packet Access)";
            case TelephonyManager.NETWORK_TYPE_EVDO_B:
                return "3G - EVDO Rev. B";
            case TelephonyManager.NETWORK_TYPE_EHRPD:
                return "3G - eHRPD (Enhanced HRPD)";
            case TelephonyManager.NETWORK_TYPE_LTE:
                return "4G - LTE (Long Term Evolution)";
            case TelephonyManager.NETWORK_TYPE_HSPAP:
                return "3G - HSPA+ (Evolved High Speed Packet Access)";
            case TelephonyManager.NETWORK_TYPE_NR:
                return "5G - NR (New Radio)";
            default:
                return "Unknown";
        }
    }

    // Get network generation
    public String getNetworkGeneration() {
        String type = getMobileNetworkType();
        if (type.startsWith("2G")) {
            return "2G";
        } else if (type.startsWith("3G")) {
            return "3G";
        } else if (type.startsWith("4G")) {
            return "4G";
        } else if (type.startsWith("5G")) {
            return "5G";
        }
        return "Unknown";
    }

    // Get data state
    public String getDataState() {
        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        if (telephonyManager == null) {
            return "Unknown";
        }

        int dataState = telephonyManager.getDataState();
        switch (dataState) {
            case TelephonyManager.DATA_CONNECTED:
                return "Connected";
            case TelephonyManager.DATA_CONNECTING:
                return "Connecting";
            case TelephonyManager.DATA_DISCONNECTED:
                return "Disconnected";
            case TelephonyManager.DATA_SUSPENDED:
                return "Suspended";
            default:
                return "Unknown";
        }
    }

    // Get signal strength (approximate)
    public String getSignalStrength() {
        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        if (telephonyManager == null) {
            return "Unknown";
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            int signalStrength = 0;
            // This requires permission and cell info
            return "Requires permissions";
        }

        return "Unknown";
    }

    // Print mobile network info
    public void printMobileNetworkInfo() {
        System.out.println("=== Mobile Network Information ===");
        System.out.println("Network Type: " + getMobileNetworkType());
        System.out.println("Generation: " + getNetworkGeneration());
        System.out.println("Data State: " + getDataState());
    }
}

// 3. Network Speed Detection
public class NetworkSpeedHelper {
    private Context context;

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

    // Estimate network speed class
    public String getNetworkSpeedClass() {
        NetworkConnectivityHelper connectivityHelper = new NetworkConnectivityHelper(context);
        MobileNetworkHelper mobileNetworkHelper = new MobileNetworkHelper(context);

        if (connectivityHelper.isWifiConnected()) {
            return "High Speed (WiFi)";
        } else if (connectivityHelper.isMobileDataConnected()) {
            String generation = mobileNetworkHelper.getNetworkGeneration();
            switch (generation) {
                case "2G":
                    return "Low Speed (2G)";
                case "3G":
                    return "Medium Speed (3G)";
                case "4G":
                    return "High Speed (4G/LTE)";
                case "5G":
                    return "Very High Speed (5G)";
                default:
                    return "Unknown Speed";
            }
        }

        return "No Network";
    }

    // Check if connection is suitable for downloads
    public boolean isSuitableForDownloads() {
        String speedClass = getNetworkSpeedClass();
        return speedClass.contains("High") || speedClass.contains("Medium");
    }

    // Check if connection is suitable for streaming
    public boolean isSuitableForStreaming() {
        String speedClass = getNetworkSpeedClass();
        return speedClass.contains("High") || speedClass.contains("Very High");
    }

    // Print network speed info
    public void printNetworkSpeedInfo() {
        System.out.println("=== Network Speed Information ===");
        System.out.println("Speed Class: " + getNetworkSpeedClass());
        System.out.println("Suitable for Downloads: " + isSuitableForDownloads());
        System.out.println("Suitable for Streaming: " + isSuitableForStreaming());
    }
}

// 4. Network Callback (API 24+)
public class NetworkCallbackHelper {
    private Context context;
    private ConnectivityManager connectivityManager;
    private ConnectivityManager.NetworkCallback networkCallback;

    public NetworkCallbackHelper(Context context) {
        this.context = context;
        this.connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    }

    public interface NetworkChangeListener {
        void onNetworkAvailable();
        void onNetworkLost();
        void onCapabilitiesChanged(NetworkCapabilities capabilities);
    }

    // Register network callback
    public void registerNetworkCallback(final NetworkChangeListener listener) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            networkCallback = new ConnectivityManager.NetworkCallback() {
                @Override
                public void onAvailable(android.net.Network network) {
                    super.onAvailable(network);
                    if (listener != null) {
                        listener.onNetworkAvailable();
                    }
                }

                @Override
                public void onLost(android.net.Network network) {
                    super.onLost(network);
                    if (listener != null) {
                        listener.onNetworkLost();
                    }
                }

                @Override
                public void onCapabilitiesChanged(android.net.Network network, NetworkCapabilities networkCapabilities) {
                    super.onCapabilitiesChanged(network, networkCapabilities);
                    if (listener != null) {
                        listener.onCapabilitiesChanged(networkCapabilities);
                    }
                }
            };

            NetworkRequest.Builder builder = new NetworkRequest.Builder();
            builder.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
            connectivityManager.registerDefaultNetworkCallback(networkCallback);
        }
    }

    // Unregister network callback
    public void unregisterNetworkCallback() {
        if (networkCallback != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            connectivityManager.unregisterNetworkCallback(networkCallback);
            networkCallback = null;
        }
    }
}

// 5. Network State Broadcast Receiver (Legacy)
public class NetworkStateReceiver extends BroadcastReceiver {
    public interface NetworkStateListener {
        void onNetworkStateChanged(boolean isConnected);
    }

    private NetworkStateListener listener;

    public void setListener(NetworkStateListener listener) {
        this.listener = listener;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        if (listener != null && ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
            NetworkConnectivityHelper helper = new NetworkConnectivityHelper(context);
            listener.onNetworkStateChanged(helper.isNetworkAvailable());
        }
    }
}

// 6. Network Monitoring Service
public class NetworkMonitoringService {
    private Context context;
    private NetworkCallbackHelper callbackHelper;
    private NetworkStateReceiver broadcastReceiver;
    private boolean isMonitoring = false;

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

    // Start monitoring
    public void startMonitoring(final NetworkMonitoringListener listener) {
        if (isMonitoring) {
            return;
        }

        isMonitoring = true;

        // Use NetworkCallback for API 24+
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            callbackHelper = new NetworkCallbackHelper(context);
            callbackHelper.registerNetworkCallback(new NetworkCallbackHelper.NetworkChangeListener() {
                @Override
                public void onNetworkAvailable() {
                    if (listener != null) {
                        listener.onNetworkConnected();
                    }
                }

                @Override
                public void onNetworkLost() {
                    if (listener != null) {
                        listener.onNetworkDisconnected();
                    }
                }

                @Override
                public void onCapabilitiesChanged(NetworkCapabilities capabilities) {
                    // Notify capabilities changed if needed
                }
            });
        } else {
            // Use BroadcastReceiver for older versions
            broadcastReceiver = new NetworkStateReceiver();
            broadcastReceiver.setListener(new NetworkStateReceiver.NetworkStateListener() {
                @Override
                public void onNetworkStateChanged(boolean isConnected) {
                    if (isConnected) {
                        if (listener != null) {
                            listener.onNetworkConnected();
                        }
                    } else {
                        if (listener != null) {
                            listener.onNetworkDisconnected();
                        }
                    }
                }
            });

            IntentFilter filter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
            context.registerReceiver(broadcastReceiver, filter);
        }
    }

    // Stop monitoring
    public void stopMonitoring() {
        if (!isMonitoring) {
            return;
        }

        if (callbackHelper != null) {
            callbackHelper.unregisterNetworkCallback();
            callbackHelper = null;
        }

        if (broadcastReceiver != null) {
            context.unregisterReceiver(broadcastReceiver);
            broadcastReceiver = null;
        }

        isMonitoring = false;
    }

    public interface NetworkMonitoringListener {
        void onNetworkConnected();
        void onNetworkDisconnected();
    }
}

// Main demonstration
public class NetworkStatusDemo {
    public static void demonstrateNetworkStatus(Context context) {
        System.out.println("=== Android Java Network Status Examples ===\n");

        // 1. Basic connectivity
        System.out.println("--- 1. Basic Network Connectivity ---");
        NetworkConnectivityHelper connectivityHelper = new NetworkConnectivityHelper(context);
        connectivityHelper.printNetworkStatus();

        // 2. Mobile network details
        System.out.println("\n--- 2. Mobile Network Details ---");
        MobileNetworkHelper mobileNetworkHelper = new MobileNetworkHelper(context);
        mobileNetworkHelper.printMobileNetworkInfo();

        // 3. Network speed
        System.out.println("\n--- 3. Network Speed ---");
        NetworkSpeedHelper speedHelper = new NetworkSpeedHelper(context);
        speedHelper.printNetworkSpeedInfo();

        // 4. Network monitoring
        System.out.println("\n--- 4. Network Monitoring ---");
        NetworkMonitoringService monitoringService = new NetworkMonitoringService(context);

        monitoringService.startMonitoring(new NetworkMonitoringService.NetworkMonitoringListener() {
            @Override
            public void onNetworkConnected() {
                System.out.println("Network connected!");
            }

            @Override
            public void onNetworkDisconnected() {
                System.out.println("Network disconnected!");
            }
        });

        // In a real app, you would stop monitoring when done
        // monitoringService.stopMonitoring();

        System.out.println("\n=== All Network Status Examples Completed ===");
    }
}

// Android Java Sensors and Vibration Examples
// Using various device sensors and vibration for haptic feedback

import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Build;
import android.os.VibrationEffect;
import android.os.Vibrator;
import android.view.Surface;
import java.util.List;

// 1. Vibration Helper
public class VibrationHelper {
    private Context context;
    private Vibrator vibrator;

    public VibrationHelper(Context context) {
        this.context = context;
        this.vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
    }

    // Check if device can vibrate
    public boolean hasVibrator() {
        return vibrator != null && vibrator.hasVibrator();
    }

    // Simple vibration
    public void vibrate(long milliseconds) {
        if (!hasVibrator()) {
            return;
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            VibrationEffect effect = VibrationEffect.createOneShot(milliseconds, VibrationEffect.DEFAULT_AMPLITUDE);
            vibrator.vibrate(effect);
        } else {
            vibrator.vibrate(milliseconds);
        }
    }

    // Vibrate with custom amplitude (API 26+)
    public void vibrate(long milliseconds, int amplitude) {
        if (!hasVibrator() || Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
            vibrate(milliseconds);
            return;
        }

        VibrationEffect effect = VibrationEffect.createOneShot(milliseconds, amplitude);
        vibrator.vibrate(effect);
    }

    // Pattern vibration
    public void vibratePattern(long[] pattern) {
        if (!hasVibrator()) {
            return;
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            VibrationEffect effect = VibrationEffect.createWaveform(pattern, -1);
            vibrator.vibrate(effect);
        } else {
            vibrator.vibrate(pattern, -1);
        }
    }

    // Repeating pattern
    public void vibratePatternRepeat(long[] pattern, int repeatIndex) {
        if (!hasVibrator()) {
            return;
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            VibrationEffect effect = VibrationEffect.createWaveform(pattern, repeatIndex);
            vibrator.vibrate(effect);
        } else {
            vibrator.vibrate(pattern, repeatIndex);
        }
    }

    // Predefined vibration patterns
    public void vibrateClick() {
        vibrate(new long[]{0, 50});
    }

    public void vibrateDoubleClick() {
        vibrate(new long[]{0, 50, 50, 50});
    }

    public void vibrateTick() {
        vibrate(new long[]{0, 25});
    }

    public void vibrateHeavyClick() {
        vibrate(new long[]{0, 100});
    }

    // Success vibration
    public void vibrateSuccess() {
        vibrate(new long[]{0, 50, 50, 50});
    }

    // Error vibration
    public void vibrateError() {
        vibratePattern(new long[]{0, 100, 50, 100, 50, 100});
    }

    // Warning vibration
    public void vibrateWarning() {
        vibratePattern(new long[]{0, 100, 50, 100});
    }

    // Stop vibration
    public void cancel() {
        if (vibrator != null) {
            vibrator.cancel();
        }
    }
}

// 2. Sensor Helper
public class SensorHelper {
    private Context context;
    private SensorManager sensorManager;

    public SensorHelper(Context context) {
        this.context = context;
        this.sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
    }

    // Check if sensor is available
    public boolean hasSensor(int type) {
        return sensorManager.getDefaultSensor(type) != null;
    }

    // Get sensor
    public Sensor getSensor(int type) {
        return sensorManager.getDefaultSensor(type);
    }

    // Get all available sensors
    public List<Sensor> getAllSensors() {
        return sensorManager.getSensorList(Sensor.TYPE_ALL);
    }

    // Print all available sensors
    public void printAllSensors() {
        System.out.println("=== Available Sensors ===");
        List<Sensor> sensors = getAllSensors();

        for (Sensor sensor : sensors) {
            System.out.println("Name: " + sensor.getName());
            System.out.println("  Type: " + sensor.getStringType());
            System.out.println("  Vendor: " + sensor.getVendor());
            System.out.println("  Version: " + sensor.getVersion());
            System.out.println("  Resolution: " + sensor.getResolution());
            System.out.println("  Maximum Range: " + sensor.getMaximumRange());
            System.out.println("  Power: " + sensor.getPower() + " mA");
            System.out.println("  Min Delay: " + sensor.getMinDelay() + " us");
        }
    }

    // Check common sensors
    public void checkCommonSensors() {
        System.out.println("=== Common Sensors Check ===");
        System.out.println("Accelerometer: " + hasSensor(Sensor.TYPE_ACCELEROMETER));
        System.out.println("Gyroscope: " + hasSensor(Sensor.TYPE_GYROSCOPE));
        System.out.println("Magnetometer: " + hasSensor(Sensor.TYPE_MAGNETIC_FIELD));
        System.out.println("Light: " + hasSensor(Sensor.TYPE_LIGHT));
        System.out.println("Proximity: " + hasSensor(Sensor.TYPE_PROXIMITY));
        System.out.println("Pressure: " + hasSensor(Sensor.TYPE_PRESSURE));
        System.out.println("Temperature: " + hasSensor(Sensor.TYPE_AMBIENT_TEMPERATURE));
        System.out.println("Humidity: " + hasSensor(Sensor.TYPE_RELATIVE_HUMIDITY));
    }
}

// 3. Accelerometer Sensor
public class AccelerometerHelper {
    private Context context;
    private SensorManager sensorManager;
    private SensorEventListener listener;

    public interface AccelerometerCallback {
        void onAccelerationChanged(float x, float y, float z);
    }

    public AccelerometerHelper(Context context) {
        this.context = context;
        this.sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
    }

    // Start listening to accelerometer
    public void startListening(final AccelerometerCallback callback) {
        Sensor accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

        listener = new SensorEventListener() {
            @Override
            public void onSensorChanged(SensorEvent event) {
                if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
                    float x = event.values[0];
                    float y = event.values[1];
                    float z = event.values[2];

                    if (callback != null) {
                        callback.onAccelerationChanged(x, y, z);
                    }
                }
            }

            @Override
            public void onAccuracyChanged(Sensor sensor, int accuracy) {
                // Handle accuracy changes if needed
            }
        };

        sensorManager.registerListener(listener, accelerometer, SensorManager.SENSOR_DELAY_NORMAL);
    }

    // Stop listening
    public void stopListening() {
        if (listener != null) {
            sensorManager.unregisterListener(listener);
            listener = null;
        }
    }

    // Get current acceleration (one-time reading)
    public void getCurrentAcceleration(final AccelerometerCallback callback) {
        Sensor accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

        SensorEventListener oneTimeListener = new SensorEventListener() {
            @Override
            public void onSensorChanged(SensorEvent event) {
                if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
                    float x = event.values[0];
                    float y = event.values[1];
                    float z = event.values[2];

                    if (callback != null) {
                        callback.onAccelerationChanged(x, y, z);
                    }

                    sensorManager.unregisterListener(this);
                }
            }

            @Override
            public void onAccuracyChanged(Sensor sensor, int accuracy) {
                // Ignore
            }
        };

        sensorManager.registerListener(oneTimeListener, accelerometer, SensorManager.SENSOR_DELAY_UI);
    }
}

// 4. Gyroscope Sensor
public class GyroscopeHelper {
    private Context context;
    private SensorManager sensorManager;
    private SensorEventListener listener;

    public interface GyroscopeCallback {
        void onRotationChanged(float x, float y, float z);
    }

    public GyroscopeHelper(Context context) {
        this.context = context;
        this.sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
    }

    // Start listening to gyroscope
    public void startListening(final GyroscopeCallback callback) {
        Sensor gyroscope = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);

        listener = new SensorEventListener() {
            @Override
            public void onSensorChanged(SensorEvent event) {
                if (event.sensor.getType() == Sensor.TYPE_GYROSCOPE) {
                    float x = event.values[0];
                    float y = event.values[1];
                    float z = event.values[2];

                    if (callback != null) {
                        callback.onRotationChanged(x, y, z);
                    }
                }
            }

            @Override
            public void onAccuracyChanged(Sensor sensor, int accuracy) {
                // Handle accuracy changes if needed
            }
        };

        sensorManager.registerListener(listener, gyroscope, SensorManager.SENSOR_DELAY_NORMAL);
    }

    // Stop listening
    public void stopListening() {
        if (listener != null) {
            sensorManager.unregisterListener(listener);
            listener = null;
        }
    }
}

// 5. Proximity Sensor
public class ProximityHelper {
    private Context context;
    private SensorManager sensorManager;
    private SensorEventListener listener;

    public interface ProximityCallback {
        void onProximityChanged(float distance);
        void onNear();
        void onFar();
    }

    public ProximityHelper(Context context) {
        this.context = context;
        this.sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
    }

    // Start listening to proximity sensor
    public void startListening(final ProximityCallback callback) {
        Sensor proximity = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);

        listener = new SensorEventListener() {
            private boolean wasNear = false;

            @Override
            public void onSensorChanged(SensorEvent event) {
                if (event.sensor.getType() == Sensor.TYPE_PROXIMITY) {
                    float distance = event.values[0];

                    if (callback != null) {
                        callback.onProximityChanged(distance);

                        if (distance < proximity.getMaximumRange()) {
                            if (!wasNear) {
                                callback.onNear();
                                wasNear = true;
                            }
                        } else {
                            if (wasNear) {
                                callback.onFar();
                                wasNear = false;
                            }
                        }
                    }
                }
            }

            @Override
            public void onAccuracyChanged(Sensor sensor, int accuracy) {
                // Handle accuracy changes if needed
            }
        };

        sensorManager.registerListener(listener, proximity, SensorManager.SENSOR_DELAY_NORMAL);
    }

    // Stop listening
    public void stopListening() {
        if (listener != null) {
            sensorManager.unregisterListener(listener);
            listener = null;
        }
    }

    // Check if device is near
    public boolean isNear() {
        Sensor proximity = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
        // This would require a one-time reading
        return false;
    }
}

// 6. Light Sensor
public class LightHelper {
    private Context context;
    private SensorManager sensorManager;
    private SensorEventListener listener;

    public interface LightCallback {
        void onLightChanged(float lux);
    }

    public LightHelper(Context context) {
        this.context = context;
        this.sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
    }

    // Start listening to light sensor
    public void startListening(final LightCallback callback) {
        Sensor light = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);

        listener = new SensorEventListener() {
            @Override
            public void onSensorChanged(SensorEvent event) {
                if (event.sensor.getType() == Sensor.TYPE_LIGHT) {
                    float lux = event.values[0];

                    if (callback != null) {
                        callback.onLightChanged(lux);
                    }
                }
            }

            @Override
            public void onAccuracyChanged(Sensor sensor, int accuracy) {
                // Handle accuracy changes if needed
            }
        };

        sensorManager.registerListener(listener, light, SensorManager.SENSOR_DELAY_NORMAL);
    }

    // Stop listening
    public void stopListening() {
        if (listener != null) {
            sensorManager.unregisterListener(listener);
            listener = null;
        }
    }
}

// 7. Orientation and Motion Detection
public class MotionDetector {
    private Context context;
    private AccelerometerHelper accelerometerHelper;

    public interface MotionCallback {
        void onShake();
        void onTilt(float x, float y, float z);
    }

    public MotionDetector(Context context) {
        this.context = context;
        this.accelerometerHelper = new AccelerometerHelper(context);
    }

    // Detect shake motion
    public void detectShake(final MotionCallback callback) {
        accelerometerHelper.startListening(new AccelerometerHelper.AccelerometerCallback() {
            private float lastX = 0, lastY = 0, lastZ = 0;
            private long lastTime = 0;
            private static final float SHAKE_THRESHOLD = 15.0f;
            private static final int SHAKE_WAIT_TIME = 100;

            @Override
            public void onAccelerationChanged(float x, float y, float z) {
                long currentTime = System.currentTimeMillis();

                if ((currentTime - lastTime) > SHAKE_WAIT_TIME) {
                    float deltaX = Math.abs(x - lastX);
                    float deltaY = Math.abs(y - lastY);
                    float deltaZ = Math.abs(z - lastZ);

                    float speed = deltaX + deltaY + deltaZ;

                    if (speed > SHAKE_THRESHOLD) {
                        if (callback != null) {
                            callback.onShake();
                        }
                    }

                    lastX = x;
                    lastY = y;
                    lastZ = z;
                    lastTime = currentTime;
                }
            }
        });
    }

    // Stop detection
    public void stopDetection() {
        accelerometerHelper.stopListening();
    }
}

// 8. Haptic Feedback Helper
public class HapticFeedbackHelper {
    private Context context;

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

    // Perform virtual key haptic feedback
    public void performVirtualKeyHapticFeedback() {
        // This would be called from a View
        // view.performHapticFeedback(android.view.HapticFeedbackConstants.VIRTUAL_KEY);
    }

    // Perform long press haptic feedback
    public void performLongPressHapticFeedback() {
        // This would be called from a View
        // view.performHapticFeedback(android.view.HapticFeedbackConstants.LONG_PRESS);
    }
}

// Main demonstration
public class SensorsAndVibrationDemo {
    public static void demonstrateSensorsAndVibration(Context context) {
        System.out.println("=== Android Java Sensors and Vibration Examples ===\n");

        // 1. Vibration examples
        System.out.println("--- 1. Vibration Examples ---");
        VibrationHelper vibrationHelper = new VibrationHelper(context);

        System.out.println("Has vibrator: " + vibrationHelper.hasVibrator());

        // Simple vibrations
        vibrationHelper.vibrateClick();
        try { Thread.sleep(500); } catch (InterruptedException e) {}

        vibrationHelper.vibrateDoubleClick();
        try { Thread.sleep(500); } catch (InterruptedException e) {}

        vibrationHelper.vibrateSuccess();
        try { Thread.sleep(500); } catch (InterruptedException e) {}

        // Pattern vibration
        vibrationHelper.vibratePattern(new long[]{0, 100, 50, 100, 50, 100});
        try { Thread.sleep(500); } catch (InterruptedException e) {}

        // 2. Sensor availability
        System.out.println("\n--- 2. Sensor Availability ---");
        SensorHelper sensorHelper = new SensorHelper(context);
        sensorHelper.checkCommonSensors();

        // 3. Print all sensors
        System.out.println("\n--- 3. All Sensors ---");
        sensorHelper.printAllSensors();

        // 4. Accelerometer
        System.out.println("\n--- 4. Accelerometer ---");
        AccelerometerHelper accelerometerHelper = new AccelerometerHelper(context);

        accelerometerHelper.getCurrentAcceleration(new AccelerometerHelper.AccelerometerCallback() {
            @Override
            public void onAccelerationChanged(float x, float y, float z) {
                System.out.println("Acceleration: X=" + x + ", Y=" + y + ", Z=" + z);
            }
        });

        // 5. Motion detection
        System.out.println("\n--- 5. Motion Detection ---");
        MotionDetector motionDetector = new MotionDetector(context);

        // Note: This would need to run longer to detect shake
        // motionDetector.detectShake(new MotionDetector.MotionCallback() {
        //     @Override
        //     public void onShake() {
        //         System.out.println("Shake detected!");
        //         vibrationHelper.vibrateTick();
        //     }
        //
        //     @Override
        //     public void onTilt(float x, float y, float z) {
        //         System.out.println("Tilt: X=" + x + ", Y=" + y + ", Z=" + z);
        //     }
        // });

        System.out.println("\n=== All Sensors and Vibration Examples Completed ===");
    }
}