本来想针对Activity中的启动模式写篇文章的，后来网上发现有人已经总结的相当好了，在此直接引用过来，并加上自己的一些理解，在此感谢原作者。

文章地址：

http://blog.csdn.net/liuhe688/article/details/6754323

————————————————————————————————-

launchMode在多个Activity跳转的过程中扮演着重要的角色，它可 以决定是否生成新的Activity实例，是否重用已存在的Activity实例，是否和其他Activity实例公用一个task里。这里简单介绍一下 task的概念，task是一个具有栈结构的对象，一个task可以管理多个Activity，启动一个应用，也就创建一个与之对应的task。

Activity一共有以下四种launchMode：

1.standard

2.singleTop

3.singleTask

4.singleInstance

我们可以在AndroidManifest.xml配置<activity>的Android:launchMode属性为以上四种之一即可。

下面我们结合实例一一介绍这四种lanchMode：

1.standard

standard模式是默认的启动模式，不用为<activity>配置android:launchMode属性即可，当然也可以指定值为standard。

我们将会一个Activity，命名为FirstActivity，来演示一下标准的启动模式。FirstActivity代码如下：

 1 package com.scott.launchmode;
 2 
 3 import android.app.Activity;
 4 import android.content.Intent;
 5 import android.os.Bundle;
 6 import android.view.View;
 7 import android.widget.Button;
 8 import android.widget.TextView;
 9 
10 public class FirstActivity extends Activity {
11     @Override
12     public void onCreate(Bundle savedInstanceState) {
13         super.onCreate(savedInstanceState);
14         setContentView(R.layout.first);
15         TextView textView = (TextView) findViewById(R.id.textView);
16         textView.setText(this.toString());
17         Button button = (Button) findViewById(R.id.button);
18         button.setOnClickListener(new View.OnClickListener() {
19             @Override
20             public void onClick(View v) {
21                 Intent intent = new Intent(FirstActivity.this, FirstActivity.class);
22                 startActivity(intent);
23             }
24         });
25     }
26 }

我们FirstActivity界面中的TextView用于显示当前Activity实例的序列号，Button用于跳转到下一个FirstActivity界面。

然后我们连续点击几次按钮，将会出现下面的现象：

我们注意到都是FirstActivity的实例，但序列号不同，并且我们需要连续按后退键两次，才能回到第一个FristActivity。standard模式的原理如下图所示：

如图所示，每次跳转系统都会在task中生成一个新的FirstActivity实例，并且放于栈结构的顶部，当我们按下后退键时，才能看到原来的FirstActivity实例。

这就是standard启动模式，不管有没有已存在的实例，都生成新的实例。

简单点理解：standard启动模式Activity栈从栈底到栈顶顺序为A1 -> B -> C -> A2…。（其中A、B、C等都表示不同的Activity实例，A1、A2则表示属于具有同一Activity类的不同实例）

2.singleTop

我们在上面的基础上为<activity>指定属性android:launchMode=”singleTop”，系统就会按照singleTop启动模式处理跳转行为。我们重复上面几个动作，将会出现下面的现象：

我们看到这个结果跟standard有所不同，三个序列号是相同的，也就是说使用的都是同一个FirstActivity实例；如果按一下后退键，程序立即退出，说明当前栈结构中只有一个Activity实例。singleTop模式的原理如下图所示：

正如上图所示，跳转时系统会先在栈结构中寻找是否有一个FirstActivity实例正位于栈顶，如果有则不再生成新的，而是直接使用。也许朋友们会有疑问，我只看到栈内只有一个Activity，如果是多个Activity怎么办，如果不是在栈顶会如何？我们接下来再通过一个示例来证实一下大家的疑问。

我们再新建一个Activity命名为SecondActivity，如下：

 1 package com.scott.launchmode;
 2 
 3 import android.app.Activity;
 4 import android.content.Intent;
 5 import android.os.Bundle;
 6 import android.view.View;
 7 import android.widget.Button;
 8 import android.widget.TextView;
 9 
10 public class SecondActivity extends Activity {
11     @Override
12     protected void onCreate(Bundle savedInstanceState) {
13         super.onCreate(savedInstanceState);
14         setContentView(R.layout.second);
15         TextView textView = (TextView) findViewById(R.id.textView);
16         textView.setText(this.toString());
17         Button button = (Button) findViewById(R.id.button);
18         button.setOnClickListener(new View.OnClickListener() {
19             @Override
20             public void onClick(View v) {
21                 Intent intent = new Intent(SecondActivity.this, FirstActivity.class);
22                 startActivity(intent);                
23             }
24         });
25     }
26 }

然后将之前的FirstActivity跳转代码改为：

1 Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
2 startActivity(intent);

是的，FirstActivity会跳转到SecondActivity，SecondActivity又会跳转到FirstActivity。演示结果如下：

