एंड्रॉइड अभिविन्यास सेंसर का विकल्प क्या है?

Question

हाय मैं एंड्रॉइड के लिए एक 3 डी गेम बना रहा हूं।

मैं वर्तमान में मेरे खेल है कि खिलाड़ी अपने नियंत्रण के रूप में एंड्रॉयड झुकाने के लिए अनुमति देता है के लिए एक सेंसर जोड़ने की कोशिश कर रहा हूँ।

आदर्श रूप में मैं अभिविन्यास सेंसर का उपयोग करना चाहते हैं, लेकिन मैंने देखा कि यह मान्य नहीं है। क्या किसी को पता है कि एंड्रॉइड में झुकाव का पता लगाने के लिए और इस सेंसर का उपयोग नहीं करता है?

Answer 1

कोई वास्तविक "अभिविन्यास" सेंसर नहीं है - यह (था) वास्तव में एक समग्र सेंसर, accelerometer और magnometer का एक संयोजन से उत्पन्न है।

http://developer.android.com/reference/android/hardware/SensorEvent.html

से "यह संवेदक प्रकार विरासत कारणों के लिए मौजूद है, remapCoordinateSystem() और getOrientation() साथ संयोजन के रूप में getRotationMatrix() का इस्तेमाल करें बजाय इन मूल्यों की गणना करने के लिए।"

public class OrientationTestActivity extends Activity implements SensorEventListener 
{ 
    private SensorManager mSensorManager; 
    private Sensor mAccelerometer; 
    private Sensor mMagnetometer; 

    private float[] mLastAccelerometer = new float[3]; 
    private float[] mLastMagnetometer = new float[3]; 
    private boolean mLastAccelerometerSet = false; 
    private boolean mLastMagnetometerSet = false; 

    private float[] mR = new float[9]; 
    private float[] mOrientation = new float[3]; 

    @Override 
    public void onCreate(Bundle savedInstanceState) 
    { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.main); 

     mSensorManager = (SensorManager)getSystemService(SENSOR_SERVICE); 
     mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); 
     mMagnetometer = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD); 
    } 

    protected void onResume() { 
     super.onResume(); 
     mLastAccelerometerSet = false; 
     mLastMagnetometerSet = false; 
     mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_NORMAL); 
     mSensorManager.registerListener(this, mMagnetometer, SensorManager.SENSOR_DELAY_NORMAL); 
    } 

    protected void onPause() { 
     super.onPause(); 
     mSensorManager.unregisterListener(this); 
    } 

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

    @Override 
    public void onSensorChanged(SensorEvent event) { 
     if (event.sensor == mAccelerometer) { 
      System.arraycopy(event.values, 0, mLastAccelerometer, 0, event.values.length); 
      mLastAccelerometerSet = true; 
     } else if (event.sensor == mMagnetometer) { 
      System.arraycopy(event.values, 0, mLastMagnetometer, 0, event.values.length); 
      mLastMagnetometerSet = true; 
     } 
     if (mLastAccelerometerSet && mLastMagnetometerSet) { 
      SensorManager.getRotationMatrix(mR, null, mLastAccelerometer, mLastMagnetometer); 
      SensorManager.getOrientation(mR, mOrientation); 
      Log.i("OrientationTestActivity", String.format("Orientation: %f, %f, %f", 
                  mOrientation[0], mOrientation[1], mOrientation[2])); 
     } 
    } 
}