অ্যান্ড্রয়েডের সাথে কাঁপানো ইভেন্টটি কীভাবে সনাক্ত করা যায়?

Question

আমি কীভাবে অ্যান্ড্রয়েডের সাথে কাঁপানো ইভেন্টটি সনাক্ত করতে পারি? আমি কীভাবে কাঁপানোর দিকটি সনাক্ত করতে পারি?

কাঁপুনি দেখা দিলে আমি চিত্র চিত্রে চিত্র পরিবর্তন করতে চাই।

Comments

আমি গুগল করেছিলাম, এবং এই ফলাফলটি শীর্ষ ফলাফল হিসাবে শেষ করেছি ...

— zmbq

stackoverflow.com/a/54745560/4307338 আপনি এই উত্তরটি চেক করতে পারেন

— হক এমডি জাহিদুল

Answer 1

কোড দৃষ্টিকোণ থেকে, আপনাকে সেন্সরলিস্টনার প্রয়োগ করতে হবে:

public class ShakeActivity extends Activity implements SensorListener

আপনার একটি সেন্সর ম্যানেজার অর্জন করতে হবে:

sensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE);

এবং এই সেন্সরটিকে কাঙ্ক্ষিত পতাকা সহ নিবন্ধ করুন:

sensorMgr.registerListener(this,
SensorManager.SENSOR_ACCELEROMETER,
SensorManager.SENSOR_DELAY_GAME);

আপনার অনসেন্সর চেঞ্জ () পদ্ধতিতে, আপনি নির্ধারণ করুন এটি কাঁপুন কিনা or

public void onSensorChanged(int sensor, float[] values) {
  if (sensor == SensorManager.SENSOR_ACCELEROMETER) {
    long curTime = System.currentTimeMillis();
    // only allow one update every 100ms.
    if ((curTime - lastUpdate) > 100) {
      long diffTime = (curTime - lastUpdate);
      lastUpdate = curTime;

      x = values[SensorManager.DATA_X];
      y = values[SensorManager.DATA_Y];
      z = values[SensorManager.DATA_Z];

      float speed = Math.abs(x+y+z - last_x - last_y - last_z) / diffTime * 10000;

      if (speed > SHAKE_THRESHOLD) {
        Log.d("sensor", "shake detected w/ speed: " + speed);
        Toast.makeText(this, "shake detected w/ speed: " + speed, Toast.LENGTH_SHORT).show();
      }
      last_x = x;
      last_y = y;
      last_z = z;
    }
  }
}

শেক থ্রেশহোল্ড হিসাবে সংজ্ঞায়িত করা হয়:

private static final int SHAKE_THRESHOLD = 800;

শেক গতি শনাক্ত করার জন্য আরও কিছু পদ্ধতি রয়েছে। এই লিঙ্কটি দেখুন। (যদি সেই লিঙ্কটি কাজ না করে বা লিঙ্কটি মারা যায় তবে এই ওয়েব সংরক্ষণাগারটি দেখুন ))

অ্যান্ড্রয়েড শেক সনাক্তকারী শ্রোতার জন্য এই উদাহরণটি একবার দেখুন ।

দ্রষ্টব্য: SensorListener হ্রাস করা হয়েছে। আমরা SensorEventListenerপরিবর্তে ব্যবহার করতে পারেন । সেন্সরএভেন্টলিস্টনার ব্যবহার করে এখানে একটি দ্রুত উদাহরণ দেওয়া আছে।

ধন্যবাদ।

Comments

সেন্সরলিস্টনার ক্লাস করবেন না। কারণ এটি চিত্রিত use

— পিকাসো

লিংক মারা গেছে ... এখানে archive.org নিবন্ধ আছে: web.archive.org/web/20100324212856/http://www.codeshogun.com/...

— Pilot_51

আমি দেখতে পেলাম যে সংবেদনশীলতাটি ডিভাইসের ভিত্তিতে পরিবর্তিত হবে। ছায়াপথ নেক্সাসে পুরোপুরি গ্রহণযোগ্য শেক সনাক্তকরণের মতো মনে হচ্ছিল একই অ্যাপ্লিকেশনটি চালিত গ্যালাক্সির তৃতীয়টিতে অনেক বেশি হিংস্র কাঁপুন। যদি আমি এই ডিভাইসটির জন্য এটি কম সংবেদনশীল করে তুলি তবে এটি নেক্সাসের মতো কোনও কিছুর প্রতি খুব সংবেদনশীল হবে। hmmmmmmm।

— topwik

কেন 10000 দ্বারা গুণিত এবং ডিনোমিনেটরে কী কোনও বন্ধনী থাকতে হবে?

