Soy nuevo en calidades y estoy tratando de averiguar cómo utilizar parse(URI) y/o setType() para obtener el tipo correcto de aplicación a abrir y me permite seleccionar cosas.

Quiero lanzar una intención de mi aplicación que permitirá al usuario elegir uno de los muchos tipos de archivos (.PDF, .DOCX, .XLSX, .PPTX, .DOC, .JPG, .PNG, .TXT, .LOG, etc.). Lo que necesito de la actividad para la devolución es una ruta de acceso completa al archivo.

Ahora mismo estoy usando setType("*/*") con un selector que he encontrado aquí, pero este es de forma automática al abrir algunos documentos selector en Android. Tengo el administrador de archivos y otras aplicaciones, y quieren saber cuál es el estándar de setType es o que tipo de MIME. Gracias de antemano.

También, pido disculpas si esto ya ha sido contestado. He mirado en internet, pero creo que yo estoy buscando algo equivocado, porque los resultados que estoy obteniendo son para las intenciones que sólo quiero uno de estos o no devolver la ruta de acceso.

Mi código aplicable es el siguiente: (Nota: esto se hace en el interior de un fragmento)

static final int PICK_FILE_REQUEST = 101;

private String pathToFile = "";

public String selectFile()  {
    String path = "";
    Intent intent = new Intent(Intent.ACTION_GET_CONTENT), chooser = null;
    intent.setType("*/*");
    chooser = Intent.createChooser(intent, "Find file to Print");
    startActivityForResult(chooser, PICK_FILE_REQUEST);
    path = pathToFile;
    return path;
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data)   {
    if(requestCode == PICK_FILE_REQUEST){
        if(resultCode == Activity.RESULT_OK){
            pathToFile = data.getDataString();
            String temp = data.getStringExtra("path");
            Log.d("Files Fragment: ", pathToFile);
            Log.d("Files Fragment: ", temp);
        }
    }
}
«Lo que necesita la actividad para volver es una ruta de acceso completa al archivo» — muchos, si no la mayoría, no va a volver una ruta de acceso del archivo en el sistema de ficheros, ya que su aplicación no tiene acceso al archivo. Si usted recibe una content:// Uri de nuevo, usted tendrá que utilizar ContentResolver y métodos como openInputStream() para leer en el contenido.
Yo sabía que me estaba perdiendo algo. No me di cuenta de que estaba sobre el acceso. Estás diciendo que por lo general se devuelve contenido:// Uri como un estándar? Sólo quiero que esto funcione para la mayoría de los exploradores de archivos. Voy a la derecha un poco de lógica para manejar el contenido de la resolución. Tengo que replantearme mi proceso de algo. Gracias!
«¿Estás diciendo que por lo general se devuelve contenido:// Uri como un estándar?» — que depende de «ellos». ACTION_GET_CONTENT puede ser manejado por cualquier cosa, desde MediaStore (que se devolverá content:// Uri valores) a un tercero, un administrador de archivos (que se devolverá… algo que, a pesar de que voy a ser la mayoría de devolver una tradicional ruta de acceso del archivo). ACTION_OPEN_DOCUMENT, como se sugiere en la respuesta, siempre devolver un content:// Uri. Y el porcentaje de veces que usted consigue un content:// Uri sólo crecerá con el tiempo.
Yo sé, se me acaba de pedir su opinión para lo que es más común (lo cual es una mala pregunta de aplicaciones para android!). Si no viene con nada voy a sugerir una aplicación gratuita para ellos para descargar. Voy a tener que crear un impresionante método para filtrar estos contenidos:// Uri ‘s !!! Mirando hacia adelante a la misma. Gracias CommonsWare. Todavía estoy curioso por saber si estas acciones será viable para los formatos de archivo que se enumeran en la pregunta original. Si usted sabe bien, si no puedo encontrar a través de las pruebas.
ACTION_GET_CONTENT y ACTION_OPEN_DOCUMENT son razonables opciones. Con respecto a los tipos MIME, el uso real de los tipos MIME para los formatos de archivo (disponible en cuestión de segundos a través de su motor de búsqueda favorito). La única extensión de archivo que lista que no tiene ningún significado en particular es .LOG.

OriginalEl autor napkinsterror | 2014-12-08

