Permitir que el usuario seleccione la cámara o la galería de imagen

Lo que yo estoy tratando de hacer parece muy simple, pero después de unos días de búsqueda no acabo de entenderlo.

Tengo una aplicación que permite al usuario seleccionar varios(hasta 5) imágenes. Estoy usando un ImageView. Cuando el usuario hace clic en el ImageView, me gustaría darles a ellos la opción de

  1. Seleccionar la imagen desde la galería, o
  2. Utilizar la cámara para capturar una imagen.

Empecé por el uso de la ACTION_GET_CONTENT intención, y que funciona bien para llegar a la galería. Así que he intentado utilizar la ACTION_PICK_ACTIVITY intención de permitir que el usuario elija la cámara o la galería:

Intent pickIntent = new Intent(Intent.ACTION_PICK_ACTIVITY);
Intent gallIntent=new Intent(Intent.ACTION_GET_CONTENT);
gallIntent.setType("image/*"); 
Intent camIntent = new Intent("android.media.action.IMAGE_CAPTURE");
pickIntent.putExtra(Intent.EXTRA_INTENT, camIntent);
pickIntent.putExtra(Intent.EXTRA_INTENT, gallIntent)
pickIntent.putExtra(Intent.EXTRA_TITLE, "Select Source");
startActivityForResult(pickIntent, IMAGE_SELECTOR);

Pero parece que sólo puedo añadir una EXTRA_INTENT. El menú se muestran como se esperaba, pero las únicas opciones de la Galería y Archivos….sin Cámara).

Hay un mejor y más fácil manera de hacer esto que me estoy perdiendo? Gracias por la ayuda.

  • FYI similar respuesta, complementaria a la de David superlativo respuesta a continuación. stackoverflow.com/a/11676554/294884 gracias de nuevo David de todo el mundo!!!
  • Echa un vistazo a esta respuesta con la intención de que fusiona ambas solicitudes (Camera & Galería) en una única Intención: stackoverflow.com/a/32475805/2232889
  • Simple: el Uso de una biblioteca como este.
InformationsquelleAutor Wulfgar | 2010-12-15

