【MediaTek X20开发板试用体验】5.MTX20开发板Android Studio开发APK应用程序预览USB Camera

MTX20开发板的操作系统是Android，所以APK模式的应用程序才是王道，而不是我上一个帖子里那样使用命令行方式来调用应用程序。Android系统开发APK程序有几种方法：1）在Android源代码里面开发APK；2）Eclipse+ADT+Android SDK+NDK开发APK；3）Android Studio+NDK开发APK。第一种方法自己只是尝试过修改一些Android自带App而已。第二种方法好几年前用过，只记得更新一次SDK真的好慢，还看运气。第三种方法是谷歌近来推荐的方式，当然此方法具有谷歌软件的标志“零碎”，测试版，正式版，1.0、2.0、2.2、2.2.2、等等，每个版本又有许多不同，比如我下载的版本2.2.2，与前面的版本相比改动蛮大滴。
不同于Android系统源代码下载的各种不容易，Android Studio下载简单，看了谷歌为了这个软件肯定做了不少功夫。下载地址为：http://www.android-studio.org/index.php/download，我下载的版本：android-studio-bundle-145.3360264-windows.exe。安装也比以前变得简单多了，不需要安装JDK直接安装即可。
Android Studio安装过程比较简单，只要注意安装的路径即可，我这里默认在C盘。

Android Studio初始化过程如下，我选择的安装方式是“Custom",避免默认方式安装过多无用的东西。虚拟机有761M大小，可能对于有真机的情况也用处不大。

Android Studio添加SDK和NDK等必要库文件

在上个帖子C语言访问USB Camera设备的基础上暴露JNI接口给Java调用。
JNI关键函数介绍：
1）Java_com_example_administrator_simplewebcam_MainActivity_prepareCamera函数被用于初始化USB Camera设备。

1. extern "C"
   
2. jint
   
3. Java_com_example_administrator_simplewebcam_MainActivity_prepareCamera( JNIEnv* env,jobject thiz, jint videoid){
   
4. 
   
5.     int ret;
   
6. 
   
7.     if(camerabase<0){
   
8.         camerabase = checkCamerabase();
   
9.     }
   
10. 
    
11.     ret = opendevice(camerabase + videoid);
    
12. 
    
13.     if(ret != ERROR_LOCAL){
    
14.         ret = initdevice();
    
15.     }
    
16.     if(ret != ERROR_LOCAL){
    
17.         ret = startcapturing();
    
18. 
    
19.         if(ret != SUCCESS_LOCAL){
    
20.             stopcapturing();
    
21.             uninitdevice ();
    
22.             closedevice ();
    
23.             LOGE("device resetted");
    
24.         }
    
25. 
    
26.     }
    
27. 
    
28.     if(ret != ERROR_LOCAL){
    
29.         rgb = (int *)malloc(sizeof(int) * (IMG_WIDTH*IMG_HEIGHT));
    
30.         ybuf = (int *)malloc(sizeof(int) * (IMG_WIDTH*IMG_HEIGHT));
    
31.     }
    
32.     return ret;
    
33. }

复制代码

2）Java_com_example_administrator_simplewebcam_MainActivity_pixeltobmp函数用于数据转换，USB Camera设备出来的数据是YUV或者MJPG形式，想要显示在Android的界面上必须转化为BMP或者个RGB格式，这里的实现主要来自网上开源代码simplewebcam，根据实际需要做了一些修改。

1. void
   
2. Java_com_example_administrator_simplewebcam_MainActivity_pixeltobmp( JNIEnv* env,jobject thiz,jobject bitmap){
   
3. 
   
4.     ***oolean bo;
   
5. 
   
6. 
   
7.     AndroidBitmapInfo  info;
   
8.     void*              pixels;
   
9.     int                ret;
   
10.     int i;
    
11.     int *colors;
    
12. 
    
13.     int width=0;
    
14.     int height=0;
    
15. 
    
16.     if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {
    
17.         LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
    
18.         return;
    
19.     }
    
20. 
    
21.     width = info.width;
    
22.     height = info.height;
    
23. 
    
24.     if(!rgb || !ybuf) return;
    
25. 
    
26.     if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
    
27.         LOGE("Bitmap format is not RGBA_8888 !");
    
28.         return;
    
29.     }
    
