2018-09-27 15:35:14 zyf13716764752 阅读数 1587
  • Android底层技术:HAL驱动开发

    本课程提供开发者学习Android底层的HAL(硬件抽象层)的开发方法和技术。HAL所在的位置是介于Android系统服务与Linux内核之间,HAL Driver是以library形式出现,给HAL Stub调用,供Android System架构者调用。而HAL Stub则是google设计出来的,保护硬件厂商的硬件驱动。

    17784 人正在学习 去看看 高煥堂
//声明权限


<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/> 
//调用方法

 //打开音乐的方法
    public  void  openMusic(){
        RingtoneManager rm=new RingtoneManager(getContext());//初始化 系统声音
        Uri uri = rm.getDefaultUri(rm.TYPE_NOTIFICATION);//获取系统声音路径
        Ringtone mRingtone = rm.getRingtone(getContext(), uri);//通过Uri 来获取提示音的实例对象
        mRingtone.play();//播放:
    }



//设置震动
Vibrator vibrator = context.getSystemService(context.VIBRATOR_SERVICE); 
vibrator.vibrate(500);//震动时长 ms 

 

2014-05-30 17:43:58 sumang_87 阅读数 12363
  • Android底层技术:HAL驱动开发

    本课程提供开发者学习Android底层的HAL(硬件抽象层)的开发方法和技术。HAL所在的位置是介于Android系统服务与Linux内核之间,HAL Driver是以library形式出现,给HAL Stub调用,供Android System架构者调用。而HAL Stub则是google设计出来的,保护硬件厂商的硬件驱动。

    17784 人正在学习 去看看 高煥堂

Android下 当 notification弹出时,有两种方法可以播放提示音


方法一:

	private void soundRing(Context context) throws IllegalArgumentException, SecurityException, IllegalStateException, IOException{

		MediaPlayer mp = new MediaPlayer();
		mp.reset();
		mp.setDataSource(context,
				RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION));
		mp.prepare();
		mp.start();
		
	}

这种方法需要加try catch


方法二:

		NotificationManager nm = (NotificationManager)context.getSystemService(android.content.Context.NOTIFICATION_SERVICE);
		Uri ringUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
        Notification noti = new NotificationCompat.Builder(context)
        			.setTicker(name+": " + msg)
        			.setContentTitle(name)
        			.setContentText(msg)
        			.setSmallIcon(R.drawable.ic_launcher)
        			.setContentIntent(pIntent)
        			.setSound(ringUri)
        			.build();
        nm.notify(MmsConfig.NOTIFY_ID, noti);
主要是setSound(ringUri)


======================================

如果文章对您有用,请 评论 支持下!! ^ ^

如果转载文章,请注明出处 。谢谢!!
宿莽 csdn
2018-05-09 14:26:22 zhuawalibai 阅读数 3615
  • Android底层技术:HAL驱动开发

    本课程提供开发者学习Android底层的HAL(硬件抽象层)的开发方法和技术。HAL所在的位置是介于Android系统服务与Linux内核之间,HAL Driver是以library形式出现,给HAL Stub调用,供Android System架构者调用。而HAL Stub则是google设计出来的,保护硬件厂商的硬件驱动。

    17784 人正在学习 去看看 高煥堂
Uri uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
Ringtone rt = RingtoneManager.getRingtone(getApplicationContext(), uri);
rt.play();
2017-03-09 11:24:36 kuai_le_de_xiao_erbi 阅读数 1312
  • Android底层技术:HAL驱动开发

    本课程提供开发者学习Android底层的HAL(硬件抽象层)的开发方法和技术。HAL所在的位置是介于Android系统服务与Linux内核之间,HAL Driver是以library形式出现,给HAL Stub调用,供Android System架构者调用。而HAL Stub则是google设计出来的,保护硬件厂商的硬件驱动。

    17784 人正在学习 去看看 高煥堂
  • 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);

    }

}

2016-01-11 15:34:41 u011630575 阅读数 2492
  • Android底层技术:HAL驱动开发

    本课程提供开发者学习Android底层的HAL(硬件抽象层)的开发方法和技术。HAL所在的位置是介于Android系统服务与Linux内核之间,HAL Driver是以library形式出现,给HAL Stub调用,供Android System架构者调用。而HAL Stub则是google设计出来的,保护硬件厂商的硬件驱动。

    17784 人正在学习 去看看 高煥堂
