elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Recuerda que debes registrarte en el foro para poder participar (preguntar y responder)


+  Foro de elhacker.net
|-+  Comunicaciones
| |-+  Dispositivos Móviles (PDA's, Smartphones, Tablets)
| | |-+  Android
| | | |-+  Crear Aplicación Para Android Desde Android. Web con control de Android por JS
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Crear Aplicación Para Android Desde Android. Web con control de Android por JS  (Leído 528 veces)
@XSStringManolo
<svg/onload=alert()>
Colaborador
***
Desconectado Desconectado

Mensajes: 2.232


Turn off the red ligth


Ver Perfil WWW
Crear Aplicación Para Android Desde Android. Web con control de Android por JS
« en: 23 Octubre 2019, 06:05 am »

Tutorial por StringManolo.
Crea tu primera aplicación .apk en Android, desde Android utilizando Java, WebView y varios lenguajes Web.

Para qué sirve esto?
-Para crear una aplicación MiPrimeraApp.apk que se puede instarlar en cualquier móvil con Android.
-Para iniciarse o sacar una idea generalizada de como se pueden crear aplicaciones.
-Para aprender un poco sobre Android y ver ejemplos de código.
-Para crear tu aplicación a partir de esta modificándola y añadiéndole trozos sin tener que escribir todo desde 0.
-Para podes programar desde tu móvil cuando no tengas un Pc a mano.
-Para obtener una applicación para tu web con la que poder utilizar el dispositivo de tus visitantes.
-Para reducir la carga del servidor, obtener información, cobrar por tus servicios...

Qué son Java, HTML, javascript, Xml, CSS y SVG?
-Lenguajes de programación que te permiten crear aplicaciones o webs a partir de código.

Qué es Android?
-El sistema operativo utilizado por la mayoría de móviles y tablets.
-También se encuentra en muchos otros dispositivos como teles, ordenadores, parquímetros...

Qué conocimientos necesito para el tutorial?
-Ninguno.

Qué conocimientos serían recomendados?
-Seguir los tutoriales de w3scholls y de Mozilla de programación.
-Saber crear páginas web sencillas con código.
-Un poco de POO(Programación orienta a objetos) preferiblemente en javascript, Java o Kotlin.

Necesito algo para hacer mi aplicación o mi web?
-Software necesario:
Java N-IDE https://play.google.com/store/apps/details?id=com.duy.compiler.javanide

Java N-IDE será el editor de texto, manager de proyectos y compilador.

*Para Windows, Mac o Linux podeis usar Android Studio.
En pdfdrive.com hay un montón de libros si buscas "Java Android" en los que se explica todo, empezando por instalar Android Studio.

Supongo que Linux es la única plataforma que se os puede complicar la instalación.
Apunté hace basante tiempo todos los pasos de la instalación, (Orientado a programar en Android con C++) puede que cambiasen cosas.
Yo usé Xubuntu 64 bits.

Quizas sea mejor que para Linux busqueis una guía más actual.
Aún así os dejo los pasos de instalación por si sirven de algo.
Cita de: Pasos:
Descargar Android Studio desde su web.
Extraer .zip en /home

Terminal:
$sudo su
$cd SDKinstallfolder
$cd bin
$./studio.sh

No import
Next -> Custom -> Next
Android SDK directory -> /home/Desktop new folder
Finish. Close.

Download NDK
Ir a la web.
older versions -> Agree terms.
Android NDK Revision 10e(May 2015) (Las hay más recientes pero no eran compatibles, no sé si ahora hay una versión más reciente sin errores de compatibilidad.)

Download Java SE Dev Kit
Ir a la web.
Java SE8u181 Linux-x64.tar.gz

Desktop make new folder to install NDK
Desktop make " " "
Download QT (ir a la web y darle a : Go open source - autodect download)
Extract JDK.gz file
Extract NDK
Extract QT installer using :$ chmod +x qt... (Darle a Tab y se completa la ruta)
$./qt.run

Next -> Skip -> Next
Select installation folder -> Desktop QT
QT -> checkbox QT 5.11.2 (La versión que quieras, aqui nl hay problemas de compatibilidad)
Tools -> QT installer framework 3.0
Next, agree, install.


Empezemos:

Una vez tenemos instalado y abierto el Java N-IDE:

Le damos a File -> New -> New Android Project

Se abre una nueva ventana que cubriremos con lo siguiente:
Nombre de la aplicación.
Nombre del paquete.
Nombre de la actividad.
Nombre de diseño.

Por ejemplo la app de facebook podría ser algo así:
Facebook
com.facebook.katana
MainActivity
activity_main.xml

En este ejemplo pondremos:
MiPrimeraApp
com.mimarca.MiPrimeraApp
ActividadPrincipal
principal_actividad.xml

Y le damos a Aceptar.

Se creará el proyecto con código básico, con un montón de carpetas y archivos.

Arriba tenemos una flecha como la flecha de PLAY. Sirve para compilar.
Al darle nos mostrará un error debido a que en el ejemplo vienen configurados nombres por defecto.

El error está en la línea 13 del archivo ActividadPrincipal.java
El código que da error es:
setContentView(R.layout.activity_main);

Tiene el nombre que se asigna por defecto R.layout.activity_main
Nosotros le llamamos al layout principal_actividad.xml
Asique substuimos el nombre y nos queda:
setContentView(R.layout.principal_actividad);

Le damos a compilar y ya se nos creará nuestra primera aplicación en Android.

El sistema por seguridad nos bloqueará la instalación si no tenemos checkeado instalar desde fuentes desconocidas.
Le damos a Ajustes.
Marcamos fuentes desconocidad tocando la caja.
Aceptamos.
Le damos a instalar.
Abrir.

Ya tenemos la aplicación instalada.
De momento al abrirla solo muestra un mensaje de saludo HELLO WORLD. (Hola mundo).

Ya podemos cerrarla.

Ahora lo que vamos a hacer es mostrar una página web en el WebView de Android en el lugar de ese mensaje.

Lo primero que necesitamos es programar nuestra página web.
1 - Podemos hacerlo directamente en el Java N-IDE.
2 - Movernos con nuestro gestor de ficheros del telefono y otro editor o web descargada.
3 - O habilitar permisos de acceso a internet y poner la url de una página web.


En el Java N-IDE localizamos la carpeta assets que se encuentra dentro de:
MiPrimeraApp - app - src - assets
Le damos al símbolo más(+) que se encuentra a la derecha de assets.

Le damos a crear un archivo XML (ya que no nos sale opción de html)
De nombre le pondré A.html y se crea el archivo.

El archivo creado es A.html.xml asique más tarde vamos a renombrarlo a webinterfaz.html
Como el editor no reconoce archivos html, escribiremos el html directmente en el A.html.xml y después
lo renombramos.

Le damos al A.html.xml para abrirlo en el editor.
Trae por defecto una o dos líneas que borramos.

Escribimos nuestra página web.
Iré añadiendo comentarios entre <!-- --> o /* */ para el tutorial y explicar cada línea de código.
No entraré en mucho detalle, explicaré para que sirve, sin más.


Código
  1. <!DOCTYPE html>
  2. <!-- Indica que es un documento de HTML5 -->
  3.  
  4. <meta content='width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0' name='viewport'/>
  5. <!-- Fija la vista para Android -->
  6.  
  7. <meta charset="UTF-8">
  8. <!-- Indica el encoding del documento para que el navegador lo reconozca. -->
  9.  
  10. <!-- Inicio de la página web -->
  11.  
  12.  
  13. <!-- Inicio de la cabecera, se usa para codigo que no va a ver el usuario directamente sobre la página -->
  14.  
  15. <title>Interfaz</title>
  16. <!-- Indica el título de la página, por ejemplo Nueva Pestaña es un título por defecto -->
  17.  
  18. /* A partir de aquí deja de ser código HTML y pasa a ser código javascript */
  19.  
  20. function CambiarColorRectangulo()
  21. /* Se crea un función(Es como un programa nuevo) y se le da un nombre.
  22. Entre los paréntesis ( ) pueden ir datos para función. En este caso no le puse */
  23.  
  24. {
  25. /* Todo lo que esté dentro de estos paréntesis pertenece a la función.
  26. Es lo que la función va a hacer. */
  27.  
  28. var Rectangulo1 = document.getElementById('Rectangulo1');
  29. /* Guarda con el nombre Rectangulo1 un rectángulo que se encuentra más adelante.
  30. Por si no te queda claro y por simplificar, todo este código javascript de la función se ejecutará
  31. mucho más adelante. */
  32.  
  33. var Rectangulo2 = document.getElementById('Rectangulo2');
  34. /* Lo mismo que lo anterior pero con otro rectángulo */
  35.  
  36. var r = Math.floor(Math.random() * 255);
  37. /* Se guarda un número aleatorio entre 0 y 255. */
  38.  
  39. var g = Math.floor(Math.random() * 255);
  40. /* Se guarda otro número aleatorio*/
  41.  
  42. var b = Math.floor(Math.random() * 255);
  43. /* Se guarda otro número aleatorio */
  44.  
  45. Rectangulo1.style.fill = 'rgb(' + r + ', ' + g + ' , ' + b + ')';
  46. /* Se le añade un estilo al rectángulo1 con los 3 númeos aleatorios.
  47. Cada número equivale a un color. Se mezclan los 3 colores para obtener un color nuevo.
  48. La r (red) equivale a la cantidad de rojo. 0 = Sin rojo, 255 = Mucho Rojo.
  49. La g (green) lo mismo pero para el color verde.
  50. La b (blue) lo mismo pero para el azul.
  51. */
  52.  
  53. Rectangulo2.style.fill = 'rgb(' + r + ', ' + g + ' , ' + b + ')';
  54. /* Los mismos colores pero para otro rectángulo */
  55.  
  56. }
  57. /* Se acaba lo que hace la función.
  58.  
  59. Como resumen, esta función lo que va a hacer es:
  60. Cada vez que le toques con el dedo a un rectángulo, se pintarán
  61. los 2 rectángulos de un color aleatorio.
  62. */
  63.  
  64. <!-- Ya se acabó el código de javascript, asique estamos otra vez en el HTML. -->
  65.  
  66. </head>
  67. <!-- Se cierra la cabecera -->
  68.  
  69. <!-- Se abre el cuerpo del documento donde se define todo lo que se va a ver -->
  70.  
  71. <div class="Web" id="Banner_StringManolo" style="text-align:center;">
  72. <!-- Se crea un contenedor, le damos varios nombres identificadores e indicamos que todo
  73. lo que pongamos dentro se centre -->
  74.  
  75. <div class = "BannerFijadoAbajo">
  76. <!-- Otro contenedor para otro Banner(El rectángulo de adorno) -->
  77.  
  78. <svg style = "display:block" width="100%" height="20">
  79. <!-- Svg son imágenes que crea el navegador y crecen automáticamente con el zoom -->
  80.  
  81. <rect width="100%" height="22" style="fill:rgb(0,0,0);stroke-width:1%;stroke:rgb(0,0,0)" id="Rectangulo2"
  82. onclick="CambiarColorRectangulo();vibrate(100);"/>
  83. <!-- Crea un rectángulo que ocupe todo el ancho de pantalla, lo pintamos de negro y le ponemos borde también negro
  84. En el onclick(Tras hacer click en el rectángulo), se activa el javascript que acabamos de ver, para cambiar el color por uno aleatorio.
  85. Al hacer click también llamamos a otro código de javascript que veremos más adelante.
  86. -->
  87.  
  88. </svg>
  89. <!-- Acabamos de usar SVG -->
  90.  
  91. </div>
  92. <!-- Cerramos el contenedor del banner de la parte inferior. -->
  93.  
  94. <div class = "BannerFijado">
  95. <!-- Contenedor para el banner de arriba -->
  96.  
  97. <svg style = "display:block" width="100%" height="40">
  98. <!-- Iniciamos el area límite de SVG sobre la que crear gráficos -->
  99.  
  100. <g>
  101. <!-- Contenedor para agrupar varios SVG distintos. En concreto para poder dibujar texto sobre el rectángulo -->
  102. <rect width="100%" height="42" style="fill:rgb(0,0,0);stroke-width:1%;stroke:rgb(0,0,0)" id="Rectangulo1"
  103. onclick="CambiarColorRectangulo();vibrate(50);"/>
  104.  
  105.  
  106. <!-- Desactivado para conexiones lentas y testeos. Lo dejo como ejemplo de fuente custom.
  107. <defs>
  108. <style>
  109. @import url("http://fonts.googleapis.com/css?family=Audiowide");
  110. <text x="50%" y="50%" font-family="Audiowide" font-size="30%" fill="white">MiPrimeraApp</text>
  111. </style>
  112. </defs>
  113. -->
  114.  
  115. <style><![CDATA[svg text{stroke:none}]]></style>
  116. <!-- Elimina los bordes del texto SVG -->
  117.  
  118. <text x="50%" y="50%" font-size="90%" fill="white" dominant-baseline="middle" text-anchor="middle">MiPrimeraApp</text>
  119. <!-- Crea texto SVG (escala junto al rectángulo) -->
  120. </g>
  121. <!-- La g sirve para meter el texto dentro del rectángulo -->
  122.  
  123.  Tu navegador no soporta Scalable Vector Graphics.
  124. <!-- Si el navegador o WebView no pudiese mostrar los SVG se mostraría este mensaje -->
  125. </svg>
  126. <!-- Se acabó el SVG -->
  127.  
  128. </div>
  129. </div>
  130. <!-- Cerrando contenedores en los que creamos gráficos SVG -->
  131.  
  132. <br><br><br>
  133. <!-- Saltos de línea -->
  134.  
  135. <div id="content-window" class="WebIncrustada">
  136. </div><br>
  137. <!-- Contenedor en el que se cargará una página web -->
  138.  
  139. <input type="text" id="url_a" value="http://www.example.com"><br>
  140. <!-- Un input para escribir una URL -->
  141.  
  142. <input id="btn" type="button" value="Ver" />
  143. <!-- Un botón que se usará para ver una Web -->
  144.  
  145. <input id="btn_a" type="button" value="Visitar" />
  146. <br><br>
  147. <!-- Un botón que se usará para ir a una Web -->
  148.  
  149.  
  150. <div class="ContenidoDelSitio" >
  151. <br><br><br><br><br>
  152.  
  153. <!-- Estilos para hacer más bonita y ordenada la web -->
  154. .BannerFijado{
  155. position: fixed;
  156. left: 0;
  157. right: 0;
  158. top: 0;
  159. }
  160.  
  161. .BannerFijadoAbajo{
  162. position: fixed;
  163. left: 0;
  164. right: 0;
  165. bottom: 0;
  166. }
  167.  
  168. .ContenidoDelSitio{
  169. margin: auto;
  170. width: 50%;
  171. height: 50%;
  172. padding: 10px;
  173. text-align: center;
  174. bottom: 0
  175. margin-left: auto;
  176. margin-right: auto;
  177. }
  178.  
  179. .WebIncrustada{
  180. width: 100%;
  181. height: 200%;
  182. text-align left;
  183. border: 1px solid green;
  184. }
  185.  
  186. /* javascript: */
  187.  
  188.  
  189. btn.onclick =
  190. function(){
  191. var temp = document.getElementById("url_a").value;
  192. document.getElementById("content-window").innerHTML='<object type="text/html" data="'+temp+'"></object>';
  193. /* Si se hace click en el botón Ver, se pega el HTML de la página web que ponga el usuario.
  194. Necesita mejoras para compatibilidad. */
  195.  
  196.  
  197. btn_a.onclick =
  198. function()
  199. {
  200. window.location = temp;
  201. }
  202. /* Si se le da al botón Ir, se abre la página en el WebView */
  203.  
  204. }
  205.  
  206. /* Con esta función haremos vibrar el Smartphone. */
  207.  
  208. function vibrate(milliseconds)
  209. {
  210. Android.Vibrate(milliseconds);
  211. } /* Llama al Vibrate en Java */
  212.  
  213. </body>
  214. </html>

Puedes copiar y pegar todo el código con los comentarios, funciona sin problemas.


Ahora tocamos el nombre del archivo. Le damos a File. Seleccionamos Save as.
Ahí abajo del todo borramos el nombre A.html.xml y le ponemos en su lugar webinterfaz.html

Arriba de todo a la izquierda volvemos a las carpetas.
Hay varios símbolos. Le tenemos que dar a la flecha que forma un círculo para actualizar
los archivos. Así detectará el nuevo archivo webinterfaz.html
Aún existe el A.html.xml asique lo eliminamos dándole a la X que está a su derecha.
Nos preguntará si estamos seguros que es el archivo que queremos borrar. Aceptamos.


Ahora añadiremos el WebView

En el archivo ActividadPrincipal.java escribimos los imports correspondientes:
Código
  1. import android.webkit.WebView;
  2. import android.webkit.WebSettings;
  3. import android.webkit.WebViewClient;
  4. import android.webkit.WebResourceError;
  5. import android.webkit.WebResourceRequest;
  6. import android.annotation.TargetApi;

Aquí os dejo links con toda la documentación por si quereis ver lo que podeis hacer:
https://developer.android.com/reference/android/webkit/WebView
https://developer.android.com/reference/android/webkit/WebSettings
https://developer.android.com/reference/android/webkit/WebViewClient
https://developer.android.com/reference/android/webkit/WebResourceError
https://developer.android.com/reference/android/webkit/WebResourceRequest
https://developer.android.com/reference/android/annotation/TargetApi

En el archivo ya tenemos
Código
  1. import android.app.Activity;
  2. import android.os.Bundle;

Aqui la documentación:
https://developer.android.com/reference/android/app/Activity
https://developer.android.com/reference/android/os/Bundle

El código que tenemos ahora en el archivo es:
package com.mimarca.MiPrimeraApp;

Código
  1. import android.app.Activity;
  2. import android.os.Bundle;
  3. import android.webkit.WebView;
  4. import android.webkit.WebSettings;
  5. import android.webkit.WebViewClient;
  6. import android.webkit.WebResourceError;
  7. import android.webkit.WebResourceRequest;
  8. import android.annotation.TargetApi;
  9.  
  10. import com.mimarca.MiPrimeraApp.R;
  11.  
  12. public class ActividadPrincipal extends Activity
  13. {
  14.   @Override
  15.   protected void onCreate(Bundle savedInstanceState)
  16.   {
  17.   super.onCreate(savedInstanceState);
  18.   setContentView(R.layout.principal_actividad);
  19.    }
  20. }

El import nos sirve para poder utilizar código y recursos que se encuentran en otros
archivos para poder usarlos en el archivo que tenemos los imports.

Los archivos que tienen la letra R. son generados automáticamente por el compilador.
Hace referencia a múltiples recursos como puedan ser imágenes, estilos, strings...

Creamos la clase ActividadPrincipal que se hereda de Activity.
Si no entiendes este código, aquí está muy bien explicado:
https://desarrolloweb.com/articulos/android-que-es-una-activity-o-actividad.html

Ahora vamos a crear el webview dentro de la clase con la Keyword Private para que solo sea accesible desde ella:
Código
  1. private WebView MiWebView;

Dentro de la clase añadimos lo siguiente:
Código
  1. MiWebView  = new WebView(this);
Así creamos un nuevo objeto. This hace referencia al propio objeto.

También obtenemos una referencia a los ajustes de nuestro WebView para poder manjarlos:
Código
  1. WebSettings webSettings = MiWebView.getSettings();

El primer ajuste que haremos será activar javascript que viene desactivado por defecto:
Código
  1. webSettings.setJavaScriptEnabled(true);

Un ejemplo de lo que podemos hacer es definir un nuevo User-Agent.
Por ejemplo:
Código
  1. String MiUserAgent = "MiPrimeraApp";
  2. MiWebView.getSettings().setUserAgentString(MiUserAgent);
Esto nos sirve por ejemplo para identificar en nuestra página web, si un usuario
nos visita desde Google Chrome, Mozilla, Opera, WebView o en este caso nuestra App.

Si creamos una web en PHP podríamos hacer lo siguiente:
Código
  1. $VisitanteDesdeMiApp = 'MiPrimeraApp';
  2. $UserAgentVisitante=$_SERVER['HTTP_USER_AGENT'];
  3. if ($UserAgentVisitante == $VisitanteDesdeMiApp)
  4. {
  5. MostrarWebEspecial();
  6. }
  7.  
  8. else
  9. {
  10. MostrarWebNormal();
  11. }

Aquí vamos a crear una interfaz para poder exponer código escrito en Java de nuestra aplicación, a javascript desde una web.
Código
  1. MiWebView.addJavascriptInterface(new JSInterface(this), "Android");
JSInterface.java lo crearemos después.
La cadena de texto "Android" es la que utilizamos en javascript para llamar a Java.
Como vimos en la web que creamos:
Código
  1. function vibrate(milliseconds)
  2. {
  3. Android.Vibrate(milliseconds);
  4. }

Añadimos lo siguiente para tema Versiones:
Código
  1. MiWebView.setWebViewClient(new WebViewClient()
  2. {
  3. @TargetApi(android.os.Build.VERSION_CODES.M)
  4. @Override
  5. public void onReceivedError(WebView view, WebResourceRequest req, WebResourceError rerr)
  6. {
  7. onReceivedError(view, rerr.getErrorCode(), rerr.getDescription().toString(), req.getUrl().toString());
  8. }});

Y por último la URL que queremos cargar en el WebView:
En este caso un archivo HTML local, pero puedes perfectamente poner cualquier link como https://www.example.com/index.php
Código
  1. MiWebView.loadUrl("file:///android_asset/webinterfaz.html");

Y lo mostramos:
Código
  1. setContentView(MiWebView);


Todo junto nos quedaría de la siguiente forma el archivo ActividadPrincipal.java:
Código
  1. package com.mimarca.MiPrimeraApp;
  2.  
  3. import android.app.Activity;
  4. import android.os.Bundle;
  5. import android.webkit.WebView;
  6. import android.webkit.WebSettings;
  7. import android.webkit.WebViewClient;
  8. import android.webkit.WebResourceError;
  9. import android.webkit.WebResourceRequest;
  10. import android.annotation.TargetApi;
  11.  
  12.  
  13. import com.mimarca.MiPrimeraApp.R;
  14.  
  15. public class ActividadPrincipal extends Activity
  16. {
  17.  
  18. private WebView MiWebView;
  19.  
  20.   @Override
  21.   protected void onCreate(Bundle savedInstanceState)
  22.   {
  23.   super.onCreate(savedInstanceState);
  24.   setContentView(R.layout.principal_actividad);
  25.  
  26.  
  27.   MiWebView  = new WebView(this);
  28.  
  29.   WebSettings webSettings = MiWebView.getSettings();
  30.  
  31.   webSettings.setJavaScriptEnabled(true);
  32.  
  33.   String MiUserAgent = "MiPrimeraApp";
  34.   MiWebView.getSettings().setUserAgentString(MiUserAgent);
  35.  
  36.   MiWebView.addJavascriptInterface(new JSInterface(this), "Android");
  37.  
  38.  
  39.  
  40.   MiWebView.setWebViewClient(new WebViewClient()
  41.   {
  42.   @TargetApi(android.os.Build.VERSION_CODES.M)
  43.   @Override
  44.   public void onReceivedError(WebView view, WebResourceRequest req, WebResourceError rerr)
  45.   {
  46.   onReceivedError(view, rerr.getErrorCode(), rerr.getDescription().toString(), req.getUrl().toString());
  47.   }
  48.   });
  49.  
  50.  
  51. MiWebView.loadUrl("file:///android_asset/webinterfaz.html");
  52.  
  53. setContentView(MiWebView);
  54. }}



Ahora en el administrador de archivos de la izquierda le damos al + para crear un nuevo archivo .java para la interfaz de javascript:
Justo encima del archivo ActividadPrincipal.java tenemos la carpeta
que lo contiene llamada MiPrimeraApp. A la derecha le damos al + para crear un nuevo archivo:
Seleccionamos Java File.
En class name nombramos el archivo como JSInterface y aceptamos.

Se nos crea un archivo JSInterface con el siguiente contenido:
Código
  1. package com.mimarca.MiPrimeraApp;
  2.  
  3. public class JSInterface {
  4.  
  5. }

Añadiremos los siguientes imports:
Código
  1. import android.content.Context;
  2. import android.os.Vibrator;
  3. import android.webkit.JavascriptInterface;

Hay muchos otros interesantes, como por ejemplo:
Código
  1. import android.telephony.SmsManager;
Que nos permite leer los SMS del Smartphone, o enviar SMS entre otras muchas cosas.
El resultado de enviar un SMS es el mismo que si lo hiciésemos normalmente, asique hay que tener
cuidado al escribir código, ya que podríamos llegar a enviar SMS en bucle por error y agotar el saldo o
recibir una factura muy alta.

Dentro de nuestra Interfaz pondremos:
Código
  1. Context mContext;
  2. JSInterface(Context c)
  3. {
  4. mContext = c;
  5. }

El contexto nos sirve para acceder a funciones de Android y exponerlas a la interfaz.
https://developer.android.com/reference/android/content/Context


Ahora podremos añadir la función del sistema a la que queremos acceder.
Para este tutorial, haremos algo simple, como hacer vibrar el SmartPhone.

Código
  1. @JavascriptInterface
  2. public void Vibrate(long milliseconds)
  3. {
  4. Vibrator v = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE);
  5. v.vibrate(milliseconds);
  6. }


