Android实现远程控制PC(Android[客户端]+Qt[服务器端])

    由于本人没有无线路由器，因此用Win7自带的虚拟wifi让手机上网：Win7虚拟wifi

    但是，电脑不在我的房间，因此每天晚上在床上玩完手机还要下床去关电脑，让很懒很懒的本人很不爽，因此自己尝试着做了一个远程控制。

    软件客户端运行在Android设备上（我的手机是Android的），服务器端运行在我的Win7本本上。客户端用的是Android平台应用编程，服务器端用的是Qt编写的。

    首先设置好默认端口，然后设置控制方法，为了方便起见，这里直接利用标准C中的system接口（调用shell，Win7下就是cmd命令提示符了）。客户端发送命令给服务器，服务器直接执行命令，并将标准输出返回给客户端。

    下面看一些代码，具体代码可以到这里下载：工程源代码

    服务器端：

    头文件：

    mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include 
#include 
#include 
#include "server.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT
    
public:
    explicit MainWindow(QWidget *parent = 0);
    QTextDocument *textDocument;
    Server *server;
    ~MainWindow();
public slots:
    void getConnect();
    void execCommand(const char *command,int length,const char *add,int clientCode);
    void showText(const char *text);

signals:
    void writeFile(int clientCode);
    
private:
    Ui::MainWindow *ui;
};

#endif // MAINWINDOW_H

    server.h

#ifndef SERVER_H
#define SERVER_H

#include 
#include 

class MainWindow;

class Server:public QTcpServer
{
    Q_OBJECT
private:
    int port;
    MainWindow *mainWindow;
    QHostAddress hostAddress;
    int clientNum;        //已建立的客户端连接数

public:
    Server(MainWindow *m,int p,QHostAddress a);
    void incomingConnection(int handle);
signals:
    void printText(const char *text);

};

#endif // SERVER_H

    serverthread.h

#ifndef SERVERTHREAD_H
#define SERVERTHREAD_H
#include 
#include 
#include "mainwindow.h"

class ServerThread:public QThread
{
    Q_OBJECT
private:
    QTcpSocket *socket;
    MainWindow *mainWindow;
    int clientCode;
public:
    ServerThread(int socketDescriptor,QObject *parent,MainWindow *m,int clientCode);
    void run();
signals:
    void newCommand(const char *str,const int length,const char *add,int clientCode);
public slots:
    void receiveData();
    void readFile(int cC);
};

#endif // SERVERTHREAD_H

    源代码：

    main.cpp

#include 
#include "mainwindow.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();

    return a.exec();
}

    mainwindow.cpp

#include 
#include 
#include 
#include 
#include 
#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    server=new Server(this,5648,QHostAddress::Any);   //初始化服务器

}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::getConnect()
{
    QTextDocument *textDocumentM=new QTextDocument(QString("new connect !"),this);
    ui->textEdit->setDocument(textDocumentM);
    server->nextPendingConnection();
}

void MainWindow::execCommand(const char *command,int length,const char *add, int clientCode)
{
    QTextDocument *textDocumentC=new QTextDocument(QString("message"),this);
    char *commandStr=new char[length+15];
    strcpy(commandStr,command);
    char *para=commandStr+length;
    char *c=" > temp.txt";        //将结果重定向到一个临时文件
    strcpy(para,c);
    system(commandStr);                        //执行shell命令
    emit writeFile(clientCode);
    ui->textEdit->setDocument(textDocumentC);
}

void MainWindow::showText(const char *text)
{
    QTextDocument *textDocumentT=new QTextDocument(QString(text),this);
    ui->textEdit->setDocument(textDocumentT);
}

    server.cpp

#include "server.h"
#include "serverthread.h"

Server::Server(MainWindow *m,int p,QHostAddress a)
{
    this->hostAddress=a;
    this->port=p;
    this->mainWindow=m;
    this->clientNum=0;             //初始化客户连接数
    this->QTcpServer::listen(hostAddress,quint16(port));
    connect(this,SIGNAL(printText(const char*)),this->mainWindow,SLOT(showText(const char*)));
}