蜂鸣提示音和震动提示此功能在手机使用中很实用,最近在读zxing项目,学到了不少东西;我们一起来看看他是怎么做的,感兴趣的朋友可以了解下哦
最近在读zxing项目,学到了不少东西。推荐大家也读读。里面有个BeepManager类,实现一个蜂鸣音和震动的实现。我们一起来看看他是怎么做的:
蜂鸣 

1.准备一个 音频文件 比如:beep.ogg。 ogg格式是声音压缩格式的一种,类似mp3这样。我们准备播放它,就产生了蜂鸣的效果。 

2.为activity注册的默认音频通道 。

  activity.setVolumeControlStream(AudioManager.STREAM_MUSIC); 
 这里声明为 STREAM_MUSIC的通道,就是多媒体播放,注册后,我们使用手机上的音量大小键就可以调节播放的声音大小。
如果不设定这个通道的话,我们的这个activity默认音量按钮处理将作用于 手机铃音的大小。 

3.检查当前的 铃音模式,或者成为 情景模式。

  说明:getRingerMode() ——返回当前的铃声模式。
RINGER_MODE_NORMAL(普通)、
RINGER_MODE_SILENT(静音)、
RINGER_MODE_VIBRATE(震动)


//如果当前是铃音模式,则继续准备下面的 蜂鸣提示音操作,如果是静音或者震动模式。就不要继续了。因为用户选择了无声的模式,我们就也不要出声了。
AudioManager audioService = (AudioManager) activity .getSystemService(Context.AUDIO_SERVICE);
if (audioService.getRingerMode() != AudioManager.RINGER_MODE_NORMAL) {
     shouldPlayBeep = false;
}


4.初始化MediaPlayer对象,指定播放的声音 通道为 STREAM_MUSIC,这和上面的步骤一致,指向了同一个通道。  
       MediaPlayer mediaPlayer = new MediaPlayer();
  mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
  注册事件。当播放完毕一次后,重新指向流文件的开头,以准备下次播放。 
  // When the beep has finished playing, rewind to queue up another one.
      mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
           @Override
           public void onCompletion(MediaPlayer player) {
              player.seekTo(0);
           }
     });


设定数据源,并准备播放 

AssetFileDescriptor file = activity.getResources().openRawResourceFd(R.raw.beep);
try {
     mediaPlayer.setDataSource(file.getFileDescriptor(),
     file.getStartOffset(), file.getLength());
     file.close();
     mediaPlayer.setVolume(BEEP_VOLUME, BEEP_VOLUME);
      mediaPlayer.prepare();
 } catch (IOException ioe) {
     Log.w(TAG, ioe);
     mediaPlayer = null;
 }
return mediaPlayer;

5.开始播放 

if (playBeep && mediaPlayer != null) {
    mediaPlayer.start();
}

-----------------------------------------------------------------
震动
这个比较简单。分两步:
1.声明权限
  在AndroidManifest.xml 里写
复制代码 代码如下:

  <uses-permission android:name="android.permission.VIBRATE"/>

2.获得震动服务。
复制代码 代码如下:

  Vibrator vibrator = (Vibrator) activity.getSystemService(Context.VIBRATOR_SERVICE);

3.启动震动。
复制代码 代码如下:

  vibrator.vibrate(VIBRATE_DURATION);

复制代码 代码如下:

public void playBeepSoundAndVibrate() {
     if (enableVibrate) {
        Vibrator vibrator = (Vibrator) activity.getSystemService(Context.VIBRATOR_SERVICE);
        //震动一次
       vibrator.vibrate(VIBRATE_DURATION);
        //第一个参数,指代一个震动的频率数组。每两个为一组,每组的第一个为等待时间,第二个为震动时间。
       // 比如 [2000,500,100,400],会先等待2000毫秒,震动500,再等待100,震动400
       //第二个参数,repest指代从 第几个索引(第一个数组参数) 的位置开始循环震动。
      //会一直保持循环,我们需要用 vibrator.cancel()主动终止
       //vibrator.vibrate(new long[]{300,500},0);
    }




android通知声音

阅读数 1118

。。。

博文 来自: flcop
没有更多推荐了,返回首页