前段时间我也在为这个问题纠结,现在也不能算完全解决了,只能activity激活时才能调节
基本上都是网上的内容,不介意你就看看吧package com.piaohong.sensor;import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.net.Uri;
import android.os.Bundle;
import android.os.PowerManager;
import android.provider.Settings;
import android.provider.Settings.SettingNotFoundException;
import android.util.Log;
import android.view.WindowManager;
import android.widget.TextView;
import android.widget.Toast;public class TestSensorActivity extends Activity {
//设置LOG标签
    private static final String LOG_TAG = "sensor";
    private  SensorManager sm; TextView TV_Info;
Activity MyActivity;
/** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        TV_Info = (TextView) findViewById(R.id.TV_Info); 
        MyActivity = this;
        
        //创建一个SensorManager来获取系统的传感器服务
        sm = (SensorManager)getSystemService(Context.SENSOR_SERVICE);
        //选取加速度感应器
        int sensorType = Sensor.TYPE_LIGHT;
        
        /*
         * 最常用的一个方法 注册事件
         * 参数1 :SensorEventListener监听器
         * 参数2 :Sensor 一个服务可能有多个Sensor实现,此处调用getDefaultSensor获取默认的Sensor
         * 参数3 :模式 可选数据变化的刷新频率
         * */
        sm.registerListener(myAccelerometerListener,sm.getDefaultSensor(sensorType),SensorManager.SENSOR_DELAY_NORMAL);    } 
    
//    Android的屏幕亮度好像在2.1+的时候提供了自动调节的功能,所以,如果当开启自动调节功能的时候, 我们进行调节好像是没有一点作用的,这点让我很是无语,结果只有进行判断,看是否开启了屏幕亮度的自动调节功能。    /**
         * 判断是否开启了自动亮度调节
         * 
         * @param aContext
         * @return
         */
        public static boolean isAutoBrightness(ContentResolver aContentResolver) {
            boolean automicBrightness = false;
            try {
                automicBrightness = Settings.System.getInt(aContentResolver,
                        Settings.System.SCREEN_BRIGHTNESS_MODE) == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC;
            } catch (SettingNotFoundException e) {
                e.printStackTrace();
            }
            return automicBrightness;
        }//    然后就是要觉得当前的亮度了,这个就比较纠结了:    /**
         * 获取屏幕的亮度
         * 
         * @param activity
         * @return
         */
        public static int getScreenBrightness(Activity activity) {
            int nowBrightnessValue = 0;
            ContentResolver resolver = activity.getContentResolver();
            try {
                nowBrightnessValue = android.provider.Settings.System.getInt(
                        resolver, Settings.System.SCREEN_BRIGHTNESS);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return nowBrightnessValue;
        }//    那如何修改屏幕的亮度呢?    /**
         * 设置亮度
         * 
         * @param activity
         * @param brightness
         */
        public static void setBrightness(Activity activity, int brightness) {
            WindowManager.LayoutParams lp = activity.getWindow().getAttributes();
            lp.screenBrightness = Float.valueOf(brightness) * (1f / 255f);
            activity.getWindow().setAttributes(lp);        }//    那么,能设置了,但是为什么还是会出现,设置了,没反映呢?//    嘿嘿,那是因为,开启了自动调节功能了,那如何关闭呢?这才是最重要的:    /**
         * 停止自动亮度调节
         * 
         * @param activity
         */
        public static void stopAutoBrightness(Activity activity) {
            Settings.System.putInt(activity.getContentResolver(),
                    Settings.System.SCREEN_BRIGHTNESS_MODE,
                    Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL);
        }//    能开启,那自然应该能关闭了哟哟,那怎么关闭呢?很简单的:    /**
         * 开启亮度自动调节
         * 
         * @param activity
         */
        public static void startAutoBrightness(Activity activity) {
            Settings.System.putInt(activity.getContentResolver(),
                    Settings.System.SCREEN_BRIGHTNESS_MODE,
                    Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);
        }//    至此,应该说操作亮度的差不多都有了,结束!//    哎,本来认为是应该结束了,但是悲剧得是,既然像刚才那样设置的话,只能在当前的activity中有作用,一段退出的时候,会发现毫无作用,悲剧,原来是忘记了保存了。汗!    /**
         * 保存亮度设置状态
         * 
         * @param resolver
         * @param brightness
         */
        public static void saveBrightness(ContentResolver resolver, int brightness) {
            Uri uri = android.provider.Settings.System
                    .getUriFor("screen_brightness");
            android.provider.Settings.System.putInt(resolver, "screen_brightness",
                    brightness);
            // resolver.registerContentObserver(uri, true, myContentObserver);
            resolver.notifyChange(uri, null);
        }//    YY滴,这回该差不多了吧,汗!
    
    
    
    /*
     * SensorEventListener接口的实现,需要实现两个方法
     * 方法1 onSensorChanged 当数据变化的时候被触发调用
     * 方法2 onAccuracyChanged 当获得数据的精度发生变化的时候被调用,比如突然无法获得数据时
     * */
    final SensorEventListener myAccelerometerListener = new SensorEventListener(){
        
        //复写onSensorChanged方法
        public void onSensorChanged(SensorEvent sensorEvent){
            if(sensorEvent.sensor.getType() == Sensor.TYPE_LIGHT){
                Log.i(LOG_TAG,"onSensorChanged");
                
                //图解中已经解释三个值的含义
                float X_lateral = sensorEvent.values[0];
                Log.i(LOG_TAG,"\n heading "+X_lateral);
                int Lightness;
                
                if(X_lateral<11)
                 Lightness = (1);
                else if(X_lateral<46)
             Lightness = (20);
                else if(X_lateral<96)
             Lightness = (40);
                else if(X_lateral<201)
             Lightness = (52);
                else if(X_lateral<401)
             Lightness = (64);
                else if(X_lateral<551)
             Lightness = (84);
                else if(X_lateral<901)
             Lightness = (94);
                else if(X_lateral<1201)
             Lightness = (110);
                else if(X_lateral<2001)
             Lightness = (130);
                else if(X_lateral<3001)
             Lightness = (168);
                else
                 Lightness = (255);
                
                setBrightness(MyActivity, Lightness);
                saveBrightness(getContentResolver(),Lightness);
                                
                TV_Info.setText(
                 String.valueOf(X_lateral)+"\n"+
                     String.valueOf(Lightness)+"\n"+
                 );
            }
        }
        //复写onAccuracyChanged方法
        public void onAccuracyChanged(Sensor sensor , int accuracy){
            Log.i(LOG_TAG, "onAccuracyChanged");
        }
    };
    
    public void onPause(){
        /*
         * 很关键的部分:注意,说明文档中提到,即使activity不可见的时候,感应器依然会继续的工作,测试的时候可以发现,没有正常的刷新频率
         * 也会非常高,所以一定要在onPause方法中关闭触发器,否则讲耗费用户大量电量,很不负责。
         * */
        sm.unregisterListener(myAccelerometerListener);
        super.onPause();
    }
    
}