30. 
    
31.     if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {
    
32.         LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
    
33.     }
    
34. 
    
35.     colors = (int*)pixels;
    
36.     int *lrgb =NULL;
    
37.     lrgb = &rgb[0];
    
38. 
    
39.     for(i=0 ; i
40.         *colors++ = *lrgb++;
    
41.     }
    
42. 
    
43.     AndroidBitmap_unlockPixels(env, bitmap);
    
44. 
    
45. }

复制代码

3）Java_com_example_administrator_simplewebcam_MainActivity_processCamera函数开始预览。

1. void
   
2. Java_com_example_administrator_simplewebcam_MainActivity_processCamera( JNIEnv* env,
   
3.                                                                          jobject thiz){
   
4. 
   
5.     readframeonce();
   
6. }

复制代码

4）Java_com_example_administrator_simplewebcam_MainActivity_stopCamera函数关闭USB Camera设备。

1. void
   
2. Java_com_example_administrator_simplewebcam_MainActivity_stopCamera(JNIEnv* env,jobject thiz){
   
3. 
   
4.     stopcapturing ();
   
5. 
   
6.     uninitdevice ();
   
7. 
   
8.     closedevice ();
   
9. 
   
10.     if(rgb) free(rgb);
    
11.     if(ybuf) free(ybuf);
    
12. 
    
13.     fd = -1;
    
14. 
    
15. }

复制代码

5）因为在代码中使用了AndroidBitmap_getInfo等Bitmap处理函数，所以需要在CMakeLists.txt中添加jnigraphics库支持。

1. # Sets the minimum version of CMake required to build the native
   
2. # library. You should either keep the default value or only pass a
   
3. # value of 3.4.0 or lower.
   
4. 
   
5. cmake_minimum_required(VERSION 3.4.1)
   
6. 
   
7. # Creates and names a library, sets it as either STATIC
   
8. # or SHARED, and provides the relative paths to its source code.
   
9. # You can define multiple libraries, and CMake builds it for you.
   
10. # Gradle automatically packages shared libraries with your APK.
    
11. 
    
12. add_library( # Sets the name of the library.
    
13.              ImageProc
    
14. 
    
15.              # Sets the library as a shared library.
    
16.              SHARED
    
17. 
    
18.              # Provides a relative path to your source file(s).
    
19.              # Associated headers in the same location as their source
    
20.              # file are automatically included.
    
21.              src/main/cpp/native-lib.cpp )
    
22. 
    
23. # Searches for a specified prebuilt library and stores the path as a
    
24. # variable. Because system libraries are included in the search path by
    
25. # default, you only need to specify the name of the public NDK library
    
26. # you want to add. CMake verifies that the library exists before
    
27. # completing its build.
    
28. 
    
29. find_library( # Sets the name of the path variable.
    
30.               log-lib
    
31. 
    
32.               # Specifies the name of the NDK library that
    
33.               # you want CMake to locate.
    
34.               log jnigraphics )
    
35. 
    
36. # Specifies libraries CMake should link to your target library. You
    
37. # can link multiple libraries, such as libraries you define in the
    
38. # build script, prebuilt third-party libraries, or system libraries.
    
39. 
    
40. target_link_libraries( # Specifies the target library.
    
41.                        ImageProc
    
42. 
    
43.                        # Links the target library to the log library
    
44.                        # included in the NDK.
    
45.                        ${log-lib} jnigraphics )
    

复制代码

6）activity_main.xml，界面设计代码

1. 
   
3.     xmlns:tools="http://schemas.android.com/tools"
   
4.     android:id="@+id/activity_main"
   
5.     android:layout_width="match_parent"
   
6.     android:layout_height="match_parent"
   
7.     android:paddingBottom="@dimen/activity_vertical_margin"
   
8.     android:paddingLeft="@dimen/activity_horizontal_margin"
   
9.     android:paddingRight="@dimen/activity_horizontal_margin"
   