4 Comentarios

  1. 5

    Puede utilizar Intent.ACTION_OPEN_DOCUMENT,

    Cada documento es representado como un contenido://URI respaldado por una DocumentsProvider, que puede ser abierto como un arroyo con openFileDescriptor(Uri, de la Cadena), o consultar para DocumentsContract.Los metadatos de los documentos.

    Todos los documentos seleccionados se devuelven a la aplicación de llamada con persistable permiso de lectura y escritura de las subvenciones. Si desea mantener el acceso a los documentos a través de dispositivo se reinicia, debe explícitamente el con persistencia de los permisos de uso de takePersistableUriPermission(Uri, int).

    Personas que llaman deben indicar el documento aceptable de los tipos MIME a través de setType(Cadena). Por ejemplo, para seleccionar las fotos, el uso de la imagen/*. Si varios distintos tipos MIME son aceptables, los definen en EXTRA_MIME_TYPES y setType(String) para */*.

    Para más detalles, por favor consulte aquí.

    Tenga en cuenta que esto sólo está disponible en la API de Nivel 19+.
    Gracias, esta «EXTRA_MIME_TYPES» es lo que me podía encontrar. Voy a tener que buscar algunos ejemplos. Sé básicos de los tipos MIME, pero yo sólo quería aceptar de 1 archivo, pero no sé qué tipo de archivo que es. El usuario tiene el derecho a elegir. Creo que este es el método correcto por la escasa documentación que he leído a través de su enlace. También será para un solo uso y no persistente a través de los reinicios, pero aprecio el conocimiento.
    Así que, ¿puede explicar cómo el soporte de múltiples tipos mime para el api por debajo de 19 (API 16 en adelante)
    No hay soporte para múltiples tipos MIME antes de la API de Nivel 19, si mal no recuerdo. En su interfaz de usuario, usted tendría que preguntar al usuario qué tipo MIME para recuperar, a continuación, utilizar ese con ACTION_GET_CONTENT. O bien, utilice un carácter comodín tipo MIME, para luego validar el actual tipo MIME del contenido que el usuario elige.

    OriginalEl autor bjiang

  2. 7

    He tenido un problema similar y pasó a menos de 15 minutos buscando un ejemplo de cómo en realidad el código con el apoyo de EXTRA_MIME_TYPES

    Afortunadamente encontré un ejemplo http://android-er.blogspot.co.uk/2015/09/open-multi-files-using.html, probado, probado y parece que funciona para mi caso de uso que es ser capaz de encontrar y cargar dos similares, pero no idénticos, los tipos mime (por lo peculiar de la razón el mismo archivo csv tiene un tipo mime si puedo copiar en el dispositivo a través de USB y la otra si que me la baje de Google Drive). Aquí está mi fragmento de código. Es de suponer que usted había añadir más tipos mime en la matriz de Cadenas para satisfacer sus necesidades.

    public void findReviewsToLoad() {
        Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
        intent.addCategory(Intent.CATEGORY_OPENABLE);
        String [] mimeTypes = {"text/csv", "text/comma-separated-values"};
        intent.setType("*/*");
        intent.putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes);
        startActivityForResult(intent, FIND_FILE_REQUEST_CODE);
    }
    Muchas gracias por el código. Estaba buscando un ejemplo de uso de la Intención.EXTRA_MIME_TYPES y su posterior mostró que de inmediato.
    Su trabajo justo en android api >= 19

    OriginalEl autor JulianHarty

  3. 1
    private static final int CHOOSE_FILE_REQUEST = 1;
    ///////////////////////////////////////////////////
     public void chooseFile(){
            Intent intent = new Intent();
            intent.setAction(Intent.ACTION_OPEN_DOCUMENT);
            intent.addCategory(Intent.CATEGORY_OPENABLE);
            intent.setType("*/*");
            String[] extraMimeTypes = {"application/pdf", "application/doc"};
            intent.putExtra(Intent.EXTRA_MIME_TYPES, extraMimeTypes);
            intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
            startActivityForResult(intent, CHOOSE_FILE_REQUEST);
    
    
        }
    
    /////////////////////////////////////////////////////
    
       @Override
        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
    
            String path = "";
            if (resultCode == RESULT_OK) {
                if (requestCode == CHOOSE_FILE_REQUEST) {
                    ClipData clipData = data.getClipData();
                    //null and not null path
                    if(clipData == null){
                        path += data.getData().toString();
                    }else{
                        for(int i=0; i<clipData.getItemCount(); i++){
                            ClipData.Item item = clipData.getItemAt(i);
                            Uri uri = item.getUri();
                            path += uri.toString() + "\n";
                        }
                    }
                }
            }
            selectedFileTV.setText(path);
        }

    OriginalEl autor Faakhir

  4. 0

    Siguiente código funciona para mí cuando sea necesario para seleccionar varios tipos MIME
    (Esto es en C# y Xamarin para Android):

    List<string> mimeTypes = new List<string>();
    
    //Filling mimeTypes with needed MIME-type strings, with * allowed.
    
    if (mimeTypes.Count > 0)
    {
        //Specify first MIME type
        intent.SetType(mimeTypes[0]);
        mimeTypes.RemoveAt(0);
    }
    if (mimeTypes.Count > 0)
    {
        //Specify the rest MIME types but the first if any
        intent.PutExtra(Intent.ExtraMimeTypes, mimeTypes.ToArray());
    }

    Nota, he intentado intent.SetType("*.*") como se describe en otras respuestas, pero esto resultó en el mal comportamiento.

    E. g. cuando me implementar el código para seleccionar las fotos de la galería, videos donde seleccionado así:

    intent.SetType("*.*");
    intent.PutExtra(Intent.ExtraMimeTypes, new string[] {"image/*"});

    Así que he venido para arriba con el código anterior: especificar el primer tipo MIME en intent.SetType, todo el resto a través de intent.PutExtra(Intent.ExtraMimeTypes, ...)

    OriginalEl autor sergtk

Dejar respuesta

Please enter your comment!
Please enter your name here