Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

Código para AIDE que haga lo siguiente: Cargar el contenido de una página web, una vez…

  1. User

    Código para AIDE que haga lo siguiente: Cargar el contenido de una página web, una vez cargado ese contenido, guarde y cargue el texto (incluso al cerrar y abrir la app) en los inputs que se cargan de forma dinámica en el contenido de dicha página web.

  2. Assistant

    Para crear una aplicación en AIDE (Android IDE) que cargue el contenido de una página web, guarde el texto de los inputs dinámicos y los recargue después de cerrar y volver a abrir la app, puedes seguir los siguientes pasos:

    1. Crear la interfaz de usuario de la aplicación: Vamos a utilizar un WebView para cargar la página y también necesitamos permisos para acceder a Internet.

    2. Guardar el contenido de los inputs: Usaremos SharedPreferences para guardar el texto de los inputs cuando se cierre la app.

    3. Recargar el contenido de los inputs: Cuando se vuelva a abrir la app, recargaremos el contenido almacenado en SharedPreferences.

    A continuación, te muestro un código de ejemplo que puedes utilizar como referencia:

    // MainActivity.java
    import android.app.Activity;
    import android.content.Context;
    import android.content.SharedPreferences;
    import android.os.Bundle;
    import android.webkit.JavascriptInterface;
    import android.webkit.WebChromeClient;
    import android.webkit.WebView;
    import android.webkit.WebViewClient;
    import java.util.HashMap;
    
    public class MainActivity extends Activity {
        private WebView myWebView;
        private static final String PREFS_NAME = "WebInputs";
        private HashMap<String, String> inputsMap = new HashMap<>();
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            myWebView = findViewById(R.id.webview);
            myWebView.getSettings().setJavaScriptEnabled(true);
            myWebView.setWebChromeClient(new WebChromeClient());
            myWebView.setWebViewClient(new WebViewClient());
            myWebView.addJavascriptInterface(new WebAppInterface(this), "Android");
    
            // Cargar la página web
            myWebView.loadUrl("http://tupaginaweb.com");
    
            // Cargar texto guardado
            loadTextFromPreferences();
        }
    
        @Override
        protected void onPause() {
            super.onPause();
            // Guardar el estado de los inputs al pausar la actividad
            myWebView.loadUrl("javascript:Android.saveInputs(getInputs());");
        }
    
        // Guardar texto en SharedPreferences
        private void saveTextToPreferences() {
            SharedPreferences.Editor editor = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE).edit();
            for (String key : inputsMap.keySet()) {
                editor.putString(key, inputsMap.get(key));
            }
            editor.apply();
        }
    
        // Cargar texto de SharedPreferences
        private void loadTextFromPreferences() {
            SharedPreferences prefs = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
            for (String key : prefs.getAll().keySet()) {
                myWebView.loadUrl("javascript:setInputValue('" + key + "', '" + prefs.getString(key, "") + "');");
            }
        }
    
        private class WebAppInterface {
            Context mContext;
    
            WebAppInterface(Context c) {
                mContext = c;
            }
    
            @JavascriptInterface
            public void saveInput(String key, String value) {
                inputsMap.put(key, value);
            }
    
            @JavascriptInterface
            public void saveInputs(String jsonString) {
                try {
                    JSONObject jsonObject = new JSONObject(jsonString);
                    inputsMap.clear();
                    Iterator<String> keys = jsonObject.keys();
                    while (keys.hasNext()) {
                        String key = keys.next();
                        inputsMap.put(key, jsonObject.getString(key));
                    }
                    saveTextToPreferences();
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    Este es el código HTML/JavaScript de ejemplo que debes cargar en tu WebView:

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Página de Ejemplo</title>
        <script>
            function getInputs() {
                const inputs = document.querySelectorAll("input");
                let inputsObj = {};
                inputs.forEach(input => {
                    inputsObj[input.id] = input.value;
                });
                return JSON.stringify(inputsObj);
            }
    
            function setInputValue(id, value) {
                const input = document.getElementById(id);
                if (input) input.value = value;
            }
        </script>
    </head>
    <body>
        <input type="text" id="input1" placeholder="Input 1"><br>
        <input type="text" id="input2" placeholder="Input 2"><br>
        <input type="text" id="input3" placeholder="Input 3"><br>
    </body>
    </html>
    

    Cosas que debes ajustar según tu caso específico:

    • URL: Asegúrate de cambiar la URL en myWebView.loadUrl() al sitio web que deseas cargar.
    • Inputs Dinámicos: Este código asume que los elementos input tienen un atributo id asignado.
    • Permisos de Internet: Agrega <uses-permission android:name="android.permission.INTERNET" /> en tu archivo AndroidManifest.xml.

    Este código proporciona una forma básica de sincronizar los inputs de una página web en una aplicación Android usando WebView. Puede necesitar ajustes adicionales para manejar inputs especiales o inputs dinámicos generados más complejos.