解决方案 »

  1.   

    前段时间我也在为这个问题纠结,现在也不能算完全解决了,只能activity激活时才能调节
    基本上都是网上的内容,不介意你就看看吧package com.piaohong.sensor;import android.app.Activity;
    import android.content.ContentResolver;
    import android.content.Context;
    import android.hardware.Sensor;
    import android.hardware.SensorEvent;
    import android.hardware.SensorEventListener;
    import android.hardware.SensorManager;
    import android.net.Uri;
    import android.os.Bundle;
    import android.os.PowerManager;
    import android.provider.Settings;
    import android.provider.Settings.SettingNotFoundException;
    import android.util.Log;
    import android.view.WindowManager;
    import android.widget.TextView;
    import android.widget.Toast;public class TestSensorActivity extends Activity {
    //设置LOG标签
        private static final String LOG_TAG = "sensor";
        private  SensorManager sm; TextView TV_Info;
    Activity MyActivity;
    /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
            
            TV_Info = (TextView) findViewById(R.id.TV_Info); 
            MyActivity = this;
            
            //创建一个SensorManager来获取系统的传感器服务
            sm = (SensorManager)getSystemService(Context.SENSOR_SERVICE);
            //选取加速度感应器
            int sensorType = Sensor.TYPE_LIGHT;
            
            /*
             * 最常用的一个方法 注册事件
             * 参数1 :SensorEventListener监听器
             * 参数2 :Sensor 一个服务可能有多个Sensor实现,此处调用getDefaultSensor获取默认的Sensor
             * 参数3 :模式 可选数据变化的刷新频率
             * */
            sm.registerListener(myAccelerometerListener,sm.getDefaultSensor(sensorType),SensorManager.SENSOR_DELAY_NORMAL);    } 
        
    //    Android的屏幕亮度好像在2.1+的时候提供了自动调节的功能,所以,如果当开启自动调节功能的时候, 我们进行调节好像是没有一点作用的,这点让我很是无语,结果只有进行判断,看是否开启了屏幕亮度的自动调节功能。    /**
             * 判断是否开启了自动亮度调节
             * 
             * @param aContext
             * @return
             */
            public static boolean isAutoBrightness(ContentResolver aContentResolver) {
                boolean automicBrightness = false;
                try {
                    automicBrightness = Settings.System.getInt(aContentResolver,
                            Settings.System.SCREEN_BRIGHTNESS_MODE) == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC;
                } catch (SettingNotFoundException e) {
                    e.printStackTrace();
                }
                return automicBrightness;
            }//    然后就是要觉得当前的亮度了,这个就比较纠结了:    /**
             * 获取屏幕的亮度
             * 
             * @param activity
             * @return
             */
            public static int getScreenBrightness(Activity activity) {
                int nowBrightnessValue = 0;
                ContentResolver resolver = activity.getContentResolver();
                try {
                    nowBrightnessValue = android.provider.Settings.System.getInt(
                            resolver, Settings.System.SCREEN_BRIGHTNESS);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return nowBrightnessValue;
            }//    那如何修改屏幕的亮度呢?    /**
             * 设置亮度
             * 
             * @param activity
             * @param brightness
             */
            public static void setBrightness(Activity activity, int brightness) {
                WindowManager.LayoutParams lp = activity.getWindow().getAttributes();
                lp.screenBrightness = Float.valueOf(brightness) * (1f / 255f);
                activity.getWindow().setAttributes(lp);        }//    那么,能设置了,但是为什么还是会出现,设置了,没反映呢?//    嘿嘿,那是因为,开启了自动调节功能了,那如何关闭呢?这才是最重要的:    /**
             * 停止自动亮度调节
             * 
             * @param activity
             */
            public static void stopAutoBrightness(Activity activity) {
                Settings.System.putInt(activity.getContentResolver(),
                        Settings.System.SCREEN_BRIGHTNESS_MODE,
                        Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL);
            }//    能开启,那自然应该能关闭了哟哟,那怎么关闭呢?很简单的:    /**
             * 开启亮度自动调节
             * 
             * @param activity
             */
            public static void startAutoBrightness(Activity activity) {
                Settings.System.putInt(activity.getContentResolver(),
                        Settings.System.SCREEN_BRIGHTNESS_MODE,
                        Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);
            }//    至此,应该说操作亮度的差不多都有了,结束!//    哎,本来认为是应该结束了,但是悲剧得是,既然像刚才那样设置的话,只能在当前的activity中有作用,一段退出的时候,会发现毫无作用,悲剧,原来是忘记了保存了。汗!    /**
             * 保存亮度设置状态
             * 
             * @param resolver
             * @param brightness
             */
            public static void saveBrightness(ContentResolver resolver, int brightness) {
                Uri uri = android.provider.Settings.System
                        .getUriFor("screen_brightness");
                android.provider.Settings.System.putInt(resolver, "screen_brightness",
                        brightness);
                // resolver.registerContentObserver(uri, true, myContentObserver);
                resolver.notifyChange(uri, null);
            }//    YY滴,这回该差不多了吧,汗!
        
        
        
        /*
         * SensorEventListener接口的实现,需要实现两个方法
         * 方法1 onSensorChanged 当数据变化的时候被触发调用
         * 方法2 onAccuracyChanged 当获得数据的精度发生变化的时候被调用,比如突然无法获得数据时
         * */
        final SensorEventListener myAccelerometerListener = new SensorEventListener(){
            
            //复写onSensorChanged方法
            public void onSensorChanged(SensorEvent sensorEvent){
                if(sensorEvent.sensor.getType() == Sensor.TYPE_LIGHT){
                    Log.i(LOG_TAG,"onSensorChanged");
                    
                    //图解中已经解释三个值的含义
                    float X_lateral = sensorEvent.values[0];
                    Log.i(LOG_TAG,"\n heading "+X_lateral);
                    int Lightness;
                    
                    if(X_lateral<11)
                     Lightness = (1);
                    else if(X_lateral<46)
                 Lightness = (20);
                    else if(X_lateral<96)
                 Lightness = (40);
                    else if(X_lateral<201)
                 Lightness = (52);
                    else if(X_lateral<401)
                 Lightness = (64);
                    else if(X_lateral<551)
                 Lightness = (84);
                    else if(X_lateral<901)
                 Lightness = (94);
                    else if(X_lateral<1201)
                 Lightness = (110);
                    else if(X_lateral<2001)
                 Lightness = (130);
                    else if(X_lateral<3001)
                 Lightness = (168);
                    else
                     Lightness = (255);
                    
                    setBrightness(MyActivity, Lightness);
                    saveBrightness(getContentResolver(),Lightness);
                                    
                    TV_Info.setText(
                     String.valueOf(X_lateral)+"\n"+
                         String.valueOf(Lightness)+"\n"+
                     );
                }
            }
            //复写onAccuracyChanged方法
            public void onAccuracyChanged(Sensor sensor , int accuracy){
                Log.i(LOG_TAG, "onAccuracyChanged");
            }
        };
        
        public void onPause(){
            /*
             * 很关键的部分:注意,说明文档中提到,即使activity不可见的时候,感应器依然会继续的工作,测试的时候可以发现,没有正常的刷新频率
             * 也会非常高,所以一定要在onPause方法中关闭触发器,否则讲耗费用户大量电量,很不负责。
             * */
            sm.unregisterListener(myAccelerometerListener);
            super.onPause();
        }
        
    }
      

  2.   

    前段时间我也在为这个问题纠结,现在也不能算完全解决了,只能activity激活时才能调节
    基本上都是网上的内容,不介意你就看看吧package com.piaohong.sensor;import android.app.Activity;
    import android.content.ContentResolver;
    import android.content.Context;
    import android.hardware.Sensor;
    import android.hardware.SensorEvent;
    import android.hardware.SensorEventListener;
    import android.hardware.SensorManager;
    import android.net.Uri;
    import android.os.Bundle;
    import android.os.PowerManager;
    import android.provider.Settings;
    import android.provider.Settings.SettingNotFoundException;
    import android.util.Log;
    import android.view.WindowManager;
    import android.widget.TextView;
    import android.widget.Toast;public class TestSensorActivity extends Activity {
    //设置LOG标签
        private static final String LOG_TAG = "sensor";
        private  SensorManager sm; TextView TV_Info;
    Activity MyActivity;
    /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
            
            TV_Info = (TextView) findViewById(R.id.TV_Info); 
            MyActivity = this;
            
            //创建一个SensorManager来获取系统的传感器服务
            sm = (SensorManager)getSystemService(Context.SENSOR_SERVICE);
            //选取加速度感应器
            int sensorType = Sensor.TYPE_LIGHT;
            
            /*
             * 最常用的一个方法 注册事件
             * 参数1 :SensorEventListener监听器
             * 参数2 :Sensor 一个服务可能有多个Sensor实现,此处调用getDefaultSensor获取默认的Sensor
             * 参数3 :模式 可选数据变化的刷新频率
             * */
            sm.registerListener(myAccelerometerListener,sm.getDefaultSensor(sensorType),SensorManager.SENSOR_DELAY_NORMAL);    } 
        
    //    Android的屏幕亮度好像在2.1+的时候提供了自动调节的功能,所以,如果当开启自动调节功能的时候, 我们进行调节好像是没有一点作用的,这点让我很是无语,结果只有进行判断,看是否开启了屏幕亮度的自动调节功能。    /**
             * 判断是否开启了自动亮度调节
             * 
             * @param aContext
             * @return
             */
            public static boolean isAutoBrightness(ContentResolver aContentResolver) {
                boolean automicBrightness = false;
                try {
                    automicBrightness = Settings.System.getInt(aContentResolver,
                            Settings.System.SCREEN_BRIGHTNESS_MODE) == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC;
                } catch (SettingNotFoundException e) {
                    e.printStackTrace();
                }
                return automicBrightness;
            }//    然后就是要觉得当前的亮度了,这个就比较纠结了:    /**
             * 获取屏幕的亮度
             * 
             * @param activity
             * @return
             */
            public static int getScreenBrightness(Activity activity) {
                int nowBrightnessValue = 0;
                ContentResolver resolver = activity.getContentResolver();
                try {
                    nowBrightnessValue = android.provider.Settings.System.getInt(
                            resolver, Settings.System.SCREEN_BRIGHTNESS);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return nowBrightnessValue;
            }//    那如何修改屏幕的亮度呢?    /**
             * 设置亮度
             * 
             * @param activity
             * @param brightness
             */
            public static void setBrightness(Activity activity, int brightness) {
                WindowManager.LayoutParams lp = activity.getWindow().getAttributes();
                lp.screenBrightness = Float.valueOf(brightness) * (1f / 255f);
                activity.getWindow().setAttributes(lp);        }//    那么,能设置了,但是为什么还是会出现,设置了,没反映呢?//    嘿嘿,那是因为,开启了自动调节功能了,那如何关闭呢?这才是最重要的:    /**
             * 停止自动亮度调节
             * 
             * @param activity
             */
            public static void stopAutoBrightness(Activity activity) {
                Settings.System.putInt(activity.getContentResolver(),
                        Settings.System.SCREEN_BRIGHTNESS_MODE,
                        Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL);
            }//    能开启,那自然应该能关闭了哟哟,那怎么关闭呢?很简单的:    /**
             * 开启亮度自动调节
             * 
             * @param activity
             */
            public static void startAutoBrightness(Activity activity) {
                Settings.System.putInt(activity.getContentResolver(),
                        Settings.System.SCREEN_BRIGHTNESS_MODE,
                        Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);
            }//    至此,应该说操作亮度的差不多都有了,结束!//    哎,本来认为是应该结束了,但是悲剧得是,既然像刚才那样设置的话,只能在当前的activity中有作用,一段退出的时候,会发现毫无作用,悲剧,原来是忘记了保存了。汗!    /**
             * 保存亮度设置状态
             * 
             * @param resolver
             * @param brightness
             */
            public static void saveBrightness(ContentResolver resolver, int brightness) {
                Uri uri = android.provider.Settings.System
                        .getUriFor("screen_brightness");
                android.provider.Settings.System.putInt(resolver, "screen_brightness",
                        brightness);
                // resolver.registerContentObserver(uri, true, myContentObserver);
                resolver.notifyChange(uri, null);
            }//    YY滴,这回该差不多了吧,汗!
        
        
        
        /*
         * SensorEventListener接口的实现,需要实现两个方法
         * 方法1 onSensorChanged 当数据变化的时候被触发调用
         * 方法2 onAccuracyChanged 当获得数据的精度发生变化的时候被调用,比如突然无法获得数据时
         * */
        final SensorEventListener myAccelerometerListener = new SensorEventListener(){
            
            //复写onSensorChanged方法
            public void onSensorChanged(SensorEvent sensorEvent){
                if(sensorEvent.sensor.getType() == Sensor.TYPE_LIGHT){
                    Log.i(LOG_TAG,"onSensorChanged");
                    
                    //图解中已经解释三个值的含义
                    float X_lateral = sensorEvent.values[0];
                    Log.i(LOG_TAG,"\n heading "+X_lateral);
                    int Lightness;
                    
                    if(X_lateral<11)
                     Lightness = (1);
                    else if(X_lateral<46)
                 Lightness = (20);
                    else if(X_lateral<96)
                 Lightness = (40);
                    else if(X_lateral<201)
                 Lightness = (52);
                    else if(X_lateral<401)
                 Lightness = (64);
                    else if(X_lateral<551)
                 Lightness = (84);
                    else if(X_lateral<901)
                 Lightness = (94);
                    else if(X_lateral<1201)
                 Lightness = (110);
                    else if(X_lateral<2001)
                 Lightness = (130);
                    else if(X_lateral<3001)
                 Lightness = (168);
                    else
                     Lightness = (255);
                    
                    setBrightness(MyActivity, Lightness);
                    saveBrightness(getContentResolver(),Lightness);
                                    
                    TV_Info.setText(
                     String.valueOf(X_lateral)+"\n"+
                         String.valueOf(Lightness)+"\n"+
                     );
                }
            }
            //复写onAccuracyChanged方法
            public void onAccuracyChanged(Sensor sensor , int accuracy){
                Log.i(LOG_TAG, "onAccuracyChanged");
            }
        };
        
        public void onPause(){
            /*
             * 很关键的部分:注意,说明文档中提到,即使activity不可见的时候,感应器依然会继续的工作,测试的时候可以发现,没有正常的刷新频率
             * 也会非常高,所以一定要在onPause方法中关闭触发器,否则讲耗费用户大量电量,很不负责。
             * */
            sm.unregisterListener(myAccelerometerListener);
            super.onPause();
        }
        
    }
      

  3.   

        /**
             * 设置亮度
             * 
             * @param activity
             * @param brightness
             */
            public static void setBrightness(Activity activity, int brightness) {
                WindowManager.LayoutParams lp = activity.getWindow().getAttributes();
                lp.screenBrightness = Float.valueOf(brightness) * (1f / 255f);
                activity.getWindow().setAttributes(lp);        }这个 方法我也 找到了
    只能修改当前的亮度是吧。。
    很感谢 你的源代码。。
    但是 我要修改 系统的
    埃 真不知道 那个 android 优化大师 是 怎么实现的谁能给一个 思路就好 不用签名的 思路
      

  4.   


    源码用的就是 IPowerManager ...
    这个需要 签名 才能使用。
      

  5.   

    http://blog.csdn.net/androidchuxueze/article/details/7452438
    我之前项目就是这样用的
      

  6.   

    建议研究一下这几个的权限范围
    android.permission.CHANGE_CONFIGURATION
    android.permission.WRITE_SETTINGS
      

  7.   

    把源码下下来,然后在源码下编译你的apk就行了
    PowerManager manager = (PowerManager) ServiceManager.getService(Context.POWER_SERVICE);
    manager.setBacklightBrightness(50);
      

  8.   

    看来只能放在源代码里编译,生成apk了,你做的也是给别人用的apk,可能会比较大
      

  9.   

    最后我的解决方案是:http://coldsummerwei.iteye.com/admin/blogs/1964174