El resultado del archivo JSInterface.java es el siguiente:
Código
  1. package com.mimarca.MiPrimeraApp;
  2.  
  3. import android.content.Context;
  4. import android.os.Vibrator;
  5. import android.webkit.JavascriptInterface;
  6.  
  7. public class JSInterface
  8. {
  9.  
  10. Context mContext;
  11.   JSInterface(Context c)
  12.   {
  13.  
  14.   mContext = c;
  15.   }
  16.  
  17.   @JavascriptInterface
  18.   public void Vibrate(long milliseconds)
  19.   {
  20.   Vibrator v = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE);
  21.   v.vibrate(milliseconds);
  22.   }
  23.  
  24. }


Ahora abrimos el archivo principal_actividad.xml y lo dejamos de la siguiente forma:
Código
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.    android:layout_width="match_parent"
  4.    android:layout_height="match_parent"
  5.    android:orientation="vertical">
  6.  
  7.        <WebView  xmlns:android="http://schemas.android.com/apk/res/android"
  8.    android:id="@+id/webview"
  9.    android:layout_width="fill_parent"
  10.    android:layout_height="fill_parent"
  11. />
  12. </LinearLayout>

De esta forma añadimos el WebView que usaremos de interfaz y decimos que ocupe toda la pantalla.


Por último el AndroidManifest.xml que dejamos de la siguiente manera:
Código
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.    package="com.mimarca.MiPrimeraApp"
  4.    android:versionCode="1"
  5.    android:versionName="1.0">
  6.  
  7.    <uses-sdk
  8.        android:minSdkVersion="14"
  9.        android:targetSdkVersion="25" />
  10. <uses-permission android:name="android.permission.INTERNET" />
  11. <uses-permission android:name="android.permission.VIBRATE" />
  12.    <application
  13.        android:allowBackup="true"
  14.        android:icon="@drawable/ic_launcher"
  15.        android:label="@string/app_name"
  16.        android:theme="@style/AppTheme">
  17.  
  18.        <activity android:name="com.mimarca.MiPrimeraApp.ActividadPrincipal">
  19.            <intent-filter>
  20.                <action android:name="android.intent.action.MAIN" />
  21.                <category android:name="android.intent.category.LAUNCHER" />
  22.            </intent-filter>
  23.        </activity>
  24.  
  25.    </application>
  26.  
  27. </manifest>

En este archivo las líneas más interesantes de conentar son:
Código
  1. <uses-permission android:name="android.permission.INTERNET" />
  2. <uses-permission android:name="android.permission.VIBRATE" />
Con estas lineas pedimos al usuario que permita estas funcionalidades a nuestra app.
Acceso a internet y control a la vibración.

Código terminado. Tras darle al botón de Play se contruirá la aplicación.
Ya podemos instalarla y probarla.
Al darle al rectángulo superior que pone MiPrimeraApp el móvil vibrará y el rectángulo cambiará
de color. Si te fijas también cambia el rectángulo de abajo. Si le tocas al de abajo, el móvil vibrará de
forma distinta.


Esto funciona de igual forma en un página en la Web. Por lo que si ya tienes una
página web, puedes hacer una versión especial para Android que controle funciones del Smartphone.
Hacer llamadas, mandar mensajes, reproducir música y efectos de sonido, obtener lista de contactos,
manejar archivos, obtener imágenes... Todo lo que se te ocurra.



« Última modificación: 23 Octubre 2019, 06:24 am por string Manolo » En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines