原生android调用手机拍照_原生调用android拍照 - CSDN
  • android 调用原生相机

    2016-10-18 11:55:11
    GitHubpublic class MeFragment extends BaseFragment implements View.OnClickListener { private String TAG = getClass().getSimpleName(); private ImageView ivPhoto; private static final int CAMER

    GitHub

    public class MeFragment extends BaseFragment implements View.OnClickListener {
    
        private String TAG = getClass().getSimpleName();
        private ImageView ivPhoto;
    
        private static final int CAMERA = 1;// 拍照
        private static final int GALLERY = 2;// 从相册中选择
        private static final int PHOTO_REQUEST_CUT = 3;// 结果
        private final String IMAGE_FILE_LOCATION = Environment.getExternalStorageDirectory() + "/temp.jpg"; //temp file
    
        private AlertDialog dialog;
        private View dialogView;
        private View backgroundView;
        private boolean isBackground;
    
        public static MeFragment newInstance(String param1, String param2) {
            MeFragment fragment = new MeFragment();
            Bundle args = new Bundle();
            return fragment;
        }
    
        @Override
        protected void initView() {
            backgroundView=bind(R.id.ivPhotoBg);
            ivPhoto = bind(R.id.ivPhoto);
            dialogView=LayoutInflater.from(getActivity()).inflate(R.layout.dialog_select_image,null);
    
            String uri = ShareUtils.getPhotoUri();
            String uriBackground=ShareUtils.getPhotoBackground();
            if(!TextUtils.isEmpty(uri)){
                ivPhoto.setImageURI(Uri.parse(uri));
            }
            if(!TextUtils.isEmpty(uriBackground)){
                setBackground(Uri.parse(uriBackground));
            }
            dialog = new AlertDialog.Builder(getActivity(), R.style.fullScreen).create();
            initListener(this,R.id.ivPhoto,R.id.ivPhotoBg);
            initListener(this,dialogView.findViewById(R.id.btCamera),dialogView.findViewById(R.id.btPhoto),dialogView.findViewById(R.id.btCancel));
        }
    
        @Override
        public int getRootLayoutId() {
            return R.layout.fragment_me;
        }
    
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.btCamera:
                    setPhotoIntent(CAMERA);
                    break;
                case R.id.btPhoto:
                    setPhotoIntent(GALLERY);
                    break;
                case R.id.ivPhoto:
    
                    isBackground=false;
                    dialog.setCancelable(true);
                    dialog.show();
                    dialog.setContentView(dialogView);
                    break;
                case R.id.ivPhotoBg:
                    isBackground=true;
                    dialog.setCancelable(true);
                    dialog.show();
                    dialog.setContentView(dialogView);
                    break;
            }
        }
    
        /**
         * 为选择的模式设置intent参数,调用系统相机 系统相册 系统裁剪
         * @param type GALLERY CAMERA PHOTO_REQUEST_CUT
         * */
        private void setPhotoIntent(int type) {
            Intent intent = new Intent();
            switch (type) {
                case PHOTO_REQUEST_CUT:
                    break;
                case GALLERY:
                    intent.setAction(Intent.ACTION_GET_CONTENT);
                    intent.setType("image/*");
                    startActivityForResult(intent, GALLERY);
                    break;
                case CAMERA:
                    Intent camera = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    startActivityForResult(camera, CAMERA);
                    break;
            }
        }
    
        /**
         * 调用系统裁剪功能:
         * 传入图片uri
         * @param uri picture uri
         */
        private void startPhotoZoom(Uri uri) {
            Log.i(TAG, " url================" + uri);
    
            Intent intent = new Intent("com.android.camera.action.CROP");
            intent.setDataAndType(uri, "image/*");
            // crop为true是设置在开启的intent中设置显示的view可以剪裁
            intent.putExtra("crop", "true");
            // aspectX aspectY 是宽高的比例
            intent.putExtra("aspectX", 1);
            intent.putExtra("aspectY", 1);
    
            // outputX,outputY 是剪裁图片的宽高
            intent.putExtra("outputX", 600);
            intent.putExtra("outputY", 600);
            intent.putExtra("return-data", true);
            intent.putExtra("noFaceDetection", true);
            startActivityForResult(intent, PHOTO_REQUEST_CUT);
        }
    
        @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
        @Override
        public void onActivityResult(int requestCode, int resultCode, Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            Log.i(TAG, String.format("request code = %d result code = %d   data is null %b", requestCode, resultCode, data == null));
    
            if(dialog!=null){
                dialog.dismiss();
            }
    
            if (resultCode != Activity.RESULT_OK || data == null) {
                Toast.makeText(getActivity(), "you have cancel option", Toast.LENGTH_SHORT).show();
                return;
            }
    
            switch (requestCode) {
                case CAMERA:// 当选择拍照时调用
                    if(isBackground){
                        setBackground(data.getData());
                    }else{
                        startPhotoZoom(data.getData());//相册返回uri丢给系统裁剪
                    }
                    break;
                case GALLERY:// 当选择相册时
                    if(isBackground){
                        setBackground(data.getData());
                        Log.i(TAG,data.getDataString());// uri content://com.android.providers.media.documents/document/image%3A32507
                        ShareUtils.setPhotoBackground(data.getDataString());
                    }else{
                        startPhotoZoom(data.getData());//相册返回uri丢给系统裁剪
                    }
                    break;
                case PHOTO_REQUEST_CUT:// 返回的结果
                    Bitmap bitmap = data.getParcelableExtra("data");//裁剪后,取出bitmap界面显示
                    ShareUtils.setPhotoUri(IMAGE_FILE_LOCATION);
                    saveBitmap(bitmap);
                    ivPhoto.setImageBitmap(bitmap);
                    break;
            }
    
        }
    
        @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
        private void setBackground(Uri uri) {
            InputStream inputStream;
            Drawable drawable=null;
            try {
                Log.i(TAG," uri "+uri);
                 inputStream = getActivity().getContentResolver().openInputStream(uri);
                drawable=Drawable.createFromStream(inputStream,"dataString");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            if(drawable!=null){
                backgroundView.setBackground(drawable);
                Log.d(TAG,"set ok");
            }else{
                Log.e(TAG,"setBackground error");
            }
        }
    
        /**
         * 把头像保存在本地
         * @param bm
         * @return
         */
        private Uri saveBitmap(Bitmap bm) {
            File tmpDir = new File(IMAGE_FILE_LOCATION);
            tmpDir.delete();
            if (!tmpDir.getParentFile().exists()) {
                tmpDir.mkdir();
            }
            File img = new File(IMAGE_FILE_LOCATION);
            try {
                FileOutputStream fos = new FileOutputStream(img);
                bm.compress(Bitmap.CompressFormat.PNG, 85, fos);
                fos.flush();
                fos.close();
                Toast.makeText(getActivity(), "保存成功了", Toast.LENGTH_SHORT).show();
                return Uri.fromFile(img);
            } catch (FileNotFoundException e) {
                Toast.makeText(getActivity(), "保存失败", Toast.LENGTH_SHORT).show();
                e.printStackTrace();
                return null;
            } catch (IOException e) {
                e.printStackTrace();
                Toast.makeText(getActivity(), "保存失败", Toast.LENGTH_SHORT).show();
                return null;
            }
        }
    
        /**
         * 1、bitmap  to  uri
         * <p/>
         * Uri uri = Uri.parse(MediaStore.Images.Media.insertImage(getContentResolver(), bitmap, null,null));
         * <p/>
         * 2、uri  to  bitmap
         * <p/>
         * Bitmap bitmap = MediaStore.Images.Media.getBitmap(this.getContentResolver(), uri);
         * 读取图片属性:旋转的角度
         *
         * @param path 图片绝对路径
         * @return degree旋转的角度
         */
        public static int readPictureDegree(String path) {
            int degree = 0;
            try {
                ExifInterface exifInterface = new ExifInterface(path);
                int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
                switch (orientation) {
                    case ExifInterface.ORIENTATION_ROTATE_90:
                        degree = 90;
                        break;
                    case ExifInterface.ORIENTATION_ROTATE_180:
                        degree = 180;
                        break;
                    case ExifInterface.ORIENTATION_ROTATE_270:
                        degree = 270;
                        break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return degree;
        }
    
        /**
         * 旋转图片
         *
         * @param angle
         * @param bitmap
         * @return Bitmap
         */
        public static Bitmap rotaingImageView(int angle, Bitmap bitmap) {
            //旋转图片 动作
            Matrix matrix = new Matrix();
            matrix.postRotate(angle);
            System.out.println("angle2=" + angle);
            // 创建新的图片
            Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0,
                    bitmap.getWidth(), bitmap.getHeight(), matrix, true);
            return resizedBitmap;
        }
    }
    
    展开全文
  • 网上调用android手机摄像头拍照的代码也挺多,总的来说都能使.但是对于刚开始接触的人用处不大,都是转来转去,看着都烦 下面我就来写一个,用代码来详细解释android手机拍照的过程 首先是使用camera需要用到的权限。 ...

    网上调用android手机摄像头拍照的代码也挺多,总的来说都能使.但是对于刚开始接触的人用处不大,都是转来转去,看着都烦

    下面我就来写一个,用代码来详细解释android手机拍照的过程

    首先是使用camera需要用到的权限。

     
    文件写入    
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
      
        <!-- 摄像头拍照 -->
        <uses-permission android:name="android.permission.CAMERA" />
        <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" />
        <uses-feature android:name="android.hardware.camera"/>

     

    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.text.SimpleDateFormat;

    import net.cartravel.app.AppContext;
    import net.cartravel.app.AppException;
    import net.cartravel.app.AppManager;
    import net.cartravel.app.R;
    import net.cartravel.app.api.RequestData;
    import net.cartravel.app.api.RequestResult;
    import net.cartravel.app.bean.CarParkingRecord;
    import net.cartravel.app.bean.URLs;
    import net.cartravel.app.common.UIHelper;
    import android.app.ProgressDialog;
    import android.content.Context;
    import android.content.Intent;
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.graphics.Matrix;
    import android.graphics.PixelFormat;
    import android.hardware.Camera;
    import android.hardware.Camera.AutoFocusCallback;
    import android.hardware.Camera.PictureCallback;
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Message;
    import android.view.KeyEvent;
    import android.view.Menu;
    import android.view.MenuItem;
    import android.view.MotionEvent;
    import android.view.SurfaceHolder;
    import android.view.SurfaceView;
    import android.view.Window;
    import android.widget.ImageView;
    import android.widget.ImageView.ScaleType;
    import android.widget.LinearLayout.LayoutParams;

     

     

    public class CameraActivity extends Activity {


     private Camera camera;  //  定义 Camera对象,调用系统的摄像头 
     private Preview preview;  // 声明Preview ,自定义类
     private ImageView ivFocus;  // 声明相机焦点
     SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss"); // 时间转换
     private String randomImage = "car.jpg";  // 文件名
     byte[] image;
     int k = 0;
     
     @Override
     protected void onCreate(Bundle savedInstanceState) {
      // TODO Auto-generated method stub
      super.onCreate(savedInstanceState);
      requestWindowFeature(Window.FEATURE_NO_TITLE); // 无标题
      preview = new Preview(this);   // 创建Preview对象,传入当前Activity.
      setContentView(preview); // 设置preview为显示界面
      ivFocus = new ImageView(this); // 创建ImageView组件
     }
     
     @Override
     public boolean onTouchEvent(MotionEvent event) {
      // TODO Auto-generated method stub
      if (event.getAction() == KeyEvent.ACTION_DOWN) { // 按下事件
       openOptionsMenu(); // 打开菜单栏
      }
      return super.onTouchEvent(event);
     }
     
     @Override
     public boolean onCreateOptionsMenu(Menu menu) {
            // TODO Auto-generated method stub
           menu.add(0, Menu.FIRST, 0, "拍照")
                    .setIcon(R.drawable.camera);
            menu.add(0, Menu.FIRST + 1, 0, "取消")
              .setIcon(R.drawable.close);
           return super.onCreateOptionsMenu(menu);
     }
     
      @Override
     public boolean onOptionsItemSelected(MenuItem item) {
      
      switch (item.getItemId()) {
             case Menu.FIRST:
              if (k == 0) {
               camera.autoFocus(new AutoFocusCallback() { // 自动对焦
             public void onAutoFocus(boolean success, Camera camera) {
              if (success) {           
               // success为true表示对焦成功,改变对焦状态图像(一个绿色的png图像)
                  preview.takePicture(); // 进行拍照
                  k = 1;
                  ivFocus.setImageResource(R.drawable.white); // white为图片
              }
             }
            }); 
              }
        break;
             case Menu.FIRST + 1:
                 camera.startPreview(); // 开始亮灯,重新获取拍摄界面
                 ivFocus.setImageResource(R.drawable.focus1); // focus1为图片 
                 k = 0;
                 break;
             }
         return super.onOptionsItemSelected(item);
     }

        /*

         * 使用接口的原因:因为使用SurfaceView 有一个原则,所有的绘图工作必须得在Surface 被创建之后才能开始(Surface—表面,这个概念在 图形编程中常常被提到。基本上我们可以把它当作显存的一个映射,写入到Surface 的内容
                          可以被直接复制到显存从而显示出来,这使得显示速度会非常快),而在Surface 被销毁之前必须结束。所以Callback 中的surfaceCreated 和surfaceDestroyed 就成了绘图处理代码的边界
         */
      class Preview extends SurfaceView implements SurfaceHolder.Callback {
       
      // 定义 SurfaceHolder对象
      private SurfaceHolder holder;
      // 创建一个PictureCallback对象,并实现其中的onPictureTaken方法
      private PictureCallback pictureCallback = new PictureCallback() {
       // 该方法用于处理拍摄后的照片数据
       public void onPictureTaken(byte[] data, Camera camera) {
        // data参数值就是照片数据,将这些数据以key-value形式保存,以便其他调用该Activity的程序可
        // 以获得照片数据  
        Bitmap cameraBitmap;
    //    // 文件名
        cameraBitmap = BitmapFactory.decodeByteArray(data, 0,
          data.length);
        if (getWindowManager().getDefaultDisplay().getOrientation() == 0)
        {
         Matrix matrix = new Matrix();
         matrix.setRotate(90);
         cameraBitmap = Bitmap.createBitmap(cameraBitmap, 0, 0,
           cameraBitmap.getWidth(), cameraBitmap.getHeight(),
           matrix, true); // 生成图片数据
        }
        File myCaptureFile = new File("/sdcard/DCIM/Camera/" + randomImage);
        try {
         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(myCaptureFile));
         cameraBitmap.compress(Bitmap.CompressFormat.JPEG, 100, bos); //压缩图片像素,将图片数据写入
         bos.flush();
         bos.close();
         cameraBitmap.recycle(); // 回收Bitmap的空间 
         camera.reconnect(); // 重新连接摄像机
        } catch(Exception e) {
         e.printStackTrace();
        }
       }
      };

      // Preview类的构造方法
      public Preview(Context context)
      {
       super(context);
      holder = getHolder(); // 显示一个surface的抽象接口,使你可以控制surface的大小和格式, 以及在surface上编辑像素,和监视surface的改变。  
       holder.addCallback(this); // 指定用于捕捉拍照事件的SurfaceHolder.Callback对象
       // 设置SurfaceHolder对象的类型
       holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS); // 表明该Surface不包含原生数据,Surface用到的数据由其他对象提供,在Camera图像预览中就使用该类型的Surface,有Camera负责提供给预览Surface数据,这样图像预览会比较流畅。
      }

      // 开始拍照时调用该方法
      public void surfaceCreated(SurfaceHolder holder) {
       // 获得Camera对象
       camera = Camera.open();
       try {    
        // 设置用于控制surface对象
        camera.setPreviewDisplay(holder);
        
       }
       catch (IOException exception) {
        // 释放手机摄像头
        camera.release();
       }
      }

      // 停止拍照时调用该方法
      public void surfaceDestroyed(SurfaceHolder holder) {
       // 释放手机摄像头
       camera.release();
      }

      // 拍照状态变化时调用该方法
      public void surfaceChanged(final SurfaceHolder holder, int format,
        int w, int h) {   
       
       try {   
        Camera.Parameters parameters = camera.getParameters();
        // 设置照片格式
        parameters.setPictureFormat(PixelFormat.JPEG);    
        camera.setDisplayOrientation(90);    
      
        // 设置拍摄照片的实际分辨率,在本例中的分辨率是1024*768
        parameters.setPictureSize(1024, 768);
        // 设置保存的图像大小
        camera.setParameters(parameters);
        // 开始拍照
        camera.startPreview();
        // 准备用于表示对焦状态的图像
        ivFocus.setImageResource(R.drawable.focus1);
        // 设置摄像图片布局
        LayoutParams layoutParams = new LayoutParams(
          LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);
        ivFocus.setScaleType(ScaleType.CENTER);
        addContentView(ivFocus, layoutParams);
        ivFocus.setVisibility(VISIBLE);               
       }
       catch (Exception e) {
        // 释放手机摄像头
        camera.release();
       }
      }
      
      // 停止拍照,并将拍摄的照片传入PictureCallback接口的onPictureTaken方法
      public void takePicture() {
       if (camera != null) {  
        camera.takePicture(null, null, pictureCallback);
       }
      }  
     }

     @Override
     protected void onPause() {
      // TODO Auto-generated method stub
      super.onPause(); 
      finish();
     }

     @Override
     protected void onRestart() {
      // TODO Auto-generated method stub
      super.onRestart();
     }
    }

    由于时间问题,我不会把每一个类,每一个配置文件都写出来,我只写一些核心代码.

    亲测了下,没问题.图片你们自己准备把,就是小图标

    就写到这吧,不懂的QQ 468903507具体问我,应该注释得很详细了.下篇写写百度地图api的使用,以及如何在地图上进行一些画图、标注等操作.

     

     

    展开全文
  • 权限:

    Android 6.0(API 23以下,不包括23)以下,无动态授权模块,

    权限:

    <uses-permission android:name="android.permission.CAMERA"/>
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    

    java代码:

    
            Intent intent = new Intent();
            intent.setAction("android.media.action.IMAGE_CAPTURE");
    
    		//以下这句可以省略,Android默认返回一个Category的DEFAULT
            intent.addCategory("android.intent.category.DEFAULT");
    
            //存入图片
            Uri uri = Uri.fromFile(new File("/sdcard/0001.jpg"));
            intent.putExtra(MediaStore.EXTRA_OUTPUT,uri);
    
            startActivity(intent);
    
    展开全文
  • Qt开发Android应用,需求是通过调用Android原生接口去打开系统相机拍照,并返回拍摄的照片。原理很简单,现在Java文件中写android代码调用相机,拍照后将将相片存储在SD卡,然后在C++ 端调用。 首先,如果是一个新...

    Qt开发Android应用,需求是通过调用Android原生接口去打开系统相机拍照,并返回拍摄的照片。原理很简单,现在Java文件中写android代码调用相机,拍照后将将相片存储在SD卡,然后在C++ 端调用。
    首先,如果是一个新创建的Qt工程,需要创建一个AndroidManifest.xml文件,创建过程不再赘述,然后创建一个Java的类,继承于

    public class MainActivity extends org.qtproject.qt5.android.bindings.QtActivity

    定义一个公有的静态函数

    /**
        *打开系统相机拍照并返回相片
        */
        public static void openSystemCamera(QtActivity activity){
            try {
                    Intent intent = new Intent("android.media.action.IMAGE_CAPTURE");//开始拍照
                    m_instance.mPhotoPath = m_instance.getSDPath()+"/picture/";//+ m_instance.getPhotoFileName();//设置图片文件路径,getSDPath()和getPhotoFileName()具体实现在下面
                    File f = new File(m_instance.mPhotoPath);
                    if(!f.exists()){
                        f.mkdirs();
                    }
                    m_instance.mPhotoPath += m_instance.getPhotoFileName();
    
                    m_instance.mPhotoFile = new File(m_instance.mPhotoPath);
    
                    if (!m_instance.mPhotoFile.exists()) {
                        try {
                           if(!m_instance.mPhotoFile.createNewFile()) {
                               System.out.println("File already exists");
                           }
                        } catch (IOException ex) {
                           System.out.println(ex);
                        }
                    }
                    intent.putExtra(MediaStore.EXTRA_OUTPUT,//Intent有了图片的信息
                                    Uri.fromFile(m_instance.mPhotoFile));
                    activity.startActivityForResult(intent, CAMERA_RESULT);//跳转界面传回拍照所得数据
    
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        public String getSDPath(){
            File sdDir = null;
            boolean sdCardExist = Environment.getExternalStorageState()
                            .equals(android.os.Environment.MEDIA_MOUNTED);   //判断sd卡是否存在
            if(sdCardExist)
            {
                sdDir = Environment.getExternalStorageDirectory();//获取目录
            }
            return sdDir.toString();
    
        }
    
        private String getPhotoFileName() {
            Date date = new Date(System.currentTimeMillis());
            SimpleDateFormat dateFormat = new SimpleDateFormat(
                            "'IMG'_yyyyMMdd_HHmmss");
            return dateFormat.format(date)  +".jpg";
        }
    展开全文
  • 1 http://www.cnblogs.com/franksunny/archive/2011/11/17/2252926.html 2 http://www.cnblogs.com/vir56k/archive/2012/10/24/2737119.html 3 http://blog.30c.org/2798.html
  • 使用Qt for android调用原生系统的摄像头来录取设备,稳定高效,使用于安卓7.0版本及以上,测试在魅族5.0会后台死掉,但是录像会成功
  • 本文实现android系统照相机的调用拍照 项目的布局相当简单,只有一个Button: &lt;RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="...
  • 声明requestCode常量: public strait final int TACK_RECORD =10000; public strait final int TACK_PHOTO =10001; public strait final int TACK_...1.拍照代码: Intent openCameraIntent = new Intent(Med...
  • 最近我在群里看到有好几个人在交流说现在网上的一些Android调用系统相册和拍照的demo都有bug,有问题,没有一个完整的。确实是,我记得一个月前,我一同学也遇到了这样的问题,在低版本的系统中没问题,用高于4.4...
  • 调用系统照相机。 private void callPhone() { //获得文件 File _file = new File(StorageUtils.getCacheDirectory(this), "temp.jpg"); //判断文件是否为null if (_file != null) { //获得图片URI Uri
  • Android 拍照完确认的时候 onActivityResult()没有执行,但是取消的时候会调用。有的手机可以,但是华为的手机好像就没有执行
  • 要从RN中调用原生相机拍照和选择照片思路是这样的,先在原生中创建一个ReactContextBaseJavaModule模块,并在该模块中显示调用原生相机和选择照片的方法。然后,将该模块添加到ReactPackage列表中。最后,在js中导入...
  • import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.util.Calendar; import java.util.Locale;...import android.annotation.Su
  • 拍照问题 司项目里面需要拍照的地方很多,因为每次选取一张单张上传,所以并没有使用很多已经写好的第三方,反而选取了android原生拍照和相册选择。 最先遇见的问题就是适配,找网上的帖子很多都有原生拍照,...
  • Android 调用系统相机怎样实现一键拍照、录像。而不是打开界面后还需要点击拍照以及确定。
  • Qt调用安卓照相机,配合Qml和Java函数接口,照相机中技术包括摄像,打开相册,照相,播放摄像视频
  • Android调用系统相机拍照保存图片有两种方式: 保存缩略图(分辨率低,文件小) 保存原始照片 保存缩略图 //伪代码通过全局Application对象获取当前App的缓存目录文件 public final static String PATH_SD = App....
  • 最近在做一个需要上传拍照的APP,上传的时候因为是小图片,但是需求提了要点击可预览大图,一看大图,被吓到了,根本看不清楚,大图中的具体内容。原因是通过MediaStore.ACTION_IMAGE_CAPTURE方式直接去调用相机,在...
  • 一丶 调用原生硬件Api实现照相机拍照和相册选择 导入第三方库:image_picker 拍照 _takePhoto() async { var image = await ImagePicker.pickImage(source: ImageSource.camera); setState(() { _imgPath = image; }...
1 2 3 4 5 ... 20
收藏数 4,587
精华内容 1,834
关键字:

原生android调用手机拍照