How to Make a Floating Window Application in Android?

package org.geeksforgeeks.demo;

public class Common {
    // The EditText String will be 
    // stored in this variable
    // when MINIMIZE or MAXIMIZE 
    // button is pressed
    public static String currentDesc = "";
    
    // The EditText String will be 
    // stored in this variable
    // when SAVE button is pressed
    public static String savedDesc = "";
}

package org.geeksforgeeks.demo;

import android.annotation.SuppressLint;
import android.app.Service;
import android.content.Intent;
import android.graphics.PixelFormat;
import android.os.IBinder;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.view.inputmethod.InputMethodManager;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

public class FloatingWindowService extends Service {

    // Declare variables for views and WindowManager
    private ViewGroup floatView;
    private WindowManager.LayoutParams floatWindowLayoutParam;
    private WindowManager windowManager;
    private Button maximizeBtn;
    private EditText descEditArea;
    private Button saveBtn;

    // This method is required but not used in this Service
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    // Service is created
    @SuppressLint("ClickableViewAccessibility")
    @Override
    public void onCreate() {
        super.onCreate();

        // Get screen width and height in pixels
        float width = getResources().getDisplayMetrics().widthPixels;
        float height = getResources().getDisplayMetrics().heightPixels;

        // Get the WindowManager system service for handling windows on the screen
        windowManager = (WindowManager) getSystemService(WINDOW_SERVICE);

        // Inflate the floating window layout using the LayoutInflater system service
        LayoutInflater inflater = (LayoutInflater) getSystemService(LAYOUT_INFLATER_SERVICE);
        floatView = (ViewGroup) inflater.inflate(R.layout.floating_layout, null);

        // Initialize the views from the layout file
        maximizeBtn = floatView.findViewById(R.id.buttonMaximize);
        descEditArea = floatView.findViewById(R.id.descEditText);
        saveBtn = floatView.findViewById(R.id.saveBtn);

        // Set the initial text in the EditText and place the cursor at the end
        descEditArea.setText(Common.currentDesc);
        descEditArea.setSelection(descEditArea.getText().length());
        // Hide the cursor initially
        descEditArea.setCursorVisible(false);

        // Set up the parameters for the floating window (size, position, etc.)
        floatWindowLayoutParam = new WindowManager.LayoutParams(
                // Set width to 60% of screen width
                (int) (width * 0.6f),
                // Set height to 50% of screen height
                (int) (height * 0.5f),
                // Type for overlay window
                WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY,
                // Make it not focusable
                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
                // Set transparent background for the window
                PixelFormat.TRANSLUCENT
        );
        floatWindowLayoutParam.gravity = Gravity.CENTER;
        floatWindowLayoutParam.x = 0;
        floatWindowLayoutParam.y = 0;

        // Add the floating view to the window using the WindowManager
        windowManager.addView(floatView, floatWindowLayoutParam);

        // Set up a listener for the maximize button to stop the service and navigate to MainActivity
        maximizeBtn.setOnClickListener(view -> {
            stopSelf();  // Stop the service
            windowManager.removeView(floatView);  // Remove the floating window
            Intent backToHome = new Intent(this, MainActivity.class);
            backToHome.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
            startActivity(backToHome);
        });

        // Set up a TextWatcher to update the current description when the text changes
        descEditArea.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence charSequence, int start, int count, int after) {}

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                // Update the current description with the text in the EditText
                Common.currentDesc = descEditArea.getText().toString();
            }

            @Override
            public void afterTextChanged(Editable editable) {}
        });

        // Set up the touch listener for the floating window to allow dragging it around
        setupFloatingWindowMovement();

        // Set up a listener for the EditText to make the cursor visible when clicked
        descEditArea.setOnTouchListener((v, event) -> {
            descEditArea.setCursorVisible(true);  // Make the cursor visible when touched
            floatWindowLayoutParam.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL |
                    WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN;
            windowManager.updateViewLayout(floatView, floatWindowLayoutParam);  // Update the layout
            return false;
        });

        // Set up a listener for the save button to save the text and hide the soft keyboard
        saveBtn.setOnClickListener(view -> {
            // Save the text in the EditText to the Common object
            Common.savedDesc = descEditArea.getText().toString();
            // Hide the cursor after saving
            descEditArea.setCursorVisible(false);
            // Make the window non-interactive
            floatWindowLayoutParam.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
            windowManager.updateViewLayout(floatView, floatWindowLayoutParam);
            InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
            inputMethodManager.hideSoftInputFromWindow(floatView.getWindowToken(), 0);
            Toast.makeText(this, "Text Saved!", Toast.LENGTH_SHORT).show();
        });
    }

    // This method is responsible for handling the movement of the floating window
    @SuppressLint("ClickableViewAccessibility")
    private void setupFloatingWindowMovement() {
        double initialX = 0.0;
        double initialY = 0.0;
        double initialTouchX = 0.0;
        double initialTouchY = 0.0;

        // Set a touch listener to detect dragging
        floatView.setOnTouchListener((view, event) -> {
            switch (event.getAction()) {
                case MotionEvent.ACTION_DOWN:
                    // Record the initial position and touch points when the touch starts
                    initialX = floatWindowLayoutParam.x;
                    initialY = floatWindowLayoutParam.y;
                    initialTouchX = event.getRawX();
                    initialTouchY = event.getRawY();
                    break;
                case MotionEvent.ACTION_MOVE:
                    // Calculate the new position of the window based on the movement of the touch
                    floatWindowLayoutParam.x = (int) ((initialX + event.getRawX()) - initialTouchX);
                    floatWindowLayoutParam.y = (int) ((initialY + event.getRawY()) - initialTouchY);
                    // Update the layout
                    windowManager.updateViewLayout(floatView, floatWindowLayoutParam);
                    break;
            }
            return false;
        });
    }

    // This method is called when the service is destroyed
    @Override
    public void onDestroy() {
        super.onDestroy();
        try {
            // Remove the floating window from the screen
            windowManager.removeView(floatView);
        } catch (Exception e) {
            // Handle any potential errors
            e.printStackTrace();
        }
    }
}