— যোদা

এটি কাজ করে, তবে ত্বরণ গণনা করতে আপনি গণিতে পরীক্ষা করতে চাইতে পারেন: সেন্সরগুলির দ্বারা ফিরে আসা মানগুলি m / s ^ 2 এর মধ্যে রয়েছে - সময় অনুসারে ভাগ করার দরকার নেই is এছাড়াও, আপনি কীভাবে ত্বরণের ভেক্টরগুলি গুণাবেন তাও আপনি দেখতে চাইতে পারেন।

— ট্যাড

Answer 2

গুগল অনেক সাহায্য করে ।

/* The following code was written by Matthew Wiggins
 * and is released under the APACHE 2.0 license
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 */
package com.hlidskialf.android.hardware;

import android.hardware.SensorListener;
import android.hardware.SensorManager;
import android.content.Context;
import java.lang.UnsupportedOperationException;

public class ShakeListener implements SensorListener 
{
  private static final int FORCE_THRESHOLD = 350;
  private static final int TIME_THRESHOLD = 100;
  private static final int SHAKE_TIMEOUT = 500;
  private static final int SHAKE_DURATION = 1000;
  private static final int SHAKE_COUNT = 3;

  private SensorManager mSensorMgr;
  private float mLastX=-1.0f, mLastY=-1.0f, mLastZ=-1.0f;
  private long mLastTime;
  private OnShakeListener mShakeListener;
  private Context mContext;
  private int mShakeCount = 0;
  private long mLastShake;
  private long mLastForce;

  public interface OnShakeListener
  {
    public void onShake();
  }

  public ShakeListener(Context context) 
  { 
    mContext = context;
    resume();
  }

  public void setOnShakeListener(OnShakeListener listener)
  {
    mShakeListener = listener;
  }

  public void resume() {
    mSensorMgr = (SensorManager)mContext.getSystemService(Context.SENSOR_SERVICE);
    if (mSensorMgr == null) {
      throw new UnsupportedOperationException("Sensors not supported");
    }
    boolean supported = mSensorMgr.registerListener(this, SensorManager.SENSOR_ACCELEROMETER, SensorManager.SENSOR_DELAY_GAME);
    if (!supported) {
      mSensorMgr.unregisterListener(this, SensorManager.SENSOR_ACCELEROMETER);
      throw new UnsupportedOperationException("Accelerometer not supported");
    }
  }

  public void pause() {
    if (mSensorMgr != null) {
      mSensorMgr.unregisterListener(this, SensorManager.SENSOR_ACCELEROMETER);
      mSensorMgr = null;
    }
  }

  public void onAccuracyChanged(int sensor, int accuracy) { }

  public void onSensorChanged(int sensor, float[] values) 
  {
    if (sensor != SensorManager.SENSOR_ACCELEROMETER) return;
    long now = System.currentTimeMillis();

    if ((now - mLastForce) > SHAKE_TIMEOUT) {
      mShakeCount = 0;
    }

    if ((now - mLastTime) > TIME_THRESHOLD) {
      long diff = now - mLastTime;
      float speed = Math.abs(values[SensorManager.DATA_X] + values[SensorManager.DATA_Y] + values[SensorManager.DATA_Z] - mLastX - mLastY - mLastZ) / diff * 10000;
      if (speed > FORCE_THRESHOLD) {
        if ((++mShakeCount >= SHAKE_COUNT) && (now - mLastShake > SHAKE_DURATION)) {
          mLastShake = now;
          mShakeCount = 0;
          if (mShakeListener != null) { 
            mShakeListener.onShake(); 
          }
        }
        mLastForce = now;
      }
      mLastTime = now;
      mLastX = values[SensorManager.DATA_X];
      mLastY = values[SensorManager.DATA_Y];
      mLastZ = values[SensorManager.DATA_Z];
    }
  }

}

Comments

java.lang.SecurityException: Requires VIBRATE permission

— প্রতীক বুটানি

SensorManager.DATA_[X,Y,Z]এখন অবহেলা করা হয়।

— রানি আলবেগ ওয়েইন

আপনি কি নিশ্চিত? আমি ডক্স এবং আইডিই পরীক্ষা করে দেখেছি এবং এটি স্ট্রাইকথ্রু বা অবমূল্যায়নের সতর্কতা পেয়েছে না।

— নিওন ওয়ার্জ

হ্রাস করা হয়েছে ... বেশিরভাগ ক্ষেত্রেই সমস্ত কিছু হ্রাস করা হয়েছে।

— প্রতীক বুটানি