void Server::incomingConnection(int handle)
{
    char ch[]="new connection !";   
    emit printText(ch);
    ServerThread *thread=new ServerThread(handle,this,mainWindow,this->clientNum);  //每建立一个连接，都会开启一个服务线程，线程有客户编号
    this->clientNum++;
    thread->start();
}

serverthread.cpp

#include "serverthread.h"
#include 
#define COMMAND_SIZE 50
ServerThread::ServerThread(int socketDescriptor,QObject *parent,MainWindow *m,int c):QThread(parent)
{
    this->mainWindow=m;
    this->clientCode=c;
    socket=new QTcpSocket(parent);
    socket->setSocketDescriptor(socketDescriptor);
}

void ServerThread::run()
{
    this->connect(socket,SIGNAL(readyRead()),this,SLOT(receiveData()));
    connect(this,SIGNAL(newCommand(const char*,int,const char*,int)),this->mainWindow,SLOT(execCommand(const char*,int,const char*,int)));
    connect(this->mainWindow,SIGNAL(writeFile(int)),this,SLOT(readFile(int)));
    exec();
}

void ServerThread::receiveData()
{
    int left=socket->bytesAvailable();
    char *command=new char[COMMAND_SIZE];
    while(left>0)
    {
        int read=socket->readLine(command,COMMAND_SIZE);  //读取原始命令
        emit newCommand(command,read,"test",this->clientCode);
        left-=read;
    }
}
//读取临时文件中的标准输出信息并写入socket传回给客户端
void ServerThread::readFile(int cC)
{
    if(cC==this->clientCode)
    {
        QFile *file=new QFile("temp.txt");
        if(file->open(QIODevice::ReadWrite))
        {
            char *buffer=new char[100];
            int length;
            while((length=file->read(buffer,100))>0)
            {
                socket->write(buffer,length);
            }
        }
        socket->flush();
        file->close();
        system("del temp.txt");//删除临时文件
    }
}

客户端：

只有一个Acitvity

MainActivity.java

package com.tobacco.phonetest;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends Activity implements OnClickListener,Runnable{
	
	private Button button;
	private Button clear;
	private EditText editText;
	private TextView tv;
	private Socket socket;
	private PrintWriter pw;
	private BufferedReader br;
	//private InputStream is;
	private Handler handler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        handler=new Handler();
        button=(Button)findViewById(R.id.button);
        clear=(Button)findViewById(R.id.clear);
        button.setOnClickListener(this);
        clear.setOnClickListener(this);
        editText=(EditText)findViewById(R.id.edittext);
        tv=(TextView)findViewById(R.id.textView);
        try {
			//socket=new Socket("tobacco5648.xicp.net",5648); //我的pc域名
        	socket=new Socket("192.168.137.1",5648);   //建立socket，这里应该根据pc的ip地址进行修改
        	//socket=new Socket("www.baidu.com",80);
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			Log.e("socket","unknown host");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			Log.e("socket","io execption");
		}
        if(socket==null){
        	Log.e("socket","null");
        }
        else
        	try {
			pw=new PrintWriter(socket.getOutputStream());
			br=new BufferedReader(new InputStreamReader(socket.getInputStream(),"gbk"));
			String remote=socket.getInetAddress().getHostAddress();
			String self=socket.getLocalAddress().getHostAddress();
			tv.setText("connected!"+"\r\n"+"remote:"+remote+"\r\n"+"local:"+self+"\r\n");
			//is=socket.getInputStream();
			if(pw!=null&&br!=null){
				new Thread(this).start();
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }

	public void onClick(View view) {
		if(view==button){
			String str;
			str=editText.getText().toString();
			pw.print(str);
			pw.flush();
		}
		else if(clear==view){
			tv.setText("");
		}
		
	}

	public void run() {
		while(true){
		try {
			String str;
			while((str=br.readLine())!=null){
				final String s=str;
				handler.post(new Runnable(){

					public void run() {
						tv.setText(tv.getText()+s+"\r\n");
						
					}});
				
				
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	}

    
}