Xamarin.Forms - Controlling Your PC 🖥️ With Your Phones📱Using TCP/IP Protocol - Part One

Introduction

 

The misuse of official computers is a common practice among users in many work environments where proper monitoring mechanisms do not exist. It results in the waste of resources and in not meeting the overall objectives of an organization. So, to achieve the maximum and desired results in a work environment, an effective mechanism through which the administrator can monitor and control the workstations under the use of employees is needed.

 

Purpose

 

The purpose of this project is to develop a Xamarin.Forms-based application which will serve the administrator with on-demand remote surveillance and controlling of workstations of the workplace. The project will involve the development of two applications, one will run on workstations and the other one will run on the mobile phone of the administrator. Both the applications will be connected through Wi-Fi. The implementation of such a mechanism will allow the administrator, to not only have an eye on the activities of users but also, will make him/her able to remotely control the specific workstation(s).

 

Scope of Project

 

There will be two applications in this project,

1. Server Application
   Server Application will continuously run on each workstation in workplace. The server application will be connected with the Client Application through a Wi-Fi connection. It will take a screenshot of user activity on the demand of the administrator and will transfer the same to client/mobile application. This application will interpret and execute commands received from the Client/mobile application.

2. Client / Xamarin.Forms Application
   Android application will run on Administrator’s smart mobile phone and will provide an effective interface through which the Administrator will be able to connect it with the Server Application. Through this application, the Administrator will be able to instruct the Server Application to take the screenshot(s) and send to this application. Through this application, the Administrator will also be able to control any workstation and perform the activities such as sending a message, turning the workstation into sleep mode and shutting down any workstation etc.

• Creating Connection Between Computer and Mobile
• Screenshot taking and sending to Client / Xamarin.Forms Mobile Application
  Server Application will take the screenshot(s) of user activity on any workstation on demand of the Administrator through Client/mobile Application. Screenshot(s) will be transferred to the client/mobile application.
• Controlling Work Stations
  The administrator will be able to control any workstation through sending commands. Administrator will be able to perform sending a message to the workstation turning that into sleep mode, locking the workstation, and shutting down the workstation.

Server Application

 

Step 1 - Create Console Application

 

Let’s create a console app project with .NET framework.

 

 

Step 2 - Add Appropriate Namespace

 

Create an instance of TcpClient and TcpListener inside your Program class by using appropriate namespaces. Also, declare a local variable type string with the name ipString.

public static TcpClient client;
private static TcpListener listener;
private static string ipString;

Step 3 - Get Your Machine IP Address

 

Let’s write a method inside your Main function that will catch and return your machine's IP Address.

IPAddress[] localIp = Dns.GetHostAddresses(Dns.GetHostName());
foreach(IPAddress address in localIp) {
    if (address.AddressFamily == AddressFamily.InterNetwork) {
        ipString = address.ToString();
    }
}

Step 4 - Start Listening On 1234 Port

 

Now, in this step, we are ready to start listening. I am using 1234 as my port number and I will use the current machine's local IP address and my port number for endpoints. After following all these steps, now, we can accept any TCP client and connect with clients.

IPEndPoint ep = new IPEndPoint(IPAddress.Parse(ipString), 1234);
listener = new TcpListener(ep);
listener.Start();
Console.WriteLine(@"
===================================================
Started listening requests at: {0}:{1}
===================================================",
ep.Address, ep.Port);
client = listener.AcceptTcpClient();
Console.WriteLine("Connected to client!" + " \n");

 

Step 5 - Build Connection With Client

 

After connecting with the client, I will perform my first function that will sleep the workstations using client command. While the client is connected with the Server, if a client will send SLP2 command, then the server will execute the sleep function that I will write in the next step.

while (client.Connected) {
    try {
        const int bytesize = 1024 * 1024;
        byte[] buffer = new byte[bytesize];
        string x = client.GetStream().Read(buffer, 0, bytesize).ToString();
        var data = ASCIIEncoding.ASCII.GetString(buffer);
        if (data.ToUpper().Contains("SLP2")) {
            Console.WriteLine("Pc is going to Sleep Mode!" + " \n");
            Sleep();
        }
    } catch (Exception exc) {
        client.Dispose();
        client.Close();
    }
}

Step 6 - Sleep Method

 

First, add the following namespaces to your project; then write the sleep function inside your Main function.

using System.Windows.Forms;
void Sleep() {
    Application.SetSuspendState(PowerState.Suspend, true, true);
}

Client Application

 

The steps given below are required to be followed in order to create a Xamarin.Forms Application, using Visual Studio.

 

Step 1 - Create a Xamarin.Forms Project

 

Open Visual Studio and go to New Project-> Cross-platform-> Xamarin.Forms-> Blank app. give it a name, like XamarinFormsClient.

 

Step 2 - Create Connection Class

 

We need to define a connection class in our project for creating a TCP Client instance. Create a new class with name Connection.cs and write the following code into it.

 

(FileName: Connection.cs)

using System;
using System.Collections.Generic;
using System.Net.Sockets;

namespace XamarinForms.Client
{
    public class Connection
    {
        private static Connection _instance;
        public static Connection Instance
        {
            get
            {
                if (_instance == null) _instance = new Connection();
                return _instance;
            }
        }
        public TcpClient client { get; set; }
    }
}

Step 2 - Creating User Interface for Connection

 

We need two edit texts boxs for IP address & port and one button for connecting with the server. Open MainPage layout file inside your layout and replace the following code into it.

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:local="clr-namespace:XamarinForms.Client"
             x:Class="XamarinForms.Client.MainPage">
    <StackLayout>
    <Label Text="Connect to Server"
           FontSize="Medium"
           HorizontalOptions="Center" />
    <Entry x:Name="IPAddress" Placeholder="IP Address"/>
    <Entry x:Name="Port" Placeholder="Port Number"/>
    <Button x:Name="Connect" Text="Connect" Clicked="Connect_Clicked"/>
    </StackLayout>
</ContentPage>

 

Step 3 - Create Connection Method

 

In this page, first, we will bind our UI controls with this MainPage class. Then, we will connect with server application using workstation IP address and port. Write the following code in your connect activity.

 

(FileName: MainPage.xaml)

using System;
using System.Net.Sockets;
using Xamarin.Forms;


namespace XamarinForms.Client
{
    public partial class MainPage : ContentPage
    {
        public MainPage()
        {
            InitializeComponent();
        }

        private async void Connect_Clicked(object sender, EventArgs e)
        {
            try
            {
                TcpClient client = new TcpClient();
                    await client.ConnectAsync(IPAddress.Text, Convert.ToInt32(Port.Text));
                if (client.Connected)
                {
                    Connection.Instance.client = client;
                    Application.Current.MainPage = new NavigationPage(new OperationsPage());

                   await DisplayAlert("Connected", "Connected to server successfully!", "Ok");
                }
                else
                {
                    await DisplayAlert("Error", "Connection unsuccessful!", "Ok");
                }
            }
            catch (Exception ex)
            {
                await DisplayAlert("Error", ""+ex.ToString(), "Ok");
            }
        }
    }
}

Step 4 - Update App Class

 

Just open your App.xaml file inside this class add the following code in the constructor of App class.

MainPage = new NavigationPage(new MainPage());

We have completed our first module of client and server application that will hit the request to the server for building a connection. Then, we will be able to send any kind of commands to our server and also receive the response from the server.

 

Test Connection

 

Let’s test the connection of the server and client app that we have just built. However, the main launcher of Xamarin.Forms application will display the Main page. Start your server application and copy the IP address & port of workstation from the server app. Put this required parameter into the client application and hit Connect.

 

 

For simplicity, I am splitting the article into two parts. In the next part, I will complete the pending functionalities of Server and Client Applications. So, please stay tuned for my next article of this series.