Informe de Proyecto

I.

Descripcin del Proyecto

Nombre del Proyecto: Transmisin de video en vivo a un celular
Justificacin: usar el celular como monitor en cualquier lugar para
poder ver qu pasa en su oficina u hogar en tiempo real, sin la
necesidad de tener una pc a mano. Este proyecto se hace con la
finalidad de que cualquier persona obtenga sus beneficios.

II.

Objetivos:
General:
Desarrollar un prototipo mediante el uso de sockets, para enviar y
recibir

datos

Especficos:
Desarrollar un prototipo que pueda realizar l envi de frames de una
cmara a un celular (android)

III.

Requerimientos del Sistema

REQUERIMIENTO DEL SISTEMA:

Que sea amigable con el usuario.
Que sea lo ms sencillo posible pero que funcione.
Que use sockets.
HARDWARE.
Una laptop
Un celular (SO Android)
SOFTWARE.
Java (NetBeans)
IV.

Factibilidad tcnica del proyecto

El estudio de factibilidad tcnica nos ayuda a la identificacin de la

idea, el cual se elabora a partir de la informacin existente, al juicio
comn y la opinin que da la experiencia.
Con base en lo anterior podemos decir que es tcnicamente posible el
desarrollo del sistema ya que la plataforma a desarrollar es java y

contamos con el conocimiento mnimo para manejarlo y realizar el

proyecto.
El hardware a utilizar son nuestras laptops y celulares.
La plataforma de sistema operativo a utilizar son xp, w7, w8.
La versin android que se utilizara es la 4.4.4 kit kat.
V.

Comparativa con algunos software ya existentes en el

mercado
IP Cam Viewer
Software libre y tambin de pago, cuenta con funciones completas en cuanto a video
vigilancia el nico problema que tienes es su poco atractivo visual.
Presence de People Power
Software que utiliza celulares en desuso (que tengan cmara y seal wifi) para poder
usarlas como cmara de vigilancia, lo interesante de este software es que al detectar
movimiento empieza a grabar para enviar el video al correo del usuario.
Beb Monitor para Cmara IP
Como su nombre lo indica este software se especializa en la video vigilancia a bebes la
particularidad de este es que al detectar un ruido fuerte manda una notificacin al
usuario.
Como vemos en el mercado existen muchos software con el propsito de transmitir
video en vivo (streaming) ya sea desde una pc, celular o cmara ip hacia un celular.
En comparacin con lo que nosotros queremos hacer lo software anteriormente
mencionados probablemente superen con creces lo que nosotros queremos hacer,
pues lo que nosotros proponemos es algo muy bsico, solo transmitir el video en
tiempo real sin algn extra, si tenemos alguna ventaja con respecto a los otros software
es que nuestro software ser cdigo abierto, es decir cualquiera podr ver la
codificacin y modificarlo si es que lo ven por conveniente.

VI.

Cdigo Beta
Implementacin para servidor
public class GTCPServer {
public static final int SERVER_PORT = 4444; // N de puerto
private boolean running = true; // Booleano para controlar el flujo
private ServerSocket serverSocket; // Socket Servidor
// Streams de entrada y salida:
private DataInputStream dis;
private DataOutputStream dos;
// Buffer:
private byte[] bytes;
private static final int BUFFER_SIZE = 512 * 4; // Tamao
/**
* Constructor. Inicia el Servidor.

*/
public GTCPServer() {
bytes = new byte[BUFFER_SIZE]; // Instanciamos el buffer
// Le metemos valores para probar:
bytes[0] = 3;
bytes[BUFFER_SIZE - 1] = 7;
try {
// Creamos el Socket de Servidor y esperamos peticiones que
vengan a travs de la red.
serverSocket = new ServerSocket(SERVER_PORT);
System.out.println("Conectando...");
// Mediante el mtodo accept() nos mantenemos a la espera de
una conexin.
// En el momento se produce esta, creamos el Socket de Cliente:
Socket client = serverSocket.accept();
System.out.println("Recibiendo...");
try {
// Instanciamos los flujos de entrada y salida:
dis = new DataInputStream(client.getInputStream());
dos = new DataOutputStream(client.getOutputStream());
} catch (Exception e) {
System.out.println("Error.");
e.printStackTrace();
}
} catch (Exception e) {
System.out.println("Error.");
e.printStackTrace();
}
} // GTCPServer()
/**
* Enva (escribe) un buffer de bytes por TCP.
* @param buffer - La memoria intermedia donde se almacenan los datos
a enviar.
* @param offset - Posicin del buffer desde donde empieza a enviar.
* @param count - Nmero de bytes a escribir.
*/
public void write(byte[] buffer, int offset, int count) {
try {
dos.write(buffer, offset, count); // Escribimos por TCP
} catch (IOException e) {
e.printStackTrace();
}
} // write()
} // GTCPServer

Cliente Android
public class GTCPClient_A {
public static final String SERVER_IP = "192.168.1.101"; // IP del

Servidor (PC)
public static final int SERVER_PORT = 4444; // N de puerto
private boolean running = true; // Booleano para controlar el flujo
// Streams de entrada y salida:
private DataInputStream dis;
private DataOutputStream dos;
// Buffer:
private byte[] bytes;
private static final int BUFFER_SIZE = 512 * 4; // Tamao
/**
* Constructor.
*/
public GTCPClient_A() {
bytes = new byte[BUFFER_SIZE]; // Instanciamos el buffer
} // GTCPClient_A()
/**
* Ejecucin del hilo. No est sobreescrito el mtodo porque usamos
una subclase (connectTask) que extiende de AsyncTask.
*/
public void run() {
try {
// Obtenemos el InetAddress a partir de la direccin IP (IPv4
del ordenador) del Servidor
InetAddress serverAddr = InetAddress.getByName(SERVER_IP);
Log.e("GTCPClient_A", "Conectando...");
// Creamos un socket para conectarnos con el Servidor:
Socket socket = new Socket(serverAddr, SERVER_PORT);
try {
// Instanciamos los flujos de entrada y salida:
dis = new DataInputStream(socket.getInputStream());
dos = new DataOutputStream(socket.getOutputStream());
int lap = 0; // Para llevar la cuenta de las vueltas
// Este while sirve para que el Cliente est escuchando los
mensajes enviados por el Servidor:
while (running) {
dis.read(bytes); // Leemos por TCP
System.out.println("IN_ini_["+lap+"]: "+bytes[0]);
System.out.println("IN_fin_["+lap+"]:

"+bytes[BUFFER_SIZE - 1]);
G.toc = System.currentTimeMillis();
G.ticToc();
G.tic = G.toc;
dos.write(bytes); // Escribimos por TCP
System.out.println("OUT_ini_["+lap+"]: "+bytes[0]);
System.out.println("OUT_fin_["+lap+"]:
"+bytes[BUFFER_SIZE - 1]);
lap++;
}
} catch (Exception e) {
Log.e("GTCP", "SERVIDOR: Error", e);
} finally {
// El Socket debe de ser cerrado. No es posible hacer una
reconexin a este Socket.
// Despus de esto se debe de realizar una nueva instancia
de Socket para poder comunicarse con el Servidor.
socket.close();
}
} catch (Exception e) {
Log.e("GTCP", "CLIENTE: Error", e);
}
} // run()
} // GTCPClient_A

VII.

Conclusin
Esto muestra que nuestro proyecto se est realizando sin mucho
inconvenientes, pero si tendramos que competir en el mercado
nuestro software seria opacado fcilmente por los otros softwares ya
disponibles que cuentan con funciones especficas a parte de
transmitir el video como comenzar a grabar cuando se detecte
movimiento en el video, o que se mande una alarma al cliente si se
detecta algn ruido.
La nica ventaja con la que cuenta nuestro software es que es cdigo
abierto as que si hay estudiantes como nosotros que necesiten
realizar algo similar a nuestro software tendrn ya un cdigo con el
cual guiarse.