Blog Informáticos Murcia – Página 4 – Desde Murcia hacia el resto del mundo.

Navegar a través de un tunel SSH con Putty y Foxyproxy

Tenemos un servidor alojado en un edificio en el cual tenemos acceso por SSH, la idea es utilizar este servidor como proxy para navegar por Internet a través de él (como si estuviésemos delante del servidor navegando por Internet).

En este tutorial voy a crear un proxy escuchando el puerto 8081, el puerto podéis cambiarlo a vuestro antojo.

1- Instalamos el Foxproxy (en firefox)

https://addons.mozilla.org/es/firefox/addon/foxyproxy-standard/

2- Descargamos el putty.

http://the.earth.li/~sgtatham/putty/latest/x86/putty.exe

3- Abrimos el putty

Ponemos la dirección IP de nuestro servidor (el cual tenemos acceso mediante SSH)

Ahora buscamos la pestaña Tunnels e introducimos el puerto por el que nosotros enrutaremos toda la navegación en nuestro Firefox.

Perfecto, ya lo tenemos configurado, le damos a «Open» e introducimos el usuario y contraseña de nuestro servidor (conexion mediante ssh).

Perfecto, ya tenemos el túnel preparado, ahora solo falta configurar el navegador Firefox para poder navegar a través del túnel que hemos creado.

Abrimos Firefox y pulsamos sobre el nuevo icono que nos aparece en la barra de navegación.

Seguidamente le damos a «Añadir nuevo proxy»
En la ventana que nos aparece introducimos la direccion ip 127.0.0.1 y el puerto que hemos configurado en el putty, en el caso de este tutorial es el 8081.

Pulsamos aceptar y ya tenemos todo configurado, ahora solo falta probarlo.

Pinchando sobre el icono del plugin con el botón derecho pulsamos sobre el proxy que hemos creado y automáticamente empezaremos a navegar a través de nuestro túnel SSH.

¿Como podemos saber si estamos navegando a través del proxy? La forma mas sencilla es viendo la ip http://www.cualesmiip.com/ que tenemos antes de utilizar el puglin Foxproxy , activamos el proxy y volvemos a consultar nuestra ip y veremos como ha cambiado.

Espero que les sea de utilidad.

Consejo: Para no estar configurando el Putty cada vez que queramos utilizarlo, podeis guardar la configuración, para ello solo teneis que darle a «Save» en la pestaña de «Session» una vez que tengáis todos los datos introducidos.

Así cada vez que habraís el putty podeis seleccionar vuestra configuración pinchando sobre el nombre de la configuracion (ej: guardarconfiguracionPROXY) y pulsar «Load», automaticamente ya tendreis todo configurado para darle a «Open» y crear el túnel SSH.

Leer o escribir en Excel desde Java

Vamos a leer un archivo Excel desde Java utilizando la librería POI.

Nos podemos descargar la librería desde su página http://www.apache.org/dyn/closer.cgi/poi/

En mi caso me he descargado la versión «poi-bin-3.10-FINAL-20140208.zip»
Descomprimimos y observamos que tenemos unos jars que añadiremos posteriormente a nuestro proyecto.

Creamos un nuevo proyecto en Eclipse o en el entorno de desarrollo que utiliceis.

Ahora añadiremos las librerias POI para poder leer el Excel, para ello pulsamos con el botón derecho sobre nuestro proyecto, propiedades. Seguidamente en Java Build Path y en la pestaña de Libraries añadimos los jar de la libreria POI. Una vez añadidas pulsamos en OK y ya tenemos las librerias en nuestro proyecto.

Creamos un excel de ejemplo y lo guardamos dentro de nuestro proyecto

Ahora creamos el Main.java con el siguiente código:

package leerXLS;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;

public class Main {

