Entrada de archivo HTML en la vista web de Android(android 4.4, kitkat)

cordova webview

Question

Estaba usando el <input type="file"> en la vista web de Android. Lo hice funcionar gracias a este hilo: Carga de archivos en WebView

Pero la respuesta aceptada (o cualquier otra) ya no funciona con android 4.4 kitkat webview.

¿Alguien sabe cómo solucionarlo?

No funciona con el objetivo 18 tampoco.

Busqué un código fuente de Android 4.4 y parece que WebChromeClient no ha cambiado, pero creo que el setWebChromeClient ya no funciona en la vista web de kitkat, o al menos no en la función openFileChooser .

Answer 1

A pesar de que la versión de Kitkat no es compatible con el tipo de vista webview type = file, podríamos usar el método addJavascriptInterface de addJavascriptInterface para realizar la tarea de carga de archivos. El lado del servidor debe juzgar la versión de Android, si es menor que 4.4 , use los métodos privados de WebViewChromeClient , si es 4.4 o superior, permita que el servidor llame al método de Android para comunicarse entre sí (por ejemplo, subir el contenido del archivo asincrónico)

// 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

Answer 2

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

https://github.com/MaginSoft/MFileChooser

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

https://github.com/jcesarmobile/FileBrowserAndroidTest

Abrí un issue en el proyecto de código abierto de Android y la respuesta fue:

Estado: WorkingAsIntended

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

Para quienes usan phonegap / cordova, esta solución se publicó en el rastreador de errores:

Cesidio DiBenedetto añadió un comentario - 28 / Mar / 14 01:27

Hola a todos, he estado experimentando este problema también, así que escribí un complemento de Cordova FileChooser en una "tirita" por el momento. Básicamente, en Android 4.4 (KitKat), como se mencionó en comentarios anteriores, el cuadro de diálogo de archivo no se abre. Sin embargo, el evento onclick aún se activa, por lo que puede llamar al complemento FileChooser para abrir un cuadro de diálogo de archivo y, una vez seleccionado, puede establecer una variable que contenga la ruta completa al archivo. En este punto, puede usar el complemento FileTransfer para cargarlo en su servidor y conectarlo al evento onprogress para mostrar el progreso. Este complemento está configurado principalmente para Android 4.4, por lo que recomendaría continuar usando los diálogos de archivos nativos para versiones anteriores de Android. Puede haber problemas con el complemento, ya que no he probado todos los escenarios posibles 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

Añadiremos una API pública a WebViewClient en la siguiente versión principal para gestionar las solicitudes de archivos.

Parece que ahora lo consideran un error y lo arreglarán

Answer 3

Creé mi propia solución para este problema sin utilizar ninguna biblioteca, complementos Cordova o WebViews personalizadas, y está funcionando correctamente en todas las versiones de Android.

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

El primer paso es activar un mensaje de la consola de 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 o ruta única. Por ejemplo, concatenando la fecha completa con un gran número aleatorio:

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

Luego, su aplicación puede leer estos mensajes reemplazando 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 , puede usar un simple intento de ACTION_PICK de 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 selecciona 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 interna (filePath, fileUploadCode y WebView) y activa una AsyncTask que carga el archivo con esa información y actualiza el WebView cuando termina:

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 usa MultipartUtility para crear una solicitud de varias partes y enviarla al servidor fácilmente. Puede obtener muchas utilidades Java Multipart desde muchos lugares, una de ellas 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 sitio web utilizando Javascript nuevamente desde nuestro método onPostExecute en nuestra AsyncTask. Lo más importante es establecer el código del archivo en un campo oculto en su formulario , 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á lista, y necesita trabajar en el servidor para recibir el archivo que carga a través de la aplicación AsyncTask de Android y guardarlo donde lo necesite.

También deberá procesar el formulario de su sitio web cuando el usuario lo envíe y hacer lo que necesite con el archivo que el usuario cargó desde la aplicación. Para hacerlo, obtendrá el código de archivo en el formulario (lo completamos en un campo en onPostExecute ()), y debe usar ese código de archivo para encontrar el archivo que la aplicación ha cargado en su servidor. Para lograrlo, puede guardar el archivo en una ruta usando ese código como nombre de archivo, o guardar el código y la ruta donde cargó el archivo en una base de datos.

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

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

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

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

Answer 4

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 que la imagen cargada por la cámara no puede funcionar.

Answer 5

El nuevo buscador de archivos de Kitkat se está volviendo igualmente loco en Chrome, viendo cómo WebView ahora está usando Chromium podría ser un problema relacionado. Descubrí que la carga de archivos directamente desde la cámara funciona, pero no desde la carpeta ''Imágenes''. Si fuera a cargar desde ''Galería'', los mismos archivos son accesibles. Gah.

Parece que una solución está lista pero en espera de ser lanzada:

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

Answer 6

File Chooser en una vista web funciona ahora en la última versión de Android 4.4.3.

Lo intenté usando Nexus 5.

Answer 7

Me las arreglé para implementar la https://github.com/cdibened/filechooser en mi aplicación. Funciona 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 poco de cómo lo armé mientras lo estaba implementando.

Apache Cordova es una plataforma que le permite crear aplicaciones móviles multiplataforma simplemente utilizando 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. La aplicación típica PhoneGap / Cordova es un sitio web estático que se incluye junto con la capa de Cordova en un APK. Pero puede usar Córdova para mostrar un sitio web remoto y ese es nuestro caso.

La solución alternativa funciona de la siguiente manera: en lugar del WebView estándar, utilizamos CordovaWebView para mostrar nuestro sitio web. Cuando el usuario hace clic en navegar para seleccionar un archivo, capturamos ese clic usando el JavaScript estándar (jQuery ...) y usando la API de Cordova 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 cargamos a nuestro servidor web.