10.     android:paddingTop="@dimen/activity_vertical_margin"
    
11.     tools:context="com.example.administrator.simplewebcam.MainActivity">
    
12.    
13.         android:id="@+id/sample_text"
    
14.         android:layout_width="150dp"
    
15.         android:layout_height="50dp"
    
16.         android:text="Hello World! C++" />
    
17.    
            android:layout_width="80dp"
    
            android:layout_height="50dp"
    
            android:text="btn1" android:id="@+id/btn1"/>
    
       
            android:layout_width="80dp"
    
            android:layout_height="50dp"
    
            android:text="btn2" android:id="@+id/btn2"/>
    
       
            android:layout_alignLeft="@id/sample_text"
    
            android:layout_alignParentTop="false"
    
            android:layout_alignParentLeft="true"
    
            android:layout_alignParentRight="true"
    
            android:layout_alignParentBottom="true"
    
            android:id="@+id/MySurface"
    
            android:layout_width="fill_parent"
    
            android:layout_height="fill_parent" />
    
    
    

复制代码

7）MainActivity.java代码

1. package com.example.administrator.simplewebcam;
   
2. 
   
3. import android.Manifest;
   
4. import android.content.Context;
   
5. import android.content.DialogInterface;
   
6. import android.content.pm.PackageManager;
   
7. import android.graphics.Bitmap;
   
8. import android.graphics.BitmapFactory;
   
9. import android.graphics.Canvas;
   
10. import android.graphics.Color;
    
11. import android.graphics.Paint;
    
12. import android.graphics.PorterDuff;
    
13. import android.graphics.PorterDuffXfermode;
    
14. import android.graphics.Rect;
    
15. import android.graphics.RectF;
    
16. import android.os.Environment;
    
17. import android.support.annotation.NonNull;
    
18. import android.support.v4.app.ActivityCompat;
    
19. import android.support.v4.content.ContextCompat;
    
20. import android.support.v7.app.AlertDialog;
    
21. import android.support.v7.app.AppCompatActivity;
    
22. import android.os.Bundle;
    
23. import android.util.Log;
    
24. import android.view.SurfaceHolder;
    
25. import android.view.SurfaceView;
    
26. import android.widget.Button;
    
27. import android.widget.TextView;
    
28. import android.app.Activity;
    
29. import android.os.Bundle;
    
30. import android.view.View;
    
31. import android.view.View.OnClickListener;
    
32. import android.widget.Toast;
    
33. 
    
34. import java.io.File;
    
35. import java.io.IOException;
    
36. import java.lang.reflect.Field;
    
37. import java.util.ArrayList;
    
38. 
    
39. import static android.graphics.BitmapFactory.*;
    
40. 
    
41. public class MainActivity extends AppCompatActivity {
    
42.     public SurfaceHolder MyHolder;
    
43.     private static final boolean DEBUG = true;
    
44.     private static final String TAG="WebCam";
    
45.     protected Context context;
    
46. 
    
47.     Thread mainLoop = null;
    
48.     private Bitmap bmp=null;
    
49. 
    
50.     private boolean cameraExists=false;
    
51.     private boolean shouldStop=false;
    
52. 
    
53.     // /dev/videox (x=cameraId+cameraBase) is used.
    
54.     // In some omap devices, system uses /dev/video[0-3],
    
55.     // so users must use /dev/video[4-].
    
56.     // In such a case, try cameraId=0 and cameraBase=4
    
57.     private int cameraId=0;
    
58.     private int cameraBase=0;
    
59. 
    
60.     // This definition also exists in ImageProc.h.
    
61.     // Webcam must support the resolution 640x480 with YUYV format.
    
62.     static final int IMG_WIDTH=640;
    
63.     static final int IMG_HEIGHT=480;
    
64. 
    
65.     // The following variables are used to draw camera images.
    
66.     private int winWidth=0;
    
67.     private int winHeight=0;
    
68.     private Rect rect;
    
69.     private int dw, dh;
    
70.     private float rate;
    
71. 
    
72.     // JNI functions
    
73.     public native int prepareCamera(int videoid);
    
74.     public native int prepareCameraWithBase(int videoid, int camerabase);
    
75.     public native void processCamera();
    
76.     public native void stopCamera();
    
77.     public native void pixeltobmp(Bitmap bitmap);
    
78.     public native void testLog();
    
79.     public native String stringFromJNI1();
    
80.     static {
    
81.         System.loadLibrary("ImageProc");
    
82.     }
    
83. SurfaceView MysurfaceView;
    
84.     private static final int MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE = 1;
    
85.     private boolean mExternalStorageAvailable = false;
    
86.     private boolean mExternalStorageWriteable = false;
    
87.     private static final int CAMERA_REQUEST_CODE = 1;
    
88.     private boolean mCamera = false;
    
89.     @Override
    
90.     protected void onCreate(Bundle savedInstanceState) {
    
91.         super.onCreate(savedInstanceState);
    
92.         setContentView(R.layout.activity_main);
    
93.         Button btn1 = (Button) findViewById(R.id.btn1);
    
94.         Button btn2 = (Button) findViewById(R.id.btn2);
    
95.         MysurfaceView = (SurfaceView)findViewById(R.id.MySurface);
    
96.         MyHolder = MysurfaceView.getHolder();
    
97.         btn1.setOnClickListener(new View.OnClickListener() {
    
98.             @Override
    
99.             public void onClick(View v) {
    
100. 
     
101.             }
     
102.         });
     
103.         btn2.setOnClickListener(new View.OnClickListener() {
     
104.             @Override
     
105.             public void onClick(View v) {
     
106. 
     
107.             }
     
108.         });
     
109.         // Example of a call to a native method
     
110.         TextView tv = (TextView) findViewById(R.id.sample_text);
     
111.         tv.setText(stringFromJNI1());
     
112.         int nRet = 0;//
     
113.         SetExternalStoragepermission_OK();
     
114.         nRet = CheckExternalStoragepermission_OK();
     
115.         if(nRet == 0)
     
116.         {
     
117.                 Log.i("Surface:", "nRet ==0");
     
118.         }
     
119.         else
     
120.         {
     
121.                 Log.i("Surface:", "nRet !=0");
     
122.                 MyHolder.addCallback(new MyCallBack());//  surfaceCreated surfaceChanged
     
123.         }
     
124.        //   
     
125.     }
     
126.         private int CheckExternalStoragepermission_OK()
     
127.     {
     
128.         String externalStorageState = Environment.getExternalStorageState();
     
129.         if (Environment.MEDIA_MOUNTED.equals(externalStorageState)) {
     
130.             mExternalStorageAvailable = true;
     
131.             mExternalStorageWriteable = true;
     
132.             return 2;      } else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(externalStorageState)) {
     
133.             mExternalStorageAvailable = true;
     
134.             mExternalStorageWriteable = false;
     
135.             return 1;       } else {
     
136.             mExternalStorageAvailable = mExternalStorageWriteable = false;
     
137.             return 0;
     
138.         }
     
139.     //    handleExternalStorageState(mExternalStorageAvailable,mExternalStorageWriteable);
     
140.     }
     
141. 
     
142.     private void SetExternalStoragepermission_OK()
     
143.     {
     
144.         String externalStorageState = Environment.getExternalStorageState();
     
145.         if (Environment.MEDIA_MOUNTED.equals(externalStorageState)) {
     
146.             mExternalStorageAvailable = true;
     
147.             mExternalStorageWriteable = true;
     
148.         } else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(externalStorageState)) {
     
149.             mExternalStorageAvailable = true;
     
150.             mExternalStorageWriteable = false;
     
151.         } else {
     
152.             mExternalStorageAvailable = mExternalStorageWriteable = false;
     
153.         }
     
154.         handleExternalStorageState(mExternalStorageAvailable,mExternalStorageWriteable);
     
155.         
     
156. 
     
157. requestPermission();
     
158.         
     
159.     }
     
