smali\com\tencent\mm\plugin\shake\ui\bq.smali
这个文件应该是触发摇一摇的函数吧
看底部：
:goto_1
iget-object v0, p0, Lcom/tencent/mm/plugin/shake/ui/bq;->aPr:Lcom/tencent/mm/plugin/shake/ui/ShakeReportUI;
invoke-static {v0}, Lcom/tencent/mm/plugin/shake/ui/ShakeReportUI;->k(Lcom/tencent/mm/plugin/shake/ui/ShakeReportUI;)V
.line 400
iget-object v0, p0, Lcom/tencent/mm/plugin/shake/ui/bq;->aPr:Lcom/tencent/mm/plugin/shake/ui/ShakeReportUI;
//这个应该就是摇一摇了
invoke-static {v0}, Lcom/tencent/mm/plugin/shake/ui/ShakeReportUI;->l(Lcom/tencent/mm/plugin/shake/ui/ShakeReportUI;)V
goto/16 :goto_0
.line 397
:cond_6
iget-object v0, p0, Lcom/tencent/mm/plugin/shake/ui/bq;->aPr:Lcom/tencent/mm/plugin/shake/ui/ShakeReportUI;
//这个是震动函数
invoke-static {v0}, Lcom/tencent/mm/plugin/shake/ui/ShakeReportUI;->j(Lcom/tencent/mm/plugin/shake/ui/ShakeReportUI;)V
具体摇一摇的函数和震动、音效等函数都在smali\com\tencent\mm/plugin/shake/ui/ShakeReportUI.smali文件里面
现在问题是我想写一个延迟，就写在 goto/16 :goto_0 这代码的上面，然后让他goto_1就行了，这样不就可以无限摇一摇了么？
然后我自己写了一个函数：
.method protected test()V
.locals 2
.prologue
.line 195
:try_start_0
invoke-static {}, Ljava/lang/Thread;->currentThread()Ljava/lang/Thread;
const-wide/16 v0, 0x1388
invoke-static {v0, v1}, Ljava/lang/Thread;->sleep(J)V
:try_end_0
.catch Ljava/lang/Exception; {:try_start_0 .. :try_end_0} :catch_0
.line 198
:goto_0
return-void
.line 197
:catch_0
move-exception v0
goto :goto_0
.end method
调用函数后，无限黑屏..求大神解答，或者给思路

手机摇一摇的测试脚本 sensor1.py
原理：x轴 y轴 z轴 有一接近或大于2g = 2*9.8= 19.6 即可
import android, time
droid = android.Android()
droid.startSensingTimed(2, 250)
time.sleep(1)
s2 = droid.sensorsReadAccelerometer().result
droid.stopSensing()
n =16 # threshold
x,y,z = s2
if abs(x)>n or abs(y)>n or abs(z)>n:
if abs(x)>n: print 'x=',x
if abs(y)>n: print 'y=',y
if abs(z)>n: print 'z=',z
droid.vibrate(500)
print 's2=',s2
参考: \sl4a\doc\SensorManagerFacade.html
startSensingTimed(): Starts recording sensor data to be available for polling.  sensorNumber (Integer) 1 = All, 2 = Accelerometer, 3 = Magnetometer and 4 = Light  delayTime (Integer) Minimum time between readings in milliseconds

实现效果图

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



此Demo可以实时设置调整灵敏度，方便测试。

摇一摇原理简介

手机摇一摇的实现，无非就是利用手机上的加速传感器，得到x、y、z轴三个方向的加速度。通过判断加速度的状态，来判断用户是否摇动了手机。而因为重力加速度一直存在，所以在一个方向上的加速度一直是9点多，设计的时候我们要考虑到这一点。

实现过程

第一步：先获得加速度传感器



sensorManager=(SensorManager)getSystemService(SENSOR_SERVICE);
        if(sensorManager==null) return;
        sensor=(sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER));

上面做了简单判断，防止出空指针 

我这里用到了手机震动，所以还需要获得手机震动服务

 vibrator=(Vibrator)getSystemService(VIBRATOR_SERVICE);

手机振动需要添加限权：

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

第二步: 为传感器设置好监听（布局文件和setViews代码比较简单，暂时不在这里写了，会出现在下面的源码中）