我们看到，两个FirstActivity的序列号是不同的，证明从SecondActivity跳转到FirstActivity时生成了新的FirstActivity实例。原理图如下：

我们看到，当从SecondActivity跳转到FirstActivity时，系统发现存在有FirstActivity实例,但不是位于栈顶，于是重新生成一个实例。

这就是singleTop启动模式，如果发现有对应的Activity实例正位于栈顶，则重复利用，不再生成新的实例。

简单点理解，singleTop即表示当前Activity栈中“栈顶唯一”，Activity跳转顺序或standard模式下栈结构如果为：A -> B -> C -> D1 -> D2，则singleTop启动模式为：A -> B -> C -> D1(此时回调D1的onNewIntent()..)。

3.singleTask

在上面的基础上我们修改FirstActivity的属性android:launchMode=”singleTask”。演示的结果如下：

我们注意到，在上面的过程中，FirstActivity的序列号是不变 的，SecondActivity的序列号却不是唯一的，说明从SecondActivity跳转到FirstActivity时，没有生成新的实例，但 是从FirstActivity跳转到SecondActivity时生成了新的实例。singleTask模式的原理图如下图所示：

在图中的下半部分是SecondActivity跳转到 FirstActivity后的栈结构变化的结果，我们注意到，SecondActivity消失了，没错，在这个跳转过程中系统发现有存在的 FirstActivity实例，于是不再生成新的实例，而是将FirstActivity之上的Activity实例统统出栈，将 FirstActivity变为栈顶对象，显示到幕前。也许朋友们有疑问，如果将SecondActivity也设置为singleTask模式，那么 SecondActivity实例是不是可以唯一呢？在我们这个示例中是不可能的，因为每次从SecondActivity跳转到 FirstActivity时，SecondActivity实例都被迫出栈，下次等FirstActivity跳转到SecondActivity时， 找不到存在的SecondActivity实例，于是必须生成新的实例。但是如果我们有ThirdActivity，让SecondActivity和 ThirdActivity互相跳转，那么SecondActivity实例就可以保证唯一。

这就是singleTask模式，如果发现所在Activity栈中有对应的Activity实例，则使此Activity实例之上的其他Activity实例统统出栈，使此Activity实例成为栈顶对象，显示到幕前。

简单点理解，singleTask表示当前Activity栈中“实例唯一”，Activity跳转顺序或standard模式下栈结构如果为：A -> B1 -> C -> D -> B2，则singleTask启动模式为：A -> B1(此时回调onNewIntent()..)

4.singleInstance

这种启动模式比较特殊，因为它会启用一个新的栈结构，将Acitvity放置于这个新的栈结构中，并保证不再有其他Activity实例进入。

我们修改FirstActivity的 launchMode=”standard”，SecondActivity的launchMode=”singleInstance”，由于涉及到了多 个栈结构，我们需要在每个Activity中显示当前栈结构的id，所以我们为每个Activity添加如下代码：

1 TextView taskIdView = (TextView) findViewById(R.id.taskIdView);
2 taskIdView.setText("current task id: " + this.getTaskId());

然后我们再演示一下这个流程：

我们发现这两个Activity实例分别被放置在不同的栈结构中，关于singleInstance的原理图如下：

我们看到从FirstActivity跳转到SecondActivity时，重 新启用了一个新的栈结构，来放置SecondActivity实例，然后按下后退键，再次回到原始栈结构；图中下半部分显示的在 SecondActivity中再次跳转到FirstActivity，这个时候系统会在原始栈结构中生成一个FirstActivity实例，然后回退 两次，注意，并没有退出，而是回到了SecondActivity，为什么呢？是因为从SecondActivity跳转到FirstActivity的时候，我们的起点变成了SecondActivity实例所在的栈结构，这样一来，我们需要“回归”到这个栈结构。

此 处的解释不是很赞同，第一次按Back键首先是在当前Activity栈中将栈顶元素出栈，然后显示当前Activity栈中下一个Activity栈， 这个没什么解释的，然后按下Back键，不是回到手机桌面，而是回到另一个Activity栈中的SecondActivityInstance，我认为 原因在于在于“最近栈”，只要此栈位于上次Home操作之后，就会先显示它。

如果我们修改FirstActivity的launchMode值为singleTop、singleTask、singleInstance中的任意一个，流程将会如图所示：

singleInstance启动模式可能是最复杂的一种模式，为了帮助大家理 解，我举一个例子，假如我们有一个share应用，其中的ShareActivity是入口Activity，也是可供其他应用调用的Activity， 我们把这个Activity的启动模式设置为singleInstance，然后在其他应用中调用。我们编辑ShareActivity的配置：

<activity android:name=".ShareActivity" android:launchMode="singleInstance">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
    <intent-filter>
        <action android:name="android.intent.action.SINGLE_INSTANCE_SHARE" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

然后我们在其他应用中这样启动该Activity：