160.     private void requestPermission() {
     
161.         if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
     
162.                 != PackageManager.PERMISSION_GRANTED) {
     
163.             // 第一次请求权限时，用户如果拒绝，下一次请求shouldShowRequestPermissionRationale()返回true
     
164.             // 向用户解释为什么需要这个权限
     
165.             if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)) {
     
166.                 new AlertDialog.Builder(this)
     
167.                         .setMessage("申请相机权限")
     
168.                         .setPositiveButton("确定", new DialogInterface.OnClickListener() {
     
169.                             @Override
     
170.                             public void onClick(DialogInterface dialog, int which) {
     
171.                                 //申请相机权限
     
172.                                 ActivityCompat.requestPermissions(MainActivity.this,
     
173.                                         new String[]{Manifest.permission.CAMERA}, CAMERA_REQUEST_CODE);
     
174.                             }
     
175.                         })
     
176.                         .show();
     
177.             } else {
     
178.                 //申请相机权限
     
179.                 ActivityCompat.requestPermissions(this,
     
180.                         new String[]{Manifest.permission.CAMERA}, CAMERA_REQUEST_CODE);
     
181.             }
     
182.         } else {
     
183.           //  Tv.setTextColor(Color.GREEN);
     
184.           //  Tv.setText("相机权限已申请");
     
185.         }
     
186.     }
     
187.     private void handleCameraState(boolean mCamera ) {
     
188.                 }
     
