FAQ AndroidConsultez toutes les FAQ

1
2
3
4
5
6
7
//Initialisation du manager 
SensorManager m_SensorMgr = (SensorManager) m_Context.getSystemService(Context.SENSOR_SERVICE); 
  
List<Sensor> listSensor = m_SensorMgr.getSensorList(Sensor.TYPE_ALL); 
for(Sensor sen : listSensor) { 
	Log.d("Sensor", sen.getName()); 
}

Sensor m_AcceloSensor = m_SensorMgr.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
private void doTakePhotoAction() { 
	// http://2009.hfoss.org/Tutorial:Camera_and_Gallery_Demo 
	// http://stackoverflow.com/questions/1050297/how-to-get-the-url-of-the-captured-image 
	// http://www.damonkohler.com/2009/02/android-recipes.html 
	// http://www.firstclown.us/tag/android/ 
	// The one I used to get everything working: http://groups.google.com/group/android-developers/msg/2ab62c12ee99ba30 
  
	Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); 
  
	//Wysie_Soh: Create path for temp file 
	File fTmp = new File(Environment.getExternalStorageDirectory(),"tmp_contact_" + String.valueOf(System.currentTimeMillis()) + ".jpg") 
	mImageCaptureUri = Uri.fromFile(fTmp); 
  
	intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, mImageCaptureUri); 
  
	try { 
		intent.putExtra("return-data", true); 
		startActivityForResult(intent, PICK_FROM_CAMERA); 
	} catch (ActivityNotFoundException e) { 
		Log.e("doTakePhotoAction", e); 
	} 
} 
  
protected void onActivityResult(int requestCode, int resultCode, Intent data) { 
	if (resultCode != RESULT_OK) { 
	    return; 
	} 
  
	switch (requestCode) { 
  
		case CROP_FROM_CAMERA: { 
			//Wysie_Soh: After a picture is taken, it will go to PICK_FROM_CAMERA, which will then come here 
			//after the image is cropped. 
  
			final Bundle extras = data.getExtras(); 
  
			if (extras != null) { 
				Bitmap photo = extras.getParcelable("data"); 
  
				mPhoto = photo; 
				mPhotoChanged = true; 
				mPhotoImageView.setImageBitmap(photo); 
				setPhotoPresent(true); 
			} 
  
			//Wysie_Soh: Delete the temporary file 
			File f = new File(mImageCaptureUri.getPath()); 
			if (f.exists()) { 
				f.delete(); 
			} 
  
			InputMethodManager mgr = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); 
			mgr.showSoftInput(mPhotoImageView, InputMethodManager.SHOW_IMPLICIT); 
  
			break; 
		} 
  
		case PICK_FROM_CAMERA: { 
			//Wysie_Soh: After an image is taken and saved to the location of mImageCaptureUri, come here 
			//and load the crop editor, with the necessary parameters (96x96, 1:1 ratio) 
  
			Intent intent = new Intent ("com.android.camera.action.CROP"); 
			intent.setClassName("com.android.camera", "com.android.camera.CropImage"); 
  
			intent.setData(mImageCaptureUri); 
			intent.putExtra("outputX", 96); 
			intent.putExtra("outputY", 96); 
			intent.putExtra("aspectX", 1); 
			intent.putExtra("aspectY", 1); 
			intent.putExtra("scale", true); 
			intent.putExtra("return-data", true); 
			startActivityForResult(intent, CROP_FROM_CAMERA); 
  
			break; 
		} 
	} 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class CustomCameraView extends SurfaceView implements SurfaceHolder.Callback { 
	SurfaceHolder holder; 
	Camera camera; 
  
	public CustomCameraView(Context context) { 
		super(context); 
		setId(ID_CAMERA_VIEW); 
		holder = this.getHolder(); 
		holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS); 
		holder.addCallback(this); 
	} 
  
	@Override 
	public void surfaceCreated(SurfaceHolder holder) { 
		camera = Camera.open(); 
		try { 
		    camera.setPreviewDisplay(holder); 
		} catch (Exception e) { 
		    e.printStackTrace(); 
		} 
	} 
  
	@Override 
	public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { 
		Parameters params = camera.getParameters(); 
  
		camera.setParameters(params); 
		camera.startPreview(); 
	} 
  
	@Override 
	public void surfaceDestroyed(SurfaceHolder holder) { 
		camera.stopPreview(); 
		camera.release(); 
	} 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//gps system 
LocationManager locationManager = (LocationManager)context.getSystemService(Context.LOCATION_SERVICE); 
LocationListener gpsListener = new LocationListener() { 
	@Override 
	public void onLocationChanged(Location location) { 
	    //TODO : faire quelques choses avec les nouvelles coordonnées 
	} 
  
	@Override 
	public void onProviderDisabled(String arg0) { 
	} 
  
	@Override 
	public void onProviderEnabled(String arg0) { 
	} 
  
	@Override 
	public void onStatusChanged(String arg0, int arg1, Bundle arg2) { 
	} 
}; 
  