package org.geeksforgeeks.demo;

import android.app.ActivityManager;
import android.content.Intent;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.provider.Settings;
import android.text.Editable;
import android.text.TextWatcher;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

import androidx.activity.result.contract.ActivityResultContracts;
import androidx.appcompat.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

    // Declare the UI components (buttons and edit text)
    private Button minimizeBtn;
    private EditText descEditArea;
    private Button save;

    // Register for result to handle overlay permission
    private final ActivityResultContracts.StartActivityForResult overlayPermissionLauncher =
            registerForActivityResult(new ActivityResultContracts.StartActivityForResult(), result -> {
                if (checkOverlayDisplayPermission()) {
                    // If permission is granted, start the floating window service
                    startService(new Intent(MainActivity.this, FloatingWindowService.class));
                    finish(); // Close the current activity
                } else {
                    // If permission is not granted, show a toast message
                    Toast.makeText(MainActivity.this, "Permission not granted", Toast.LENGTH_SHORT).show();
                }
            });

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

        // Initialize the UI components
        minimizeBtn = findViewById(R.id.buttonMinimize);
        descEditArea = findViewById(R.id.descEditText);
        save = findViewById(R.id.saveBtn);

        // Check if the floating window service is already running, and stop it if it is
        if (isServiceRunning(FloatingWindowService.class)) {
            stopService(new Intent(this, FloatingWindowService.class));
        }

        // Set the text of the description edit text field from the Common.currentDesc variable
        descEditArea.setText(Common.currentDesc);
        // Move the cursor to the end of the text
        descEditArea.setSelection(descEditArea.getText().length());

        // Add a TextWatcher to update Common.currentDesc whenever the text in the edit area changes
        descEditArea.addTextChangedListener(new TextWatcher() {
            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                Common.currentDesc = descEditArea.getText().toString(); // Update the currentDesc variable
            }

            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {}

            @Override
            public void afterTextChanged(Editable s) {}
        });

        // Set an OnClickListener for the save button
        save.setOnClickListener(v -> {
            // Save the text from the edit area to the savedDesc variable
            Common.savedDesc = descEditArea.getText().toString();
            // Remove focus from the edit text field and hide the cursor
            descEditArea.clearFocus();
            descEditArea.setCursorVisible(false);
            // Show a toast message to notify the user that the text has been saved
            Toast.makeText(MainActivity.this, "Text Saved!", Toast.LENGTH_SHORT).show();
        });

        // Set an OnClickListener for the minimize button
        minimizeBtn.setOnClickListener(v -> {
            // Check if overlay permission is granted
            if (checkOverlayDisplayPermission()) {
                // If permission is granted, start the floating window service and finish the activity
                startService(new Intent(MainActivity.this, FloatingWindowService.class));
                finish();
            } else {
                // If permission is not granted, request overlay permission
                requestOverlayDisplayPermission();
            }
        });
    }

    // Check if a service is currently running
    private boolean isServiceRunning(Class<?> serviceClass) {
        ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
        // Check if the service is running using the deprecated method (for compatibility)
        @SuppressWarnings("deprecation")
        for (ActivityManager.RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
            if (service.service.getClassName().equals(serviceClass.getName())) {
                return true;
            }
        }
        return false;
    }

    // Request the user to enable the "Display over other apps" permission from system settings
    private void requestOverlayDisplayPermission() {
        new AlertDialog.Builder(this)
                .setTitle("Screen Overlay Permission Needed") // Title of the dialog
                .setMessage("Enable 'Display over other apps' from System Settings.") // Message in the dialog
                .setCancelable(true) // Allow the dialog to be canceled
                .setPositiveButton("Open Settings", (dialog, which) -> {
                    // If the user clicks "Open Settings", open the system settings for overlay permission
                    Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
                            Uri.parse("package:" + getPackageName()));
                    overlayPermissionLauncher.launch(intent); // Launch the settings activity
                })
                .show(); // Show the dialog
    }

    // Check if the app has the overlay permission
    private boolean checkOverlayDisplayPermission() {
        // If the SDK version is below Marshmallow (API 23), overlay permission is not needed
        return Build.VERSION.SDK_INT < Build.VERSION_CODES.M || Settings.canDrawOverlays(this);
    }
}