1 Intent intent = new Intent("android.intent.action.SINGLE_INSTANCE_SHARE");
2 startActivity(intent);

当我们打开 ShareActivity后再按后退键回到原来界面时，ShareActivity做为一个独立的个体存在，如果这时我们打开share应用，无需创建 新的ShareActivity实例即可看到结果，因为系统会自动查找，存在则直接利用。大家可以在ShareActivity中打印一下taskId， 看看效果。关于这个过程，原理图如下：

原作者此处的解释可能有点让人误解。当我们打开ShareActivity后再按后退键回到原来界面时，ShareActivity做为一个独立的个体存在，此 处不应该是按Back键，而是Home键，因为一旦按下了Back键，ShrareActivityInstance自然就销毁了，也就不存在所谓的“无 须重新创建了”。按下Home键后，接下来打开app MainActivity，在另一个Activity栈中app MainActivity入栈，此时startActivity到ShareActivity，无需创建新的ShareActivity实例即可看到结 果，因为系统会自动查找，存在则直接利用。此时第一次按下Back，ShareActivity Instance出栈，此时这个栈中没有其他Activity了，自然是回到了app MainActivity所在的栈并显示app MainActivity，接下来按Back键，此时app MainActivity所在的栈也没有其他Activity了，同时又不包含任何其他的“最近栈”，自然是回到了手机桌面。注：此处理解的“最近栈”是 以Home键或桌面状态为间隔区分。

简 单点理解，singleInstance所标识的Activity，当被启动时，系统会首先判断系统其他栈中是否已经存在此Activity实例，有则直 接使用，并且其所在的Activity栈理论上只有它一个Activity元素。所以启动它的Activity与它并不在一个task中，所以才需要特别 注意Back的问题。一般表示为：task1 A -> task2 B。

singleInstance表示该Activity在系统范围内“实例唯一”。由此我们发现，singInstance和singleTask主要区别在与系统范围内的“实例唯一”还是当前Activity栈“实例唯一”。

来源： [转载]Applying Low Pass Filter to Android Sensor’s Readings | raw engineering

This is a continuation of the AugmentedRealityView project which was released previously on GitHub. You can find the code referenced in this project there, as well.

Overview of Android Sensors

The Android sensor framework lets you access many types of sensors. Two very basic types are:

1. Hardware Sensors.
2. Software Sensors.

Hardware sensors are physical components built into a handset or tablet device. They derive their data by directly measuring specific environmental properties, such as acceleration, geomagnetic field strength, or angular change.

For example: Sensor.TYPE_ACCELEROMETER", Sensor.TYPE_MAGNETIC_FIELD

Software sensors are not physical devices, although they mimic hardware-based sensors. Software-based sensors derive their data from one or more of the hardware-based sensors and are sometimes called virtual sensors or synthetic sensors.

For example: Sensor.TYPE_ORIENTATION, Sensor.TYPE_ROTATION_VECTOR

Best Practices for Accessing and Using Sensors

1. Unregister sensor listeners.
2. Don’t test your code on the emulator.
3. Don’t block the onSensorChanged() method.
4. Avoid using deprecated methods or sensor types.
5. Verify sensors before you use them.
6. Choose sensor delays carefully.
7. Filter the values received in onSensorChanged(). Allow only those that are needed.

After we register the Sensors, the sensor readings get notified in SensorEventListener‘s onSensorChanged() method. However, the rate of change in sensor values is so high that if we map these small changes a.k.a ‘Noise’ the values jump within a large range of values.

We can also specify the SensorManager‘s delay properties from one of these:

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

This, however, is only a peek into the system. Events may be received faster or slower than the specified rate, but usually events are received faster.

Moral of the story is:

Allow only those values which are useful and discard the unnecessary noise.

The solution for this is to apply a Low-Pass Filter on these values.

A Small Glimpse of Low Pass Filter

A low-pass filter passes low-frequency signals/values and attenuates (reduces the amplitude of) signals/values with frequencies higher than the cutoff frequency.

Take an example of simple signal with values ranging from 0 to 1.
Due to an external source (environmental factors such as jerks or vibrations), a considerable amount of noise is added to these signals. These high frequency signals (noise) cause the readings to hop between considerable high and low values.

Programmatically Apply Low Pass Filter

A device’s sensor readings contribute noise data due to high sensitivity of its hardware to various factors. For gaming purposes, these highly sensitive values are a boon, but for application hat need smooth readings, these hopping values are a mess.

Lets look at AugmentedRealityView on GitHub, where we have to point markers on Camera SurfaceView.

The high sensitivity causes the markers to change positions randomly due to noise.
A Low-Pass Filter concept comes to rescue, because we can omit those high frequencies in the input signal, applying a suitable threshold to the filter output reading to plot the markers.

With this implementation the markers won’t hop randomly because we have removed the unwanted high reading values.

Here is the algorithm implementation:

for i from 1 to n  
y[i] := y[i-1] + α * (x[i] - y[i-1])

Here, α is the cut-off/threshold.

Lets implement it in Android:

lowPass(float[] input, float[] output)

The above method filters the input values and applies LPF and outputs the filtered signals. static final float ALPHA = 0.25f; // if ALPHA = 1 OR 0, no filter applies.

protected float[] lowPass( float[] input, float[] output ) {
    if ( output == null ) return input;     
    for ( int i=0; i<input.length; i++ ) {
        output[i] = output[i] + ALPHA * (input[i] - output[i]);
    }
    return output;
}

Low-Pass Filter is finally applied to sensor values in onSensorChanged(SensorEvent event) as follows:

<pre><code class="java"><span class="annotation">@Override</span>
<span class="keyword">public</span> <span class="keyword">void</span> onSensorChanged(SensorEvent evt) {
    <span class="keyword">if</span> (evt.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
        gravSensorVals = lowPass(evt.values.clone(), gravSensorVals);
    } <span class="keyword">else</span> <span class="keyword">if</span> (evt.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
        magSensorVals = lowPass(evt.values.clone(), magSensorVals);
    }
    <span class="keyword">if</span> (gravSensorVals != <span class="keyword">null</span> &amp;&amp; magSensorVals != <span class="keyword">null</span>) {
        SensorManager.getRotationMatrix(RTmp, I, gravSensorVals, magSensorVals);
        <span class="keyword">int</span> rotation = Compatibility.getRotation(<span class="keyword">this</span>);
        <span class="keyword">if</span> (rotation == <span class="number">1</span>) {
            SensorManager.remapCoordinateSystem(RTmp, SensorManager.AXIS_X, SensorManager.AXIS_MINUS_Z, Rot);
        } <span class="keyword">else</span> {
            SensorManager.remapCoordinateSystem(RTmp, SensorManager.AXIS_Y, SensorManager.AXIS_MINUS_Z, Rot);
        }
        SensorManager.getOrientation(Rot, results);
        UIARView.azimuth = (<span class="keyword">float</span>)(((results[<span class="number">0</span>]*<span class="number">180</span>)/Math.PI)+<span class="number">180</span>);
        UIARView.pitch = (<span class="keyword">float</span>)(((results[<span class="number">1</span>]*<span class="number">180</span>/Math.PI))+<span class="number">90</span>);
        UIARView.roll = (<span class="keyword">float</span>)(((results[<span class="number">2</span>]*<span class="number">180</span>/Math.PI)));
        radarMarkerView.postInvalidate();
    }
}

来源： [转载]Android 自定义camera – peterZ.D – 博客园

根据官方教程，翻译而来。

创建一个Camera App：

& 一般步骤

• 检查并访问Camera  —— 写代码检查是否存在cameras并请求使用
• 创建一个Preview类 —— 创建一个preview类，继承自SurfaceView 并实现SurfaceHolder 接口。这个类是用来预览在拍照时的影像
• 创建一个Preview布局 —— 接下去创建一个跟Preview类对应的布局文件，里面可以放一些你想要的交互控件
• 为Capture(拍照)设置监听(Listener) —— 为你的交互控件设置监听，比如按下一个Button
• 拍照并保存文件 —— 为拍照或录像写代码，并保存到输出流(output)
• 释放Camera —— 在使用完后，必须要合理地释放，以供其他应用使用。

注意：要及时地释放Camera资源，通过调用Camera.release() 来实现。否则其他应用，包括你自己的应用，如果想要使用Camera，都会被关闭。

* 检查(detecting)并访问(access)Camera：

如果应用没有在Manifest文件里声明要使用Camera硬件，那就应该在runtime时检查Camera是否可用。通过PackageManager.hasSystemFeature()检查。整体代码如下：

/** Check if this device has a camera */
private boolean checkCameraHardware(Context context) {
if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA)){
// this device has a camera
return true;
} else {
// no camera on this device
return false;
}
}

可能会有多个摄像头，在API9之后，可以通过Camera.getNumberOfCameras()得到有几个可用的摄像头。

* 访问Cameras：

确定有设备之后，要通过得到一个Camera实例来访问它。(除非使用intent 来访问Camera)，通过Camera.open()方法，可以得到主摄像头。代码如下：

/** A safe way to get an instance of the Camera object. */
public static Camera getCameraInstance(){
Camera c = null;
try {
c = Camera.open(); // attempt to get a Camera instance
}
catch (Exception e){
// Camera is not available (in use or does not exist)
}
return c; // returns null if camera is unavailable
}

注意：要用try/catch Camera.open()这个方法，防止其他应用在使用Camera，而导致本应用被系统关闭。在API Level 9以上，可以通过Camera.open(int)来打开特定的摄像头。

* 检查Camera特征