listener=new SensorEventListener() {
            @Override
            public void onSensorChanged(SensorEvent event) {
                try{
                    long currentTime=System.currentTimeMillis();
                    long timeInterval=Long.valueOf(etTimeInterval.getText().toString());
                    if(timeInterval>currentTime-lastTime) return;//如果两次回调间隔过小，直接忽略
                    float[] values=event.values;
                    float x=values[0];
                    float y=values[1];
                    float z=values[2];
                    if(Math.abs(z)>11||Math.abs(x)>5||Math.abs(y)>3) {
                        Log.i("TAG","x:"+x);
                        Log.i("TAG","y:"+y);
                        Log.i("TAG","z:"+z);
                    }
                    float deltaX=x-lastX;
                    float deltaY=y-lastY;
                    float deltaZ=z-lastZ;

                    lastX=x;
                    lastY=y;
                    lastZ=z;
                    double speed=(Math.sqrt(deltaX*deltaX+deltaY*deltaY+deltaZ*deltaZ)/timeInterval)*100;
                    if(speed>Double.valueOf(etSpeed.getText().toString())){
                        vibrator.vibrate(300);
                        text.append("x:"+x+"   y:"+y+"   z:"+z+"\n"+"speed:"+speed+"\n");
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }



            }

因为加速度传感器回调特别快，所以做了一次时间上的过滤，小于50毫秒时间的回调自动忽略了。（这个时间其实可以根据需要自己设置） 

  然后在传感事件event中分别得到x、y、z三个方向的加速度，因为摇一摇的加速度肯定变化特别剧烈，而不是一个均匀的加速，所以为了防干扰，判断这次加速度和上一次的变化会比较好。 

  在三个方向上的加速度不一定是正数还是负数，所以计算的时候最好加个平方，其他方法当然也可以。

第三步： 为传感器添加监听

 @Override
    protected void onResume() {
        super.onResume();
        lastTime=System.currentTimeMillis();
        text.setText("");
        sensorManager.registerListener(listener,sensor,sensorManager.SENSOR_DELAY_UI);
    }

    @Override
    protected void onPause() {
        super.onPause();
       sensorManager.unregisterListener(listener,sensor);
    }

为了防止摇一摇Activity在后台中也不断地监听，所以最好把此监听器设置在onResume()和onPause()上。

这样一个简单的摇一摇功能就实现了。

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.yang.test20170411.MainActivity">

    <LinearLayout
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        app:layout_constraintTop_toTopOf="parent"
        android:layout_marginTop="8dp"
        android:layout_marginLeft="8dp"
        app:layout_constraintLeft_toLeftOf="parent"
        android:layout_marginRight="8dp"
        app:layout_constraintRight_toRightOf="parent"
        android:layout_marginStart="8dp"
        android:layout_marginEnd="8dp"
        android:id="@+id/linearLayout">


        <android.support.design.widget.TextInputLayout
            android:layout_width="0dp"
            android:layout_weight="1"
            android:layout_height="wrap_content">

            <EditText
                android:id="@+id/et_time_interval"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:hint="回调间隔（数字）" />
        </android.support.design.widget.TextInputLayout>

        <android.support.design.widget.TextInputLayout
            android:layout_weight="1"
            android:layout_width="0dp"
            android:layout_height="match_parent">

            <EditText
                android:id="@+id/et_speed"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:hint="敏感度（数字）" />
        </android.support.design.widget.TextInputLayout>
    </LinearLayout>

    <ScrollView
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_marginTop="8dp"
        app:layout_constraintTop_toBottomOf="@+id/linearLayout"
        android:layout_marginRight="8dp"
        app:layout_constraintRight_toRightOf="parent"
        android:layout_marginLeft="8dp"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintBottom_toBottomOf="parent"
        android:layout_marginBottom="8dp">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical" >

            <TextView
                android:id="@+id/textView"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="" />
        </LinearLayout>
    </ScrollView>

</android.support.constraint.ConstraintLayout>


MainActivity：

package com.example.yang.test20170411;

import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.os.Vibrator;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {


    private SensorManager sensorManager;
    private Sensor sensor;
    private SensorEventListener listener;
    private Vibrator vibrator;
    private EditText etSpeed;
    private EditText etTimeInterval;
    private TextView text;
    private float lastX;
    private float lastY;
    private float lastZ;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        sensorManager=(SensorManager)getSystemService(SENSOR_SERVICE);
        if(sensorManager==null) return;
        sensor=(sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER));
        if(sensor==null) return;
        vibrator=(Vibrator)getSystemService(VIBRATOR_SERVICE);
        setViews();
        listener=new SensorEventListener() {
            @Override
            public void onSensorChanged(SensorEvent event) {
                try{
                    long currentTime=System.currentTimeMillis();
                    long timeInterval=Long.valueOf(etTimeInterval.getText().toString());
                    if(timeInterval>currentTime-lastTime) return;//如果两次回调间隔过小，直接忽略
                    float[] values=event.values;
                    float x=values[0];
                    float y=values[1];
                    float z=values[2];
                    if(Math.abs(z)>11||Math.abs(x)>5||Math.abs(y)>3) {
                        Log.i("TAG","x:"+x);
                        Log.i("TAG","y:"+y);
                        Log.i("TAG","z:"+z);
                    }
                    float deltaX=x-lastX;
                    float deltaY=y-lastY;
                    float deltaZ=z-lastZ;

                    lastX=x;
                    lastY=y;
                    lastZ=z;
                    double speed=(Math.sqrt(deltaX*deltaX+deltaY*deltaY+deltaZ*deltaZ)/timeInterval)*100;
                    if(speed>Double.valueOf(etSpeed.getText().toString())){
                        vibrator.vibrate(300);
                        text.append("x:"+x+"   y:"+y+"   z:"+z+"\n"+"speed:"+speed+"\n");
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }



            }

            @Override
            public void onAccuracyChanged(Sensor sensor, int accuracy) {

            }
        };
    }

    private void setViews() {
        etSpeed=(EditText)findViewById(R.id.et_speed);
        etTimeInterval=(EditText)findViewById(R.id.et_time_interval);
        text=(TextView)findViewById(R.id.textView);
    }
    long lastTime;
    @Override
    protected void onResume() {
        super.onResume();
        lastTime=System.currentTimeMillis();
        text.setText("");
        sensorManager.registerListener(listener,sensor,sensorManager.SENSOR_DELAY_UI);
    }

    @Override
    protected void onPause() {
        super.onPause();
       sensorManager.unregisterListener(listener,sensor);
    }
}


别忘了申请震动限权哈： 



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

最后附上github源码地址： https://github.com/linyang59685689/Test20170411


    在应用中为了能达到更好的用户交互体验，很多应用都采用了所谓的“摇一摇”来实现一些如随机速配、自动遴选等功能。在Android应用开发中为了实现这一功能需要运用到传感器相关API。下面通过一个Demo我们一起来看看如何实现“摇一摇”功能。
     首先我们需要定义一个类ShakeListener ，这个类实现了SensorEventListener接口，我们在这个类中定义一个接口OnShakeListener用于通知界面开始摇动和停止摇动，在界面需要监听摇动事件时首先需要通过得到ShakeListener 的一个实例，并在onResume()中需要调用ShakeListener类的register()方法注册监听，在onPause()、onStop()、onDestroy()中需要调用ShakeListener类的unregister()方法方法来注销监听，这么做的目的是为了在黑屏或者按下Home键将应用置于后台运行后不再监听摇动同时保证回到界面后可以继续监听摇动。

package cn.Longmaster.iPeng.Listener;

import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Handler;

/**
 * 手机摇动监听器
 * 
 * @author Jone
 */
public class ShakeListener implements SensorEventListener
{
	/** 速度阈值，当摇晃速度达到这值后产生作用 */
	private static final int SPEED_SHRESHOLD = 3000;
	/** 两次检测的时间间隔 */
	private static final int UPTATE_INTERVAL_TIME = 70;
	/** 最大间隔时间，超过该时间未再次摇动认为已停止摇动 */
	private static final int MAX_INTERVAL_TIME = 500;
	/** 摇动监听器 */
	private OnShakeListener mOnShakeListener;
	/** 传感器管理类 */
	private SensorManager mSensorManager;
	/** 传感器 */
	private Sensor mSensor;
	private Handler mHandler;
	// 手机上一个位置时重力感应坐标
	private float mLastX;
	private float mLastY;
	private float mLastZ;
	// 上次检测时间
	private long mLastUpdateTime;

	public ShakeListener(Context context)
	{
		mSensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
		// 获得加速度传感器
		if (mSensorManager != null)
			mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
		mHandler = new Handler();
	}

	/**
	 * 注册监听，本方法应该在Activity的onResume()中调用
	 */
	public void register()
	{
		if (mSensor != null)
			mSensorManager.registerListener(this, mSensor, SensorManager.SENSOR_DELAY_GAME);
	}

	/**
	 * 注销监听器，必须在Activity的onPause()、onStop()、onDestroy()中调用本方法，防止内存溢出同时防止在黑屏或者按下Home键后任可回调摇动
	 */
	public void unregister()
	{
		mSensorManager.unregisterListener(this);
	}

	/**
	 * 设置摇动回调监听
	 * 
	 * @param onShakeListener
	 *            摇动回调监听
	 */
	public void setOnShakeListener(OnShakeListener onShakeListener)
	{
		mOnShakeListener = onShakeListener;
	}

	@Override
	public void onAccuracyChanged(Sensor sensor, int accuracy)
	{
		// do nothing
	}

	@Override
	public void onSensorChanged(SensorEvent event)
	{
		// 现在检测时间
		long currentUpdateTime = System.currentTimeMillis();
		// 两次检测的时间间隔
		long timeInterval = currentUpdateTime - mLastUpdateTime;
		// 判断是否达到了检测时间间隔
		if (timeInterval < UPTATE_INTERVAL_TIME)
			return;
		// 现在的时间变成last时间
		mLastUpdateTime = currentUpdateTime;

		// 获得x,y,z坐标
		float x = event.values[0];
		float y = event.values[1];
		float z = event.values[2];

		// 获得x,y,z的变化值
		float deltaX = x - mLastX;
		float deltaY = y - mLastY;
		float deltaZ = z - mLastZ;

		// 将现在的坐标变成last坐标
		mLastX = x;
		mLastY = y;
		mLastZ = z;
		// 返回最近的双近似的平方根
		double speed = Math.sqrt(deltaX * deltaX + deltaY * deltaY + deltaZ * deltaZ) / timeInterval * 10000;
		// 达到速度阀值，发出提示
		if (speed >= SPEED_SHRESHOLD)
		{
			mOnShakeListener.onShakeStart();
			mHandler.removeCallbacks(runnable);
			mHandler.postDelayed(runnable, MAX_INTERVAL_TIME);
		}
	}

	Runnable runnable = new Runnable()
	{
		@Override
		public void run()
		{
			mOnShakeListener.onShakeFinish();
		}
	};

	/**
	 * 摇动监听接口
	 * 
	 * @author Jone
	 */
	public interface OnShakeListener
	{
		/**
		 * 开始新的一次摇动
		 */
		public abstract void onShakeStart();

		/**
		 * 停止结束
		 */
		public abstract void onShakeFinish();
	}
}

下面我们来写一个简单的Activity用于测试，界面布局很简单，只有一个文本区域用来显示摇动的次数：
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >
    
	<TextView
	    android:id="@+id/activity_shake_info" 
	    android:layout_width="match_parent"
	    android:layout_height="match_parent"
	    android:gravity="center"
	    android:textSize="18sp"
	    android:textColor="#ff0000"/>
</LinearLayout>

接下来编写Activity类中的代码，其中R.raw.shake是一个文件类型为ogg的音效：
package com.researchdemo.tools;

import android.app.Activity;
import android.app.Service;
import android.media.AudioManager;
import android.media.SoundPool;
import android.os.Bundle;
import android.os.Vibrator;
import android.widget.TextView;

import com.researchdemo.R;
import com.researchdemo.tools.ShakeListener.OnShakeListener;

/**
 * 摇一摇界面
 * 
 * @author Jone
 */
public class ShakeUI extends Activity
{
	/** 摇动回调监听器 */
	private ShakeListener mShakeListener;
	/** 信息显示文本控件 */
	private TextView mInfo;
	/** 摇动次数 */
	private int mCount;
	/** 用于播放音效 */
	private SoundPool mSoundPool;
	/** 音效资源 */
	private int mSoundSource;
	/** 震动 */
	private Vibrator mVibrator;

	@Override
	protected void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_shake);
		initView();
		initData();
	}

	private void initView()
	{
		mInfo = (TextView) findViewById(R.id.activity_shake_info);
	}

	private void initData()
	{
		mShakeListener = new ShakeListener(this);
		mSoundPool = new SoundPool(10, AudioManager.STREAM_MUSIC, 100);
		mSoundSource = mSoundPool.load(this, R.raw.shake, 100);

		mVibrator = (Vibrator) getSystemService(Service.VIBRATOR_SERVICE);
	}

	@Override
	protected void onResume()
	{
		mShakeListener.setOnShakeListener(onShakeListener);
		mShakeListener.register();
		super.onResume();
	}

	@Override
	protected void onPause()
	{
		mShakeListener.unregister();
		super.onPause();
	}

	@Override
	protected void onStop()
	{
		mShakeListener.unregister();
		super.onStop();
	}

	@Override
	protected void onDestroy()
	{
		mShakeListener.unregister();
		mSoundPool.release();
		super.onDestroy();
	}

	OnShakeListener onShakeListener = new OnShakeListener()
	{
		@Override
		public void onShakeStart()
		{
			mCount++;
			mInfo.setText("摇动" + mCount + "次！！");
			mVibrator.vibrate(500);
			mSoundPool.play(mSoundSource, 1, 1, 0, 0, 1);
		}

		@Override
		public void onShakeFinish()
		{
			mInfo.setText("摇动完成！！");
		}
	};
}