	public static void main(String[] args) throws Exception {

		//
		// An excel file name. You can create a file name with a full
		// path information.
		//
		String filename = "test.xls";
		//
		// Create an ArrayList to store the data read from excel sheet.
		//
		List sheetData = new ArrayList();
		FileInputStream fis = null;
		try {
			//
			// Create a FileInputStream that will be use to read the
			// excel file.
			//
			fis = new FileInputStream(filename);
			//
			// Create an excel workbook from the file system.
			//
			HSSFWorkbook workbook = new HSSFWorkbook(fis);
			//
			// Get the first sheet on the workbook.
			//
			HSSFSheet sheet = workbook.getSheetAt(0);
			//
			// When we have a sheet object in hand we can iterator on
			// each sheet's rows and on each row's cells. We store the
			// data read on an ArrayList so that we can printed the
			// content of the excel to the console.
			//
			Iterator rows = sheet.rowIterator();
			while (rows.hasNext()) {
				HSSFRow row = (HSSFRow) rows.next();
				
				Iterator cells = row.cellIterator();
				List data = new ArrayList();
				while (cells.hasNext()) {
					HSSFCell cell = (HSSFCell) cells.next();
				//	System.out.println("Añadiendo Celda: " + cell.toString());
					data.add(cell);
				}
				sheetData.add(data);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fis != null) {
				fis.close();
			}
		}
		showExelData(sheetData);
	}

	private static void showExelData(List sheetData) {
		//
		// Iterates the data and print it out to the console.
		//
		for (int i = 0; i < sheetData.size(); i++) {
			List list = (List) sheetData.get(i);
			for (int j = 0; j < list.size(); j++) {
				Cell cell = (Cell) list.get(j);
				if (cell.getCellType() == Cell.CELL_TYPE_NUMERIC) {
					System.out.print(cell.getNumericCellValue());
				} else if (cell.getCellType() == Cell.CELL_TYPE_STRING) {
					System.out.print(cell.getRichStringCellValue());
				} else if (cell.getCellType() == Cell.CELL_TYPE_BOOLEAN) {
					System.out.print(cell.getBooleanCellValue());
				}
				if (j < list.size() - 1) {
					System.out.print(", ");
				}
			}
			System.out.println("");
		}
	}
}

Ejecutamos y comprobamos que ha leído nuestro archivo Excel.

Ejemplo de escribir en un Excel que se guarda en la ruta del proyecto.

package leerXLS;

import java.io.FileOutputStream;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

public class EjemploCrearExcel {

    /**
     * Crea una hoja Excel y la guarda.
     * 
     * @param args
     */
   
