Android 注解快速入门和实用解析

首先什么是注解?@Override就是注解,它的作用是:

1、检查是否正确的重写了父类中的方法。 
2、标明代码,这是一个重写的方法。

1、体现在于:检查子类重写的方法名与参数类型是否正确;检查方法private/final/static等不能被重写。实际上@Override对于应用程序并没有实际影响,从它的源码中可以出来。

2、主要是表现出代码的可读性。

作为Android开发中熟知的注解,Override只是注解的一种体现,更多时候,注解还有以下作用:

  • 降低项目的耦合度。
  • 自动完成一些规律性的代码。
  • 自动生成java代码,减轻开发者的工作量。

一、注解基础快读

1、元注解

元注解是由java提供的基础注解,负责注解其它注解,如上图Override被@Target@Retention修饰,它们用来说明解释其它注解,位于sdk/sources/android-25/java/lang/annotation路径下。

元注解有:

  • @Retention:注解保留的生命周期
  • @Target:注解对象的作用范围。
  • @Inherited:@Inherited标明所修饰的注解,在所作用的类上,是否可以被继承。
  • @Documented:如其名,javadoc的工具文档化,一般不关心。

@Retention

Retention说标明了注解被生命周期,对应RetentionPolicy的枚举,表示注解在何时生效:

  • SOURCE:只在源码中有效,编译时抛弃,如上面的@Override
  • CLASS:编译class文件时生效。
  • RUNTIME:运行时才生效。

如下图X1,com.android.support:support-annotations中的Nullable注解,会在编译期判断,被注解的参数是否会空,具体后续分析。

@Target

Target标明了注解的适用范围,对应ElementType枚举,明确了注解的有效范围。

  • TYPE:类、接口、枚举、注解类型。
  • FIELD:类成员(构造方法、方法、成员变量)。
  • METHOD:方法。
  • PARAMETER:参数。
  • CONSTRUCTOR:构造器。
  • LOCAL_VARIABLE:局部变量。
  • ANNOTATION_TYPE:注解。
  • PACKAGE:包声明。
  • TYPE_PARAMETER:类型参数。
  • TYPE_USE:类型使用声明。

如上图X1所示,@Nullable可用于注解方法,参数,类成员,注解,包声明中,常用例子如下所示:

 /**
   * Nullable表明
   * bind方法的参数target和返回值Data可以为null
   */
  @Nullable 
  public static Data bind(@Nullable Context target) {
    //do someThing and return
    return bindXXX(target);
  }

@Inherited

注解所作用的类,在继承时默认无法继承父类的注解。除非注解声明了 @Inherited。同时Inherited声明出来的注,只对类有效,对方法/属性无效。

如下方代码,注解类@AInherited声明了Inherited ,而注解BNotInherited 没有,所在在它们的修饰下:

  • 类Child继承了父类Parent的@AInherited,不继承@BNotInherited
  • 重写的方法testOverride()不继承Parent的任何注解;
  • testNotOverride()因为没有被重写,所以注解依然生效。

继续阅读全文 “Android 注解快速入门和实用解析”

玩转Android之加速度传感器的使用,模仿微信摇一摇

Android系统带的传感器有很多种,最常见的莫过于微信的摇一摇了,那么今天我们就来看看Anroid中传感器的使用,做一个类似于微信摇一摇的效果。

OK ,废话不多说,我们就先来看看效果图吧:

玩转Android之加速度传感器的使用,模仿微信摇一摇

当我摇动手机的时候这里的动画效果基本和微信上的动画效果一致,这里请大家自行脑补微信摇一摇画面。

那我们就动手吧。

1.布局文件