189.     private void handleExternalStorageState(boolean mExternalStorageAvailable,boolean mExternalStorageWriteable ) {
     
190.         if(mExternalStorageAvailable && mExternalStorageWriteable){
     
191.             //STORAGE is dangerous so check
     
192.             // checkSelfPermission()
     
193.             int permissionCheck = ContextCompat.checkSelfPermission(this,
     
194.                     Manifest.permission.WRITE_EXTERNAL_STORAGE);
     
195.             Log.d("permission", "permissionCheck=="+permissionCheck);
     
196.             if (permissionCheck != PackageManager.PERMISSION_GRANTED) {
     
197.                 //has not granted request permission
     
198.                 // Should we show an explanation?
     
199.                 if (ActivityCompat.shouldShowRequestPermissionRationale(this,
     
200.                         Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
     
201. 
     
202.                     // Show an expanation to the user *asynchronously* -- don't block
     
203.                     // this thread waiting for the user's response! After the user
     
204.                     // sees the explanation, try again to request the permission.
     
205.                     //  Toast.makeText(MainActivity.this, "Permission++++", Toast.LENGTH_SHORT).show();
     
206. 
     
207. //                    ActivityCompat.requestPermissions(this,
     
208. //                            new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
     
209. //                            MY_PERMISSIONS_REQUEST_READ_CONTACTS);
     
210.                     new AlertDialog.Builder(this)
     
211.                             .setMessage("您拒绝过授予访问外部存储设备的权限,但是只有申请该权限,才能往外部存储设备写入数据,你确定要重新申请获取权限吗？")
     
212.                             .setPositiveButton("ok", new DialogInterface.OnClickListener() {
     
213.                                 @Override
     
214.                                 public void onClick(DialogInterface dialog, int which) {
     
215.                                     dialog.dismiss();
     
216.                                     //again request permission
     
217.                                     ActivityCompat.requestPermissions(MainActivity.this,
     
218.                                             new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
     
219.                                             MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE);
     
220. 
     
221.                                 }
     
222.                             })
     
223.                             .setNegativeButton("no", new DialogInterface.OnClickListener() {
     
224.                                 @Override
     
225.                                 public void onClick(DialogInterface dialog, int which) {
     
226.                                     dialog.dismiss();
     
227.                                 }
     
228.                             })
     
229.                             .create()
     
230.                             .show();
     
231.                 } else {
     
232.                     // No explanation needed, we can request the permission.
     
233.                     ActivityCompat.requestPermissions(this,
     
234.                             new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
     
235.                             MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE);
     
236. 
     
237.                     // MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE is an
     
238.                     // app-defined int constant. The callback method gets the
     
239.                     // result of the request.
     
240.                 }
     
241. 
     
242.             }else{
     
243.                 //had granted
     
244.                 Toast.makeText(MainActivity.this, "run writeDatasToExternalStorage() method", Toast.LENGTH_SHORT).show();
     
245.                 // writeDatasToExternalStorage();
     
246.             }
     
247.         }else{
     
248.             Log.d("permission", "ExternalStorage can not be write  or unAvailable");
     
249.         }
     
250.     }
     
251. 
     
252.     /**          */
     
253.     private void writeDatasToExternalStorage(){
     
254.         File directory = Environment.getExternalStorageDirectory();// 6.0 /storage/emulated/0    5.0 /storage/sdcard
     
255.             /*
     
256.              Environment.getDataDirectory();//  /data
     
257.              Environment.getRootDirectory();// /system
     
258.              Environment.getDownloadCacheDirectory();//  /cache
     
259.              Environment.getExternalStoragePublicDirectory(
     
260.                     Environment.DIRECTORY_PICTURES);// 6.0 /storage/emulated/0/Pictures   5.0/storage/sdcard/Pictures
     
261.            */
     
262.         File file = new File(directory, "permisson");
     
263.         if(!file.exists()){
     
264.             try {
     
265.                 file.createNewFile();
     
266.             } catch (IOException e) {
     
267.                 e.printStackTrace();
     
268.             }
     
269.         }
     
270.     }
     
271. 
     
272.     /**
     
273.      *
     
274.      * @param requestCode
     
275.      * @param permissions
     
276.      * @param grantResults
     
277.      */
     
278.     @Override
     
279.     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
     
280.         Log.d("permission", "onRequestPermissionsResult  requestCode" + requestCode);
     
281.         if (requestCode == MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE) {
     
282. 
     
283.                 // If request is cancelled, the result arrays are empty.
     
284.                 if (grantResults.length > 0
     
285.                         && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
     
286. 
     
287.                     // permission was granted, yay! Do the
     
288.                     // contacts-related task you need to do.
     
289.                     Toast.makeText(MainActivity.this, "run writeDatasToExternalStorage() method", Toast.LENGTH_SHORT).show();
     
290.                     //   writeDatasToExternalStorage();
     
291. 
     
292.                 } else {
     
293.                     // Permission Denied
     
294.                     Toast.makeText(MainActivity.this, "Permission Denied", Toast.LENGTH_SHORT).show();
     
295.                     // permission denied, boo! Disable the
     
296.                     // functionality that depends on this permission.
     
297.                 }
     
298.                 return;
     
299.             }
     
300.         if (requestCode == CAMERA_REQUEST_CODE) {
     
301. 
     
302.                     if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
     
303.                    // Tv.setTextColor(Color.GREEN);
     
304.                   //  Tv.setText("相机权限已申请");
     
305.             } else {
     
306.                 //用户勾选了不再询问
     
307.                 //提示用户手动打开权限
     
308.                 if (!ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)) {
     
309.                     Toast.makeText(this, "相机权限已被禁止", Toast.LENGTH_SHORT).show();
     
310.                 }
     
311.             }
     
312.             }
     
313.             // other 'case' lines to check for other
     
314.             // permissions this app might request
     
315. 
     
316. 
     
317.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
     
318. 
     
319.     }
     