	public static void main(String[] args) {
        // Se crea el libro
        HSSFWorkbook libro = new HSSFWorkbook();

        // Se crea una hoja dentro del libro
        HSSFSheet hoja = libro.createSheet();

        // Se crea una fila dentro de la hoja
        HSSFRow fila = hoja.createRow(0);

        // Se crea una celda dentro de la fila
        HSSFCell celda = fila.createCell((short) 0);

        // Se crea el contenido de la celda y se mete en ella.
        HSSFRichTextString texto = new HSSFRichTextString("hola mundo");
        celda.setCellValue(texto);

        // Se salva el libro.
        try {
            FileOutputStream elFichero = new FileOutputStream("holamundo.xls");
            libro.write(elFichero);
            elFichero.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Notas:

Workbook crea el Excel con el que vamos a trabajar (tanto para leer como para crear uno nuevo).
HSSFSheet son las Hojas del Excel, como mínimo un Excel debe de tener al menos una hoj.a
HSSFRow son las filas de la hoja del Excel.
HSSFCell son las celdas de la celda/columna.

Como aumentar la velocidad en wordpress

Vamos a explicar un poco como aceleré la velocidad de carga de este blog, un tiempo después de haberlo puesto en marcha procedí a comprobar la velocidad de carga con la herramientaPAGESPEED INSIGHTS de Google.

Elimninar plugins innecesarios

Lo primero que hay que hacer si o si, es eliminar los plugins que sepamos que no son realmente imprescindibles o que tengamos activos pero no usemos.

Habilitar compresión GZIP

Para este paso, podemos usar algún plugins o mejor aún hacerlo nosotros mismos con las opciones ocultas de wordpress, para ello nos vamos a www.nuestrodominio.com/wp-admin/options.php y entraremos en las opciones avanzadas de wordpress.

Buscamos la casilla gzipcompression y cambiamos la opción 0 a 1.

con esto obtenemos lo siguiente:

Ventajas:
Tiempo de carga de la web.
Mejor experiencia para el usuario.
De cara a google esto es mucho mejor ya que vamos a acelerar notablemente nuestra web.

Inconvenientes:
Al ser una opción que viene desactivada por defecto en wordpress, debemos de comprobar en cada actualziación que siga activada.
Como estamos comprimiendo muchos archivos de la web, veremos aumentado el consumo de CPU y RAM de nuestro servidor.

Puede ser que al hacer esto aún no esté habilitado GZIP en nuestro servidor con lo cual debemos de acceder a nuestro CPANEL ir al apartado optimizar el sitio web

y habilitar la opción para todo el sitio.

Accedemos al sitio web GIDNETWORK y comprobamos que en nuestro hosting está habilitada la opción, si nos indica NO en Web page compressed? debemos comunicarnos con nuestro proveedor para que nos active dicha opción.

He realizado un test, una vez finalizado esta configuración y estos son los resultados:
Resultados Móvil:

Resultados Pc:

Como podéis ver, en el PC hemos pasado de 52 puntos a 73 y en el Móvil de 50 a 64, vamos mejorando!!

¿Que más podemos hacer?

Otra cosa que vamos a ver es el tema de la caché, para ello se pueden usar plugins, pero un metodo rápido de acelerar la caché es habilitar la propia caché de wordpress, para ello debemos irnos a nuestro archivo wp-config.php y añadir la siguiente linea:

define( ‘ENABLE_CACHE’, true );

una vez realizado esto hay que crear una carpeta en wp-content/ llamada caché (si no existe) y le damos permisos de escritura.

Ahora vamos a decirle al la duración de los archivos de la caché para ello modificamos el archivo .htaccess de nuestra web y añadimos el siguiente código:

<IfModule mod_expires.c>
<filesmatch "\.(jpg|JPG|gif|GIF|png|PNG|css|ico|svg|woff|js)$">
ExpiresActive on
ExpiresDefault "access plus 31 day"
</filesmatch>
</IfModule>

La puntuación actual es la siguiente:

VERSIÓN PC:83 PUNTOS ( ANTES 73)
VERSIÓN MOVIL: 71 PUNTOS (ANTES 64)

Como podemos ver solo con estos pasos he pasasdo mi web de una puntuación 52 a 83 en la versión pc y de 50 a 71 en la versión movil, sin duda una muy buena puntuación.

Quitar llamadas php innecesarias

Recomendamos quitar todas las llamadas innecesrias posibles como por ejemplo el título de nuestra web o blog.

Cambiar:

<title>< ?php bloginfo('name'); ?> < ?php bloginfo('description');?></title>

Por el título que teníamos en los ajustes:

<title>Título de nuestro Blog | Descripción de nuestro blog</title>

Esta es solo un ejemplo, pero podemos cambiar las llamadas a los archivos css, rss, javascript.. y así con muchas llamadas que hay que en realidad nos hacen todo más comodo pero poco a poco nos van perjudicando.

Eliminar titulo de nuestro aplicación Android

Tenemos 2 opciones:

Dentro del AndroidManifest.xml seria poner:

Por código:

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

requestWindowFeature(Window.FEATURE_NO_TITLE);
}

Administración de Oracle 11g – Tema 2 (Ficheros de inicialización: init.ora y spfile.ora)

Hoy vamos a ver todo lo que tiene que ver con el arranque y la parada de la base de datos, para ello vamos a ver primero el fichero de configuración de la instancia.

Para arrancar la instancia, el servidor Oracle tiene que leer el fichero de parámetros de inicialización (spfile o init), cuya ubicación predeterminada es $ORACLE_HOME/dbs.

El fichero de parámetros de inicialización puede ser de dos tipos

Init: se trata de un fichero de texto, editable, cuyo nombre sigue el patron init$ORACLE_SID.ora
Spfile: es un fichero binario, no editable pero visualizable, cuyo nombre sigue el patrón spfiles$ORACLE_SID.ora.
- Para poder crear un fichero binario (Spfile) es necesario crear un crear un fichero ascii, por tanto hay que partir de un fichero init.
  La primera vez que arrancamos la base de datos oracle lo hacemos con el fichero init, y luego ya creamos el Spfile.
  CREATE SPFILE [=’nombre’] FROM PFILE [=’nombre’];
  Si se omiten los nombres, toma los valores por defecto.
  La Base de datos no podrá abrir el nuevo spfile hasta el siguiente arranque.
  Se puede crear un init a partir de un spfile, invirtiendo la sixtansis.
- Los parámetros del spfile se modifican con:
  ALTER SYSTEM SET parametro = valor [SCOPE = MEMORY | SPFILE | BOTH]Si sólo queremos modificar el parámetros en el spfile, indicaremos SPFILE. Para hacer el cambio solo en memoria, especifica MEMORY.

Oracle cuando arranca primero comprueba si existe el fichero Spfile, si este no existe buscara el fichero Init y arranca con este.

¿Por qué la base de datos Oracle busca primero el fichero Init?

El fichero binario te proporciona mayor seguridad a la hora de configurar la base de datos Oracle porque te parsea los parámetros, por tanto si metes un parámetros que no existe o un valor que se sale del rango te dirá oracle donde esta el error cosa que con el texto plano solo te indicará que existe un error en el fichero pero no te indica el motivo.

¿Cómo se crea un fichero Init?

Hay dos tipos de parámetros:
- Explícitos: los que se indican en el fichero de parámetros.
- Implícitos: el resto, que tomarán un valor por defecto.
La forma de indicar valor a los parámetros es
parametro=valor.
El símbolo # indica el comienzo de un comentario, pudiendoestar al principio o en medio de la línea.
En el init.ora, el parámetro ifile permite incluir otros ficheros con parámetros.
Una lista de valores se indicará entre paréntesis, separando los valores por comas.
Para indicar un valor de tipo cadena de caracteres hay que encerrarlo entre comillas simples.
Si usamos OFA, la ubicación típica para el init.ora es $ORACLE_BASE/admin/$ORACLE_SID/pfile. Después creamos unenlace en $ORACLE_HOME/dbs (ubicación por defecto).

Ejemplo de código INIT.ORA

db_name=CURSO08
db_block_size=2048
compatible = 11.1.0
control_files = (/u02/oradata/CURSO08/control1.ctl,
/u03/oradata/CURSO08/control2.ctl)
undo_management = auto # Utilizado para realizar rollback de las transacciones
undo_tablespace = undo_rbs 
diagnostic_dest = /u01/app/oracle # Parámetro que define donde va estar el directorio de diagnostico.
memory_max_target = 208M
memory_target = 200M
sga_max_size = 160M
sga_target = 0
pga_aggregate_target = 0
log_buffer = 1048576
log_checkpoint_interval = 0
log_checkpoint_timeout = 1800 # t. en segundos
processes = 40 # Establece el nº max procesos simultaneos en la instancia, (procesos background + procesos servidores)
remote_login_passwordfile=EXCLUSIVE # Para activar el fichero de claves para usar el sys en remoto.
nls_territory=spain
nls_language=spanish
session_cached_cursors=50 # En <=9i era open_cursors (Numero de cursores que se van a cachear en la sesion)
result_cache_max_size = 8M

Instalar Oracle SQL Developer

Vamos a ver como instalar de forma rápida el SQL Developer en entorno Windows.

SQL Developer en un programa que no requiere de instalación, se descomprime, se ejecuta y se utiliza.

El SQL Developer solo requiere del SDK de java, en el caso caso del SQL Developer 4.0 requiere como mínimo el JDK 7.

Veamos los pasos para instalar el SQL Developer

Abrimos nuestro amigo www.google.es y escribimos «SQL Developer» Pulsamos en la primera entrada que nos aparezca (cerciórate que el el domino sea www.oracle.com)
Pulsamos en «Download», Aceptamos los términos y nos descargamos la versión que mas no interese (Windows 32 bits o 64 bits).

Ahora nos vamos a descargar el JDK de java, para ello seguimos los siguientes pasos

Abrimos www.google.es y escribimos «JAVA JDK» Pulsamos en la primera entrada que nos aparezca (cerciórate que el el domino sea www.oracle.com)

Aceptamos la licencia y nos descargamos la versión que mas nos interese

Una vez que tengamos los dos ficheros descargados instalamos el JDK, no voy a poner pantallazos porque es muy sencillo instalarlo.

Una vez instalado el JDK descomprimimos el SQL Developer.

Lo ejecutamos y nos saldrá una ventanita como esta para que le indiquemos donde esta el JDK de java si no lo ha encontrado el automáticamente.

Una vez puesto el path del Java JDK el programa SQL Developer arrancará.

Administración de Oracle 11g – Arquitectura de la Base de datos (parte2)

En este capitulo nos vamos a centrar en como nos conectamos a una base de datos de Oracle y que tipo de conexiónes podemos hacer hacia una base de datos, por último veremos como conectarnos a través del SQL Developer a un servidor Oracle.

Para poder conectarnos a una Base de Datos Oracle, necesitamos una serie de variables en el entorno del usuario del Sistema Operativo desde el que realizaremos la conexión.

En el caso de unix/linux:

ORACLE_HOME : Contiene el directorio donde esta el software de Oracle instalado.
ORACLE_SID: Es el nombre de nuestra base de datos o mejor dicho, el identificador de la instancia Oracle.
PATH: $PATH:$ORACLE_HOME/bin .
LD_LIBRARY_PATH=$ORACLE_HOME/lib. Localización de las librerías compartidas (Linux /Unix)
NLS_LANG=spanish_spain. Idioma del cliente (opcional)

Proceso de usuari: La ejecución de la aplicación que permite al usuario iniciar la conexión. Por ejemplo cuando un usuario se conecta con el sql*plus
Proceso servidor: se crea en el SBD cuando el usuario se conecta a la base de datos, y es el que realmente interactúa con la base de datos.
Una conexión de un proceso de usuario a la al SBD es una sesión en la base de datos (puede haber varias del mismo usuario) que se inician cuando el usuario se valida contra la base de datos y termina al desconectarse.
Desconectar una sesión de un usuario podemos hacerlo de la siguiente manera
«ALTER SYSTEM DISCONNECT SESSION ‘sid, serial#’;
existen opciones para la desconexión, por ejemplo [POST_TRANSACTION] espera que termina de escribir en base de datos y una vez finalizado finaliza la sesión y el [IMMEDIATE] finaliza la sesión inmediatamente, si al eliminar la sesión esta metiendo datos, se haría rollback de los datos.
Desconectar destruye la conexión con el servidor dedicado ( o el circuito virtual si MTS).

En nuestro base de datos por norma general tendremos tantas sesiones como clientes estén conectados, conforme estos salen y entran se crearán o eliminaran sesiones.
Se crea un proceso por cada sesión que se establezca en base de datos.

Para que una base de datos Oracle funcione adecuadamente hay que proporcionar a nuestro hardware suficientes recursos para que pueda trabajar.

Por ejemplo:

La instancia contiene luna SGA y esa SGA consume memoria RAM, por tanto necesitamos saber cuanta memoria RAM necesitamos asignarle para que la base de datos funcione bien.
El Número de sesiones simultaneas que se ejecutan (vamos suponer que consumen cada proceso/sesión unos 10 megabytes). Si hay 10 usuarios conectados necesitamos 100 megabytes, si hay 100 , necesitaremos 1000 megabytes.

Podemos hacer dos cosas o limitar el numero máximo de procesos que se pueden ejecutar en esa instancia o tener suficiente memoria RAM para que todos clientes puedan ejecutarse al mismo tiempo.

Otra solución es a través de una conexión con Servidor compartido (MTS) con un sistema de Dispatcher, el Dispacher se encarga de recibir las peticiones de los usuarios y el Dispacher por medio de una cola va tratando cada petición.

La ventaja del servidor compartido es que nuestra base de datos requerirá de menos recursos de nuestro hardware.
El inconveniente es que el servidor compartido ralentiza las peticiones a la base de datos debido a que las peticiones están encoladas.

También es posible simultanear los dos tipos de conexiones, por ejemplo nuestras peticiones que se realicen a través de nuestra página web se realicen a través de un servidor compartido, y la aplicación de nuestra secretaria sea a través de una conexión con servidor dedicado.

Vale, ya tenemos un poco de teoría, ahora vamos a ver como creamos una conexión para la base de datos, para ello vamos a utilizar el SQL Developer.

Abrimos nuestra aplicación SQL Developer.
Pulsamos en el boton + (en color verde).
Rellenamos los datos de conexión
- Nombre de la Conexion: Nombre para identificar nuestra conexión a la base de datos, por si tuvieramos muchas base de datos para que la podamos identificar facilmente.
- Usuario: Usuario de la base de datos.
- Contraseña: Contraseña de la base de datos
- Nombre del Host: La dirección ip o dominio de nuestro host donde esta nuestra BD
- Puerto: Es el puerto donde escucha nuestra BBDD por defecto es el 1521
- Nombre del Servicio: El nombre de del servicio de nuestra DB
Pulsamos en «Probar» y comprobamos que en Estado aparece «Estado: Correcto»
Pulsa «Guardar» para guardar la configuración y no tenerla que meter cada vez que abres el SQL Developer.
Por último pulsamos en «Conectar».

Una vez conectado nos debe aparecer nuestra conexión con la base de datos en la parte izquierda del SQL Developer.

Administración de Oracle 11g – Arquitectura de la Base de datos (parte1)

En esta primera parte vamos a ver que es una Base de Datos Oracle, de que se compone, y definiremos la Instancia.

Un servidor Oracle es una Instancia más una base de datos.

La Instancia esta formada por la SGA mas procesos en background.

La SGA (Área Global del Sistema) es una estructura básica de memoria ( es una gran cache ) donde Oracle cachea toda la información que maneja, tanto los datos de las tablas como las sentencias SQL que ejecutamos contra el servidor de Oracle. Los datos recuperados de las consultas SQL ejecutadas también son cacheadas por la SGA.

Los procesos en background:

SMON (System Monitor): Es el supervisor del sistema y se encarga de todas las recuperaciones que sean necesarias durante el arranque.
DBWR (Database Writer): El proceso DBWR es el responsable de gestionar el contenido de los buffers de datos y del caché del diccionario.
PMON (Process Monitor):Este proceso restaura las transacciones no validadas de los procesos de usuario que abortan, liberando los bloqueos y los recursos de la SGA.
CKPT (Checkpoint):Este proceso escribe en los ficheros de control los checkpoints. Estos puntos de sincronización son referencias al estado coherente de todos los ficheros de la BD en un instante determinado, en un punto de sincronización.
LGWR (Log Writer): Este proceso es que se encarga de escribir el contenido de los buffers del redo log en el disco.
ARCH (Proceso archivador): El proceso archivador tiene que ver con los ficheros redo log. Por defecto, estos ficheros se reutilizan de manera cíclica de modo que se van perdiendo los registros redo log que tienen una cierta antigüedad.

La Base de Datos en definitiva son son ficheros. Estos ficheros podemos identificar en ficheros de datos, ficheros de control y ficheros de Redo Log.

La manera que tenemos de trabajar con los datos que almacenamos en la base de datos de Oracle es a través de la instancia. La instancia es lo que permite abrir y arrancar una base de datos, cuando hablamos de arrancar la base de datos, realmente lanzamos la instancia.

Una instancia esta asociada solo a una base de datos, no es posible tener una instancia que apunte a varias base de datos.
La instancia es la encargada de acceder a la base de datos.

Para saber la instancia de nuestra base de datos que estamos ejecutando podemos saberlo si nos conectamos a la maquina donde esta instalado el servidor Oracle y escribimos ORACLE_SID (identifica a la instancia con la que estamos trabajando).

Salto de línea en un Textview en Android

En esta ocasión me ha ocurrido que quería hacer un salto de línea, probando con el clásico «<br />» no me funcionaba, pero buscando por Internet encontré la forma correcta de realizar un salto de línea.

mTextView.setText( "Primera liena. " + Html.fromHtml("<br />") + "Segunda Linea.");

El resultado queda:

Primera línea.
Segunda línea.

Android obtener número télefono

Para obtener el número de télefono desde código, este nos devolverá un String con el número de teléfono en el cual se está ejecutando la aplicación.

//Obtengo el número de teléfono
TelephonyManager mTelephonyManager;
mTelephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
String numeroTelefono = mTelephonyManager.getLine1Number();

Para que funcione debemos añadir permisos al archivo manifest.xml

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