可以通过Camera.getParameters()方法来得到更多的关于它的功能。在API Level 9及以上版本中，使用Camera.getCameraInfo()来确定这个摄像头是前面的还是后面的，以及这个图像的朝向(orientation)。

* 创建一个预览类(preview class)

下面的代码演示了如何创建一个基本的可以包含在一个View 布局里的预览图，这个类实现了SurfaceHolder.Callback接口，来捕获创建/删除这个view的回调事件，这些事件是被安排Camera预览所需要的。

/** A basic Camera preview class */
public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {
private SurfaceHolder mHolder;
private Camera mCamera;

public CameraPreview(Context context, Camera camera) {
super(context);
mCamera = camera;

// 把这个监听添加进去，这样可以监听到创建和销毁的事件了
mHolder = getHolder();
mHolder.addCallback(this);
// deprecated setting, but required on Android versions prior to 3.0
mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
}

public void surfaceCreated(SurfaceHolder holder) {
// The Surface has been created, now tell the camera where to draw the preview.
try {
mCamera.setPreviewDisplay(holder);
mCamera.startPreview();
} catch (IOException e) {
Log.d(TAG, "Error setting camera preview: " + e.getMessage());
}
}

public void surfaceDestroyed(SurfaceHolder holder) {
// empty. Take care of releasing the Camera preview in your activity.
}

public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
// If your preview can change or rotate, take care of those events here.
// Make sure to stop the preview before resizing or reformatting it.

if (mHolder.getSurface() == null){
// preview surface does not exist
return;
}

// stop preview before making changes
try {
mCamera.stopPreview();
} catch (Exception e){
// ignore: tried to stop a non-existent preview
}

// set preview size and make any resize, rotate or
// reformatting changes here

// start preview with new settings
try {
mCamera.setPreviewDisplay(mHolder);
mCamera.startPreview();

} catch (Exception e){
Log.d(TAG, "Error starting camera preview: " + e.getMessage());
}
}
}

如果自己想指定大小，在surfaceChanged()方法里可以写。设置之前，必须使用从getSupportedPreviewSizes()得到的值，不要在setPreviewSize()里使用合意值。注：supportedPreviewSize()是在camera.getParameters()后再得到的。

* 把预览图放在一个布局里

一个Preview类，要放在一个布局里，这个布局还要包括其他用来控制拍照等行为的交互界面。这部分展示如何为预览图构建一个布局以及 Activity。在这个例子里，FrameLayout元素用来包含预览图。使用这种布局，可以把多余的信息或控制覆盖到活动的Camera预览图上。

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<FrameLayout
android:id="@+id/camera_preview"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:layout_weight="1"
/>

<Button
android:id="@+id/button_capture"
android:text="Capture"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
/>
</LinearLayout>

在多数的设备上，默认的朝向是横向的。这个例子的布局指定一个水平的布局，下面的代码固定应用的朝向是横向的。在Manifest里如下指定，就可以简单地让应用保持横向。

<activity android:name=".CameraActivity"
android:label="@string/app_name"

android:screenOrientation="landscape">
<!-- configure this activity to use landscape orientation -->

<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>

note:Preview没有必要一定是Landscape(横向)模式。从API Level 8开始，可以使用setDiaplayOrientation()方法来设置预览图的旋转。如果要改变朝向，在surfaceChanged()方法里， 先用Camera.stopPreview()方法stop这个Preview，改变朝向，然后再用Camera.startPreview()来开始 Preview。

在你的CameraActivity中，把Preview类加入到这个Framelayout中。你的CameraActivity必须要保证在停止或关闭时释放这个camera。下面代码说明一切。

public class CameraActivity extends Activity {

private Camera mCamera;
private CameraPreview mPreview;

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

// Create an instance of Camera
mCamera = getCameraInstance();

// Create our Preview view and set it as the content of our activity.
mPreview = new CameraPreview(this, mCamera);
FrameLayout preview = (FrameLayout) findViewById(R.id.camera_preview);
preview.addView(mPreview);
}
}

* 拍照

一旦设置好Preview，就可以使用它去拍照了。在应用代码里，必须要为你的交互界面设置拍照的响应。

为了得到图，要使用Camera.takePicture()方法。这个方法带了三个参数，用来接收来自Camera的数据。为了接收JPEG 格式的数据，必须要实现Camera.PictureCallback接口，来接收图像数据，并写入到一个文件。下例展示了一个基本的实现，用来保存来自 Camera的图片。

private PictureCallback mPicture = new PictureCallback() {

@Override
public void onPictureTaken(byte[] data, Camera camera) {

File pictureFile = getOutputMediaFile(MEDIA_TYPE_IMAGE);
if (pictureFile == null){
Log.d(TAG, "Error creating media file, check storage permissions: " +
e.getMessage());
return;
}

try {
FileOutputStream fos = new FileOutputStream(pictureFile);
fos.write(data);
fos.close();
} catch (FileNotFoundException e) {
Log.d(TAG, "File not found: " + e.getMessage());
} catch (IOException e) {
Log.d(TAG, "Error accessing file: " + e.getMessage());
}
}
};

“getOutputMediaFile(MEDIA_TYPE_IMAGE)”这个方法及这个常量会在之后“保存文件”一节中说到

调用Camera.takePicture()方法来触发拍照事件。

// Add a listener to the Capture button
Button captureButton = (Button) findViewById(id.button_capture);
captureButton.setOnClickListener(
new View.OnClickListener() {
@Override
public void onClick(View v) {
// get an image from the camera
mCamera.takePicture(null, null, mPicture);
}
}
);

* 释放Camera

当停止使用Camera时要及时把它释放掉。在Activity.onPause()方法中也要释放。通过Camera.release()方法来释放。代码如下：

public class CameraActivity extends Activity {
private Camera mCamera;
private SurfaceView mPreview;
private MediaRecorder mMediaRecorder;

...

@Override
protected void onPause() {
super.onPause();
releaseMediaRecorder();       // if you are using MediaRecorder, release it first
releaseCamera();              // release the camera immediately on pause event
}

private void releaseMediaRecorder(){
if (mMediaRecorder != null) {
mMediaRecorder.reset();   // clear recorder configuration
mMediaRecorder.release(); // release the recorder object
mMediaRecorder = null;
mCamera.lock();           // lock camera for later use
}
}

private void releaseCamera(){
if (mCamera != null){
mCamera.release();        // release the camera for other applications
mCamera = null;
}
}
}

* 保存文件

Media文件应该被保存到设备的外部存储目录(SD Card)，以此来节约系统空间。有很多可以存放文件的地方，但作为开发者，有两个标准的目录可以使用：

• Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES) 这 个方法返回一个标准的，分享的，并被推荐的目录，用来存放图片和Video。如果被用户卸载了，文件也会存在。为了防止与用户已存在的文件冲突，你应该再 创建一个子目录用来存放自己应用的图片。如下面的例子。这个方法在API Level 8以上可以使用，更早的设备，可以查看其他方法。
• Context.getExternalFilesDir(Environment.DIRECTORY_PICTURES) ，这个方法返回一个标准的用来存放你的应用的图片和Video的地方。如果应用被卸载，这里的文件也会被卸载。其他应用也可以操作这里的文件。

如下代码展示了如何创建一个File或者一个Uri，用来保存文件。适用于通过Intent或者自己构建的应用。

public static final int MEDIA_TYPE_IMAGE = 1;
public static final int MEDIA_TYPE_VIDEO = 2;

/** Create a file Uri for saving an image or video */
private static Uri getOutputMediaFileUri(int type){
return Uri.fromFile(getOutputMediaFile(type));
}

/** Create a File for saving an image or video */
private static File getOutputMediaFile(int type){
// To be safe, you should check that the SDCard is mounted
// using Environment.getExternalStorageState() before doing this.

File mediaStorageDir = new File(Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_PICTURES), "MyCameraApp");
// This location works best if you want the created images to be shared
// between applications and persist after your app has been uninstalled.

// Create the storage directory if it does not exist
if (! mediaStorageDir.exists()){
if (! mediaStorageDir.mkdirs()){
Log.d("MyCameraApp", "failed to create directory");
return null;
}
}

// Create a media file name
String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
File mediaFile;
if (type == MEDIA_TYPE_IMAGE){
mediaFile = new File(mediaStorageDir.getPath() + File.separator +
"IMG_"+ timeStamp + ".jpg");
} else if(type == MEDIA_TYPE_VIDEO) {
mediaFile = new File(mediaStorageDir.getPath() + File.separator +
"VID_"+ timeStamp + ".mp4");
} else {
return null;
}

return mediaFile;
}

* Camera Features

可以设置很多的特性，比如图片格式，闪光模式，焦点，还有其他。本节列出几个常用的特性，简单介绍如何使用它们。很多的特性可以通过访问Camera.Parameters对象来得到。但还是有一些重要的特性需要更多的设置。概括为以下几个部分：

• 计量和焦点区域
• 面部识别
• 定时摄影

关于如何使用这些由Camera.Parameters对象控制的特性，可以查看”使用Camera特性”一节。从API Level1到14,有很多的特性，便并不是所有的都可以被设备使用，使用前要先检查一下。

& 检测特性是否可用

要明确使用哪些特性，以及是哪个版本的，之后可以在代码里检查设备硬件是否支持这个特性，如果不行的话，要合理地处理。

可以通过得到一个Camera Parameters对象还检查特性是否可用，以及相应的方法。下例演示如何得到一个Camera.Parameters对象，并检查是否支持自动对焦功能：

// get Camera parameters
Camera.Parameters params = mCamera.getParameters();

List<String> focusModes = params.getSupportedFocusModes();
if (focusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
// Autofocus mode is supported
}