320.     class MyCallBack implements SurfaceHolder.Callback , Runnable {
     
321.         @Override
     
322.         public void run() {
     
323.             while (true && cameraExists) {
     
324.                 //obtaining display area to draw a large image
     
325.                 if(winWidth==0){
     
326.                     winWidth=MysurfaceView.getWidth();
     
327.                     winHeight=MysurfaceView.getHeight();
     
328. 
     
329.                     if(winWidth*3/4<=winHeight){
     
330.                         dw = 0;
     
331.                         dh = (winHeight-winWidth*3/4)/2;
     
332.                         rate = ((float)winWidth)/IMG_WIDTH;
     
333.                         rect = new Rect(dw,dh,dw+winWidth-1,dh+winWidth*3/4-1);
     
334.                     }else{
     
335.                         dw = (winWidth-winHeight*4/3)/2;
     
336.                         dh = 0;
     
337.                         rate = ((float)winHeight)/IMG_HEIGHT;
     
338.                         rect = new Rect(dw,dh,dw+winHeight*4/3 -1,dh+winHeight-1);
     
339.                     }
     
340.                 }
     
341. 
     
342.                 // obtaining a camera image (pixel data are stored in an array in JNI).
     
343.                 processCamera();
     
344.                 // camera image to bmp
     
345.                 pixeltobmp(bmp);
     
346. 
     
347.                 Canvas canvas = MyHolder.lockCanvas();
     
348.                 if (canvas != null)
     
349.                 {
     
350.                     // draw camera bmp on canvas
     
351.                     canvas.drawBitmap(bmp,null,rect,null);
     
352. 
     
353.                     MyHolder.unlockCanvasAndPost(canvas);
     
354.                 }
     
355. 
     
356.                 if(shouldStop){
     
357.                     shouldStop = false;
     
358.                     break;
     
359.                 }
     
360.             }
     
361.         }
     
362.         @Override
     
363.         public void surfaceChanged(SurfaceHolder holder, int format, int width,
     
364.                                    int height) {
     
365.             Log.i("Surface:", "Change");
     
366. 
     
367.         }
     
368. 
     
369.         @Override
     
370.         public void surfaceCreated(SurfaceHolder holder) {
     
371.             Log.i("Surface:", "Create");
     
372. 
     
373.             String TAG1 = "test1111";
     
374.             Log.d(TAG, "surfaceCreated");
     
375.             if(bmp==null){
     
376.                 bmp = Bitmap.createBitmap(IMG_WIDTH, IMG_HEIGHT, Bitmap.Config.ARGB_8888);
     
377.             }
     
378.                     if(DEBUG) Log.d(TAG, "-10-prepareCamera surfaceCreated"  + "TAG1=" + TAG1);
     
379.         if(DEBUG) Log.d(TAG, "-11-prepareCamera surfaceCreated cameraId="+ cameraId + "cameraBase="+ cameraBase);
     
380.         testLog();
     
381.         if(DEBUG) Log.d(TAG, "-12-prepareCamera surfaceCreated cameraId="+ cameraId + "cameraBase="+ cameraBase);
     
382.         int ret = prepareCamera(cameraId);
     
383.        // int ret = prepareCameraWithBase(cameraId, cameraBase);
     
384.         if(DEBUG) Log.d(TAG, "prepareCamera surfaceCreated cameraId="+ cameraId + "cameraBase="+ cameraBase + "ret=" + ret);
     
385. 
     
386.         if(ret!=-1) cameraExists = true;
     
387. 
     
388.         mainLoop = new Thread(this);
     
389.         mainLoop.start();
     
390.         }
     
391. 
     
392.         @Override
     
393.         public void surfaceDestroyed(SurfaceHolder holder) {
     
394.             Log.i("Surface:", "Destroy");
     
395.         if(DEBUG) Log.d(TAG, "surfaceDestroyed");
     
396.         if(cameraExists){
     
397.             shouldStop = true;
     
398.             while(shouldStop){
     
399.                 try{
     
400.                     Thread.sleep(100); // wait for thread stopping
     
401.                 }catch(Exception e){}
     
402.             }
     
403.         }
     
404.         stopCamera();
     
405.         }
     
406. 
     
407.     }
     
408. 
     
409.     /**
     
410.      * A native method that is implemented by the 'native-lib' native library,
     
411.      * which is packaged with this application.
     
412.      */
     
413. 
     
414. }
     

复制代码

运行抓图如下：

总结：
1）JNI中定义函数名与Android Studio中Java程序调用的函数名的对应关系：
Java_com_example_administrator_simplewebcam_MainActivity_pixeltobmp pixeltobmp
注意：（1）前者中‘_’是特殊分隔符不能在使用在函数名中，我就遇到了这个坑。
          （2）pixeltobmp函数在哪个类里面调用，这个类名必须包含在JNI函数名的定义里面。
2）Android Studio开发的APK程序如何访问/dev/video0等类似设备节点，可以参考下面的方法 ，在这里自己验证了很多方法，后面会专门开一个帖子记录一下。
       The permission of /dev/video0 is set 0666 in /ueventd.xxxx.rc