Android 系统开关，wifi、手电筒等的开关详解手机开发

• wifi是否开启
• wifi开关
• 蓝牙是否开启
• 蓝牙开关
• 是否开启自动旋转
• 屏幕旋转开关
• 是否开启同步
• 同步开关
• 屏幕亮度切换
• 设置屏幕亮度
• 是否开启飞行模式
• 飞行模式开关
• 是否开启数据连接
• 数据连接开关
• 情景模式切换
• 是否开启gps
• gps开关
• 锁屏
• 重启
• 关机
• 是否开启了闪光灯
• 闪光灯开关
• 闪光灯开关2
• 跳转到系统设置
• 跳转到系统app管理
• 跳转到系统显示设置
• 跳转到系统声音设置
• 跳转到系统日期设置
• 跳转到系统位置设置
• 跳转到系统同步设置
• 跳转到系统输入设置
• 调大媒体音量

package android.widget; 
 
import java.lang.reflect.Field; 
import java.lang.reflect.Method; 
 
import android.bluetooth.BluetoothAdapter; 
import android.content.ContentResolver; 
import android.content.Context; 
import android.content.Intent; 
import android.hardware.Camera; 
import android.hardware.Camera.Parameters; 
import android.location.LocationManager; 
import android.media.AudioManager; 
import android.net.ConnectivityManager; 
import android.net.Uri; 
import android.net.wifi.WifiManager; 
import android.os.PowerManager; 
import android.os.SystemClock; 
import android.provider.Settings; 
import android.provider.Settings.Secure; 
import android.provider.Settings.SettingNotFoundException; 
import android.widget.Toast; 
 
 
 
public class SystemSwitchUtils { 
    private Context context; 
    private WifiManager mWifiManager; 
    private BluetoothAdapter mBluetoothAdapter; 
    private ConnectivityManager connManager; 
    private PowerManager mPowerManager; 
    private AudioManager mAudioManager; 
    private static Camera camera; 
 
    private final int LIGHT_NORMAL = 64; 
    private final int LIGHT_50_PERCENT = 127; 
    private final int LIGHT_75_PERCENT = 191; 
    private final int LIGHT_100_PERCENT = 255; 
    private final int LIGHT_AUTO = 0; 
    private final int LIGHT_ERR = -1; 
 
    private static SystemSwitchUtils util; 
 
    public static void getInstance(Context context){ 
        if (util==null) { 
            util=new SystemSwitchUtils(context); 
        } 
 
 
    } 
 
    private SystemSwitchUtils(Context context) { 
        super(); 
        this.context = context; 
    } 
 
    /** 
     * wifi是否开启 
     * @return 
     */ 
    public boolean isWifiOn() { 
        if (mWifiManager == null) { 
            mWifiManager = (WifiManager) context 
                    .getSystemService(Context.WIFI_SERVICE); 
        } 
        return mWifiManager.isWifiEnabled(); 
    } 
 
    /** 
     * wifi开关 
     */ 
    public void wifiUtils() { 
 
        if (isWifiOn()) { 
            // 关闭Wifi，按钮显示开启 
            mWifiManager.setWifiEnabled(false); 
            Toast.makeText(context, "关闭wifi", Toast.LENGTH_SHORT).show(); 
        } else { 
            // 开启Wifi，按钮显示关闭 
            mWifiManager.setWifiEnabled(true); 
 
            Toast.makeText(context, "开启wifi", Toast.LENGTH_SHORT).show(); 
        } 
 
    } 
 
    /** 
     * 蓝牙是否开启 
     * @return 
     */ 
    public boolean isBlueToothOn() { 
        if (mBluetoothAdapter == null) { 
            mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); 
        } 
         switch (mBluetoothAdapter.getState()) { 
         case BluetoothAdapter.STATE_ON: 
         return true; 
 
         case BluetoothAdapter.STATE_TURNING_ON: 
         return true; 
         case BluetoothAdapter.STATE_OFF: 
         return false; 
         case BluetoothAdapter.STATE_TURNING_OFF: 
         return false; 
         } 
        return false; 
    } 
 
    /** 
     * 蓝牙开关 
     */ 
    public void bluetoothUtils() { 
 
        if (isBlueToothOn()) { 
            mBluetoothAdapter.disable(); 
            Toast.makeText(context, "关闭蓝牙", Toast.LENGTH_SHORT).show(); 
        } else { 
            mBluetoothAdapter.enable(); 
            Toast.makeText(context, "开启蓝牙", Toast.LENGTH_SHORT).show(); 
        } 
 
    } 
 
    /** 
     * 是否开启自动旋转 
     * @return 
     */ 
    public boolean isRotationOn() { 
        int status = 0; 
 
        try { 
            status = android.provider.Settings.System.getInt( 
                    context.getContentResolver(), 
                    android.provider.Settings.System.ACCELEROMETER_ROTATION); 
        } catch (SettingNotFoundException e) { 
            // TODO Auto-generated catch block 
            e.printStackTrace(); 
        } 
 
        // 设置status的值改变屏幕旋转设置 
        if (status == 0) { 
            return false; 
        } else { 
            return true; 
        } 
 
    } 
 
    /** 
     * 屏幕旋转开关 
     */ 
    public void rotationUtils() { 
        int status = 0; 
 
        Uri uri = android.provider.Settings.System 
                .getUriFor("accelerometer_rotation"); 
        // 设置status的值改变屏幕旋转设置 
        if (!isRotationOn()) { 
            status = 1; 
            Toast.makeText(context, "开启旋转", Toast.LENGTH_SHORT).show(); 
        } else if (status == 1) { 
            status = 0; 
            Toast.makeText(context, "关闭旋转", Toast.LENGTH_SHORT).show(); 
        } 
        android.provider.Settings.System.putInt(context.getContentResolver(), 
                "accelerometer_rotation", status); 
        // 通知改变 
        context.getContentResolver().notifyChange(uri, null); 
 
    } 
 
    /** 
     * 是否开启同步 
     * @return 
     */ 
    @SuppressWarnings("deprecation") 
    public boolean isSyncSwitchOn() { 
        if (connManager == null) { 
            connManager = (ConnectivityManager) context 
                    .getSystemService(Context.CONNECTIVITY_SERVICE); 
        } 
 
        return connManager.getBackgroundDataSetting() 
                && ContentResolver.getMasterSyncAutomatically(); 
    } 
 
    /** 
     * 同步开关 
     */ 
    public void syncSwitchUtils() { 
 
        if (isSyncSwitchOn()) { 
            Toast.makeText(context, "关闭同步", Toast.LENGTH_SHORT).show(); 
        } else { 
            Toast.makeText(context, "开启同步", Toast.LENGTH_SHORT).show(); 
        } 
        ContentResolver.setMasterSyncAutomatically(!isSyncSwitchOn()); 
 
    } 
 
    /** 
     * 屏幕亮度切换 
     */ 
    public void brightnessSwitchUtils() { 
 
        int light = 0; 
        ContentResolver cr = context.getContentResolver(); 
        try { 
            boolean auto = Settings.System.getInt(cr, 
                    Settings.System.SCREEN_BRIGHTNESS_MODE) == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC; 
 
            if (!auto) { 
                light = android.provider.Settings.System.getInt(cr, 
                        Settings.System.SCREEN_BRIGHTNESS, -1); 
                if (light > 0 && light <= LIGHT_NORMAL) { 
                    light = LIGHT_NORMAL; 
                } else if (light > LIGHT_NORMAL && light <= LIGHT_50_PERCENT) { 
                    light = LIGHT_50_PERCENT; 
                } else if (light > LIGHT_50_PERCENT 
                        && light <= LIGHT_75_PERCENT) { 
                    light = LIGHT_75_PERCENT; 
                } else { 
                    light = LIGHT_100_PERCENT; 
                } 
            } else { 
                light = LIGHT_AUTO; 
            } 
 
            switch (light) { 
            case LIGHT_NORMAL: 
                light = LIGHT_50_PERCENT - 1; 
                Toast.makeText(context, "正常亮度", Toast.LENGTH_SHORT).show(); 
                break; 
            case LIGHT_50_PERCENT: 
                light = LIGHT_75_PERCENT - 1; 
                Toast.makeText(context, "较高亮度", Toast.LENGTH_SHORT).show(); 
                break; 
            case LIGHT_75_PERCENT: 
                light = LIGHT_100_PERCENT - 1; 
                Toast.makeText(context, "高亮度", Toast.LENGTH_SHORT).show(); 
                break; 
            case LIGHT_100_PERCENT: 
                light = LIGHT_NORMAL - 1; 
                Settings.System.putInt(cr, 
                        Settings.System.SCREEN_BRIGHTNESS_MODE, 
                        Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC); 
                Toast.makeText(context, "自动亮度", Toast.LENGTH_SHORT).show(); 
 
                break; 
            case LIGHT_AUTO: 
                light = LIGHT_NORMAL - 1; 
                Settings.System.putInt(cr, 
                        Settings.System.SCREEN_BRIGHTNESS_MODE, 
                        Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL); 
                Toast.makeText(context, "低亮度", Toast.LENGTH_SHORT).show(); 
 
                break; 
            case LIGHT_ERR: 
                light = LIGHT_NORMAL - 1; 
                break; 
 
            } 
 
            setLight(light); 
            android.provider.Settings.System.putInt(cr, 
                    Settings.System.SCREEN_BRIGHTNESS, light); 
 
        } catch (SettingNotFoundException e) { 
            // TODO Auto-generated catch block 
            e.printStackTrace(); 
        } 
 
    } 
 
    /** 
     * 设置屏幕亮度 
     * @param light 
     */ 
    private void setLight(int light) { 
        try { 
            if (mPowerManager == null) { 
                mPowerManager = (PowerManager) context 
                        .getSystemService(Context.POWER_SERVICE); 
            } 
 
            Class<?> pmClass = Class 
                    .forName(mPowerManager.getClass().getName()); 
            // 得到PowerManager类中的成员mService（mService为PowerManagerService类型） 
            Field field = pmClass.getDeclaredField("mService"); 
            field.setAccessible(true); 
            // 实例化mService 
            Object iPM = field.get(mPowerManager); 
            // 得到PowerManagerService对应的Class对象 
            Class<?> iPMClass = Class.forName(iPM.getClass().getName()); 
            /* 
             * 得到PowerManagerService的函数setBacklightBrightness对应的Method对象， 
             * PowerManager的函数setBacklightBrightness实现在PowerManagerService中 
             */ 
            Method method = iPMClass.getDeclaredMethod( 
                    "setBacklightBrightness", int.class); 
            method.setAccessible(true); 
            // 调用实现PowerManagerService的setBacklightBrightness 
            method.invoke(iPM, light); 
 
        } catch (Exception e) { 
            // TODO Auto-generated catch block 
            e.printStackTrace(); 
        } 
    } 
 
    /** 
     * 是否开启飞行模式 
     * @return 
     */ 
    @SuppressWarnings("deprecation") 
    public boolean isAirplaneModeOn() { 
        return Settings.System.getInt(context.getContentResolver(), 
                Settings.System.AIRPLANE_MODE_ON, 0) != 0; 
    } 
 
    /** 
     * 飞行模式开关 
     */ 
    @SuppressWarnings("deprecation") 
    public void airplaneModeSwitchUtils() { 
        boolean enable = isAirplaneModeOn(); 
        if (enable) { 
 
            Toast.makeText(context, "关闭飞行模式", Toast.LENGTH_SHORT).show(); 
        } else { 
 
            Toast.makeText(context, "开启飞行模式", Toast.LENGTH_SHORT).show(); 
        } 
        Settings.System.putInt(context.getContentResolver(), 
                Settings.System.AIRPLANE_MODE_ON, !enable ? 1 : 0); 
        Intent intent = new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED); 
        intent.putExtra("state", !enable); 
        context.sendBroadcast(intent); 
 
    } 
 
    /** 
     * 是否开启数据连接 
     * @return 
     */ 
    @SuppressWarnings({ "unchecked", "rawtypes" }) 
    public boolean isMobileDataOn() { 
        Boolean isOpen = false; 
        if (connManager == null) { 
            connManager = (ConnectivityManager) context 
                    .getSystemService(Context.CONNECTIVITY_SERVICE); 
        } 
 
        try { 
            String methodName = "getMobileDataEnabled"; 
            Class cmClass = connManager.getClass(); 
 
            Method method = cmClass.getMethod(methodName, null); 
            isOpen = (Boolean) method.invoke(connManager, null); 
        } catch (Exception e) { 
            // TODO Auto-generated catch block 
            e.printStackTrace(); 
        } 
 
        return isOpen; 
 
    } 
 
    /** 
     * 数据连接开关 
     */ 
    @SuppressWarnings({ "unused", "unchecked" }) 
    public void MobileDataSwitchUtils() { 
        if (connManager == null) { 
            connManager = (ConnectivityManager) context 
                    .getSystemService(Context.CONNECTIVITY_SERVICE); 
        } 
        try { 
 
            String methodName = "getMobileDataEnabled"; 
            Class cmClass = connManager.getClass(); 
            // Boolean isOpen = null; 
            Method method = cmClass.getMethod(methodName, null); 
 
            // isOpen = (Boolean) method.invoke(connManager, null); 
 
            Class<?> conMgrClass = Class.forName(connManager.getClass() 
                    .getName()); 
            // 得到ConnectivityManager类的成员变量mService（ConnectivityService类型） 
            Field iConMgrField = conMgrClass.getDeclaredField("mService"); 
            iConMgrField.setAccessible(true); 
            // mService成员初始化 
            Object iConMgr = iConMgrField.get(connManager); 
            // 得到mService对应的Class对象 
            Class<?> iConMgrClass = Class.forName(iConMgr.getClass().getName()); 
            /* 
             * 得到mService的setMobileDataEnabled(该方法在android源码的ConnectivityService类中实现 
             * )， 该方法的参数为布尔型，所以第二个参数为Boolean.TYPE 
             */ 
            Method setMobileDataEnabledMethod = iConMgrClass.getDeclaredMethod( 
                    "setMobileDataEnabled", Boolean.TYPE); 
            setMobileDataEnabledMethod.setAccessible(true); 
            /* 
             * 调用ConnectivityManager的setMobileDataEnabled方法（方法是隐藏的）， 
             * 实际上该方法的实现是在ConnectivityService(系统服务实现类)中的 
             */ 
 
            if (isMobileDataOn()) { 
                Toast.makeText(context, "关闭数据连接", Toast.LENGTH_SHORT).show(); 
            } else { 
                Toast.makeText(context, "开启数据连接", Toast.LENGTH_SHORT).show(); 
            } 
            setMobileDataEnabledMethod.invoke(iConMgr, !isMobileDataOn()); 
 
        } catch (Exception e) { 
            // TODO: handle exception 
        } 
    } 
 
 
    /** 
     * 情景模式切换 
     */ 
    public void silentSwitchUtils() { 
        if (mAudioManager == null) { 
            mAudioManager = (AudioManager) context 
                    .getSystemService(Context.AUDIO_SERVICE); 
        } 
        int ringerMode = mAudioManager.getRingerMode(); 
 
        switch (ringerMode) { 
        case AudioManager.RINGER_MODE_SILENT: 
            mAudioManager.setRingerMode(AudioManager.RINGER_MODE_VIBRATE); 
            Toast.makeText(context, "震动模式", Toast.LENGTH_SHORT).show(); 
            break; 
        case AudioManager.RINGER_MODE_NORMAL: 
            mAudioManager.setRingerMode(AudioManager.RINGER_MODE_SILENT); 
            Toast.makeText(context, "静音模式", Toast.LENGTH_SHORT).show(); 
            break; 
        case AudioManager.RINGER_MODE_VIBRATE: 
            mAudioManager.setRingerMode(AudioManager.RINGER_MODE_NORMAL); 
            Toast.makeText(context, "正常模式", Toast.LENGTH_SHORT).show(); 
            break; 
        } 
 
    } 
 
    /** 
     * 是否开启gps 
     * @return 
     */ 
    public boolean isGpsSwitchOn() { 
        return Secure.isLocationProviderEnabled(context.getContentResolver(), 
                LocationManager.GPS_PROVIDER); 
    } 
 
    /** 
     * gps开关 
     */ 
    public void GpsSwitchUtils() { 
 
        Secure.setLocationProviderEnabled(context.getContentResolver(), 
                LocationManager.GPS_PROVIDER, !isGpsSwitchOn()); 
 
    } 
 
    /** 
     * 锁屏 
     */ 
    public void lockScreenSwitchUtils() { 
        if (mPowerManager == null) { 
            mPowerManager = (PowerManager) context 
                    .getSystemService(Context.POWER_SERVICE); 
        } 
        mPowerManager.goToSleep(SystemClock.uptimeMillis()); 
    } 
 
    /** 
     * 重启 
     */ 
    public void rebootUtils() { 
        if (mPowerManager == null) { 
            mPowerManager = (PowerManager) context 
                    .getSystemService(Context.POWER_SERVICE); 
        } 
        mPowerManager.reboot(null); 
 
    } 
 
    /** 
     * 关机 
     */ 
    public void shutDownSwitchUtils() { 
        Intent intent = new Intent("android.intent.action.ACTION_REQUEST_SHUTDOWN"); 
        intent.putExtra("android.intent.extra.KEY_CONFIRM", false); 
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
        // 弹出系统内置的对话框，选择确定关机或取消关机 
        context.startActivity(intent); 
 
 
    } 
 
    /** 
     * 是否开启了闪光灯 
     * @return 
     */ 
    public boolean isFlashlightOn() { 
        if (camera == null) { 
            camera = Camera.open(); 
        } 
 
        Parameters parameters = camera.getParameters(); 
        String flashMode = parameters.getFlashMode(); 
 
        if (flashMode.equals(Parameters.FLASH_MODE_TORCH)) { 
 
            return true; 
        } else { 
            return false; 
        } 
    } 
 
    /** 
     * 闪光灯开关 
     */ 
    public void flashlightUtils() { 
        if (camera == null) { 
            camera = Camera.open(); 
        } 
 
        Parameters parameters = camera.getParameters(); 
        // String flashMode = parameters.getFlashMode(); 
 
        if (isFlashlightOn()) { 
 
            parameters.setFlashMode(Parameters.FLASH_MODE_OFF);// 关闭 
            camera.setParameters(parameters); 
            camera.release(); 
            camera = null; 
            Toast.makeText(context, "关闭手电筒", Toast.LENGTH_SHORT).show(); 
        } else { 
            parameters.setFlashMode(Parameters.FLASH_MODE_TORCH);// 开启 
            camera.setParameters(parameters); 
            Toast.makeText(context, "开启手电筒", Toast.LENGTH_SHORT).show(); 
        } 
 
    } 
 
    /** 
     * 闪光灯开关2 
     */ 
    public void flashUtils() { 
 
        Camera camera = Camera.open(); 
 
        Camera.Parameters parameters = camera.getParameters(); 
        String flashMode = parameters.getFlashMode(); 
        if (flashMode.equals(Camera.Parameters.FLASH_MODE_TORCH)) { 
            camera.stopPreview(); 
            camera.release(); 
            camera = null; 
 
        } else { 
 
            parameters.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH); 
            camera.setParameters(parameters); 
            camera.autoFocus(new Camera.AutoFocusCallback() { 
                public void onAutoFocus(boolean success, Camera camera) { 
                } 
            }); 
            camera.startPreview(); 
        } 
    } 
 
    /** 
     * 跳转到系统设置 
     */ 
    public void systemSetUtils() { 
        Intent intent = new Intent(Settings.ACTION_SETTINGS); 
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
        context.startActivity(intent); 
 
    } 
 
    /** 
     * 跳转到系统app管理 
     */ 
    public void systemAppsUtils() { 
        Intent intent = new Intent(Settings.ACTION_APPLICATION_SETTINGS); 
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
        context.startActivity(intent); 
 
    } 
 
    /** 
     * 跳转到系统显示设置 
     */ 
    public void systemDisplayUtils() { 
        Intent intent = new Intent(Settings.ACTION_DISPLAY_SETTINGS); 
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
        context.startActivity(intent); 
 
    } 
 
    /** 
     * 跳转到系统声音设置 
     */ 
    public void systemSoundUtils() { 
        Intent intent = new Intent(Settings.ACTION_SOUND_SETTINGS); 
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
        context.startActivity(intent); 
 
    } 
 
    /** 
     * 跳转到系统日期设置 
     */ 
    public void systemDateUtils() { 
        Intent intent = new Intent(Settings.ACTION_DATE_SETTINGS); 
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
        context.startActivity(intent); 
 
    } 
 
    /** 
     * 跳转到系统位置设置 
     */ 
    public void systemLocationUtils() { 
        Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS); 
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
        context.startActivity(intent); 
 
    } 
    /** 
     * 跳转到系统同步设置 
     */ 
    public void systemSyncUtils() { 
        Intent intent = new Intent(Settings.ACTION_SYNC_SETTINGS); 
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
        context.startActivity(intent); 
 
    } 
    /** 
     * 跳转到系统输入设置 
     */ 
    public void systemInputUtils() { 
        Intent intent = new Intent(Settings.ACTION_INPUT_METHOD_SETTINGS); 
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
        context.startActivity(intent); 
 
    } 
 
 
 
    /** 
     * 调大媒体音量 
     */ 
    public void setMusicAudio() { 
        if (mAudioManager == null) { 
            mAudioManager = (AudioManager) context 
                    .getSystemService(Context.AUDIO_SERVICE); 
        } 
 
        // int max = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_ALARM 
        // ); 
        // int current = mAudioManager.getStreamVolume(AudioManager.STREAM_ALARM 
        // ); 
        mAudioManager.adjustStreamVolume(AudioManager.STREAM_MUSIC, 
                AudioManager.ADJUST_RAISE, AudioManager.FX_FOCUS_NAVIGATION_UP); 
 
    } 
 
}