有些功能是要在Manifest里进行声明，比如闪光和自动对焦。可以在Manifest里的“Features Reference”中查到。

& 使用特性

从camera中getParameters()；然后进行setXXX()；之后再setParameters()进Camera。

重要：有些参数的设置，可能需要先stop preview，变换preview size ，然后再重启preview。从4.0开始之后就不用再重启preview了。

上文提到的三个部分，需要写一些更多的代码，下面会说到。

& Metering和对焦区域

跟其他的调用方法差不多

& 面部识别

大多数包括人的照片里，脸部很重要，拍照时应该被焦点或者白平衡。4.0提供了API来确定脸部，并利用面部识别来捕捉照片。

注意：当使用面部识别时，setWhiteBalance(String)，setFocusAreas(List)以及setMeteringAreas(List)就没有用了。

使用这个通常需要几个步骤：

• • 检查这个功能是是否被设备支持
  • 创建一个面部监测的监听
  • 把这个监听添加到Camera对象里
  • 在preview之后开始面部监测

面部识别不被所有设备支持，通过调用getMaxNumDetectedFaces()来检查是否可以使用。在下面的startFAceDetection()例子中，展示一个这个检测。

为了能被提醒并且响应面部识别的监测，需要对面部检测加一个监听。创建一个实现了Camera.FaceDetectionListener接口的监听。如下代码所示：

class MyFaceDetectionListener implements Camera.FaceDetectionListener {

@Override
public void onFaceDetection(Face[] faces, Camera camera) {
if (faces.length > 0){
Log.d("FaceDetection", "face detected: "+ faces.length +
" Face 1 Location X: " + faces[0].rect.centerX() +
"Y: " + faces[0].rect.centerY() );
}
}
}

创建完之后，把它加入到Camera对象里。