Answer 3

আপনি সিসমিক লাইব্রেরিতে একবার দেখে নিতে পারেন

public class Demo extends Activity implements ShakeDetector.Listener {
  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    SensorManager sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
    ShakeDetector sd = new ShakeDetector(this);
    sd.start(sensorManager);

    TextView tv = new TextView(this);
    tv.setGravity(CENTER);
    tv.setText("Shake me, bro!");
    setContentView(tv, new LayoutParams(MATCH_PARENT, MATCH_PARENT));
  }

  @Override public void hearShake() {
    Toast.makeText(this, "Don't shake me, bro!", Toast.LENGTH_SHORT).show();
  }
}

Comments

আন্ডাররেটেড উত্তর।

— মোরগথ

এটা বরং ভালো. এই গ্রন্থাগারটি স্কয়ার দ্বারা তৈরি করা হয়েছে।

— সদ্দা হুসেন

কোটলিনে

— পঞ্চিকরে

Answer 4

ইতিমধ্যে এই প্রশ্নের অনেকগুলি সমাধান রয়েছে, তবে আমি এটি পোস্ট করতে চেয়েছিলাম:

• এপিআই 3-এ বর্ণিত লাইব্রেরি ব্যবহার করবেন না
• ত্বরণের মাত্রা সঠিকভাবে গণনা করে
• শেক ইভেন্টগুলির মধ্যে সঠিকভাবে একটি সময়সীমা প্রয়োগ করে

এই জাতীয় সমাধান এখানে দেওয়া হল:

// variables for shake detection
private static final float SHAKE_THRESHOLD = 3.25f; // m/S**2
private static final int MIN_TIME_BETWEEN_SHAKES_MILLISECS = 1000;
private long mLastShakeTime;
private SensorManager mSensorMgr;

টাইমারটি শুরু করতে:

// Get a sensor manager to listen for shakes
mSensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE);

// Listen for shakes
Sensor accelerometer = mSensorMgr.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
if (accelerometer != null) {
    mSensorMgr.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_NORMAL);
}

SensorEventListener ওভাররাইড করার পদ্ধতি:

@Override
public void onSensorChanged(SensorEvent event) {
    if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
        long curTime = System.currentTimeMillis();
        if ((curTime - mLastShakeTime) > MIN_TIME_BETWEEN_SHAKES_MILLISECS) {

            float x = event.values[0];
            float y = event.values[1];
            float z = event.values[2];

            double acceleration = Math.sqrt(Math.pow(x, 2) +
                    Math.pow(y, 2) +
                    Math.pow(z, 2)) - SensorManager.GRAVITY_EARTH;
            Log.d(APP_NAME, "Acceleration is " + acceleration + "m/s^2");

            if (acceleration > SHAKE_THRESHOLD) {
                mLastShakeTime = curTime;
                Log.d(APP_NAME, "Shake, Rattle, and Roll");
            }
        }
    }
}

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

যখন আপনি সব সম্পন্ন করা হয়

// Stop listening for shakes
mSensorMgr.unregisterListener(this);

Answer 5

যেহেতু SensorListener হয় অবচিত তাই নিচের কোডটি ব্যবহার করুন:

/* put this into your activity class */
private SensorManager mSensorManager;
private float mAccel; // acceleration apart from gravity
private float mAccelCurrent; // current acceleration including gravity
private float mAccelLast; // last acceleration including gravity

private final SensorEventListener mSensorListener = new SensorEventListener() {

  public void onSensorChanged(SensorEvent se) {
    float x = se.values[0];
    float y = se.values[1];
    float z = se.values[2];
    mAccelLast = mAccelCurrent;
    mAccelCurrent = (float) Math.sqrt((double) (x*x + y*y + z*z));
    float delta = mAccelCurrent - mAccelLast;
    mAccel = mAccel * 0.9f + delta; // perform low-cut filter
  }

  public void onAccuracyChanged(Sensor sensor, int accuracy) {
  }
};

@Override
protected void onResume() {
  super.onResume();
  mSensorManager.registerListener(mSensorListener, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_NORMAL);
}

@Override
protected void onPause() {
  mSensorManager.unregisterListener(mSensorListener);
  super.onPause();
}

তারপর:

/* do this in onCreate */
mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
mSensorManager.registerListener(mSensorListener, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_NORMAL);
mAccel = 0.00f;
mAccelCurrent = SensorManager.GRAVITY_EARTH;
mAccelLast = SensorManager.GRAVITY_EARTH;

পূর্ণ বিবরণ সহ প্রশ্নটি এখানে পাওয়া যাবে:

অ্যান্ড্রয়েড: আমি এটি নাড়াতে চাই

Comments

সর্বশেষে আমি লো-পাস ফিল্টারটি পরীক্ষা করেছি [আলফা * কারেন্ট + (১-আলফা) * পূর্ববর্তী] এবং 0.9 (আলফা?) পুরোপুরি সেন্সরের নমুনার হারের উপর নির্ভরশীল, যেমন 100 মাইলের জন্য আলফাটি 0.146 ইশ হওয়া উচিত, এবং আপনি ধরে নিতে পারবেন না সমস্ত ডিভাইস হুবহু একই সেন্সর রেট ব্যবহার করে।

— -llc

আমি অ্যান্ড্রয়েডে বেশ নতুন। আপনি কী আমাকে বুঝতে সাহায্য করতে পারেন যে স্ক্রিন কাঁপছে যখন অনারিউম এবং অনপেজ বলা হয়? আমি সেই অংশটি পাই না।

— পিকমন্দর 2

@ পিকামান্ডার 2 আমাদের সেন্সর ম্যানেজারে একটি শ্রোতার নিবন্ধন করতে হবে, আমরা এটি চালু করেছি এবং শ্রোতাদের অনপস-এ নিবন্ধন করি যাতে ব্যবহারকারী অ্যাপ্লিকেশনটি ছেড়ে গেলে এই শ্রোতা যখনই অ্যাপটিতে ফিরে না আসে ততক্ষণ এই শ্রোতা কাজ করবে না।

— সাইয়েদ এন।

Answer 6

আপনি সিসমিক ব্যবহার করতে পারেন :

কোডটি এখানে দেখুন:

https://github.com/square/seismic/blob/master/library/src/main/java/com/squareup/seismic/ShakeDetector.java

Answer 7

এটি Kotlinএবং ব্যবহারের জন্যSensorEventListener

নতুন ক্লাস তৈরি করুন ShakeDetector

class ShakeDetector : SensorEventListener {
    private var mListener: OnShakeListener? = null
    private var mShakeTimestamp: Long = 0
    private var mShakeCount = 0
    fun setOnShakeListener(listener: OnShakeListener?) {
        mListener = listener
    }

    interface OnShakeListener {
        fun onShake(count: Int)
    }

    override fun onAccuracyChanged(
        sensor: Sensor,
        accuracy: Int
    ) { // ignore
    }

    override fun onSensorChanged(event: SensorEvent) {
        if (mListener != null) {
            val x = event.values[0]
            val y = event.values[1]
            val z = event.values[2]
            val gX = x / SensorManager.GRAVITY_EARTH
            val gY = y / SensorManager.GRAVITY_EARTH
            val gZ = z / SensorManager.GRAVITY_EARTH
            // gForce will be close to 1 when there is no movement.
            val gForce: Float = sqrt(gX * gX + gY * gY + gZ * gZ)
            if (gForce > SHAKE_THRESHOLD_GRAVITY) {
                val now = System.currentTimeMillis()
                // ignore shake events too close to each other (500ms)
                if (mShakeTimestamp + SHAKE_SLOP_TIME_MS > now) {
                    return
                }
                // reset the shake count after 3 seconds of no shakes
                if (mShakeTimestamp + SHAKE_COUNT_RESET_TIME_MS < now) {
                    mShakeCount = 0
                }
                mShakeTimestamp = now
                mShakeCount++
                mListener!!.onShake(mShakeCount)
            }
        }
    }

    companion object {
        /*
     * The gForce that is necessary to register as shake.
     * Must be greater than 1G (one earth gravity unit).
     * You can install "G-Force", by Blake La Pierre
     * from the Google Play Store and run it to see how
     *  many G's it takes to register a shake
     */
        private const val SHAKE_THRESHOLD_GRAVITY = 2.7f
        private const val SHAKE_SLOP_TIME_MS = 500
        private const val SHAKE_COUNT_RESET_TIME_MS = 3000
    }
}

আপনার মূল ক্রিয়াকলাপ

class MainActivity : AppCompatActivity() {