好,那我们先来看看布局文件吧,在布局文件的正中央是一个花的图片,上图大家看到的手机图片实际上是两张图片拼接在一起,将花的那张图片遮住了,当摇一摇的时候,这两张图片分别向上或者向下移动,然后花的图片就可以显示出来。OK,基本原理就是这样,我们来看看代码:

  1. <?xml version=“1.0” encoding=“utf-8”?>  
  2. <RelativeLayout  
  3.     xmlns:android=“http://schemas.android.com/apk/res/android”  
  4.     xmlns:tools=“http://schemas.android.com/tools”  
  5.     android:layout_width=“match_parent”  
  6.     android:layout_height=“match_parent”  
  7.     android:background=“#1f1f1f”>  
  8.   
  9.     <ImageView  
  10.         android:layout_width=“wrap_content”  
  11.         android:layout_height=“wrap_content”  
  12.         android:src=“@drawable/flower”/>  
  13.   
  14.     <LinearLayout  
  15.         android:layout_width=“wrap_content”  
  16.         android:layout_height=“wrap_content”  
  17.         android:layout_centerInParent=“true”  
  18.         android:orientation=“vertical”>  
  19.   
  20.         <ImageView  
  21.             android:id=“@+id/up”  
  22.             android:layout_width=“wrap_content”  
  23.             android:layout_height=“wrap_content”  
  24.             android:src=“@drawable/up”/>  
  25.   
  26.         <ImageView  
  27.             android:id=“@+id/down”  
  28.             android:layout_width=“wrap_content”  
  29.             android:layout_height=“wrap_content”  
  30.             android:src=“@drawable/down”/>  
  31.     </LinearLayout>  
  32. </RelativeLayout>  

2.传感器监听手机晃动

既然要监听手机加速度的变化,那我首先需要获取系统的传感器:

  1. //获取到一个传感器管理器  
  2.         sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);  
  3.         //获得一个加速度传感器  
  4.         Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);  

这两行代码首先是获取一个传感器管理器,然后获取加速度传感器,因为关于传感器的API 有很多,这里你需要指明自己要获取的是哪一个传感器。拿到传感器之后,需要注册监听,如下:

  1. sensorManager.registerListener(listener, sensor, SensorManager.SENSOR_DELAY_GAME);  

注册传感器的监听一共需要三个参数,第一个是监听器,第二个是加速度传感器,第三个是传感器的灵敏度,传感器的灵敏度一共分为四级,如下,从上往下灵敏度依次降低:

    1. SENSOR_DELAY_FASTEST
   2. SENSOR_DELAY_GAME
   3. SENSOR_DELAY_UI
   4. SENSOR_DELAY_NORMAL

OK ,注册完之后,我们还是来看看这个监听器是什么吧:

  1. private SensorEventListener listener = new SensorEventListener() {  
  2.         //当手机的加速度发生变化时调用  
  3.         @Override  
  4.         public void onSensorChanged(SensorEvent event) {  
  5.             //获取手机在不同方向上加速度的变化  
  6.             float valuesX = Math.abs(event.values[0]);  
  7.             float valuesY = Math.abs(event.values[1]);  
  8.             float valuesZ = Math.abs(event.values[2]);  
  9.   
  10.             if (valuesX > 17 || valuesY > 17 || valuesZ > 17) {  
  11.                 startAnimation();  
  12.                 playSound();  
  13.             }  
  14.         }  
  15.   
  16.         @Override  
  17.         public void onAccuracyChanged(Sensor sensor, int accuracy) {  
  18.   
  19.         }  
  20.     };  

这个listener中一共就两个方法,一个是当手机的加速度发生改变的时候调用,还有一个是当传感器的灵敏度发生改变的时候调用,当手机的加速度发生改变的时候,我们可以获取到手机在X
、Y、Z
三个维度上的变化值,拿到这个值之后,我们只需要进行简单的比较即可,如果有任意一个方向的值大于17,则认为有人在晃动手机,这个时候开启动画和声音的播放。

3.开启动画和声音

动画实际上就是两个平移动画,我们来看看:

  1. private void startAnimation() {  
  2.     //如果两次晃动手机的时间小于1秒,则只执行一次动画  
  3.     long currentTimeMillis = System.currentTimeMillis();  
  4.     if (currentTimeMillis – lastTime < 1000) {  
  5.         return;  
  6.     }  
  7.     lastTime = currentTimeMillis;  
  8.     AnimationSet upSet = new AnimationSet(true);  
  9.     TranslateAnimation upUp = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
  10.             0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, –1);  
  11.     upUp.setDuration(1000);  
  12.     TranslateAnimation upDown = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
  13.             0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, 1);  
  14.     upDown.setDuration(1000);  
  15.     upDown.setStartOffset(1000);  
  16.     upSet.addAnimation(upUp);  
  17.     upSet.addAnimation(upDown);  
  18.     up.startAnimation(upSet);  
  19.     AnimationSet downSet = new AnimationSet(true);  
  20.     TranslateAnimation downUp = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
  21.             0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, 1);  
  22.     downUp.setDuration(1000);  
  23.     TranslateAnimation downDown = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
  24.             0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, –1);  
  25.     downDown.setDuration(1000);  
  26.     downDown.setStartOffset(1000);  
  27.     downSet.addAnimation(downUp);  
  28.     downSet.addAnimation(downDown);  
  29.     down.startAnimation(downSet);  
  30. }  

至于声音,由于我这里只是播放比较短小的音效而已,所以并没有必要使用MediaPlayer,我可以通过一个声音池来解决这个问题,代码如下:

  1. /** 
  2.  * 初始化声音池 
  3.  */  
  4. private void initSoundPool() {  
  5.     if (Build.VERSION.SDK_INT > 20) {  
  6.         SoundPool.Builder builder = new SoundPool.Builder();  
  7.         //1.最大并发流数  
  8.         builder.setMaxStreams(3);  
  9.         AudioAttributes.Builder aaBuilder = new AudioAttributes.Builder();  
  10.         aaBuilder.setLegacyStreamType(AudioManager.STREAM_MUSIC);  
  11.         builder.setAudioAttributes(aaBuilder.build());  
  12.         soundPool = builder.build();  
  13.     } else {  
  14.         soundPool = new SoundPool(3, AudioManager.STREAM_MUSIC, 0);  
  15.     }  
  16.     //加载一个音频文件  
  17.     sound1 = soundPool.load(this, R.raw.awe, 1);  
  18. }  

在创建一个声音池的时候我采取了两种不同的方案,如果系统的版本大于20,则是用第一种方式获取声音池,否则使用第二种方式获取声音池。获取声音池之后,再通过声音池加载一个音频文件。加载完成之后,我就可以对这个音频文件进行播放了,如下:

  1. //1.声音的id  
  2. //2.3.表示左右声道的音量  
  3. //4.优先级  
  4. //5.是否循环  
  5. //6.声音播放速率  
  6. soundPool.play(sound1, 1, 1, 0, 0, 1);  

每个参数的含义都写的很清楚了,大家又不清楚的地方可以直接看源码,这里的源码注释很好懂。

 

最后一步就是开启手机震动了,开启手机震动,我需要首先获取震动服务,如下:

  1. //获取手机震动服务  
  2.        vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);  

然后调用Vibrator类中的vibrator方法执行震动,如下:

  1. //1.表示震动的节奏off/on/off/on/off/on……  
  2.         //2.表示是否重复震动,-1表示不重复  
  3.         vibrator.vibrate(new long[]{100, 200, 100, 200, 100, 200}, –1);  

手机震动一定要记得添加震动权限哦,如下:

  1. <uses-permission android:name=“android.permission.VIBRATE” />  

OK ,最后,在销毁Activity的时候要解除对传感器的监听,同时释放声音池资源,如下:

  1. @Override  
  2. protected void onDestroy() {  
  3.     super.onDestroy();  
  4.     //解除对加速度传感器的监听  
  5.     sensorManager.unregisterListener(listener);  
  6.     if (soundPool != null) {  
  7.         //声音池释放资源  
  8.         soundPool.release();  
  9.     }  
  10. }  

完整的Activity 代码如下:

  1. public class MainActivity extends AppCompatActivity {  
  2.     private ImageView up;  
  3.     private ImageView down;  
  4.     //上一次晃动手机的时间  
  5.     private long lastTime;  
  6.     private SoundPool soundPool;  
  7.     private int sound1;  
  8.     private Vibrator vibrator;  
  9.     private SensorEventListener listener = new SensorEventListener() {  
  10.         //当手机的加速度发生变化时调用  
  11.         @Override  
  12.         public void onSensorChanged(SensorEvent event) {  
  13.             //获取手机在不同方向上加速度的变化  
  14.             float valuesX = Math.abs(event.values[0]);  
  15.             float valuesY = Math.abs(event.values[1]);  
  16.             float valuesZ = Math.abs(event.values[2]);  
  17.   
  18.             if (valuesX > 17 || valuesY > 17 || valuesZ > 17) {  
  19.                 startAnimation();  
  20.                 playSound();  
  21.             }  
  22.         }  
  23.   
  24.         @Override  
  25.         public void onAccuracyChanged(Sensor sensor, int accuracy) {  
  26.   
  27.         }  
  28.     };  
  29.     private SensorManager sensorManager;  
  30.   
  31.     private void playSound() {  
  32.         //1.声音的id  
  33.         //2.3.表示左右声道的音量  
  34.         //4.优先级  
  35.         //5.是否循环  
  36.         //6.声音播放速率  
  37.         soundPool.play(sound1, 1, 1, 0, 0, 1);  
  38.         //手机震动  
  39.         //1.表示震动的节奏off/on/off/on/off/on……  
  40.         //2.表示是否重复震动,-1表示不重复  
  41.         vibrator.vibrate(new long[]{100, 200, 100, 200, 100, 200}, –1);  
  42.     }  
  43.   
  44.     private void startAnimation() {  
  45.         //如果两次晃动手机的时间小于1秒,则只执行一次动画  
  46.         long currentTimeMillis = System.currentTimeMillis();  
  47.         if (currentTimeMillis – lastTime < 1000) {  
  48.             return;  
  49.         }  
  50.         lastTime = currentTimeMillis;  
  51.         AnimationSet upSet = new AnimationSet(true);  
  52.         TranslateAnimation upUp = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
  53.                 0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, –1);  
  54.         upUp.setDuration(1000);  
  55.         TranslateAnimation upDown = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
  56.                 0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, 1);  
  57.         upDown.setDuration(1000);  
  58.         upDown.setStartOffset(1000);  
  59.         upSet.addAnimation(upUp);  
  60.         upSet.addAnimation(upDown);  
  61.         up.startAnimation(upSet);  
  62.         AnimationSet downSet = new AnimationSet(true);  
  63.         TranslateAnimation downUp = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
  64.                 0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, 1);  
  65.         downUp.setDuration(1000);  
  66.         TranslateAnimation downDown = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
  67.                 0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, –1);  
  68.         downDown.setDuration(1000);  
  69.         downDown.setStartOffset(1000);  
  70.         downSet.addAnimation(downUp);  
  71.         downSet.addAnimation(downDown);  
  72.         down.startAnimation(downSet);  
  73.     }  
  74.   
  75.     @Override  
  76.     protected void onCreate(Bundle savedInstanceState) {  
  77.         super.onCreate(savedInstanceState);  
  78.         setContentView(R.layout.activity_main);  
  79.         up = ((ImageView) findViewById(R.id.up));  
  80.         down = ((ImageView) findViewById(R.id.down));  
  81.         initSensor();  
  82.         initSoundPool();  
  83.         //获取手机震动服务  
  84.         vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);  
  85.     }  
  86.   
  87.     /** 
  88.      * 初始化声音池 
  89.      */  
  90.     private void initSoundPool() {  
  91.         if (Build.VERSION.SDK_INT > 20) {  
  92.             SoundPool.Builder builder = new SoundPool.Builder();  
  93.             //1.最大并发流数  
  94.             builder.setMaxStreams(3);  
  95.             AudioAttributes.Builder aaBuilder = new AudioAttributes.Builder();  
  96.             aaBuilder.setLegacyStreamType(AudioManager.STREAM_MUSIC);  
  97.             builder.setAudioAttributes(aaBuilder.build());  
  98.             soundPool = builder.build();  
  99.         } else {  
  100.             soundPool = new SoundPool(3, AudioManager.STREAM_MUSIC, 0);  
  101.         }  
  102.         //加载一个音频文件  
  103.         sound1 = soundPool.load(this, R.raw.awe, 1);  
  104.     }  
  105.   
  106.     /** 
  107.      * 初始化传感器 
  108.      */  
  109.     private void initSensor() {  
  110.         //获取到一个传感器管理器  
  111.         sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);  
  112.         //获得一个加速度传感器  
  113.         Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);  
  114.         //注册传感器监听,  
  115.         //1.监听器  
  116.         //2.加速度传感器  
  117.         //3.传感器灵敏度  
  118.         //传感器灵敏度分为四级,从上往下灵敏度依次降低  
  119.         //SENSOR_DELAY_FASTEST  
  120.         //SENSOR_DELAY_GAME  
  121.         //SENSOR_DELAY_UI  
  122.         //SENSOR_DELAY_NORMAL  
  123.         sensorManager.registerListener(listener, sensor, SensorManager.SENSOR_DELAY_GAME);  
  124.     }  
  125.   
  126.     @Override  
  127.     protected void onDestroy() {  
  128.         super.onDestroy();  
  129.         //解除对加速度传感器的监听  
  130.         sensorManager.unregisterListener(listener);  
  131.         if (soundPool != null) {  
  132.             //声音池释放资源  
  133.             soundPool.release();  
  134.         }  
  135.     }  
  136. }  

以上。