17 Kommentare

  1. 31

    Usted tendrá que crear su propio selector de cuadro de diálogo de la fusión de ambos intención de resolución de resultados.

    Para hacer esto, usted tendrá que consultar el PackageManager con PackageManager.queryIntentActivities() para el original intenciones y crear la lista definitiva de las posibles Intenciones con una nueva Intención para cada recuperado actividad como esta:

    List<Intent> yourIntentsList = new ArrayList<Intent>();
    
    List<ResolveInfo> listCam = packageManager.queryIntentActivities(camIntent, 0);
    for (ResolveInfo res : listCam) {
        final Intent finalIntent = new Intent(camIntent);
        finalIntent.setComponent(new ComponentName(res.activityInfo.packageName, res.activityInfo.name));
        yourIntentsList.add(finalIntent);
    }
    
    List<ResolveInfo> listGall = packageManager.queryIntentActivities(gallIntent, 0);
    for (ResolveInfo res : listGall) {
        final Intent finalIntent = new Intent(gallIntent);
        finalIntent.setComponent(new ComponentName(res.activityInfo.packageName, res.activityInfo.name));
        yourIntentsList.add(finalIntent);
    }

    (Esto lo escribí directamente aquí, así que esto no puede compilar)

    A continuación, para obtener más información sobre la creación de un cuadro de diálogo personalizado a partir de una lista de ver https://developer.android.com/guide/topics/ui/dialogs.html#AlertDialog

  2. 318

    Cómo lanzar una única Intención de seleccionar las imágenes desde la Galería o de la Cámara, o cualquier aplicación registrado para examinar el sistema de archivos.

    Lugar de crear un cuadro de Diálogo con una lista de opciones de calidad, es mucho mejor utilizar Intención.createChooser con el fin de obtener acceso a la interfaz gráfica de los iconos y los nombres cortos de los diversos ‘Cámara’, ‘Galería’ y de Terceros, incluso de sistema de archivos del explorador de aplicaciones tales como ‘Astro’, etc.

    Se describe cómo utilizar el selector de intención de añadir color para que.

    private Uri outputFileUri;
    
    private void openImageIntent() {
    
        //Determine Uri of camera image to save.
        final File root = new File(Environment.getExternalStorageDirectory() + File.separator + "MyDir" + File.separator);
        root.mkdirs();
        final String fname = Utils.getUniqueImageFilename();
        final File sdImageMainDirectory = new File(root, fname);
        outputFileUri = Uri.fromFile(sdImageMainDirectory);
    
        //Camera.
        final List<Intent> cameraIntents = new ArrayList<Intent>();
        final Intent captureIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
        final PackageManager packageManager = getPackageManager();
        final List<ResolveInfo> listCam = packageManager.queryIntentActivities(captureIntent, 0);
        for(ResolveInfo res : listCam) {
            final String packageName = res.activityInfo.packageName;
            final Intent intent = new Intent(captureIntent);
            intent.setComponent(new ComponentName(packageName, res.activityInfo.name));
            intent.setPackage(packageName);
            intent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
            cameraIntents.add(intent);
        }
    
        //Filesystem.
        final Intent galleryIntent = new Intent();
        galleryIntent.setType("image/*");
        galleryIntent.setAction(Intent.ACTION_GET_CONTENT);
    
        //Chooser of filesystem options.
        final Intent chooserIntent = Intent.createChooser(galleryIntent, "Select Source");
    
        //Add the camera options.
        chooserIntent.putExtra(Intent.EXTRA_INITIAL_INTENTS, cameraIntents.toArray(new Parcelable[cameraIntents.size()]));
    
        startActivityForResult(chooserIntent, YOUR_SELECT_PICTURE_REQUEST_CODE);
    }
    
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (resultCode == RESULT_OK) {
            if (requestCode == YOUR_SELECT_PICTURE_REQUEST_CODE) {
                final boolean isCamera;
                if (data == null) {
                    isCamera = true;
                } else {
                    final String action = data.getAction();
                    if (action == null) {
                        isCamera = false;
                    } else {
                        isCamera = action.equals(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
                    }
                }
    
                Uri selectedImageUri;
                if (isCamera) {
                    selectedImageUri = outputFileUri;
                } else {
                    selectedImageUri = data == null ? null : data.getData();
                }
            }
        }
    }
    • funciona bien! pero, ¿cómo puedo averiguar la bruja de la fuente viene la imagen de? Mi código real que sólo se ocupan de la intención correctamente si el usuario ha elegido a la cámara.
    • Lucas, he añadido una edición que se muestra cómo determinar si el origen de la imagen es de la Cámara o de la Galería (isCamera) en el ‘onActivityResult’ método. También determina la imagen guardada URI que puede ser muy diferente dependiendo de la plataforma y dispositivo. La única forma segura de saber la cámara de URI en todos los dispositivos es especificar de antemano.
    • Muy bueno! Sólo una rápida mejora: en la primera persona isCamera = MediaStore.ACTION_IMAGE_CAPTURE.de igual(de datos.getAction()); Una línea para gobernarlos a todos 😉
    • Recomiendo hacer el campo outputFileUri estática, debido a la posible cambio de orientación. Y…. Una línea para gobernarlos a TODOS: Uri selectedImageUri = (intención) = = null ? verdadero : MediaStore.ACTION_IMAGE_CAPTURE.es igual a(intención.getAction())) ? outputFileUri : (intención) = = null ? null : intención.getData());
    • Esto es impresionante, gracias. A solo 1 pequeño problema, siempre se utiliza Holo tema, incluso si todas mis actividades de uso Holo.La luz. ¿Cómo puedo cambiar el tema de la emergente? Gracias
    • En mi caso final String fname = Utils.getUniqueImageFilename(); no funciona… dice Utils cannot be resolved🙁
    • es mi propio método para generar un nombre de archivo único. Hay muchas maneras de hacerlo. Una de las más sencillas es usar algo como "img_"+ System.currentTimeMillis() + ".jpg". Otro es File.createTempFile().
    • ohh tengo. ¿Qué acerca de las extensiones? se pueden especificar otros que .jpg? y es que especifica la extensión es opcional u obligatoria?
    • Sí, estoy atascado aquí también.. tengo que tener la extensión correcta debido a que el archivo luego de ser subido a un servidor web donde se mostrará.. si la extensión está mal, entonces Se rompe en el servidor web. Gracias.
    • Yo creo que el Android de la cámara sólo puede capturar en formato jpeg, por lo que debe usar siempre «.jpg» extensión de nombre de archivo (en realidad hay formas de obtener nativa los formatos raw de la cámara de devolución de llamada, pero esas son de tamaño miniatura y complicado para decodificar, así que no vayas por ese camino, a menos que sea absolutamente necesario, porque de pseudo-requisitos en tiempo real o similar).
    • Esto funcionó muy bien para mí, pero yo tenía un problema donde el uso de la cámara como la fuente no estaba llamando onActivityResult y la cámara en sí no estaba despidiendo. La causa fue una falta de permiso en el manifiesto: <uses-permission android:name=»android.el permiso.WRITE_EXTERNAL_STORAGE»/>
    • Gracias por esta respuesta que funciona muy bien. Y gracias a @BitsEvolved para la Cámara, no se desestima, acabo de añadir <uses-permission android:name=»android.el permiso.WRITE_EXTERNAL_STORAGE»/> para manifestarse.
    • Cómo es este código de trabajo para las personas que OS KitKat 4.4? Parece haber caído de la «Galera» y «Fotos» de las selecciones y los reemplazó con «Documentos» que no es muy amigable. Este post androiddev.orkitra.com/?p=128645 parece decir que es el comportamiento esperado, pero no parece muy buena.
    • como todos los que me dicen gracias – un punto crítico para mí fue determinar si el usuario utiliza la cámara o la galería. Los «datos==null» era el secreto para mí! GRACIAS!
    • He utilizado este código tal como es, sino isCamara siempre devuelve false, incluso si selecciono la cámara de selector de intención. Alguna idea??
    • ver Plexo de la respuesta a continuación.
    • ¿Puede alguien por favor me diga por qué estoy recibiendo null para outputFileUri (sólo cuando se utiliza la cámara, con la galería funciona bien) ? Mi dispositivo de prueba Galaxy s2 con Anroid 4.2.
    • Hey, yo también quiero agregar Quitar el Botón de la Imagen..¿cómo hacerlo posible??
    • Encontré esto en 5.1.1. Veo los datos!=null y datos.getAction()==null. Esto hace que adjuntar una captura de cámara de imagen a fallar desde el uri es el tiempo null. Alguna sugerencia?
    • Como Rohan, dijo, esto es un cambio en 5.1.1. Usted necesitará hacer if (data == null || data.getData() == null).
    • Me pareció que para ser if (data == null || (data.getData() == null && data.getClipData() == null)) como data.getClipData() no puede ser null si el usuario ha seleccionado varias imágenes de la biblioteca.
    • Es un problema conocido que todo el mundo se enfrenta a un NullPointerException mientras se trabaja con la cámara incorporada de la aplicación. Cuando lanzamos la cámara a la que en realidad se reinicia nuestra actividad que hace que outputFileUri a ser nulo. Así que cuando utilizamos outputFileUri para mostrar la imagen capturada o vídeo grabado, vamos a llegar a NullPointerException.Así que para solucionarlo tenemos que usar onSaveInstanceState() y onRestoreInstanceState() para conservar outputFileUri valor.
    • El uso de Intent.ACTION_PICK en lugar de Intent.ACTION_GET_CONTENT devolverá la más natural de las Fotos de la aplicación en lugar de los Documentos de aplicación en la acción resultante selector.
    • en mi caso, google cámara no se abra cuando me toque la cámara desde el selector. Aunque tanto la cámara y la galería se muestran en el selector. Estoy corriendo android 6.0 Malvavisco.
    • Yo intente if (data == null || data.getScheme().equals("file")) y funciona bien
    • Siempre terminaba con imágenes vacías con esta respuesta así que me tenía que adaptar: consulte stackoverflow.com/questions/38090474/…
    • Esta es una buena respuesta, pero el resultado es una especie de complicado. Por ejemplo, ahora tengo la opción de elegir desde ES explorador de archivos y Sistema Android. ES explorador de archivos es sencillo pero esperar hasta el acceso del Sistema Android, se muestra la opción para ES el Administrador de Archivos, explorador de archivos predeterminado, galería etc. Estas opciones ya están disponibles antes. Ahora solo quería acotar la opción de la Galería, el Sistema de Archivos + aplicaciones externas que pueden tener acceso a archivos del sistema (si lo hay) y de la Cámara
    • Hola, a la hora de elegir cámara, devuelve null, sólo si elijo una de la galería funciona!
    • Alguien tan amable de compartir un firemonkey (fmx), la versión de código? Por ejemplo, no puedo encontrar createChooser bajo JIntent. Gracias.
    • Cuando se utiliza la cámara siempre me resultCode == Actividad.RESULT_CANCELED en onActivityResult. El Uso De Android De 7+
    • He utilizado este código. en el botón haga clic en tengo 2 opción de la cámara y del documento,(quiero galería). el segundo punto es que cuando selecciono la misma imagen dos veces recibiendo un error de que la imagen no se encuentra. cuando seleccione la primera vez que Se trabaja.
    • Mi aplicación se abre la cámara, pero si hago clic en aceptar no pasa nada. Cualquier idea acerca de eso? No sé cuál es el problema

  3. 22

    He encontrado este. Uso:

    galleryIntent.setType("image/*");
    galleryIntent.setAction(Intent.ACTION_GET_CONTENT);

    para uno de los intentos se muestra al usuario la opción de seleccionar la opción «documentos» de Android 4, lo cual me pareció muy confuso. El uso de este lugar muestra la galería de ‘la’ opción:

    Intent pickIntent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
    • esto funciona bien..pero cuando navegamos por la imagen de la cámara,retrato de la imagen de muestra en el modo de paisaje..
    • y otros que tienen problemas con la orientación de la imagen seleccionada, consulte stackoverflow.com/a/6931373/1975002 para obtener la orientación correcta y, a continuación, girar si es necesario.
  4. 12

    También he tenido este problema y lo que hice fue crear un AlertDialog y el uso de la setItems() método, junto con la DialogInterface oyente:

    AlertDialog.Builder getImageFrom = new AlertDialog.Builder(Fotos.this);
    getImageFrom.setTitle("Select:");
    final CharSequence[] opsChars = {getResources().getString(R.string.takepic), getResources().getString(R.string.opengallery)};
    getImageFrom.setItems(opsChars, new android.content.DialogInterface.OnClickListener(){
    
        @Override
        public void onClick(DialogInterface dialog, int which) {
            if(which == 0){
                Intent cameraIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
                startActivityForResult(cameraIntent, CAMERA_PIC_REQUEST);
            }else
                if(which == 1){
                    Intent intent = new Intent();
                    intent.setType("image/*");
                    intent.setAction(Intent.ACTION_GET_CONTENT);
                    startActivityForResult(Intent.createChooser(intent,
                        getResources().getString(R.string.pickgallery)), SELECT_PICTURE);
                }
            dialog.dismiss();
        }
    });
  5. 11

    Me han fusionado algunas soluciones para hacer una completa util para elegir una imagen desde la Galería o de la Cámara. Estas son las características de ImagePicker util (también en un Github lib):

    • Fusionado intenciones para la Galería y la Cámara resquests.
    • Cambiar el tamaño seleccionado las imágenes grandes (por ejemplo: 2500 x 1600)
    • Rotar la imagen en caso de considerarlo necesario

    Captura de pantalla:

    Permitir que el usuario seleccione la cámara o la galería de imagen

    Editar: Aquí es un fragmento de código para obtener una fusión de Intención para la Galería y aplicaciones de la Cámara juntos.
    Usted puede ver el código completo en ImagePicker util (también en un Github lib):

    public static Intent getPickImageIntent(Context context) {
        Intent chooserIntent = null;
    
        List<Intent> intentList = new ArrayList<>();
    
        Intent pickIntent = new Intent(Intent.ACTION_PICK,
                android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
        Intent takePhotoIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        takePhotoIntent.putExtra("return-data", true);
        takePhotoIntent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(getTempFile(context)));
        intentList = addIntentsToList(context, intentList, pickIntent);
        intentList = addIntentsToList(context, intentList, takePhotoIntent);
    
        if (intentList.size() > 0) {
            chooserIntent = Intent.createChooser(intentList.remove(intentList.size() - 1),
                    context.getString(R.string.pick_image_intent_text));
            chooserIntent.putExtra(Intent.EXTRA_INITIAL_INTENTS, intentList.toArray(new Parcelable[]{}));
        }
    
        return chooserIntent;
    }
    
    private static List<Intent> addIntentsToList(Context context, List<Intent> list, Intent intent) {
        List<ResolveInfo> resInfo = context.getPackageManager().queryIntentActivities(intent, 0);
        for (ResolveInfo resolveInfo : resInfo) {
            String packageName = resolveInfo.activityInfo.packageName;
            Intent targetedIntent = new Intent(intent);
            targetedIntent.setPackage(packageName);
            list.add(targetedIntent);
        }
        return list;
    }
    • Esto funciona realmente bien. Gracias. Único problema que estoy teniendo es que las fotos tomadas con la cámara en vertical vienen apareciendo como paisaje. ¿Qué necesito hacer para obtener rotar las imágenes requeridas?
    • Se puede comprobar si se está entrando en el método getRotationFromCamera (ImagePicker.java) y el valor de regresar? En qué teléfono están realizando pruebas?
    • Estoy usando un Sony Experia C y el Android Studio emulador. Acabo de poner en algunos puntos de interrupción para comprobar las cosas que le pidieron y parece booleano isCamera es falso en el getRotation método que es el de detener la getRotationFromCamera de ser llamado.
    • ¿Qué versión de Android estás tratando? He añadido una modificación de la semana pasada en la línea 58, comprobar si se resolvió: boolean isCamera = (imageReturnedIntent == null || imageReturnedIntent.getData() == null);
    • Ok, el emulador es la versión 6.0 y parece que la línea 58 está trabajando bien en este. En el emulador isCamera es verdadera y getRotationFromCamera se llama bien, pero int orientación es 0, lo que significa getRotationFromCamera está volviendo 0… El Sony dispositivo con Android 4.2 y en este caso ni imageReturnedIntent o imageReturnedIntent.getData() son nulos en la línea 58 significado isCamera es falso y no voy a llegar tan lejos como llamar getRotationFromCamera.
    • Probablemente el emulador no tiene sensores para saber si la fotografía se toma en modo retrato o paisaje, pero en el teléfono debería estar trabajando. Voy a investigar más por qué no está funcionando en el teléfono. Dime si encuentras la solución.
    • Permítanos seguir esta discusión en el chat.

  6. 6

    Para los que obtener un error en 4.4 hacia arriba a la vez tratando de usar la selección de la Imagen puede utilizar el código siguiente.

    Lugar de crear un cuadro de Diálogo con una lista de opciones de calidad, es mucho mejor utilizar Intención.createChooser con el fin de obtener acceso a la interfaz gráfica de los iconos y los nombres cortos de los diversos ‘Cámara’, ‘Galería’ y de Terceros, incluso de sistema de archivos del explorador de aplicaciones tales como ‘Astro’, etc.

    Se describe cómo utilizar el selector de intención de añadir color para que.

    private void openImageIntent(){
    
        //Determine Uri of camera image to save.
        final File root = new File(Environment.getExternalStorageDirectory() + File.separator + "amfb" + File.separator);
        root.mkdir();
        final String fname = "img_" + System.currentTimeMillis() + ".jpg";
        final File sdImageMainDirectory = new File(root, fname);
        outputFileUri = Uri.fromFile(sdImageMainDirectory);
    
        //Camera.
        final List<Intent> cameraIntents = new ArrayList<Intent>();
        final Intent captureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        final PackageManager packageManager = getPackageManager();
        final List<ResolveInfo> listCam = packageManager.queryIntentActivities(captureIntent, 0);
        for (ResolveInfo res : listCam){
            final String packageName = res.activityInfo.packageName;
            final Intent intent = new Intent(captureIntent);
            intent.setComponent(new ComponentName(res.activityInfo.packageName, res.activityInfo.name));
            intent.setPackage(packageName);
            intent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
            cameraIntents.add(intent);
        }
    
        //FileSystem
        final Intent galleryIntent = new Intent();
        galleryIntent.setType("image/");
        galleryIntent.setAction(Intent.ACTION_GET_CONTENT);
    
        //Chooser of filesystem options.
        final Intent chooserIntent = Intent.createChooser(galleryIntent, "Select Source");
        //Add the camera options.
        chooserIntent.putExtra(Intent.EXTRA_INITIAL_INTENTS, cameraIntents.toArray(new Parcelable[]{}));
        startActivityForResult(chooserIntent, CAMERA_CAPTURE_IMAGE_REQUEST_CODE);
    
    }
    
    
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        //super.onActivityResult(requestCode, resultCode, data);
        if (resultCode == RESULT_OK) {
            if (requestCode == CAMERA_CAPTURE_IMAGE_REQUEST_CODE) {
                final boolean isCamera;
                if (data == null) {
                    isCamera = true;
                } else {
                    final String action = data.getAction();
                    if (action == null) {
                        isCamera = false;
                    } else {
                        isCamera = action.equals(MediaStore.ACTION_IMAGE_CAPTURE);
                    }
                }
    
                Uri selectedImageUri;
                if (isCamera) {
                    selectedImageUri = outputFileUri;
                    //Bitmap factory
                    BitmapFactory.Options options = new BitmapFactory.Options();
                    //downsizing image as it throws OutOfMemory Exception for larger
                    //images
                    options.inSampleSize = 8;
                    final Bitmap bitmap = BitmapFactory.decodeFile(selectedImageUri.getPath(), options);
                    preview.setImageBitmap(bitmap);
                } else {
                    selectedImageUri = data == null ? null : data.getData();
                    Log.d("ImageURI", selectedImageUri.getLastPathSegment());
                    ///Bitmap factory
                    BitmapFactory.Options options = new BitmapFactory.Options();
                    //downsizing image as it throws OutOfMemory Exception for larger
                    //images
                    options.inSampleSize = 8;
                    try {//Using Input Stream to get uri did the trick
                        InputStream input = getContentResolver().openInputStream(selectedImageUri);
                        final Bitmap bitmap = BitmapFactory.decodeStream(input);
                        preview.setImageBitmap(bitmap);
                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    }
                }
            }
        } else if (resultCode == RESULT_CANCELED){
            //user cancelled Image capture
            Toast.makeText(getApplicationContext(),
                    "User cancelled image capture", Toast.LENGTH_SHORT)
                    .show();
        } else {
            //failed to capture image
            Toast.makeText(getApplicationContext(),
                    "Sorry! Failed to capture image", Toast.LENGTH_SHORT)
                    .show();
        }
    }
    • Hola. He intentado la solución, pero recogiendo una imagen de gallary no funciona: echa un vistazo aquí: stackoverflow.com/questions/36884651/…
    • En mi malvavisco dispositivo se echa a perder cuando se utiliza la cámara. para mí de datos no es nulo, pero la acción es causante de isCamera se establece en false.
  7. 6

    Este debe tener cuidado de Tina null outputFileUri tema:

    private static final String STORED_INSTANCE_KEY_FILE_URI = "output_file_uri";
    
    @Override
    public void onSaveInstanceState( Bundle outState ) {
        super.onSaveInstanceState( outState );
    
        if ( outputFileUri != null ) {
            outState.putString( STORED_INSTANCE_KEY_FILE_URI, outputFileUri.toString() );
        }
    }
    
    @Override
    public void onViewStateRestored( Bundle savedInstanceState ) {
        super.onViewStateRestored( savedInstanceState );
    
        if ( savedInstanceState != null ) {
          final String outputFileUriStr = savedInstanceState.getString( STORED_INSTANCE_KEY_FILE_URI );
          if ( outputFileUriStr != null && !outputFileUriStr.isEmpty() ) {
              outputFileUri = Uri.parse( outputFileUriStr );
          }
        }
    }

    Nota: estoy usando este código dentro de android.apoyo.v4.app.Fragmento de sus métodos sobrescritos podrían cambiar dependiendo de qué Fragmento/Actividad de la versión que estés utilizando.

  8. 5

    Puede crear la opción de diálogo

    De Cámara Abierta:

    Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                            cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT,
                                    MediaStore.Images.Media.EXTERNAL_CONTENT_URI.toString());
                            if (cameraIntent.resolveActivity(getActivity().getPackageManager()) != null) {
                                startActivityForResult(cameraIntent, CAMERA_IMAGE);
                            }

    Galería Abierta:

    if (Build.VERSION.SDK_INT <= 19) {
                Intent i = new Intent();
                i.setType("image/*");
                i.setAction(Intent.ACTION_GET_CONTENT);
                i.addCategory(Intent.CATEGORY_OPENABLE);
                startActivityForResult(i, GALLARY_IMAGE);
            } else if (Build.VERSION.SDK_INT > 19) {
                Intent intent = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
                startActivityForResult(intent, GALLARY_IMAGE);
            }

    Para obtener la selección del resultado

    @Override
        public void onActivityResult(int requestCode, int resultCode, Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            if (resultCode == Activity.RESULT_OK) {
                if (requestCode == GALLARY_IMAGE) {
                    Uri selectedImageUri = data.getData();
                    String selectedImagePath = getRealPathFromURI(selectedImageUri);
                } else if (requestCode == CAMERA_IMAGE) {
                    Bundle extras = data.getExtras();
                    Bitmap bmp = (Bitmap) extras.get("data");
                    SaveImage(bmp);
                }
            }
        }
    
     public String getRealPathFromURI(Uri uri) {
            if (uri == null) {
                return null;
            }
            String[] projection = {MediaStore.Images.Media.DATA};
            Cursor cursor = getActivity().getContentResolver().query(uri, projection, null, null, null);
            if (cursor != null) {
                int column_index = cursor
                        .getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
                cursor.moveToFirst();
                return cursor.getString(column_index);
            }
            return uri.getPath();
        }

    Método para guardar la imagen capturada

     private void SaveImage(final Bitmap finalBitmap) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    String root = Environment.getExternalStorageDirectory().toString();
    
                    File myDir = new File(root + "/Captured Images/");
                    if (!myDir.exists())
                        myDir.mkdirs();
    
                    String fname = "/image-" + System.currentTimeMillis() + ".jpg";
                    File file = new File(myDir, fname);
                    try {
                        FileOutputStream out = new FileOutputStream(file);
                        finalBitmap.compress(Bitmap.CompressFormat.JPEG, 100, out);
                        out.flush();
                        out.close();
                        localImagePath = myDir + fname;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
    
    
            });
            t.start();
    
        }
  9. 2

    Resuelto demasiado grande problema de imagen y evitar que fuera de la memoria.

        private static final int SELECT_PICTURE = 0;
        private static final int REQUEST_CAMERA = 1;
        private ImageView mImageView;
    
        private void selectImage() {
            final CharSequence[] items = {"Take Photo", "Choose from Library",
                    "Cancel"};
            AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
            builder.setTitle("Add Photo!");
            builder.setItems(items, new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int item) {
                    if (items[item].equals("Take Photo")) {
                        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                        File f = new File(android.os.Environment
                                .getExternalStorageDirectory(), "temp.jpg");
                        intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(f));
                        startActivityForResult(intent, REQUEST_CAMERA);
                    } else if (items[item].equals("Choose from Library")) {
                        Intent intent = new Intent(
                                Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
                        intent.setType("image/*");
                        startActivityForResult(
                                Intent.createChooser(intent, "Select File"),
                                SELECT_PICTURE);
                    } else if (items[item].equals("Cancel")) {
                        dialog.dismiss();
                    }
                }
            });
            builder.show();
        }
        @Override
        public void onActivityResult(int requestCode, int resultCode, Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            if (resultCode == Activity.RESULT_OK) {
                if (requestCode == REQUEST_CAMERA) {
                    File f = new File(Environment.getExternalStorageDirectory()
                            .toString());
                    for (File temp : f.listFiles()) {
                        if (temp.getName().equals("temp.jpg")) {
                            f = temp;
                            break;
                        }
                    }
                    try {
                        Bitmap bm;
                        BitmapFactory.Options btmapOptions = new BitmapFactory.Options();
                        btmapOptions.inSampleSize = 2;
                        bm = BitmapFactory.decodeFile(f.getAbsolutePath(),
                                btmapOptions);
    
                        //bm = Bitmap.createScaledBitmap(bm, 70, 70, true);
                        mImageView.setImageBitmap(bm);
    
                        String path = android.os.Environment
                                .getExternalStorageDirectory()
                                + File.separator
                                + "test";
                        f.delete();
                        OutputStream fOut = null;
                        File file = new File(path, String.valueOf(System
                                .currentTimeMillis()) + ".jpg");
                        fOut = new FileOutputStream(file);
                        bm.compress(Bitmap.CompressFormat.JPEG, 85, fOut);
                        fOut.flush();
                        fOut.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                } else if (requestCode == SELECT_PICTURE) {
                    Uri selectedImageUri = data.getData();
                    String tempPath = getPath(selectedImageUri, this.getActivity());
                    Bitmap bm;
                    btmapOptions.inSampleSize = 2;
                    BitmapFactory.Options btmapOptions = new BitmapFactory.Options();
                    bm = BitmapFactory.decodeFile(tempPath, btmapOptions);
                    mImageView.setImageBitmap(bm);
                }
            }
        }
        public String getPath(Uri uri, Activity activity) {
            String[] projection = {MediaStore.MediaColumns.DATA};
            Cursor cursor = activity
                    .managedQuery(uri, projection, null, null, null);
            int column_index = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.DATA);
            cursor.moveToFirst();
            return cursor.getString(column_index);
        }
  10. 1

    Agregar mi solución – se va a volver una devolución de llamada si es desde la cámara o desde la galería, junto a la intención:

    public class ImagePickerManager extends BaseAdapter {
    
    private List<ResolveInfo> mApplications;
    private TreeSet<Integer> mImageCaptureIntents;
    private TreeSet<Integer> mImagePickerIntents;
    private Context mContext;
    private final ImagePickerManagerListener listener;
    
    private static enum intentType {
        choosePhoto,
        takePhoto,
        unknown;
    
        public int getIntValue() {
            switch (this) {
                case choosePhoto:
                    return 0;
                case takePhoto:
                    return 1;
                case unknown:
                    return 2;
            }
            return 0;
        }
    }
    
    public interface ImagePickerManagerListener {
        void onChooseImage(Intent intent);
        void onCaptureImage(Intent intent);
    }
    
    public ImagePickerManager(Context context,ImagePickerManagerListener listenr) {
        this.mContext = context;
        this.listener = listenr;
    
        mImageCaptureIntents = new TreeSet<>();
        mImagePickerIntents = new TreeSet<>();
    
        //Picking photo intent
        Intent intent = new Intent(Intent.ACTION_PICK);
        intent.setType("image/*");
        mApplications = mContext.getPackageManager().queryIntentActivities(intent, 0);
    
        int index = 0;
        for (int i = 0; i < mApplications.size(); i++) {
            mImagePickerIntents.add(index);
            index++;
        }
    
        //Capture photo intent
        intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        List<ResolveInfo> resolveInfoList = mContext.getPackageManager().queryIntentActivities(intent, 0);
        mApplications.addAll(resolveInfoList);
        for (int i = 0; i < mApplications.size(); i++) {
            mImageCaptureIntents.add(index);
            index++;
        }
    }
    
    public static void openChooseAndCaptureImageDialog(final Context context, final ImagePickerManagerListener listener) {
    
        Log.d("openChooseAndCaptureImageDialog", "enter");
    
        final AlertDialog.Builder builder = new AlertDialog.Builder(context);
        final ImagePickerManager imagePickerManager = new ImagePickerManager(context,listener);
        builder.setTitle(context.getString(R.string.image_picker_dialog_box_title));
        builder.setAdapter(imagePickerManager, new DialogInterface.OnClickListener() {
    
            @Override
            public void onClick(DialogInterface dialoginterface, int i) {
                ResolveInfo resolveInfo = (ResolveInfo) imagePickerManager.getItem(i);
                Intent pickerIntent = imagePickerManager.getIntentForPackage(context,resolveInfo,i);
                switch (imagePickerManager.getIntentType(i)){
                    case choosePhoto:
                        listener.onChooseImage(pickerIntent);
                        break;
                    case takePhoto:
                        listener.onCaptureImage(pickerIntent);
                        break;
                    case unknown:
                        break;
                }
            }
        });
    
        builder.setCancelable(true);
        builder.setInverseBackgroundForced(true);
        AlertDialog dialog = builder.create();
        dialog.show();
    }
    
    
    private intentType getIntentType(int index) {
    
        if (mImageCaptureIntents.contains(index)) {
           return intentType.takePhoto;
        } else if(mImagePickerIntents.contains(index)) {
            return intentType.choosePhoto;
        }
        return intentType.unknown;
    }
    
    private Intent getIntentForPackage(Context context, ResolveInfo info,int index) {
        Intent intent = context.getPackageManager().getLaunchIntentForPackage(info.activityInfo.packageName);
    
        ComponentName chosenName = new ComponentName(
                info.activityInfo.packageName,
                info.activityInfo.name);
    
        intent.setComponent(chosenName);
        intent.setFlags(Intent.FLAG_ACTIVITY_TASK_ON_HOME);
        if (mImageCaptureIntents.contains(index)) {
            intent.setAction(MediaStore.ACTION_IMAGE_CAPTURE);
        } else if(mImagePickerIntents.contains(index)) {
            intent.setType("image/*");
            intent.setAction(Intent.ACTION_PICK);
        }
        return intent;
    }
    
    @Override
    public int getCount() {
        return mApplications.size();
    }
    
    @Override
    public Object getItem(int position) {
        return mApplications.get(position);
    }
    
    @Override
    public long getItemId(int position) {
        return position;
    }
    
    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        ResolveInfo item = mApplications.get(position);
        if (convertView == null) {
            TextView applicationTextView = new TextView(mContext);
            LayoutParams param = new LayoutParams(
                    LayoutParams.MATCH_PARENT,
                    LayoutParams.WRAP_CONTENT);
            applicationTextView.setLayoutParams(param);
            final int horizontalPadding = (int) FVRGeneralUtils.convertDpToPx(mContext, 15);
            final int verticalPadding = (int) FVRGeneralUtils.convertDpToPx(mContext, 5);
            applicationTextView.setPadding(horizontalPadding,verticalPadding, horizontalPadding, verticalPadding);
            applicationTextView.setGravity(android.view.Gravity.CENTER_VERTICAL);
            Resources.Theme th = mContext.getTheme();
            TypedValue tv = new TypedValue();
    
            if (th.resolveAttribute(android.R.attr.textAppearanceMedium, tv, true)) {
                applicationTextView.setTextAppearance(mContext, tv.resourceId);
            }
    
            applicationTextView.setMinHeight((int) FVRGeneralUtils.convertDpToPx(mContext, 25));
            applicationTextView.setCompoundDrawablePadding((int) FVRGeneralUtils.convertDpToPx(mContext, 7));
            convertView = applicationTextView;
        }
    
        TextView textView = (TextView) convertView;
        textView.setText(item.loadLabel(mContext.getPackageManager()));
        textView.setCompoundDrawablesWithIntrinsicBounds(item.loadIcon(mContext.getPackageManager()), null, null, null);
        return textView;
    } }
    • Mientras que este vínculo puede responder a la pregunta, es mejor incluir a las partes esenciales de la respuesta aquí y proporcionar el enlace de referencia. Enlace-sólo respuestas puede ser válido si la página enlazada cambios.
    • Añadido el código, gracias por los comentarios.
  11. 1

    Que usted puede probar esto :

    Para abrir la Galería :

    private void browseImage() {
    
            try {
      Intent galleryIntent = new Intent(Intent.ACTION_PICK,
                        android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
      startActivityForResult(galleryIntent, GALLERY_IMAGE_PICK); //GALLERY_IMAGE_PICK it is a string
      } catch (Exception e) {}
         }

    Para abrir la Cámara :

     private void captureImage() {
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    
        fileUri = getOutputMediaFileUri(MEDIA_TYPE_IMAGE);
    
        intent.putExtra(MediaStore.EXTRA_OUTPUT, fileUri);
    
        //start the image capture Intent
    
        startActivityForResult(intent, CAMERA_CAPTURE_IMAGE_REQUEST_CODE);
    
    }
    • Esta es una pasta de otro lugar ASÍ. Por ejemplo – ¿qué getOutputMediaFileUri hacer? Por favor, comparta ejemplos, con la explicación.
  12. 0

    Esto es simple mediante el uso de AlertDialog y la Intención.ACTION_PICK

        //camOption is a string array contains two items (Camera, Gallery)
        AlertDialog.Builder builder = new AlertDialog.Builder(CarPhotos.this);
        builder.setTitle(R.string.selectSource)
        .setItems(R.array.imgOption, new DialogInterface.OnClickListener() {
    
        public void onClick(DialogInterface dialog, int which)
    
         {
    
            if (which==0) {
            Intent intent = new Intent(this, CameraActivity.class);
            startActivityForResult(intent, REQ_CAMERA_IMAGE);               }
    
            if (which==1) {
            Intent i = new Intent(Intent.ACTION_PICK,android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
            startActivityForResult(i, RESULT_LOAD_IMAGE);
                }
    
         }
                });
                 builder.create();
                 builder.show();
  13. 0

    Edificio sobre David de la respuesta, mis dos centavos sobre el onActivityResult() parte. Se ocupa de los cambios introducidos en 5.1.1 y detecta si el usuario ha elegido una sola o de varias imágenes de la biblioteca.

    private enum Outcome {
        camera, singleLibrary, multipleLibrary, unknown
    }
    
    /**
     * Returns a List<Uri> containing the image uri(s) chosen by the user
     *
     * @param data      The data intent coming from the onActivityResult()
     * @param cameraUri The uri that had been passed to the intent when the chooser was invoked.
     * @return A List<Uri>, never null.
     */
    public List<Uri> getPicturesUriFromIntent(Intent data, Uri cameraUri) {
    
        Outcome outcome = Outcome.unknown;
    
        if (data == null || (data.getData() == null && data.getClipData() == null)) {
            outcome = Outcome.camera;
        } else if (data.getData() != null && data.getClipData() == null) {
            outcome = Outcome.singleLibrary;
        } else if (data.getData() == null) {
            outcome = Outcome.multipleLibrary;
        } else {
            final String action = data.getAction();
            if (action != null && action.equals(MediaStore.ACTION_IMAGE_CAPTURE)) {
                outcome = Outcome.camera;
            }
        }
    
        //list the uri(s) we got back
        List<Uri> uris = new ArrayList<>();
        switch (outcome) {
            case camera:
                uris.add(cameraUri);
                break;
    
            case singleLibrary:
                uris.add(data.getData());
                break;
    
            case multipleLibrary:
                final ClipData clipData = data.getClipData();
                for (int i = 0; i < clipData.getItemCount(); i++) {
                    ClipData.Item item = clipData.getItemAt(i);
                    uris.add(item.getUri());
                }
                break;
        }
    
        return uris;
    }
  14. 0

    Trate de esta manera

    final CharSequence[] items = { "Take Photo", "Choose from Library",
                "Cancel" };
    
        AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
        builder.setTitle("Add Photo!");
        builder.setItems(items, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int item) {
                if (items[item].equals("Take Photo")) {
                    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    File f = new File(android.os.Environment
                            .getExternalStorageDirectory(), "temp.jpg");
                    intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(f));
                    startActivityForResult(intent, REQUEST_CAMERA);
                } else if (items[item].equals("Choose from Library")) {
                    Intent intent = new Intent(
                            Intent.ACTION_PICK,
                            android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
                    intent.setType("image/*");
                    startActivityForResult(
                            Intent.createChooser(intent, "Select File"),
                            SELECT_FILE);
                } else if (items[item].equals("Cancel")) {
                    dialog.dismiss();
                }
            }
        });
        builder.show();

    A continuación, crear el método onactivityresult y hacer algo como esto

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (resultCode == RESULT_OK) {
            if (requestCode == REQUEST_CAMERA) {
                File f = new File(Environment.getExternalStorageDirectory()
                        .toString());
                for (File temp : f.listFiles()) {
                    if (temp.getName().equals("temp.jpg")) {
                        f = temp;
                        break;
                    }
                }
                try {
                    Bitmap bm;
                    BitmapFactory.Options btmapOptions = new BitmapFactory.Options();
    
                    bm = BitmapFactory.decodeFile(f.getAbsolutePath(),
                            btmapOptions);
    
                    //bm = Bitmap.createScaledBitmap(bm, 70, 70, true);
                    ivImage.setImageBitmap(bm);
    
                    String path = android.os.Environment
                            .getExternalStorageDirectory()
                            + File.separator
                            + "Phoenix" + File.separator + "default";
                    f.delete();
                    OutputStream fOut = null;
                    File file = new File(path, String.valueOf(System
                            .currentTimeMillis()) + ".jpg");
                    try {
                        fOut = new FileOutputStream(file);
                        bm.compress(Bitmap.CompressFormat.JPEG, 85, fOut);
                        fOut.flush();
                        fOut.close();
                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } else if (requestCode == SELECT_FILE) {
                Uri selectedImageUri = data.getData();
    
                String tempPath = getPath(selectedImageUri, MainActivity.this);
                Bitmap bm;
                BitmapFactory.Options btmapOptions = new BitmapFactory.Options();
                bm = BitmapFactory.decodeFile(tempPath, btmapOptions);
                ivImage.setImageBitmap(bm);
            }
        }
    }

    Ver este http://www.theappguruz.com/blog/android-take-photo-camera-gallery-code-sample

  15. 0

    Como por David Manpearl respuesta

    https://stackoverflow.com/a/12347567/7226732

    tan sólo tenemos que modificar onActivityResult() como

     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (resultCode == RESULT_OK) {
            if (requestCode == YOUR_SELECT_PICTURE_REQUEST_CODE) {
                final boolean isCamera;
                if (data == null) {
                    isCamera = true;
                } else {
                    final String action = data.getAction();
                    if (action == null) {
                        isCamera = false;
                    } else {
                        isCamera = action.equals(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
                    }
                }
                Uri selectedImageUri;
                if (isCamera) {
                    selectedImageUri = fileUri;
                    try {
                        Bitmap bitmap = MediaStore.Images.Media.getBitmap(this.getContentResolver(), selectedImageUri);
                        Toast.makeText(CreateWaterType.this, "Image Saved!", Toast.LENGTH_SHORT).show();
                        image_view.setImageBitmap(bitmap);
    
                    } catch (IOException e) {
                        e.printStackTrace();
                        Toast.makeText(CreateWaterType.this, "Failed!", Toast.LENGTH_SHORT).show();
                    }
    
                } else {
                    selectedImageUri = data == null ? null : data.getData();
                    try {
                        Bitmap bitmap = MediaStore.Images.Media.getBitmap(this.getContentResolver(), selectedImageUri);
    
                        Toast.makeText(CreateWaterType.this, "Image Saved!", Toast.LENGTH_SHORT).show();
                        image_view.setImageBitmap(bitmap);
    
                    } catch (IOException e) {
                        e.printStackTrace();
                        Toast.makeText(CreateWaterType.this, "Failed!", Toast.LENGTH_SHORT).show();
                    }
                }
            }
        }
    }

    y establecer la captura o recogida de imágenes en la vista de imagen.

  16. 0

    La selección de la cámara o la galería de imágenes en Android

    Yo había trabajado duro en de la Cámara o de la galería de la Selección de la Imagen, y creó algunos util clase para este trabajo.
    Con el uso de estas clase ‘Selección de imagen de la cámara o de la galería es demasiado fácil’
    sólo tomó 5 a 10 mints de su desarrollo.

    Paso 1: Agregar estas clases en el código.

    ImagePickerUtils :- http://www.codesend.com/view/f8f7c637716bf1c693d1490635ed49b3/

    BitmapUtils :-
    http://www.codesend.com/view/81c1c2a3f39f1f7e627f01f67be282cf/

    ConvertUriToFilePath :-
    http://www.codesend.com/view/f4668a29860235dd1b66eb419c5a58b5/

    MediaUtils :- https://codeshare.io/5vKEMl

    Tenemos que Añadir estas Permiso en menifest :

      <uses-permission android:name="android.permission.CAMERA" />
      <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
      <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
      <uses-feature android:name="android.hardware.camera" />
      <uses-feature android:name="android.hardware.camera.autofocus" />

    Este función de la clase (checkAndRequestPermissions) verificación automática el permiso en Android-Malvavisco y Android – Turrón.

    Paso-2. Llamar a la cámara de la clase para el lanzamiento de la cámara intención :

     //Create a global veriable .  
         private Uri mCameraUri;
         private static final int CAMERA_REQUEST_CODE = 100;
    
    //Call this function when you wants to select or capture an Image.
           mCameraUri = ImagePickerUtils.createTakePictureIntent(this, CAMERA_REQUEST_CODE);

    Paso 3: Agregar onActivityResult en su Actividad para la recepción de datos de la Intención

        @Override
        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            if (resultCode == Activity.RESULT_OK) {
                Uri fileUri = ImagePickerUtils.getFileUriOfImage(this, data, mCameraUri);
                try {
                    Bitmap bitmap = null;
                    if (CAMERA_REQUEST_CODE == requestCode) {
                        bitmap = new BitmapUtils().getDownsampledBitmap(this, fileUri, imageView.getWidth(), imageView.getHeight());
                    }
                    if (bitmap != null)
                    imageView.setImageBitmap(bitmap);
    
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    Espero te sirva de ayuda, Si alguno tener cualquier sugerencia para mejorar esta clase por favor añade tu opinión en los comentarios.

    • Tiene un problema. Donde es la clase MediaUtils que se utiliza en BitmapUtils y en ImagePickerUtils?
    • gracias por avisarme , se me acaba de actualizar la Respuesta con el nuevo archivo de clase.
    • Gracias a ti voy a comprobar ahora. He intentado resolverlo por mí mismo funciona pero no en todos

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea