Entrada de archivo HTML en android webview (android 4.4, kitkat)

Actualización 2: hay un complemento más sencillo para usar con phonegap / cordova

https://github.com/MaginSoft/MFileChooser

Actualización: Ejemplo de proyecto con el complemento Cesidio DiBenedetto

https://github.com/jcesarmobile/FileBrowserAndroidTest

Abri un problema en el proyecto de código abierto android y la respuesta fue:

Estado: TrabajandoAsIntencionado

Desafortunadamente, openFileChooser no es una API pública. Estamos trabajando en una API pública en futuras versiones de Android.

Para aquellos que utilizan phonegap / cordova, esta solución se publicó en el seguimiento de errores:

Cesidio DiBenedetto agregó un comentario – 28 / Mar / 14 01:27

Hola a todos, He estado experimentando este problema también, así que escribí un Cordova FileChooser plugin para un "band-aid" por el momento. Básicamente, en Android 4.4 (KitKat), como se mencionó en comentarios anteriores, el diálogo de archivo no se abre. Sin embargo, el evento onclick sigue activado para que pueda llamar al complemento FileChooser para abrir un cuadro de diálogo de archivo y al seleccionarlo, puede establecer una variable que contenga la ruta completa al archivo. En este punto, puede utilizar el complemento FileTransfer para subir a su servidor y conectarse al evento onprogress para mostrar el progreso. Este complemento está configurado principalmente para Android 4.4, por lo que recomendaría seguir utilizando los diálogos de archivos nativos para las versiones anteriores de Android. Puede haber problemas con el complemento, ya que no he probado todos los posibles escenarios en muchos dispositivos, pero lo he instalado en un Nexus 5 y funcionó bien.

https://github.com/cdibened/filechooser

No lo probé porque construí mi propia solución

Un comentario de un desarrollador de cromo

Seremos una adición de una API pública a WebViewClient en la próxima versión principal para manejar las solicitudes de archivo.

Parece que lo consideran como un error ahora y lo van a arreglar

He logrado implementar la solución de Cesidio DiBenedetto mencionada en mi aplicación. Está funcionando muy bien, pero para alguien que nunca ha usado PhoneGap / Cordove antes (como yo) podría ser un poco complicado. Así que aquí hay un pequeño howto que puse juntos mientras yo lo estaba implementando.

Apache Cordova es una plataforma que te permite crear aplicaciones móviles multiplataforma simplemente usando tecnologías web. La característica clave es que exporta API nativa a JavaScript y, por lo tanto, proporciona una forma de comunicarse entre el sitio web y la aplicación nativa. Típica PhoneGap / Cordova aplicación es un sitio web estático que se agrupa junto con la capa de Córdoba en un APK. Pero puede usar Cordova para mostrar un sitio web remoto y ese es nuestro caso.

La solución funciona de la siguiente manera: En lugar de la WebView estándar, utilizamos CordovaWebView para mostrar nuestro sitio web. Cuando los usuarios hacen clic para seleccionar un archivo, capturamos ese clic usando JavaScript estándar (jQuery …) y usando Cordova API activamos el plugin filechooser de Cesidio DiBenedetto en el lado nativo que abrirá un buen navegador de archivos. Cuando el usuario selecciona un archivo, el archivo se envía de vuelta al lado de JavaScript desde donde lo subemos a nuestro servidor web.

Lo importante es saber que usted necesita para agregar Cordova apoyo a su sitio web. Bueno, ahora el howto real …

En primer lugar, tienes que agregar Cordova a tu aplicación existente. Seguí esta documentación . Algunos pasos no estaban claros para mí, así que voy a tratar de explicar más:

1. Descarga y extrae Cordova en algún lugar fuera de tu aplicación y edita cordova-3.4.0.jar como se describe. Probablemente fallará por primera vez como archivo local.properties falta. Se le indicará cómo crearlo en la salida de error; Sólo tienes que apuntarlo al SDK que usas para construir tu aplicación para Android.

2. Copie el archivo jar compilado en su directorio app lib y agregue el jar como una biblioteca. Si usas Android Studio como yo, asegúrate de tener compile fileTree(dir: 'libs', include: ['*.jar', '*.aar']) en las dependencies dentro de build.gradle . A continuación, simplemente pulse el proyecto de sincronización con los archivos gradle botón y usted estará bien.

3. No es necesario crear el archivo /res/xml/main.xml . Puedes tratar el CordovaWebView de la misma manera que tratas el WebView estándar para que puedas colocarlo directamente en tu archivo de diseño.

4. Ahora siga los pasos 5-7 de la documentación original para armar su propia Activity donde se CordobaWebView el CordobaWebView . Es una buena idea comprobar el /framework/src/org/apache/cordova/CordovaActivity.java en el paquete de Cordova que ha descargado. Usted puede simplemente copiar la mayoría de los métodos requeridos para ser implementado. El paso 6. es realmente crucial para nuestro propósito, ya que permitirá utilizar el plugin filechooser.

5. No copie archivos HTML y JavaScript en ningún sitio, lo agregaremos a su sitio web más adelante.

6. No olvide copiar el archivo config.xml (no tiene que cambiarlo).

Para cargar su sitio web en CordovaWebView , simplemente pase su url a cwv.loadUrl() lugar de Config.getStartUrl() .

En segundo lugar, tienes que agregar el complemento FileChooser a tu aplicación. Como no estamos usando la configuración estándar de Cordova no podemos simplemente cordova plugin add a cordova plugin add como se indica en el readme, tenemos que agregarlo manualmente.

1. Descargue el repositorio y copie los archivos de origen a su aplicación. Asegúrese de que el contenido de la carpeta res vaya a la carpeta de su aplicación. Puede ignorar el archivo JavaScript por ahora.

2. Agrega permiso READ_EXTERNAL_STORAGE a tu aplicación.

3. Agregue el siguiente código a /res/xml/config.xml :

 <feature name="FileChooser"> <param name="android-package" value="com.cesidiodibenedetto.filechooser.FileChooser" /> </feature> 

Ahora es el momento de añadir el apoyo de Cordova a su sitio web. Es más simple de lo que suena, sólo tiene que vincular cordova.js a su sitio web, sin embargo, hay dos cosas que debe saber.

Primero, cada plataforma (Android, iOS, WP) tiene su propio cordova.js , así que asegúrate de usar la versión de Android (puedes encontrarla en el paquete de Cordova que has descargado en / framework / assets / www ).

En segundo lugar, si su sitio web se va a acceder desde CordovaWebView y los navegadores estándar (de escritorio o móvil) es generalmente una buena idea cargar cordova.js sólo cuando la página se muestra en CordovaWebView . He encontrado varias maneras de detectar CordovaWebView pero la siguiente funcionó para mí. Aquí está el código completo para su sitio web:

 function getAndroidVersion(ua) { var ua = ua || navigator.userAgent; var match = ua.match(/Android\s([0-9\.]*)/); return match ? parseFloat(match[1]) : false; }; if (window._cordovaNative && getAndroidVersion() >= 4.4) { // We have to use this ugly way to get cordova working document.write('<script src="/js/cordova.js" type="text/javascript"></script>'); } 

Ten en cuenta que también estamos revisando la versión de Android. Esta solución sólo se requiere para KitKat.

En este punto, debería ser capaz de invocar manualmente el complemento FileChooser desde su sitio web.

 var cordova = window.PhoneGap || window.Cordova || window.cordova; cordova.exec(function(data) {}, function(data) {}, 'FileChooser', 'open', [{}]); 

Esto debería abrir el explorador de archivos y permitirle escoger un archivo. Tenga en cuenta que esto sólo se puede hacer después de que se desencadene el evento deviceready. Para probarlo, simplemente vincule este código a algún botón usando jQuery.

El paso final es poner todo esto y obtener el formulario de carga de trabajo. Para lograr esto, simplemente puede seguir las instrucciones de Cesidio DiBenedetto descritas en el README . Cuando el usuario escoge el archivo en FileChooser , el path de archivo se devuelve al lado de JavaScript desde donde se utiliza otro complemento de Cordova, FileTransfer , para realizar la carga real. Eso significa que el archivo se carga en el lado nativo, no en CordovaWebView (si lo entiendo correctamente).

No tenía ganas de añadir otro plugin de Cordova a mi aplicación y tampoco estaba seguro de cómo funcionaría con las cookies (necesito enviar cookies con la solicitud porque sólo se permite a los usuarios autenticados cargar archivos) así que decidí hacer Es mi manera Modifiqué el complemento de FileChooser para que no devuelva la ruta sino el archivo completo. Así que cuando el usuario elige un archivo, leo su contenido, lo base64 usando base64 , lo paso como JSON al lado del cliente donde lo decodifico y lo envío usando JavaScript al servidor. Funciona, pero hay una desventaja obvia como base64 es bastante CPU exigente por lo que la aplicación puede congelar un poco cuando se cargan archivos grandes.

Para hacerlo es posible, primero agregue este método a FileUtils :

 public static byte[] readFile(final Context context, final Uri uri) throws IOException { File file = FileUtils.getFile(context, uri); return org.apache.commons.io.FileUtils.readFileToByteArray(file); } 

Tenga en cuenta que utiliza la biblioteca Apache Commons así que no olvide incluirla o implementar la lectura de archivos de alguna otra manera que no requiera la biblioteca externa.

A continuación, modifique el método FileChooser.onActivityResult para devolver el contenido del archivo en lugar de su ruta de acceso:

 // Get the URI of the selected file final Uri uri = data.getData(); Log.i(TAG, "Uri = " + uri.toString()); JSONObject obj = new JSONObject(); try { obj.put("filepath", FileUtils.getPath(this.cordova.getActivity(), uri)); obj.put("name", FileUtils.getFile(this.cordova.getActivity(), uri).getName()); obj.put("type", FileUtils.getMimeType(this.cordova.getActivity(), uri)); // attach the actual file content as base64 encoded string byte[] content = FileUtils.readFile(this.cordova.getActivity(), uri); String base64Content = Base64.encodeToString(content, Base64.DEFAULT); obj.put("content", base64Content); this.callbackContext.success(obj); } catch (Exception e) { Log.e("FileChooser", "File select error", e); this.callbackContext.error(e.getMessage()); } 

Y finalmente, este es el código que usará en su sitio web (jQuery es necesario):

 var cordova = window.PhoneGap || window.Cordova || window.cordova; if (cordova) { $('form.fileupload input[type="file"]', context).on("click", function(e) { cordova.exec( function(data) { var url = $('form.fileupload', context).attr("action"); // decode file from base64 (remove traling = first and whitespaces) var content = atob(data.content.replace(/\s/g, "").replace(/=+$/, "")); // convert string of bytes into actual byte array var byteNumbers = new Array(content.length); for (var i = 0; i < content.length; i++) { byteNumbers[i] = content.charCodeAt(i); } var byteContent = new Uint8Array(byteNumbers); var formData = new FormData(); var blob = new Blob([byteContent], {type: data.type}); formData.append('file', blob, data.name); $.ajax({ url: url, data: formData, processData: false, contentType: false, type: 'POST', success: function(data, statusText, xhr){ // do whatever you need } }); }, function(data) { console.log(data); alert("error"); }, 'FileChooser', 'open', [{}]); }); } 

Bueno eso es todo. Me tomó varias horas para conseguir este trabajo por lo que estoy compartiendo mi conocimiento con una humilde esperanza de que podría ayudar a alguien.

Si alguien todavía está buscando una solución para archivar la entrada usando una webview en kitkat.

OpenFileChooser no se llama cuando se hace clic en android 4.4
https://code.google.com/p/android/issues/detail?id=62220

Una biblioteca basada en cromo llamada Crosswalk se puede usar para resolver esto
https://crosswalk-project.org/documentation/downloads.html

Pasos
1. Importe el proyecto android de xwalk_core_library descargado del enlace anterior en su proyecto como una biblioteca
2. En su diseño xml, añada lo siguiente

  <org.xwalk.core.XWalkView android:id="@+id/webpage_wv" android:layout_width="match_parent" android:layout_height="match_parent" /> 

3. En el método onCreate de su actividad, haga lo siguiente

 mXwalkView = (XWalkView) context.findViewById(R.id.webpage_wv); mXwalkView.setUIClient(new UIClient(mXwalkView)); mXwalkView.load(navigateUrl, null); //navigate url is your page URL 

4. Agregar variables de clase de actividad

   Private ValueCallback mFilePathCallback; Privado XWalkView mXwalkView

5. El diálogo de entrada de archivos debería aparecer ahora. Sin embargo, necesitará proporcionar devoluciones de llamada para obtener el archivo y enviarlo al servidor.

6. Usted necesitará anular el resultado onActivityResult de su actividad

    public void onActivityResult(int requestCode, int resultCode, Intent intent) { super.onActivityResult(requestCode, resultCode, intent); if (mXwalkView != null) { if (mFilePathCallback != null) { Uri result = intent == null || resultCode != Activity.RESULT_OK ? null : intent.getData(); if (result != null) { String path = MediaUtility.getPath(getActivity(), result); Uri uri = Uri.fromFile(new File(path)); mFilePathCallback.onReceiveValue(uri); } else { mFilePathCallback.onReceiveValue(null); } } mFilePathCallback = null; } mXwalkView.onActivityResult(requestCode, resultCode, intent); } 

7. La clase MediaUtility se puede encontrar en
   Obtener la ruta real de URI, Android KitKat nuevo marco de acceso de almacenamiento
   Ver la respuesta de Paul Burke

8. Para obtener el objeto de datos para mFilePathCallback , cree una subclase en su actividad

    class UIClient extends XWalkUIClient { public UIClient(XWalkView xwalkView) { super(xwalkView); } public void openFileChooser(XWalkView view, ValueCallback<Uri> uploadFile, String acceptType, String capture) { super.openFileChooser(view, uploadFile, acceptType, capture); mFilePathCallback = uploadFile; Log.d("fchooser", "Opened file chooser."); } 

   }

9. Ya está todo hecho. El fileupload ahora debería funcionar. No olvide agregar los permisos requeridos por Crosswalk a su manifiesto.

   Uses-permission android: name = "android.permission.ACCESS_FINE_LOCATION"
   Uses-permission android: nombre = "android.permission.ACCESS_NETWORK_STATE"
   Uses-permission android: nombre = "android.permission.ACCESS_WIFI_STATE"
   Uses-permission android: name = "android.permission.CAMERA"
   Usa-permission android: name = "android.permission.INTERNET"
   Uses-permission android: name = "android.permission.MODIFY_AUDIO_SETTINGS"
   Uses-permission android: name = "android.permission.RECORD_AUDIO"
   Uses-permission android: name = "android.permission.WAKE_LOCK"
   Uses-permission android: name = "android.permission.WRITE_EXTERNAL_STORAGE"

El Selector de archivos en una vista web funciona ahora en la última versión de Android 4.4.3.

Lo probé usando Nexus 5.

A pesar de que la versión de Kitkat no es compatible con webview tipo = campo de formulario de archivo, podríamos usar el método addJavascriptInterface de addJavascriptInterface para llevar a cabo la tarea de carga de archivos. El lado del servidor debe juzgar la versión de android, si es inferior a 4.4 , el uso de métodos privados WebViewChromeClient , si 4.4 o superior, dejar que el servidor llama al método android para comunicarse entre sí (por ejemplo, asíncrono de contenido de archivo de carga)

// código

 webView.getSettings().setJavaScriptEnabled(true); webView.addJavascriptInterface(new WebViewJavaScriptInterface(this), "app"); 

Aquí hay un enlace que podría ayudar …

Call-android-methods-from-javascript

El nuevo navegador de archivos de Kitkat se está volviendo igualmente loco en Chrome, viendo cómo WebView está utilizando Chromium podría ser un problema relacionado. Encontré que subir archivos directamente desde la cámara funciona, pero no desde la carpeta 'Imágenes'. Si tuviera que cargar desde 'Galería' en su lugar, los mismos archivos son accesibles. Gah.

Parece que una corrección está lista pero en espera de la liberación:

https://code.google.com/p/chromium/issues/detail?id=278640

Si vas a añadir un webview envoltorio alrededor de su sitio web y lo lanzan como una aplicación, simplemente no mire a su alrededor con la web por defecto android, de una manera u otra es un enorme dolor de cabeza .. para mí dos cosas no funcionó Out 1. Archivo de entrada 2. Stripe checkout integeration (que utiliza JS API avanzado)

Lo que hice para salir de la oscuridad

Acabo de crear una aplicación de ejemplo utilizando Córdoba. Es mucho más simple que pensamos.

1. Instale Cordova desde su página oficial, construya una aplicación de ejemplo.
2. Le dará un archivo apk. ( Lo tienes)

3. Ir a la carpeta www desde la aplicación creada y abrir index.js, encontrar y reemplazar la línea con onDeviceReady: function () {window.open (' http://yourdomain.com/yourpage ')} Ejecutar la aplicación de nuevo, it Abrirá el sitio

4. Ahora el paso maestro. Hasta ahora, Cordova no utilizó nada más que una moderada webview. Todo debería cambiar un día. Agregue el complemento de cruce de peatones a su aplicación de Cordova, que reemplazará a la lenta webview con una nueva vista de cromo completamente desarrollada https://crosswalk-project.org/documentation/cordova.html

5. Ejecutar cordova clean , luego cordova build --release a la limpieza de la vieja construcción.

6. Abra el archivo config.xml dentro del directorio de la aplicación dado por la aplicación Cordva y agregue <allow-navigation href="http://yourdomain.com/*" />
7. Ejecute la aplicación de nuevo. ¡Magia!.

Construí mi propia solución para este problema sin usar bibliotecas, plugins de Cordova o WebViews personalizados, y funciona correctamente en todas las versiones de Android.

Esta solución implica el uso de JavaScript muy simple para comunicarse entre su sitio web en WebView y la aplicación de Android, y realizar la selección de archivos y cargar directamente desde su aplicación de Android, eliminando todos los métodos openFileChooser (), showFileChooser () y onShowFileChooser () WebChromeClient.

El primer paso es activar un mensaje de consola javascript desde el sitio web cuando el usuario hace clic en una entrada de archivo, escribiendo un código único , que se utilizará para cargar el archivo con un nombre único o una ruta. Por ejemplo, concatenar el datetime completo con un número aleatorio enorme:

 <input type="file" name="user_file" onclick="console.log('app.upload=20170405173025_456743538912');"> 

A continuación, su aplicación puede leer estos mensajes sobrepasando el método onConsoleMessage () de WebChromeClient , detectar ese mensaje, leer el código y activar la selección de archivos :

 webview.setWebChromeClient(new WebChromeClient() { // Overriding this method you can read messages from JS console. public boolean onConsoleMessage(ConsoleMessage message){ String messageText = message.message(); // Check if received message is a file upload and get the unique code if(messageText.length()>11 && messageText.substring(0,11).equals("app.upload=")) { String code = messageText.substring(11); triggerFileUploadSelection(code); return true; } return false; } }); 

Para la selección de archivos , sólo puede utilizar un intento simple de ACTION_PICK para Android como este:

 public void triggerFileUploadSelection(String code){ // For Android 6.0+ you must check for permissions in runtime to read from external storage checkOrRequestReadPermission(); // Store code received from Javascript to use it later (code could also be added to the intent as an extra) fileUploadCode = code; // Build a simple intent to pick any file, you can replace "*/*" for "image/*" to upload only images if needed Intent filePickerIntent = new Intent(Intent.ACTION_PICK); filePickerIntent.setType("*/*"); // FILE_UPLOAD_CODE is just any unique integer request code to identify the activity result when the user selects the file startActivityForResult( Intent.createChooser(filePickerIntent, getString(R.string.chooseFileToUpload) ), FILE_UPLOAD_CODE ); } 

Después de que el usuario seleccione un archivo (o no), puede recibir el archivo Uri y traducirlo a una ruta de archivo real con:

 @Override public void onActivityResult (int requestCode, int resultCode, Intent data) { if(requestCode==FILE_UPLOAD_CODE) { if(data != null && resultCode == RESULT_OK){ // user selected a file try{ Uri selectedFileUri = data.getData(); if(selectedFileUri!=null) { // convert file URI to a real file path with an auxiliary function (below) String filePath = getPath(selectedFileUri); if(filePath!=null) { // I got the file path, I can upload the file to the server (I pass webview as an argument to be able to update it when upload is completed) uploadSelectedFile(getApplicationContext(), filePath, fileUploadCode, webview); }else{ showToastFileUploadError(); } }else{ showToastFileUploadError(); } }catch (Exception e){ e.printStackTrace(); showToastFileUploadError(); } }else{ // user didn't select anything } } } // I used this method for images, and it uses MediaStore.Images so you should probably // use another method to get the path from the Uri if you are working with any kind of file public String getPath(Uri uri) { String[] projection = { MediaStore.Images.Media.DATA }; Cursor cursor = managedQuery(uri, projection, null, null, null); if(cursor==null)return null; int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA); cursor.moveToFirst(); return cursor.getString(column_index); } 

El método uploadSelectedFile, simplemente crea un objeto con toda la información dentro de (filePath, fileUploadCode y WebView) y activa un AsyncTask que carga el archivo usando esa información y actualiza el WebView cuando se hace:

 public static void uploadSelectedFile(Context c, String filePath, String code, WebView webView){ // YOU CAN SHOW A SPINNER IN THE WEB VIEW EXECUTING ANY JAVASCRIPT YOU WANT LIKE THIS: webView.loadUrl("javascript: Element.show('my_upload_spinner');void 0"); // void 0 avoids at the end avoids some browser redirection problems when executing javascript commands like this // CREATE A REQUEST OBJECT (you must also define this class with those three fields and a response field that we will use later): FileUploadRequest request = new FileUploadRequest(filePath, code, webView); // Trigger an async task to upload the file, and pass on the request object with all needed data FileUploadAsyncTask task = new FileUploadAsyncTask(); task.execute(request); } 

AsyncTask recibe el objeto de solicitud con toda la información y utiliza MultipartUtility para crear una solicitud de varias partes y enviarla al servidor fácilmente. Usted puede obtener un montón de Java Multipart Utilities de muchos lugares, uno de ellos está aquí: http://www.codejava.net/java-se/networking/upload-files-by-sending-multipart-request-programmatically

 public class FileUploadAsyncTask extends AsyncTask<FileUploadRequest, Void, FileUploadRequest> { @Override protected FileUploadRequest doInBackground(FileUploadRequest... requests) { FileUploadRequest request = requests[0]; try { // Generate a multipart request pointing to the URL where you will receive uploaded file MultipartUtility multipart = new MultipartUtility("http://www.example.com/file_upload.php", "UTF-8"); // Add a field called file_code, to send the code to the server script multipart.addFormField("file_code", request.code); // Add the file to the request multipart.addFilePart("file_path", new File(request.filePath)); // Send the request to the server and get the response and save it back in the request object request.response = multipart.finish(); // response from server. } catch (IOException e) { request.response = "FAILED"; e.printStackTrace(); } return request; } 

Ahora hemos subido el archivo al servidor y podemos actualizar nuestro Web site usando Javascript otra vez de nuestro método del onPostExecute en nuestro AsyncTask. Lo más importante es establecer el código de archivo en un campo oculto en su forma , para que pueda obtener ese código cuando el usuario envía el formulario. También puede mostrar un mensaje en el sitio o incluso mostrar fácilmente la imagen cargada (si es una imagen):

 @Override protected void onPostExecute(FileUploadRequest request) { super.onPostExecute(request); // check for a response telling everything if upload was successful or failed if(request.response.equals("OK")){ // set uploaded file code field in a hidden field in your site form (ESSENTIAL TO ASSOCIATE THE UPLOADED FILE WHEN THE USER SENDS THE WEBSITE FORM) request.webView.loadUrl("javascript: document.getElementById('app_upload_code_hidden').value = '"+request.code+"';void 0"); // Hide spinner (optional) //request.webView.loadUrl("javascript: Element.hide('my_upload_spinner');void 0"); // show a message in the website, or the uploaded image in an image tag setting the src attribute // to the URL of the image you just uploaded to your server. // (you must implement your own fullUrl method in your FileUploadRequest class) // request.webView.loadUrl("javascript: document.getElementById('app_uploaded_image').src = '"+request.fullUrl()+"';void 0"); // request.webView.loadUrl("javascript: Element.show('app_uploaded_image');void 0"); } } 

Ahora la parte de Android está terminada y necesitas trabajar en el lado del servidor para recibir el archivo que subas a través de la aplicación Android AsyncTask y guardarlo donde quieras.

También tendrá que procesar su formulario de sitio web cuando el usuario lo envíe y hacer lo que necesite con el archivo que el usuario subió de la aplicación. Para ello, obtendrá el código de archivo en el formulario (lo completamos en un campo de onPostExecute ()), y usted tiene que usar ese código de archivo para encontrar el archivo que la aplicación ha subido a su servidor. Para lograrlo, puede guardar el archivo en una ruta utilizando ese código como nombre de archivo o guardar el código y la ruta de acceso donde ha cargado el archivo en una base de datos.

Esta solución sólo se basa en elementos que están disponibles y compatibles con todas las versiones de Android, por lo que debe funcionar en cualquier dispositivo (y no he recibido a los usuarios se queja de esto más).

Si tiene varias entradas de archivo en la misma página, puede enviar un número de campo o identificador adicional junto con el código de archivo único en el mensaje javascript inicial, pasar ese identificador en todo el código de la aplicación y usarlo para actualizar los elementos correctos En onPostExecute ().

He modificado el código actual un poco aquí, así que si algo falla, probablemente será un error tipográfico o algún detalle menor al cambiar el nombre de un par de cosas.

Es bastante mucha información para procesar así que si alguien necesita alguna aclaración o tiene sugerencias o correcciones por favor díganme.

Cuando use crosswalk-webview-21.51.546.7 y seleccione la imagen a través de la cámara. En onActivityResult() the intent.getData() es null . Significa cargar la imagen por cámara no puede trabajar.