Código de uso común en desarrollo de aplicaciones Android: dummies

" Mi aplicación necesita un receptor de difusión. ¿Alguien puede recordarme cómo puedo codificar un receptor de difusión? Y mientras lo hace, ¿cómo devuelve una actividad el resultado? Oh, diablos. ¿Dónde puedo encontrar todo eso rápidamente? "

Tener ejemplos del tipo de código utilizado en el desarrollo de aplicaciones de Android puede ser de gran ayuda. Aquí encontrarás muchos ejemplos.

Actividades

Aquí hay una actividad que inicia otra actividad:

public class CheatSheetActivity extends La actividad implementa OnClickListener {Button button1; static final String MY_ACTION = "com. allmycode. action"; static final String MY_URI = "my_scheme: my_scheme_specific_part"; @Override public void onCreate (Bundle savedInstanceState) {super. onCreate (savedInstanceState); setContentView (R. layout. main); button1 = (Botón) findViewById (R id. button1); botón 1. setOnClickListener (this);} public void onClick (View arg0) {Intent intennt = new Intent (); intención. setAction (MY_ACTION); intención. setData (Uri. parse (MY_URI)); startActivity (intent);}}

Y no olvides que cuando creas una nueva clase de actividad, debes agregar un elemento correspondiente a tu AndroidManifest. archivo xml El filtro de intención del elemento de OtherActivity se parece a esto:

Para obtener un resultado de una actividad, agregue el siguiente código (o algo parecido) a su aplicación:

final int CODE_NUMBER = 42; final String CLASSNAME = "CheatSheetActivity"; public void onClick (View arg0) {Intent intennt = new Intent (); intención. setAction (MY_ACTION); intención. setData (Uri. parse (MY_URI)); startActivityForResult (intent, CODE_NUMBER);} protected void onActivityResult (int codeNumber, int resultCode, Intent intent) {if (resultCode == RESULT_OK) {if (codeNumber == CODE_NUMBER) {Log. i (CLASSNAME, intento. getData (). getSchemeSpecificPart ());}}}

Y en la actividad que crea el resultado, agregue código del siguiente tipo:

Intent intennt = new Intent (); intención. setData (Uri. parse ("resultado: hola")); setResult (RESULT_OK, intención); terminar();

Servicios

Un servicio generalmente hace su trabajo sin molestar (o incluso notificar) al usuario. Por ejemplo, un servicio de precios de acciones podría llegar a la web y obtener los precios más recientes de las selecciones favoritas del usuario. La actividad de otra aplicación puede obtener datos del servicio y mostrar los datos en la pantalla del dispositivo.

El siguiente código es un servicio meteorológico completo (pero no muy preciso):

public class MyWeatherService extiende el servicio {Messenger messengerToClient = null; MyIncomingHandler myIncomingHandler = new MyIncomingHandler (); Messenger messengerToService = new Messenger (myIncomingHandler); @Override public IBinder onBind (intención intencionada) {return messengerToService.getBinder ();} clase MyIncomingHandler extends Handler {@Override public void handleMessage (Message incomingMessage) {messengerToClient = incomingMessage. responder a; Respuesta del paquete = nuevo Bundle (); respuesta. putString ("clima", "Está oscuro por la noche"); Mensaje replyMessage = Mensaje. obtener(); mensaje de respuesta. setData (respuesta); prueba {messengerToClient. send (replyMessage);} catch (RemoteException e) {e. printStackTrace ();}}}}

En otro paquete, pones el código para llamar al servicio meteorológico. Aquí hay algunos ejemplos de código:

public class ServiceConsumerActivity extends La actividad implementa OnClickListener {Messenger messengerToService = null; MyIncomingHandler myIncomingHandler = new MyIncomingHandler (); Messenger messengerFromService = new Messenger (myIncomingHandler); Conexión de ServiceConnection = new MyServiceConnection (); SharedPreferences prefs; boolean isBound = false; void bind () {Intent intennt = new Intent (); intención. setAction ("com. allmycode. WEATHER"); isBound = bindService (intención, conexión, Contexto. BIND_AUTO_CREATE);} public void queryService () {if (isBound) {Bundle bundle = new Bundle (); haz. putString ("ubicación", "Filadelfia"); Mensaje mensaje = Mensaje. obtener(); mensaje. replyTo = messengerFromService; mensaje. setData (paquete); prueba {messengerToService. enviar (mensaje);} captura (RemoteException e) {e. printStackTrace ();}} else {textView1. setText (cadena R. service_not_bound);}} clase MyIncomingHandler extends Handler {@Override public void handleMessage (Message msg) {Bundle bundle = msg. obtener datos(); textView1. setText (bundle. getString ("weather"));}} void unbind () {if (isBound) {unbindService (conexión); isBound = false;}} clase MyServiceConnection implementa ServiceConnection {public void onServiceConnected (ComponentName className, Binder de IBinder) {messengerToService = new Messenger (binder);} public void onServiceDisconnected (ComponentName n) {messengerToService = null;}} // I don ' t incluye el método onCreate o el método // onClick en este ejemplo.}

Por supuesto, ninguna aplicación sobrevive sin algunos elementos en el archivo de manifiesto. Para registrar el servicio de esta sección, necesita un elemento del siguiente tipo:

Receptores de difusión

Cuando hace una transmisión, arroja un intento en la naturaleza. Los receptores de difusión con filtros de intención compatibles se activan y hacen algo útil con la información de transmisión. (Después de hacer algo con la información de la transmisión, el receptor vuelve a dormirse. En mi próxima encarnación, quiero ser un receptor de difusión).

Para crear su propio receptor de difusión, amplía la clase BroadcastReceiver de Android y declara una respuesta. método. Por ejemplo, el siguiente código responde a las transmisiones coincidentes:

public class MyReceiver extiende BroadcastReceiver {@Override public void onReceive (contexto contextual, intención intencionada) {// hace cosas importantes}}

otra aplicación crea una emisión con código del siguiente tipo:

Intent intention = new Intent (); intención. setAction ("com. allmycode. ACTION"); sendBroadcast (intención);

Puede registrar un receptor de difusión en su AndroidManifest.archivo xml:

Para mayor flexibilidad, puede registrar un receptor en su código Java. El siguiente código de Java hace esencialmente lo que el elemento en un AndroidManifest. El archivo xml lo hace:

IntentFilter filter = new IntentFilter (); filtrar. addAction ("com. allmycode. ACTION"); registerReceiver (nuevo MyReceiver (), filtro);

Proveedores de contenido

El proveedor de contenido de una aplicación hace que los datos estén disponibles para otras aplicaciones que se ejecutan en el mismo dispositivo. La interfaz del proveedor se asemeja a la interfaz de una base de datos, con tablas, filas, cursores y todas esas cosas buenas. Por ejemplo, el código para consultar un proveedor de contenido tiene el siguiente aspecto:

consulta pública del cursor (columnas Uri uri, String [], String whereClause, String [] whereArgs, String sortOrder) {Cursor cursor = null; código int = uriMatcher. partido (uri); if (código == 1) {cursor = db. consulta (SIMPLETABLE, columnas, whereClause, whereArgs, null, null, sortOrder);} else if (code == 2) {String [] columnNames = {"_id", "name", "amount"}; String [] rowValues ​​= {"Tabla", "4", "2"}; MatrixCursor matrixCursor = new MatrixCursor (columnNames); matrizCursor. addRow (rowValues); cursor = matrizCursor;} devolver cursor;}

Fragmentos

Un fragmento es como una vista, algo visible que se puede visualizar dentro de una actividad. Pero a diferencia de una vista, un fragmento tiene sus propios métodos de ciclo de vida. Entonces, Android puede crear una pequeña pila de fragmentos dentro de una actividad. Cuando el usuario presiona el botón Atrás, Android saca un fragmento de la pila. (Si no hay fragmentos para mostrar, Android saca toda la actividad de la pila de tareas.)

Puede poner un fragmento en el siguiente diseño de marco:

Para poner un fragmento en el diseño, realiza una transacción de fragmento. Así es como se ve una transacción de fragmento:

DocsFragment docsFragment = DocsFragment. nuevaInstancia (índice); FragmentManager fragmentManager = getFragmentManager (); FragmentTransaction fragmentTransaction = fragmentManager. beginTransaction (); fragmentoTransacción. replace (R id id docs, docsFragment); fragmentoTransacción. addToBackStack (null); fragmentoTransacción. cometer();

Intentos y filtros de intención

Cuando una intención cumple con el filtro de intención correcta, el resultado es una coincidencia hecha en el cielo. Pero las reglas para hacer coincidir intenciones con filtros son complicadas. Las reglas se leen como las cláusulas legales en un acuerdo prenupcial.

Puede usar métodos Java para describir un intento. Estos son algunos de los métodos más utilizados:

• setAction: Establece la acción del intento. (Un intento solo puede tener una acción).

• addCategory: Agrega una categoría al intento. (Un intento puede tener muchas categorías).

• setData: Establece el URI del intento y elimina el tipo MIME del intento (si el intento tiene un tipo MIME).

• setType: Establece el tipo MIME del intento y elimina el URI del intento (si el intento tiene un URI).

• setDataAndType: Establece el URI del intento y el tipo MIME del intento. De acuerdo con los documentos, "Este método debería usarse muy raramente. "

También puede usar código XML para describir un intento.

En el URI // www.allmycode. com: 80 / android, el esquema es http, el host es www. allmycode. com, el puerto es 80, y la ruta es android. La autoridad (que no es uno de los atributos de un elemento, pero es útil conocer) es www. allmycode. com: 80.

Normalmente establece los valores de un filtro de intención en el AndroidManifest. archivo xml Pero en código Java, el android. contenido. La clase IntentFilter tiene muchos métodos útiles. Aquí hay algunos de ellos:

• addAction: Agrega una acción al filtro.

• addCategory: Agrega una categoría al filtro.

• addDataScheme: Agrega un esquema al filtro.

• addDataAuthority: Agrega una autoridad al filtro.

• addDataPath: Agrega una ruta al filtro.

• addDataType: Agrega un tipo MIME al filtro.

Un filtro de intención puede tener muchas acciones, muchas categorías, etc.

Aquí hay una breve lista de requisitos para una coincidencia entre un intento y un filtro de intención. Esta lista no está completa así que, si desea una lista completa, es mejor que compre Desarrollo de aplicaciones Android Todo en Uno para Dummies de Barry Burd.

• Si un intento tiene una acción, para que coincida con la intención, un filtro de intención debe tener una acción idéntica. El filtro de intención puede tener acciones adicionales. Cualquiera de estas acciones adicionales no tiene efecto en la coincidencia.

• Si un intento tiene categorías, para que coincida con la intención, un filtro de intención debe tener estas (y posiblemente más) categorías.

• Si un intento tiene un tipo MIME, para que coincida con la intención, un filtro de intención debe tener un tipo MIME coincidente. El filtro de intención puede tener tipos MIME adicionales. Cualquiera de estos tipos MIME adicionales no tiene ningún efecto en la coincidencia.

• Si un filtro de intención tiene tipos MIME, para que coincida con el filtro de intención, un intento debe tener un tipo MIME y el tipo MIME del intento debe coincidir con uno de los tipos MIME del filtro.

• Hasta cierto punto, la coincidencia de tipos MIME puede incluir comodines y expresiones regulares.

• Si un intento tiene un esquema de URI, para que coincida con la intención, un filtro de intención debe tener un esquema de URI coincidente.

• Si un filtro de intención tiene esquemas de URI, para que coincida con el filtro de intención, un intento debe tener un esquema de URI y el esquema de URI del intento debe coincidir con uno de los esquemas de URI del filtro.

Para finalizar esta lista, copie las dos últimas reglas, cambiando una o dos palabras en cada una de las copias:

• Si una intención tiene un URI host , para que coincida con el intento, un filtro de intención debe tener un URI coincidente host .

• Si un filtro de intención tiene URI hosts , para que coincida con el filtro de intención, un intento debe tener un URI host y el URI del intento host < debe coincidir con uno de los URI del filtro host s . Si un intento tiene un URI

• puerto , para que coincida con la intención, un filtro de intención debe tener un URI coincidente puerto . Si un filtro de intención tiene URI

• puertos , para que coincida con el filtro de intención, un intento debe tener un URI puerto y el URI del intento puerto < debe coincidir con uno de los URI del filtro por t s . Si un intento tiene un URI ruta

• , para que coincida con la intención, un filtro de intención debe tener un URI coincidente ruta . Si un filtro de intención tiene URI rutas

• , para coincidir con el filtro de intención, una intención debe tener una ruta URI y la ruta URI del intento