¿Cómo crear una barra de progreso en una notificación con Android?

Como hemos dicho anteriormente para realizar esta tarea vamos a utilizar una AsyncTask, la cual va a ejecutar una tarea larga (en nuestro caso usaremos un sleep para simular la tarea) que vaya actualizando la barra de progreso en la notificación a medida que pase el tiempo:

import android.annotation.SuppressLint;
import android.app.NotificationManager;
import android.content.Context;
import android.os.AsyncTask;
import android.support.v4.app.NotificationCompat;

public class ProgressNotification extends AsyncTask<Void, Integer, Boolean> {

	private Context context;
	private NotificationManager mNotificationManager;
	private android.support.v4.app.NotificationCompat.Builder mNotifyBuilder;
	private int numMessages;

	public ProgressNotification(Context context) {
		this.context = context;
	}

	@Override
	protected Boolean doInBackground(Void... object) {
		// Tarea larga que se ejecuta en segundo plano
		Integer value = 0;

		while (value < 100) {
			value += 10;
			try {
				Thread.sleep(1000);
				// Cada 1 segundo actualiza la barra de progreso
				publishProgress(value);
			} catch (InterruptedException e) {
				return false;
			}
		}

		return true;
	}

	@SuppressLint("NewApi")
	@Override
	protected void onProgressUpdate(Integer... values) {
		// Actualiza la barra de progreso
		mNotifyBuilder.setProgress(100, values[0], false);
		mNotificationManager.notify(numMessages, mNotifyBuilder.build());

	}

	protected void onPreExecute() {
		mNotificationManager = (NotificationManager) context
				.getSystemService(Context.NOTIFICATION_SERVICE);
		// Establece un ID para la notificación, para que se pueda actualizar
		mNotifyBuilder = new NotificationCompat.Builder(context)
				.setContentTitle("Tarea en ejecución")
				.setContentText("Tarea en ejecución")
				.setSmallIcon(R.drawable.ic_launcher);
		// Comienza un bucle que procesa los datos y luego notifica al usuario
		mNotifyBuilder.setContentText("En proceso..");
		// Debido a que el ID se mantiene sin cambios, la notificación
		// existente se actualiza
		mNotificationManager.notify(numMessages, mNotifyBuilder.build());
	}

	@Override
	protected void onPostExecute(Boolean resultado) {

		// Muestra el resultado en la notificación si fue exitoso o no
		if (resultado) {
			mNotifyBuilder.setContentText("Tarea terminada correctamente");
		} else {
			mNotifyBuilder.setContentText("La tarea no se pudo realizar");
		}
		// Elimina la barra de progreso
		mNotifyBuilder.setProgress(0, 0, false);
		mNotificationManager.notify(numMessages, mNotifyBuilder.build());

	}
}

Luego para probar nuestra barra de progreso podemos ejecutar el siguiente código en una Activity:

new ProgressNotification(getApplicationContext()).execute();

Y el resultado de ejecutar el programa sería el siguiente:

Barra de progreso en Android

Bueno gente, hemos llegado al final de este tutorial, espero que les sea de gran utilidad. Ante cualquier problema no duden en dejar un comentario.

La entrada Barra de progreso en una notificación con Android usando Java aparece primero en ProgramaciónExtrema.com.

Para comenzar con este tutorial primero vamos a descargar la librería json-simple que nos va a facilitar esta tarea. El JAR se lo pueden descargar desde: https://code.google.com/p/json-simple/downloads/list. Luego debemos importar el JAR como dependencia en nuestro proyecto. Si estamos utilizando Eclipse como IDE podemos hacer click derecho en nuestro proyecto e ir a “Properties -> Java Build Path -> Libraries -> Add External JARs” y seleccionar el archivo JAR descargado.

¿Cómo parsear un JSON en Java?

En el siguiente ejemplo podemos ver como parsear un texto de formato JSON utilizando el método estático parse de la clase JSONValue:

import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.JSONValue;

public class JSONParser {

	public static void main(String[] args) {

		String s = "[0,{\"1\":{\"2\":{\"3\":{\"4\":[5,{\"6\":7}]}}}}]";
		Object obj = JSONValue.parse(s);
		JSONArray array = (JSONArray) obj;
		System.out.println("======El segundo elemento del Array======");
		System.out.println(array.get(1));
		System.out.println();

		JSONObject obj2 = (JSONObject) array.get(1);
		System.out.println("======Campo \"1\"==========");
		System.out.println(obj2.get("1"));

		s = "{}";
		obj = JSONValue.parse(s);
		System.out.println(obj);

		s = "[5,]";
		obj = JSONValue.parse(s);
		System.out.println(obj);

		s = "[5,,2]";
		obj = JSONValue.parse(s);
		System.out.println(obj);
	}

}

Ahora si queremos hacer lo contrario, osea crear nuestro propio JSON en Java, tenemos que utilizar el objeto JSONObject de la siguiente forma:

import org.json.simple.JSONObject;

public class JSONParser {

	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		JSONObject obj = new JSONObject();
		obj.put("name", "foo");
		obj.put("num", new Integer(100));
		obj.put("balance", new Double(1000.21));
		obj.put("is_vip", new Boolean(true));
		obj.put("nickname", null);
		System.out.print(obj);
	}

}

Bueno gente, esto es todo por hoy espero que les sea de gran utilidad. Si quieren saber un poco más sobre esta librería les recomiendo ver la documentación oficial en: https://code.google.com/p/json-simple.

La entrada Parsear un JSON en Java aparece primero en ProgramaciónExtrema.com.

Ya hemos visto que NuSOAP sirve para crear un Web Service en PHP, ahora para crear nuestro cliente vamos a utilizar la librería para android llamada KSOAP2. Esta misma se la pueden descargar desde el sitio: https://oss.sonatype.org/content/repositories/ksoap2-android-releases/com/google/code/ksoap2-android/ksoap2-android-assembly/3.5.0/ksoap2-android-assembly-3.5.0-jar-with-dependencies.jar.
Una vez que descargamos el JAR lo debemos incluir en la carpeta libs de nuestro proyecto y agregarlo como dependencia haciendo click derecho en el proyecto -> Properties -> Java Build Path -> Add JARs.

¿Cómo consumir un Web Service NuSOAP en Android?

El primer paso que vamos a realizar en nuestra aplicación es agregar el permiso para poder conectar a internet:

<uses-permission android:name="android.permission.INTERNET" />

Luego de realizar esto podemos empezar a programar. En este caso vamos a crear una clase llamada ClienteWS, la cual va a ejecutar la función saludar (de nuestro Web Service) con un parámetro (nombre) y recibirá una respuesta:

import java.io.IOException;

import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapPrimitive;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
import org.xmlpull.v1.XmlPullParserException;

import android.content.Context;
import android.os.AsyncTask;
import android.util.Log;
import android.widget.Toast;

public class ClienteWS extends AsyncTask<String, Integer, String> {

	private Context context;
	
	private static final String SOAP_ACTION = "SaludoXMLwsdl#Saludar";
	private static final String OPERATION_NAME = "Saludar";
	private static final String WSDL_TARGET_NAMESPACE = "SaludoXMLwsdl";
	public static final String SOAP_ADDRESS = "http://midominio.com/path/to/servicio.php";

	public ClienteWS(Context context) {
		this.context = context;
	}

	@Override
	protected String doInBackground(String... params) {

		String result = null;

		SoapObject request = new SoapObject(WSDL_TARGET_NAMESPACE,
				OPERATION_NAME);

		SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(
				SoapEnvelope.VER10);

		// Con esta opción indicamos que el web service no es .net
		envelope.dotNet = false;

		envelope.setOutputSoapObject(request);

		HttpTransportSE httpTransport = new HttpTransportSE(SOAP_ADDRESS);
        
		// Enviando un parámetro al web service
		request.addProperty("nombre", params[0]);

		try {
			
			// Enviando la petición al web service
			httpTransport.call(SOAP_ACTION, envelope);

			// Recibiendo una respuesta del web service
			SoapPrimitive resultsRequestSOAP = (SoapPrimitive) envelope
					.getResponse();

			result = resultsRequestSOAP.toString();

			httpTransport.getServiceConnection().disconnect();
		} catch (IOException | XmlPullParserException e) {
			Log.v("Error", e.getMessage());
			result = e.getMessage();
		}

		return result;
	}

	@Override
	protected void onPostExecute(String result) {
		// Mostramos la respuesta del web service
		Toast.makeText(context, result, Toast.LENGTH_LONG).show();
	}

}

Luego para probar este cliente solamente tenemos que ejecutar el siguiente código en nuestra Activity:

new ClienteWS(this).execute("ProgramaciónExtrema.com");

Eso es todo por hoy, espero que les sea de gran utilidad. Ante cualquier problema no duden en dejar un comentario.

La entrada Consumir un Web Service NuSOAP en Android usando KSOAP2 aparece primero en ProgramaciónExtrema.com.

¿Cómo agregar una barra de control a un streaming de radio con Android usando Java?

Para realizar esto y siguiendo con lo que habíamos hecho en el anterior tutorial vamos a comenzar agregando los componentes en la vista. En nuestro xml (activity_main.xml en mi caso) agregaremos el siguiente código:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.programacionextrema.radio.MainActivity" >

    <LinearLayout
        android:id="@+id/controlLayout"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"
        android:layout_centerInParent="true"
        android:layout_margin="5dp"
        android:gravity="center_horizontal" >

        <RelativeLayout
            android:id="@+id/volumeLayout"
            android:layout_width="wrap_content"
            android:layout_height="70dp"
            android:layout_gravity="center_vertical"
            android:layout_marginRight="10dp"
            android:background="@drawable/volume_background"
            android:gravity="center_vertical"
            android:padding="3dp" >

            <ImageView
                android:id="@+id/volumeImageView"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:contentDescription="@string/iconVolumeDescription"
                android:src="@android:drawable/ic_lock_silent_mode_off" />

            <SeekBar
                android:id="@+id/volumeSeekBar"
                android:layout_width="180dp"
                android:layout_height="wrap_content"
                android:layout_marginLeft="36dp"
                android:indeterminate="false" />
        </RelativeLayout>

        <RelativeLayout
            android:id="@+id/layoutButton"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:background="@drawable/volume_background"
            android:padding="3dp" >

            <ToggleButton
                android:id="@+id/playPauseButton"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:background="@drawable/start_pause_button_selector"
                android:contentDescription="@string/clear"
                android:minHeight="64dp" />
        </RelativeLayout>
    </LinearLayout>

</RelativeLayout>

Seguido de esto debemos agregar los siguientes strings en res/values/strings.xml:

<string name="clear"></string>
<string name="iconVolumeDescription">Volumen</string>

Luego debemos crear (si no la tenemos) una carpeta llamada drawable dentro del directorio res. Ahí vamos a incluir los siguientes tres archivos que representan el diseño de la barra de control que incluimos en nuestra vista:

media_button_layer.xml

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android" >

    <item>
        <shape
            xmlns:android="http://schemas.android.com/apk/res/android"
            android:dither="true"
            android:shape="oval" >
            <size
                android:height="15dp"
                android:width="15dp" />

            <solid android:color="#000" />
        </shape>
    </item>
    <item>
        <shape
            xmlns:android="http://schemas.android.com/apk/res/android"
            android:dither="true"
            android:shape="oval" >
            <size
                android:height="13dp"
                android:width="13dp" />

            <gradient
                android:angle="90"
                android:endColor="#0099FF"
                android:startColor="#003399"
                android:type="linear" />
        </shape>
    </item>
    <item>
        <selector>
            <item
                android:drawable="@android:drawable/ic_media_pause"
                android:state_checked="true"/>
            <item
                android:drawable="@android:drawable/ic_media_play"
                android:state_checked="false"/>
            <item android:drawable="@android:drawable/ic_media_play"/>
        </selector>
    </item>

</layer-list>

start_pause_button_selector.xml

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@android:drawable/ic_media_pause" android:state_checked="true"/>
    <item android:drawable="@android:drawable/ic_media_play" android:state_checked="false"/>
    <item android:drawable="@android:drawable/ic_media_play" />
</selector>

volume_background.xml

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle" >
    <solid android:color="#000" />
    <corners android:radius="5dp" />
</shape>

Una vez que ya terminamos con los pasos anteriores debemos agregar la funcionalidad con Java para que al apretar play o stop realice la acción adecuada y además que se pueda manejar el volumen. Para esto vamos a incluir el siguiente código, el cual es una versión mejorada del tutorial anterior:

package com.programacionextrema.radio;

import java.io.IOException;

import android.app.Activity;
import android.content.Context;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnBufferingUpdateListener;
import android.media.MediaPlayer.OnPreparedListener;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.SeekBar;
import android.widget.SeekBar.OnSeekBarChangeListener;
import android.widget.Toast;
import android.widget.ToggleButton;

public class MainActivity extends Activity {

	private MediaPlayer player;
	private String url = "Aquí va la URL";
	protected boolean isPlay = false;
	private ToggleButton buttonStreaming;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		// Inicializo el objeto MediaPlayer
		initializeMediaPlayer();

		// Inicializando el volumen
		initializeVolume();

		buttonStreaming = (ToggleButton) findViewById(R.id.playPauseButton);
		buttonStreaming.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View arg0) {
				buttonStreaming.setEnabled(false);
				isPlay = !isPlay;

				if (isPlay) {
					startPlaying();
				} else {
					stopPlaying();
				}
			}
		});
	}

	public void stopPlaying() {
		if (player.isPlaying()) {
			player.stop();
			player.release();
			initializeMediaPlayer();
			buttonStreaming.setEnabled(true);
		}
	}

	private void initializeVolume() {
		try {
			final SeekBar volumeBar = (SeekBar) findViewById(R.id.volumeSeekBar);
			final AudioManager audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);

			volumeBar.setMax(audioManager
					.getStreamMaxVolume(AudioManager.STREAM_MUSIC));
			volumeBar.setProgress(audioManager
					.getStreamVolume(AudioManager.STREAM_MUSIC));

			final OnSeekBarChangeListener eventListener = new OnSeekBarChangeListener() {
				@Override
				public void onStopTrackingTouch(SeekBar seekBar) {
				}

				@Override
				public void onStartTrackingTouch(SeekBar seekBar) {
				}

				@Override
				public void onProgressChanged(SeekBar seekBar, int progress,
						boolean fromUser) {
					audioManager.setStreamVolume(AudioManager.STREAM_MUSIC,
							progress, 0);
				}
			};

			volumeBar.setOnSeekBarChangeListener(eventListener);
		} catch (Exception e) {
			Log.e("MainActivity", e.getMessage());
		}
	}

	private void initializeMediaPlayer() {
		player = new MediaPlayer();

		player.setOnBufferingUpdateListener(new OnBufferingUpdateListener() {

			public void onBufferingUpdate(MediaPlayer mp, int percent) {
				Log.i("Buffering", "" + percent);
			}
		});
	}

	public void startPlaying() {

		try {

			Toast.makeText(getApplicationContext(),
					"Conectando con la radio, espere unos segundos...",
					Toast.LENGTH_LONG).show();

			player.reset();
			player.setDataSource(url);
			player.setAudioStreamType(AudioManager.STREAM_MUSIC);

			player.setOnPreparedListener(new OnPreparedListener() {

				public void onPrepared(MediaPlayer mp) {

					player.start();
					buttonStreaming.setEnabled(true);
				}
			});

			player.prepareAsync();

		} catch (IllegalArgumentException | SecurityException
				| IllegalStateException | IOException e) {
			Toast.makeText(getApplicationContext(),
					"Error al conectar con la radio", Toast.LENGTH_LONG).show();
		}

	}

}

Para que esta aplicación funcione es importante recordar que hay que agregar el permiso para poder conectarse a internet en el AndroidManifest.xml.

<uses-permission android:name="android.permission.INTERNET" >
</uses-permission>

Luego podemos compilar e instalar nuestra aplicación en un dispositivo. El resultado tendría que ser el siguiente:

Ejemplo de streaming de radio con Android

Bueno, hemos llegado al final de este tutorial como ya saben ante cualquier problema no duden en dejar un comentario.

La entrada Streaming de radio con Android usando Java (parte 2) aparece primero en ProgramaciónExtrema.com.

¿Cómo hacer streaming de radio con android usando Java?

Realizar esta tarea en Android no es nada difícil, para esto vamos a utilizar el objeto MediaPlayer que nos proporciona la API de Android y nos permite manipular en este caso un streaming de música con solo ingresar la URL.
Antes de comenzar a programar es necesario agregar un permiso en el archivo AndroidManifest.xml para que la aplicación se pueda conectar a internet:

<uses-permission android:name="android.permission.INTERNET" >
</uses-permission>

A continuación el código fuente del streaming de radio:

package com.programacionextrema.radio;

import java.io.IOException;

import android.app.Activity;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnBufferingUpdateListener;
import android.media.MediaPlayer.OnPreparedListener;
import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;

public class MainActivity extends Activity {

	private MediaPlayer player;
	private String url = "Aquí va la URL";

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		// Inicializo el objeto MediaPlayer
		initializeMediaPlayer();

		// Inicio el streaming de radio
		startPlaying();
	}

	private void initializeMediaPlayer() {
		player = new MediaPlayer();

		player.setOnBufferingUpdateListener(new OnBufferingUpdateListener() {

			public void onBufferingUpdate(MediaPlayer mp, int percent) {
				Log.i("Buffering", "" + percent);
			}
		});
	}

	public void startPlaying() {

		try {

			Toast.makeText(getApplicationContext(),
					"Conectando con la radio, espere unos segundos...",
					Toast.LENGTH_LONG).show();

			player.reset();
			player.setDataSource(url);
			player.setAudioStreamType(AudioManager.STREAM_MUSIC);

			player.setOnPreparedListener(new OnPreparedListener() {

				public void onPrepared(MediaPlayer mp) {

					player.start();

				}
			});

			player.prepareAsync();

		} catch (IllegalArgumentException | SecurityException
				| IllegalStateException | IOException e) {
			Toast.makeText(getApplicationContext(),
					"Error al conectar con la radio", Toast.LENGTH_LONG).show();
		}

	}

}

Al ejecutar el código anterior en Android se reproducirá automáticamente la radio. Si queremos agregar una barra de control para manipular el audio podemos seguir el siguiente tutorial: http://programacionextrema.com/2015/10/29/streaming-de-radio-con-android-usando-java-parte-2

Bueno hemos llegado al final de este tutorial, ante cualquier problema no duden en dejar un comentario.

La entrada Streaming de radio con Android usando Java aparece primero en ProgramaciónExtrema.com.

Cómo usar Genymotion

Para poder utilizarlo primero tenemos que descargarlo del sitio oficial www.genymotion.com, debemos elegir la opción de uso personal ya que es la gratuita.
Una vez descargado debemos proceder a la instalación, la cual es en pocos pasos y para nada complicada.

Listado de máquinas virtuales en Genymotion

Luego si queremos configurar Genymotion con Ecplipse o Android Studio debemos ir a settings e indicarle la ubicación del SDK en nuestra PC.

Settings Genymotion

De esta forma podemos probar nuestras aplicaciones en Genymotion con nuestro IDE favorito sin perder tanto tiempo como con otros emuladores.

Bueno hemos llegado al final de este breve artículo, ante cualquier problema no duden en dejar un comentario.

La entrada Genymotion: El emulador más rápido para Android aparece primero en ProgramaciónExtrema.com.

A veces y por distintos motivos es necesario obtener estos códigos en Android, es por eso que en este tutorial aprenderemos a obtenerlos usando Java.

Cómo obtener códigos MCC y MNC en Android usando Java

Con el siguiente método estático podemos obtener el código MCC con Java. Es importante ver que esta función retorna el código como un string y recibe como parámetro un contexto.

public static String getMCC(Context context) {
  TelephonyManager tel = (TelephonyManager) context
        .getSystemService(Context.TELEPHONY_SERVICE);
  String networkOperator = tel.getNetworkOperator();

  if (networkOperator != null && !networkOperator.equals("")) {
    int mcc = Integer.parseInt(networkOperator.substring(0, 3));
    return mcc + "";
  }
  return "No detectado";
}

Ahora podemos pasar a nuestro segundo método estático. Este permite obtener el código MNC del dispositivo en Android. Como podemos ver también recibe un contexto y retorna un string.

 public static String getMNC(Context context) {
  TelephonyManager tel = (TelephonyManager) context
        .getSystemService(Context.TELEPHONY_SERVICE);
  String networkOperator = tel.getNetworkOperator();

  if (networkOperator != null && !networkOperator.equals("")) {
    int mnc = Integer.parseInt(networkOperator.substring(3));
    return mnc + "";
  }
  return "No detectado";
 }

Bueno gente, espero que les sea de gran utilidad estos dos métodos y ante cualquier problema no duden en deja un comentario.

La entrada Obtener códigos MCC y MNC en Android usando Java aparece primero en ProgramaciónExtrema.com.

¿Cómo crear un AsyncTask en Android?

Para crear nuestro propio hilo de ejecución en Android debemos crear una clase que herede de AsyncTask. Esta clase nos da la posibilidad de implementar varios métodos:

onPreExecute: Aquí va todo el código que se ejecuta antes de comenzar el hilo.
doInBackground(Params…): Aquí va el código que se desea ejecutar en segundo plano.
onProgressUpdate(Progress…): Este método es invocado después de llamar a publishProgress(Progress…). Es utilizado para crear barras de progreso.
onPostExecute(Result): Aquí va el código que es ejecutado una vez que termina el hilo, el parámetro que recibe es el resultado de la función doInBackground(Params…).

De los métodos mencionados el único obligatorio es el doInBackground. Una vez que entendimos cuales son los componentes principales podemos crear nuestra AsyncTask:

import android.content.Context;
import android.os.AsyncTask;
import android.widget.Toast;

public class MyAsyncTask extends AsyncTask<String, Void, String> {

	private Context context;

	public MyAsyncTask(Context context) {
		this.context = context;
	}

	@Override
	protected String doInBackground(String... params) {
		try {
			Thread.sleep(5000);
			return params[0];
		} catch (InterruptedException e) {
			return "Ha ocurrido un error.";
		}

	}

	@Override
	protected void onPostExecute(String result) {
		Toast.makeText(context, result,
				Toast.LENGTH_LONG).show();
	}
}

Esta AsyncTask es muy simple. Lo único que hace es dormirse 5 segundos y luego mostrar un resultado. Un detalle importante a mencionar es que el tipo genérico indicado en AsyncTask no necesariamente debe ser un string.

Para ejecutar esta tarea debemos hacer:

new MyAsyncTask(getApplicationContext()).execute("Tarea ejecutada correctamente.");

Donde el parámetro pasado al método execute es el resultado que se mostrará en caso de ejecutarse correctamente. A esta función también es posible enviarle más de un parámetro, la única condición es que todos deben ser del mismo tipo.

Espero que les haya gustado el ejemplo y ya saben que si tienen alguna duda al respecto no duden en preguntar.

La entrada AsyncTask en Android aparece primero en ProgramaciónExtrema.com.

Por diversos motivos a veces es necesario obtener este código en una aplicación hecha en Java para Android, es por eso que en este tutorial vamos a ver como recuperarlo.

¿Cómo obtener el IMEI en Android con Java?

Con la siguiente función estática podemos obtener el IMEI de cualquier dispositivo Android:

/*Función que obtiene el IMEI de un dispositivo en Android.*/
public static String getImei(Context c) {
  TelephonyManager telephonyManager = (TelephonyManager) c
         .getSystemService(Context.TELEPHONY_SERVICE);
  return telephonyManager.getDeviceId();
}

Luego para utilizar la función simplemente hacemos lo siguiente:

/*Para que funcione el siguiente código, la función getImei debe
  estar definida en el MainActivity*/
Toast.makeText(getApplicationContext(),
        MainActivity.getImei(getApplicationContext()),
        Toast.LENGTH_LONG).show();

Bueno gente, espero que les haya sido útil la función y ante cualquier problema no duden en dejar un comentario.

La entrada Obtener el IMEI en Android con Java aparece primero en ProgramaciónExtrema.com.

¿Cómo obtener el carrier en Android?

Con la siguiente función estática podemos obtener el carrier de un dispositivo:

/*Función que obtiene el carrier del dispositivo y lo retorna. En caso de no
  detectarlo retorna una string vacio*/
public static String getCarrier(Context context) {
  TelephonyManager manager = (TelephonyManager) context
                               .getApplicationContext().getSystemService(Context.TELEPHONY_SERVICE);
  String carrierName = manager.getNetworkOperatorName();
  return carrierName == null ? "" : carrierName;
}

Luego para utilizar la función simplemente hacemos lo siguiente:

/*Para que funcione el siguiente código la función getCarrier debe
  estar definida en el MainActivity*/
Toast.makeText(getApplicationContext(),
		MainActivity.getCarrier(getApplicationContext()),
		Toast.LENGTH_LONG).show();

Bueno gente, espero que les haya sido útil la función y ante cualquier problema no duden en dejar un comentario.

La entrada Obtener el carrier en Android con Java aparece primero en ProgramaciónExtrema.com.