Android手机监控软件设计实现

一、需求分析：

随着IT信息技术的飞速发展，手机的普及，伴随着智能手机的出现及快速的更新换代，手机已不仅仅是一个通信工具，更是一个多功能的应用平台。

手机监控软件则是基于电脑监控软件的原理，植入手机平台的一款软件，由于手机具有良好的网络支持及出色的便携性，植入手机平台十分有现实意义。

二、概要设计：

服务器端：

1．          启动服务器，接收socket

2．          截取屏幕图像，压缩并编码发送

客户端：

1．          登陆服务器及验证

2．          接收服务器信息并解码显示

 

    各个功能通过各自的类来完成。

三、详细设计：

1、手机客户端用ImageView来显示监控画面。

2、手机端使用线程完成接收信息、译码等费时操作。

3、完成Activity之间的数据传递。

4、使用流布局、相对布局等布局方式

5、使用布局与程序功能代码分离的设计方法

6、使用横向、全屏

四、程序结构

1、程序结构说明：

本程序采用模块化设计方法，各个功能的实现都有具体的方法，在主函数调用相应的方法即可实现程序的要求。程序的整体性很强。

2、重要数据说明：

程序通信中，使用字节流协议进行通信。

四个字节

一个字节

后N个字节

一个INT，代表信息长度

代表类型

信息

其中，类型：0代表图片类型数据 （针对客户端）

0代表移动命令     （针对服务器）

            1代表鼠标点击命令 2代表鼠标释放命令

            3代表键盘点击命令 4代表键盘释放命令

 

3、函数清单：

    见代码

五、调试分析：

程序截图：



 

 

使用预览



 

 

欢迎界面



 

 

使用界面

六、源代码：

1.服务器端（电脑）

Java代码  
  1. package cn.netjava7;  
  2.   
  3. public class CharRoom {  
  4.     /** 
  5.      * 写一个服务器打开的程序 
  6.      * @param port:端口 
  7.      */  
  8.     public void startServer (int port){  
  9.          
  10.           
  11.         try{  
  12.             //建立一个Serverc 对象  
  13.            java.net.ServerSocket sc=new java.net.ServerSocket(port);  
  14.             System.out.println("服务器创建成功");  
  15.            //开始不断地接收数据  
  16.            while (true){  
  17.                //建立一个联结对象  
  18.              java.net.Socket client=sc.accept();  
  19.              UserThread ust=new UserThread(client);  
  20.              ust.init();  
  21.              ust.start();  
  22.            }  
  23.              
  24.         }catch(Exception ef){  
  25.             ef.printStackTrace();  
  26.         }  
  27.           
  28.        
  29.     }  
  30.       
  31.       
  32.       
  33.     /** 
  34.      * 主函数 
  35.      */  
  36.     public static void main(String args[]){  
  37.         CharRoom cr=new CharRoom();  
  38.         cr.startServer(9090);  
  39.     }  
  40.       
  41.   
  42. }  

 

Java代码  
  1. package cn.netjava7;  
  2.   
  3. import java.awt.Dimension;  
  4. import java.awt.Graphics;  
  5. import java.awt.Image;  
  6. import java.awt.Rectangle;  
  7. import java.awt.Robot;  
  8. import java.awt.Toolkit;  
  9. import java.awt.image.BufferedImage;  
  10. import java.io.ByteArrayOutputStream;  
  11. import java.io.DataOutputStream;  
  12. import java.io.IOException;  
  13.   
  14. import javax.imageio.ImageIO;  
  15. import javax.swing.ImageIcon;  
  16. import javax.swing.JFrame;  
  17.   
  18. public class UserThread extends Thread{  
  19.     //定义构造器，传入对client  
  20.     private java.net.Socket client;  
  21.     private java.io.InputStream ins;  
  22.     private java.io.OutputStream ous;  
  23.     public UserThread(java.net.Socket client){  
  24.         this.client=client;  
  25.     }  
  26.     //初始化  
  27.     public void init(){  
  28.         try {  
  29.             ins=client.getInputStream();  
  30.             ous=client.getOutputStream();  
  31.         } catch (IOException e) {  
  32.             // TODO Auto-generated catch block  
  33.             e.printStackTrace();  
  34.         }  
  35.           
  36.     }  
  37.     //写run方法  
  38.     public void run(){  
  39.         try {  
  40.             sendImg();  
  41.         } catch (Exception e) {  
  42.             // TODO Auto-generated catch block  
  43.             e.printStackTrace();  
  44.         }  
  45.     }  
  46.       
  47.     public void sendImg() throws Exception{  
  48.         DataOutputStream dous=new DataOutputStream(ous);  
  49.         Robot ro=new Robot();  
  50.         Dimension scrSize=Toolkit.getDefaultToolkit().getScreenSize();   
  51.         Rectangle r=new Rectangle(scrSize.width,scrSize.height);  
  52.         System.out.println("大小是："+scrSize.height+" "+scrSize.width);  
  53.         while(true){  
  54.         BufferedImage bui=ro.createScreenCapture(r);  
  55.   
  56.         ByteArrayOutputStream imageStream=new ByteArrayOutputStream();  
  57.         boolean resultWrite = ImageIO.write(bui, "jpg", imageStream);  
  58.         byte [] tagInfo=imageStream.toByteArray();  
  59.         System.out.println(tagInfo.length);  
  60.         System.out.println(tagInfo[0]+" "+tagInfo[1]);  
  61. Image img=Toolkit.getDefaultToolkit().createImage(tagInfo, 0,tagInfo.length);  
  62.         dous.writeInt(tagInfo.length+5);  
  63.         dous.writeByte((byte)4);  
  64.         dous.write(tagInfo);  
  65.         Thread.sleep(1000);  
  66.         }  
  67.           
  68.           
  69.           
  70.           
  71.             
  72.     
  73.           
  74.           
  75.     }  
  76.       
  77. }  

 2.手机端：

 

Java代码  
  1. package cn.netjava;  
  2.   
  3. import java.io.DataInputStream;  
  4. import android.app.Activity;  
  5. import android.content.Context;  
  6. import android.graphics.Bitmap;  
  7. import android.graphics.BitmapFactory;  
  8. import android.net.wifi.WifiManager;  
  9. import android.os.Bundle;  
  10. import android.os.Handler;  
  11. import android.os.Looper;  
  12. import android.os.Message;  
  13. import android.view.View;  
  14. import android.view.View.OnClickListener;  
  15. import android.widget.ImageView;  
  16. import android.widget.TextView;  
  17.   
  18. public class FunctionViewActivity extends Activity{  
  19.        
  20.     //定义各个stream  
  21.     private java.io.InputStream ins;  
  22.     private java.io.OutputStream ous;  
  23.     private java.io.DataInputStream dins;  
  24.       
  25.     //定义各个组件  
  26.     private ImageView img;  
  27.     private TextView tvw;  
  28.       
  29.     //定义一个Bitmap 用来存ImageView的每个图  
  30.     private Bitmap bmm;  
  31.     //放接收到数据的数组  
  32.     private byte[] data;  
  33.       
  34.     //初始化  
  35.     public void init(String ip){  
  36.         try{  
  37.             System.out.println(ip);  
  38.             java.net.Socket soc=new java.net.Socket(ip,9090);  
  39.             ins=soc.getInputStream();  
  40.             dins=new DataInputStream(ins);  
  41.             ous=soc.getOutputStream();  
  42.             System.out.println("创建成功！");  
  43.         }catch(Exception ef){  
  44.             ef.printStackTrace();  
  45.         }  
  46.           
  47.     }  
  48.     //内部类，myHandler  
  49.     class MyHandler extends Handler{  
  50.         public MyHandler(){  
  51.             
  52.         }  
  53.         public MyHandler(Looper looper){  
  54.             super(looper);  
  55.         }  
  56.        public void handleMessage(Message msg){  
  57.              
  58.            img.setImageBitmap((Bitmap)msg.obj);  
  59.              
  60.     }  
  61.     }  
  62.   
  63.     //onCreate  
  64.     public void onCreate(Bundle savedInstanceState) {  
  65.             super.onCreate(savedInstanceState);  
  66.             setContentView(R.layout.mainfunctionactivity);  
  67.             //得到各个组件  
  68.             img=(ImageView)findViewById(R.id.imgView);  
  69.             tvw=(TextView)findViewById(R.id.exitTextView);  
  70.               
  71.             //textView 添加监听器  
  72.             tvw.setOnClickListener(new OnClickListener(){   
  73.                 public void onClick(View v) {  
  74.                     System.exit(0);  
  75.                 }     
  76.             });  
  77.               
  78.             init(this.getIntent().getStringExtra("ipaddress"));  
  79.               
  80.             Looper looper = Looper.myLooper();      
  81.                  //此处甚至可以不需要设置Looper，因为 Handler默认就使用当前线程的Looper     
  82.             final MyHandler  myhandler= new MyHandler(looper);     
  83.   
  84.             new Thread() {     
  85.                      public void run() {     
  86.                        while(true){  
  87.                        try{  
  88.                        data=new byte[dins.readInt()-5];  
  89.                        dins.readByte();  
  90.                        //注意，这里要用readfully  
  91.                        dins.readFully(data);  
  92.                        //注意，这里要回收bmm ,否则报错  
  93.                        if (bmm!=null){  
  94.                            bmm.recycle();  
  95.                        }  
  96.                        bmm=BitmapFactory.decodeByteArray(data, 0, data.length);  
  97.                        System.out.println("decode after："+System.currentTimeMillis());  
  98.                        //每一百ms 执行 （可调）  
  99.                     //  Thread.sleep(100);  
  100.                         //创建一个Message对象，并把得到的天气信息赋值给Message对象     
  101.                         Message message = Message.obtain();     
  102.                         message.obj = (Bitmap)bmm;   
  103.                         myhandler.sendMessage(message);    
  104.                     } catch (Exception e) {  
  105.                         // TODO Auto-generated catch block  
  106.                         e.printStackTrace();  
  107.                     }  
  108.                            
  109.                    }  
  110.                   }     
  111.                
  112.                 }.start();    
  113.      }  
  114.       
  115. }  
posted @ 2014-07-24 14:08  xiaochao1234  阅读(2639)  评论(0)  编辑  收藏  举报