Criteria criteria = new Criteria(); 
criteria.setAccuracy(Criteria.ACCURACY_FINE); 
criteria.setAltitudeRequired(false); 
criteria.setBearingRequired(false); 
criteria.setCostAllowed(true); 
criteria.setPowerRequirement(Criteria.POWER_MEDIUM); 
  
locationManager.requestLocationUpdates(locationManager.getBestProvider(criteria, true), 100, 1, gpsListener);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//orientation sensor 
SensorEventListener sensorListener = new SensorEventListener(){ 
	@Override 
	public void onSensorChanged(SensorEvent evt) {                 
		float values[] = evt.values;               
		if(evt.sensor.getType() == Sensor.TYPE_ORIENTATION) { 
			int azimuth = int) values[0]; 
			int pitch = (int) values[1]; 
			int roll = (int) values[2]; 
			//TODO : faire quelques choses avec ces valeurs 
		} 
	} 
  
	@Override 
	public void onAccuracyChanged(Sensor sensor, int accuracy){                 
	} 
};    
  
SensorManager sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);        
sensorManager.registerListener(sensorListener,sensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION),SensorManager.SENSOR_DELAY_FASTEST);

1
2
3
4
5
6
7
MonListener acceleroListener = new MonListener(); 
// Initialisation de l'accéléromètre 
boolean accelSupported = m_SensorMgr.registerListener(this, m_AcceloSensor, SENSOR_DELAY_GAME); 
if (! accelSupported) { 
	Log.e(TAG, "Accelerometre inactif"); 
	m_SensorMgr.unregisterListener(this, m_AcceloSensor); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class MonListener implements SensorEventListener { 
  
	publoc boolean m_SensorOnPause = false; 
	private long m_LastSensorUpdate = -1; 
  
	public MonListener() { 
	} 
  
	@Override 
	public void onAccuracyChanged(Sensor sensor, int accuracy) {} 
  
	@Override 
	public void onSensorChanged(SensorEvent event) { 
		if (m_SensorOnPause) { 
			return ; 
		} 
  
		float dirX; 
		float dirY; 
  
		if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) { 
			long curTime = System.currentTimeMillis(); 
			// On autorise uniquement les mises à jour toutes les 50 ms, sinon c'est trop rapide 
			if (m_LastSensorUpdate == -1 || (curTime - m_LastSensorUpdate) > 30) { 
				m_LastSensorUpdate = curTime; 
				dirX = event.values[DATA_X]; 
				dirY = event.values[DATA_Y]; 
  
				//TODO : faire quelque chose avec les données... 
				//.... 
			} 
		} 
	} 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
private MediaRecorder recorder; 
  
public void StartRecording() { 
	Log.d("StartRecording", "On lance l'enregistrement"); 
	recorder = new MediaRecorder(); 
	recorder.setAudioSource(MediaRecorder.AudioSource.MIC); 
	recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP); 
  
	recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB); 
	recorder.setOutputFile(path_file); 
	try { 
		recorder.prepare(); 
	} catch (IllegalStateException e) { 
		Log.e("StartRecording", "IllegalStateException " + e.getMessage()); 
		e.printStackTrace(); 
	} catch (IOException e) { 
		Log.e("StartRecording", "IOException " + e.getMessage()); 
		e.printStackTrace(); 
	} 
	recorder.start();   // Recording is now started 
} 
  
public void StopRecording() { 
	Log.e("StopRecording", "On stop l'enregistrement"); 
	recorder.stop(); 
	recorder.reset();   // You can reuse the object by going back to setAudioSource() step 
	recorder.release(); // Now the object cannot be reused 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
private CameraDevice device = null; 
private int width = 320; 
private int height = 240; 
  
public boolean open() { 
  
	if (device != null) return true; 
  
	device = CameraDevice.open(); 
  
	if (device == null) return false; 
  
	//parameters for the device mostly as specified in sample app 
	CameraDevice.CaptureParams param = new CameraDevice.CaptureParams(); 
	param.type = 1; // preview 
	param.srcWidth = 1280; 
	param.srcHeight = 960; 
	param.leftPixel = 0; 
	param.topPixel = 0; 
	param.outputWidth = width; 
	param.outputHeight = height; 
	param.dataFormat = 2; // RGB_565 
  
	//attempt to configure the device here 
	if (!device.setCaptureParams(param)) { 
		device.close(); 
		device = null; 
		return false; 
	} 
  
	return true; 
} 
  
public void close() { 
	if (device == null) return; 
	device.close(); 
	device = null; 
} 
  
public boolean capture(Canvas canvas) { 
	if (device == null) { 
	    return false; 
	} 
	return device.capture(canvas); 
}