微波EDA网，见证研发工程师的成长！
首页 > 研发问答 > 嵌入式设计讨论 > 嵌入式系统设计讨论 > 5.MTX20开发板Android Studio开发APK应用程序预览USB Camera

5.MTX20开发板Android Studio开发APK应用程序预览USB Camera

时间：10-02 整理：3721RD 点击：
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){

  5.     int ret;

  7.     if(camerabase<0){
  8.         camerabase = checkCamerabase();
  9.     }

  11.     ret = opendevice(camerabase + videoid);

  13.     if(ret ！= ERROR_LOCAL){
  14.         ret = initdevice();
  15.     }
  16.     if(ret ！= ERROR_LOCAL){
  17.         ret = startcapturing();

  19.         if(ret ！= SUCCESS_LOCAL){
  20.             stopcapturing();
  21.             uninitdevice ();
  22.             closedevice ();
  23.             LOGE("device resetted");
  24.         }

  26.     }

  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){

  4.     jboolean bo;


  7.     AndroidBitmapInfo  info;
  8.     void*              pixels;
  9.     int                ret;
  10.     int i;
  11.     int *colors;

  13.     int width=0;
  14.     int height=0;

  16.     if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {
  17.         LOGE("AndroidBitmap_getInfo() failed ！ error=%d", ret);
  18.         return;
  19.     }

  21.     width = info.width;
  22.     height = info.height;

  24.     if(！rgb || ！ybuf) return;

  26.     if (info.format ！= ANDROID_BITMAP_FORMAT_RGBA_8888) {
  27.         LOGE("Bitmap format is not RGBA_8888 ！");
  28.         return;
  29.     }

  31.     if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {
  32.         LOGE("AndroidBitmap_lockPixels() failed ！ error=%d", ret);
  33.     }

  35.     colors = (int*)pixels;
  36.     int *lrgb =NULL;
  37.     lrgb = &rgb[0];

  39.     for(i=0 ; i<width*height ; i++){
  40.         *colors++ = *lrgb++;
  41.     }

  43.     AndroidBitmap_unlockPixels(env, bitmap);

  45. }

复制代码

3）Java_com_example_administrator_simplewebcam_MainActivity_processCamera函数开始预览。

  1. void
  2. Java_com_example_administrator_simplewebcam_MainActivity_processCamera( JNIEnv* env,
  3.                                                                          jobject thiz){

  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){

  4.     stopcapturing ();

  6.     uninitdevice ();

  8.     closedevice ();

  10.     if(rgb) free(rgb);
  11.     if(ybuf) free(ybuf);

  13.     fd = -1;

  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.

  5. cmake_minimum_required(VERSION 3.4.1)

  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.

  12. add_library( # Sets the name of the library.
  13.              ImageProc

  15.              # Sets the library as a shared library.
  16.              SHARED

  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 )

  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.

  29. find_library( # Sets the name of the path variable.
  30.               log-lib

  32.               # Specifies the name of the NDK library that
  33.               # you want CMake to locate.
  34.               log jnigraphics )

  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.

  40. target_link_libraries( # Specifies the target library.
  41.                        ImageProc

  43.                        # Links the target library to the log library
  44.                        # included in the NDK.
  45.                        ${log-lib} jnigraphics )

复制代码

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

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  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.     <TextView
  13.         android:id="@+id/sample_text"
  14.         android:layout_width="150dp"
  15.         android:layout_height="50dp"
  16.         android:text="Hello World！ C++" />
  17.     <Button android:layout_toRightOf="@id/sample_text"
  18.         android:layout_width="80dp"
  19.         android:layout_height="50dp"
  20.         android:text="btn1" android:id="@+id/btn1"/>
  21.     <Button android:layout_toRightOf="@id/btn1"
  22.         android:layout_width="80dp"
  23.         android:layout_height="50dp"
  24.         android:text="btn2" android:id="@+id/btn2"/>
  25.     <SurfaceView android:layout_below="@id/sample_text"
  26.         android:layout_alignLeft="@id/sample_text"
  27.         android:layout_alignParentTop="false"
  28.         android:layout_alignParentLeft="true"
  29.         android:layout_alignParentRight="true"
  30.         android:layout_alignParentBottom="true"
  31.         android:id="@+id/MySurface"
  32.         android:layout_width="fill_parent"
  33.         android:layout_height="fill_parent" />
  34. </RelativeLayout>

复制代码

7）MainActivity.java代码

  1. package com.example.administrator.simplewebcam;

  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;

  34. import java.io.File;
  35. import java.io.IOException;
  36. import java.lang.reflect.Field;
  37. import java.util.ArrayList;

  39. import static android.graphics.BitmapFactory.*;

  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;

  47.     Thread mainLoop = null;
  48.     private Bitmap bmp=null;

  50.     private boolean cameraExists=false;
  51.     private boolean shouldStop=false;

  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;

  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;

  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;

  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) {

  101.             }
  102.         });
  103.         btn2.setOnClickListener(new View.OnClickListener() {
  104.             @Override
  105.             public void onClick(View v) {

  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.     }

  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.         

  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)) {

  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();

  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);

  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);

  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.                 }

  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.     }

  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.     }

  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) {

  283.                 // If request is cancelled, the result arrays are empty.
  284.                 if (grantResults.length > 0
  285.                         && grantResults[0] == PackageManager.PERMISSION_GRANTED) {

  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();

  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) {

  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


  317.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);

  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();

  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.                 }

  342.                 // obtaining a camera image (pixel data are stored in an array in JNI).
  343.                 processCamera();
  344.                 // camera image to bmp
  345.                 pixeltobmp(bmp);

  347.                 Canvas canvas = MyHolder.lockCanvas();
  348.                 if (canvas ！= null)
  349.                 {
  350.                     // draw camera bmp on canvas
  351.                     canvas.drawBitmap(bmp,null,rect,null);

  353.                     MyHolder.unlockCanvasAndPost(canvas);
  354.                 }

  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");

  367.         }

  369.         @Override
  370.         public void surfaceCreated(SurfaceHolder holder) {
  371.             Log.i("Surface:", "Create");

  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);

  386.         if(ret！=-1) cameraExists = true;

  388.         mainLoop = new Thread(this);
  389.         mainLoop.start();
  390.         }

  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.         }

  407.     }

  409.     /**
  410.      * A native method that is implemented by the 'native-lib' native library,
  411.      * which is packaged with this application.
  412.      */

  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


上一篇：c语言中如何把字符串的ASCII码通过printf函数打印字符串
下一篇：工业4.0时代最新前沿技术、创新方案……你想要的都在这里！

Android 相关文章：

栏目分类
热门文章

Copyright © 2017-2020 微波EDA网 版权所有

网站地图

Top