如何设置Android系统的亮度

floweriswho 2012-05-31 02:06:30

源代码实现方式是使用 IPowerManager

private void setBrightness(int brightness) {
try {
IPowerManager power = IPowerManager.Stub.asInterface(
ServiceManager.getService("power"));
if (power != null) {
power.setBacklightBrightness(brightness);
}
} catch (RemoteException doe) {

}
}

但是这个方法需要系统签名阿。。。。
有没有别的办法或是思路阿？
我看 Android优化大师就实现了这个功能？
希望大神帮忙阿。

...全文

886 14 打赏收藏举报

写回复

用AI写文章

14 条回复

切换为时间正序

请发表友善的回复…

发表回复

Jianhua09 2014-07-07

打赏
举报

引用 13 楼 coldsummerwei 的回复:

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

方案很好啊！不过最好在设置亮度前，将用户系统的亮度值先存下来本地，方便恢复默认的。当然 -1 也行。

coldsummerwei 2013-10-24

打赏
举报

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

coldsummerwei 2013-09-13

打赏
举报

楼主，请问最后找到解决办法了吗？系统设置里的亮度，如果是手动调节亮度模式，则滑动时，亮度可以实时改变。应用里的亮度条滑动时，亮度一直不变……

zhongyuanceshi 2012-09-28

打赏
举报

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

hp5212000 2012-09-28

打赏
举报

把源码下下来，然后在源码下编译你的apk就行了

PowerManager manager = (PowerManager) ServiceManager.getService(Context.POWER_SERVICE);
manager.setBacklightBrightness(50);

AMinfo 2012-06-07

打赏
举报

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

floweriswho 2012-06-07

打赏
举报

[Quote=引用 7 楼的回复:]

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

你这个也只能设置当前页面的亮度阿不能设置整个系统的亮度。。。

fhhdg 2012-05-31

打赏
举报

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

floweriswho 2012-05-31

打赏
举报

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

ngf318 2012-05-31

打赏
举报

参考Setting源码呢

floweriswho 2012-05-31

打赏
举报

/**
* 设置亮度
*
* @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 优化大师是怎么实现的

谁能给一个思路就好不用签名的思路

飘之鸿 2012-05-31

打赏
举报

前段时间我也在为这个问题纠结，现在也不能算完全解决了，只能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();

    }

    

}

飘之鸿 2012-05-31

打赏
举报

前段时间我也在为这个问题纠结，现在也不能算完全解决了，只能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();

    }

    

}

飘之鸿 2012-05-31

打赏
举报

前段时间我也在为这个问题纠结，现在也不能算完全解决了，只能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();

    }

    

}