<pre>mCamera.setFaceDetectionListener(new MyFaceDetectionListener()

应用应该在每次开始(或重启)Camera Preview时开启这个监听方法。创建一个用来开启面部识别的方法，如下所示：

public void startFaceDetection(){
    // Try starting Face Detection
    Camera.Parameters params = mCamera.getParameters();

    // start face detection only *after* preview has started
    if (params.getMaxNumDetectedFaces() > 0){
        // camera supports face detection, so can start it:
        mCamera.startFaceDetection();
    }
}

　　必须在每次打开(或重启)preview时，开启面部监测。把上面这个方法添加到你的Preview类里的surfaceCreated()和surfaceChanged()方法中。如下所示：

public void surfaceCreated(SurfaceHolder holder) {
    try {
        mCamera.setPreviewDisplay(holder);
        mCamera.startPreview();

        startFaceDetection(); // start face detection feature

    } catch (IOException e) {
        Log.d(TAG, "Error setting camera preview: " + e.getMessage());
    }
}

public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {

    if (mHolder.getSurface() == null){
        // preview surface does not exist
        Log.d(TAG, "mHolder.getSurface() == null");
        return;
    }

    try {
        mCamera.stopPreview();

    } catch (Exception e){
        // ignore: tried to stop a non-existent preview
        Log.d(TAG, "Error stopping camera preview: " + e.getMessage());
    }

    try {
        mCamera.setPreviewDisplay(mHolder);
        mCamera.startPreview();

        startFaceDetection(); // re-start face detection feature

    } catch (Exception e){
        // ignore: tried to stop a non-existent preview
        Log.d(TAG, "Error starting camera preview: " + e.getMessage());
    }
}

　注意：记住要在调用startPreview()之后调用这个方法。不要尝试在mainActivity 的onCreate()方法里启动面部识别。

问题描述：

使用eclipse编译程序，在Android手机上运行，报错如下：

Installation error: INSTALL_FAILED_MEDIA_UNAVAILABLE

Please check logcat output for more details.

Launch canceled!

解决方案：

使用adb shell命令让手机自己选择安装在哪里。命令如下：

adb shell

pm setInstallLocation 0
注：不同的setInstallLocation说明：

pm setInstallLocation 0 由App自行决定软件能否安装在SD卡

pm setInstallLocation 1 强制全部App安装在ROM内

pm setInstallLocation 2 强制全部App安装在SD卡

操作步骤：

1、win+R快捷键打开运行窗口（或开始开始菜单，直接在搜索程序或文件框中）直接输入cmd命令

（win7 cmd切换目录不了的可参考win7系统cmd命令切换到指定文件夹目录 ）

2、cd 命令直接更改目录到platform-tools目录，比如我下载的SDK文件存放的目录为：

G:\Feitianxinhong\Android\adt-bundle-windows-x86\sdk\platform-tools

3、输入adb shell命令

4、输入pm setInstallLocation 0 命令

完了以后，再运行程序，测试正常。

测试结果如下图所示：

最近项目需要研究下人脸识别，在领导推荐下准备研究OpenCV

一，上官网了解下 基本知识

http://docs.opencv.org/doc/tutorials/introduction/android_binary_package/android_dev_intro.html#android-dev-intro

到此、如果你已经安装了jdk/ndk/sdk/adt/cdt并且配置了 windows的环境变量Path最后面添加ndk的根目录，请接着看。

验证：cmd命令行收入 ndk-build有明确的提示。

二，下载最新的opencv-Android库http://opencv.org/

三，下载完成如下图

解压到和你的sdk同一个目录：

如：我的sdk目录放在D盘如下图所示。

四，导入opencv的lib项目库

注意：不要导入自己的工作目录、等下使用ndk编译的时候会牵扯到一个路径的问题

五，导入face-detection的代码 File->new Project->other->Android project from Existing code

六，修改jni/Android.mk的路径 ../../sdk/native/jni/OpenCV.mk 为../../../sdk/native/jni/OpenCV.mk

七，编译jni的lib文件

回到eclipse刷新下项目会发现多了一个libs的文件，这里就是上面的ndk-build编译生成的so文件。

八，右键->run Application->Android

手机运行效果如下图：期间会不断的闪烁蓝色的方框进行人脸的捕捉！

ok,至此 人脸识别的demo就运行起来的，下面还需要进一步研究！

其他的人脸识别技术：http://blog.jobbole.com/45936/

树莓派（raspberry）启用root账户

今天玩树莓派，需要安装些东西，老是sudo感觉不方便于是想直接用root。咦···？默认不是空密码？试下密码raspberry。还不对。那是神马？？

论他找了下，原来之前用centos习惯了，错觉，错觉！！

树莓派使用的linux是debian系统，所以树莓派启用root和debian是相同的。

debian里root账户默认没有密码，但账户锁定。

当需要root权限时，由默认账户经由sudo执行，Raspberry pi 系统中的Raspbian

默认用户是pi 密码为raspberry

重新开启root账号，可由pi用户登录后，在命令行下执行

sudo passwd root

执行此命令后系统会提示输入两遍的root密码，输入你想设的密码即可，然后在执行

sudo passwd --unlock root

这样就可以解锁root账户了。

好了，搞定！

hellogv再次发力，献出opencv2.2Android教程 全文照抄如下。 Android-opencv是opencv在android手机上的移植版，而CVCamera是这个移植版的一个sample。本文主要介绍android-opencv的安装和使用。 android-openc

来源： [转载]Android-opencv之CVCamera | 增强视觉 | 计算机视觉 增强现实

hellogv再次发力，献出opencv2.2android教程

全文照抄如下。

android-opencv是opencv在android手机上的移植版，而CVCamera是这个移植版的一个sample。本文主要介绍android-opencv的安装和使用。

• android-opencv的安装

opencv基于C++，因此android-opencv也必须依赖NDK(android-ndk-r4-crystax)来编译。PS:关于android-ndk-r4-crystax和CYGWIN的安装和使用，本文不再唠叨，详见http://blog.csdn.net/hellogv/archive/2010/12/23/6094127.aspx

安装步骤具体如下：

1. svn checkout http://android-opencv.googlecode.com/svn/trunk/， 下载源码
2. 确保在系统Path中包含了D:\cygwin\bin;D:\cygwin\android-ndk-r4-crystax;(存放目录自己决定，Path中必须包含cygwin的bin和android-ndk-r4-crystax的路径)
3. 再拷贝android-ndk-r4-crystax到\cygwin\home\GV\android-ndk-r4-crystax，编译android-opencv时需要，编译成功之后可以删除这份拷贝。
4. 运行cygwin，来到opencv目录下，输入sh build.sh进行编译，编译成功的话会在\opencv\android\libs\生成armeabi和armeabi-v7a两个文件夹，里面都包含libandroid-opencv.so。

PS：编译的时候提示缺少文件的话，从网上搜索下载。

• android-opencv的使用
  1：打开eclipse ，Import Opencv这个工程，工程位于\opencv\android\ 。PS:如果也提示缺少文件，也需要从网上搜索下载
  2：Opencv 这个工程编译通过之后，就可以Export它，选择JAVA的JAR file，导出时去掉[obj]和[libs]这两个文件夹，AndroidManifest.xml和default.properties，输出文件 名为Opencv.jar，Export
  设置如下图
  
  3：下载swigwin-1.3.39,在系统path中加入D:\cygwin\swigwin-1.3.39(存放位置自定),重启
  4：打开cygwin，去到\samples\CVCamera\，输入sh build.sh，开始编译CVCamera的JNI，成功编译之后会生成libcvcamera.so
  5：把 \opencv\android\libs 复制到\samples\CVCamera\，因为CVCamera同时需要libandroid-opencv.so和libcvcamera.so
  6：Import CVCamera这个工程，加入Opencv.jar 这个Libraries
  7：编译CVCamera这个工程，生成CVCamera.apk(有6.06MB大小)