Lo importante es saber que necesita agregar soporte de Cordova a su sitio web. De acuerdo, ahora el verdadero cómo ...

En primer lugar, debe agregar Cordova a su aplicación existente. Seguí esta documentación . Algunos pasos no me fueron claros, así que trataré de explicar más:

1. Descargue y extraiga Cordova en algún lugar fuera de su aplicación y cree cordova-3.4.0.jar como se describe. Probablemente fallará por primera vez ya que falta el archivo local.properties . Se le indicará cómo crearlo en la salida de error; solo tiene que apuntarlo al SDK que usa para construir su aplicación de Android.

2. Copie el archivo jar compilado al directorio lib de la aplicación y agregue el jar como una biblioteca. Si usa Android Studio como yo, simplemente asegúrese de tener compile fileTree(dir: ''libs'', include: [''*.jar'', ''*.aar'']) en dependencies dentro de build.gradle . Luego solo presiona el botón Sync project with gradle files y estarás bien.

3. No es necesario crear el archivo /res/xml/main.xml . Puede tratar el CordovaWebView de la misma manera que trata el WebView estándar para que pueda colocarlo directamente en su archivo de diseño.

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

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

6. No olvides copiar el archivo config.xml (no tienes que cambiarlo).

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

En segundo lugar, debe agregar el https://github.com/cdibened/filechooser a su aplicación. Como no estamos usando la configuración estándar de Cordova, no podemos simplemente cordova plugin add como se indica en el archivo léame, tenemos que agregarlo manualmente.

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

2. Agrega el 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 agregar el soporte de Cordova a su sitio web. Es más simple de lo que parece, solo 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 propia cordova.js , así que asegúrese de usar la versión de Android (puede encontrarla en el paquete Cordova que descargó en / framework / assets / www ).

En segundo lugar, si se accede a su sitio web desde CordovaWebView y los navegadores estándar (de escritorio o móviles), generalmente es una buena idea cargar cordova.js solo cuando la página se muestra en CordovaWebView . Encontré varias maneras de detectar CordovaWebView pero el siguiente me funcionó. 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>'');
}

Tenga en cuenta que también estamos verificando la versión de Android. Esta solución alternativa solo se requiere para KitKat.

En este punto, debería poder 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 buscador de archivos y dejarte elegir un archivo. Tenga en cuenta que esto solo puede hacerse después de que el dispositivo se dispare. Para probarlo, simplemente enlace este código a un botón usando jQuery.

El último paso es unir todo esto y hacer que el formulario de carga funcione. Para lograr esto, simplemente puede seguir las instrucciones de Cesidio DiBenedetto descritas en el archivo README . Cuando el usuario selecciona el archivo en FileChooser , el 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 agregar otro complemento de Cordova a mi aplicación y tampoco estaba seguro de cómo funcionaría con las cookies (tengo que enviar las cookies con la solicitud porque solo los usuarios autenticados pueden cargar archivos), así que decidí es mi camino. Modifiqué el complemento FileChooser para que no devuelva la ruta sino todo el archivo. Entonces, 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, ya que base64 exige mucho CPU, por lo que la aplicación se congelará un poco cuando se carguen archivos de gran tamaño.

Para hacerlo, puede agregar primero 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 de Apache Commons, así que no se olvide de incluirla o implementar la lectura de archivos de otra forma 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:

// 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 (se requiere jQuery):

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 llevó varias horas hacerlo funcionar, así que estoy compartiendo mi conocimiento con la humilde esperanza de que podría ayudar a alguien.

Answer 8

Si alguien aún está buscando una solución para ingresar un archivo usando una vista web en kitkat.

No se llama a openFileChooser 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 de Android xwalk_core_library descargado desde el enlace de arriba en su proyecto como una biblioteca
2. En su diseño xml agregue 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; private XWalkView mXwalkView

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

6. Debería anular el resultado de actividad 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 una ruta real desde URI, Android KitKat, nuevo marco de acceso de almacenamiento
   Ver la respuesta de Paul Burke

8. Para obtener el objeto de datos para mFilePathCallback , crea una subclase en tu 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 has terminado. La carga del archivo ahora debería funcionar. No olvides agregar los permisos requeridos por Crosswalk a tu manifiesto.

   uses-permission android: name = "android.permission.ACCESS_FINE_LOCATION"
   uses-permission android: name = "android.permission.ACCESS_NETWORK_STATE"
   uses-permission android: name = "android.permission.ACCESS_WIFI_STATE"
   uses-permission android: name = "android.permission.CAMERA"
   uses-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"

Answer 9

Si solo va a agregar un contenedor de vista web alrededor de su sitio web y ejecutarlo como una aplicación, simplemente no mire a su alrededor con la vista de android predeterminada, de una manera u otra es un gran dolor de cabeza ... para mí dos cosas no funcionaron 1. Archivo de entrada 2. Integeración de comprobación de banda (que usa API avanzada de JS)

Lo que hice para salir de la oscuridad

Acabo de crear una aplicación de muestra con Cordova. Es mucho más simple que pensemos.

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

3. Vaya a la carpeta www desde la aplicación creada y abra index.js, busque y reemplace la línea con onDeviceReady: function () {window.open ('' http://yourdomain.com/yourpage '')} Ejecute la aplicación nuevamente, abrirá el sitio

4. Ahora el paso maestro. Hasta el momento, Córdoba no usa más que una visión web moderada. Todo debería cambiar un día. Agregue el complemento de paso de peatones a su aplicación Cordova, reemplazará la vista web lenta con una nueva vista completa de cromo https://crosswalk-project.org/documentation/cordova.html

5. ejecutar cordova clean , luego cordova build --release para limpiar la versión anterior.

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