    // The following are used for the shake detection
    private var mSensorManager: SensorManager? = null
    private var mAccelerometer: Sensor? = null
    private var mShakeDetector: ShakeDetector? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        initSensor()
    }
    override fun onResume() {
        super.onResume()
        // Add the following line to register the Session Manager Listener onResume
        mSensorManager!!.registerListener(
            mShakeDetector,
            mAccelerometer,
            SensorManager.SENSOR_DELAY_UI
        )
    }

    override fun onPause() { // Add the following line to unregister the Sensor Manager onPause
        mSensorManager!!.unregisterListener(mShakeDetector)
        super.onPause()
    }

    private fun initSensor() {
        // ShakeDetector initialization
        // ShakeDetector initialization
        mSensorManager = getSystemService(SENSOR_SERVICE) as SensorManager
        mAccelerometer = mSensorManager!!.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
        mShakeDetector = ShakeDetector()
        mShakeDetector!!.setOnShakeListener(object : OnShakeListener {
            override fun onShake(count: Int) { /*
                 * The following method, "handleShakeEvent(count):" is a stub //
                 * method you would use to setup whatever you want done once the
                 * device has been shook.
                 */
                Toast.makeText(this@MainActivity, count.toString(), Toast.LENGTH_SHORT).show()
            }
        })
    }
}

ফোনে একটি অ্যাকসিলোমিটার রয়েছে কিনা তা নিশ্চিত করতে অবশেষে এই কোডটি ম্যানিফেস্টে যুক্ত করুন

<uses-feature android:name="android.hardware.sensor.accelerometer" android:required="true" />

Answer 8

নিম্নলিখিতগুলি করুন:

private float xAccel, yAccel, zAccel;
private float xPreviousAccel, yPreviousAccel, zPreviousAccel;
private boolean firstUpdate = true;
private final float shakeThreshold = 1.5f;
private boolean shakeInitiated = false;
SensorEventListener mySensorEventListener;
SensorManager mySensorManager;

এটি অনক্রিট পদ্ধতিতে রাখুন।

mySensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
    mySensorManager.registerListener(mySensorEventListener,
            mySensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
            SensorManager.SENSOR_DELAY_NORMAL);

এবং এখন মূল অংশ।

private boolean isAccelerationChanged() {
    float deltaX = Math.abs(xPreviousAccel - xAccel);
    float deltaY = Math.abs(yPreviousAccel - yAccel);
    float deltaZ = Math.abs(zPreviousAccel - zAccel);
    return (deltaX > shakeThreshold && deltaY > shakeThreshold)
            || (deltaX > shakeThreshold && deltaZ > shakeThreshold)
            || (deltaY > shakeThreshold && deltaZ > shakeThreshold);
}

private void updateAccelParameters(float xNewAccel, float yNewAccel, float zNewAccel) {
    if (firstUpdate) {
        xPreviousAccel = xNewAccel;
        yPreviousAccel = yNewAccel;
        zPreviousAccel = zNewAccel;
        firstUpdate = false;
    }else{
        xPreviousAccel = xAccel;
        yPreviousAccel = yAccel;
        zPreviousAccel = zAccel;
    }
    xAccel = xNewAccel;
    yAccel = yNewAccel;
    zAccel = zNewAccel;
}

private void executeShakeAction() {
    //this method is called when devices shakes
}

public void onSensorChanged(SensorEvent se) {
    updateAccelParameters(se.values[0], se.values[1], se.values[2]);
    if ((!shakeInitiated) && isAccelerationChanged()) {
        shakeInitiated = true;
    }else if ((shakeInitiated) && isAccelerationChanged()){
        executeShakeAction();
    }else if((shakeInitiated) && (!isAccelerationChanged())){
        shakeInitiated = false;
    }
}

public void onAccuracyChanged(Sensor sensor, int accuracy) {
    //setting the accuracy
}

Comments

আমি যদি ব্যবহারকারী তিনবার ফোনটি নাড়া দেয় এবং তারপরে একটি অডিও

— চালায়

এই জাতীয় কোড (এবং আরও অনেক অনুরূপ উদাহরণ) কেবল তীব্রতরকরণের টেকসই সময় সনাক্ত করে, অগত্যা কাঁপানো নয়। এটি পিছনে-পিছনের গতি শনাক্ত করবে না, যা আসলে নেতিবাচক ত্বরণের পরে ত্বরণ হয় ration

— -llc

Answer 9

আপনার এই কোড যোগ করতে ভুলবেন Dont MainActivity.java:

MainActivity.java

mShaker = new ShakeListener(this);
mShaker.setOnShakeListener(new ShakeListener.OnShakeListener () {
    public void onShake() {
        Toast.makeText(MainActivity.this, "Shake " , Toast.LENGTH_LONG).show();        
    }
});

@Override
protected void onResume() {
    super.onResume();
    mShaker.resume();
}

@Override
protected void onPause() {
    super.onPause();
    mShaker.pause();
}

অথবা আমি আপনাকে এই স্টাফ সম্পর্কে একটি লিঙ্ক দিচ্ছি ।