MainActivity.java

/*
Hypatia: A realtime malware scanner for Android
Copyright (c) 2017-2018 Divested Computing Group
Copyleft  (🄯) 2025 MaintainTeam Organization

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
package us.spotco.malwarescanner;

import static android.os.Build.VERSION.SDK_INT;

import android.Manifest;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.PowerManager;
import android.provider.Settings;
import android.text.InputType;
import android.util.Log;
import android.text.method.ScrollingMovementMethod;
import android.view.Menu;
import android.view.MenuItem;
import android.view.WindowManager;
import android.widget.EditText;
import android.widget.TextView;

import android.widget.Toast;

import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;

import java.io.File;
import java.util.HashSet;

public class MainActivity extends AppCompatActivity {

    private SharedPreferences prefs = null;
    private MalwareScanner malwareScanner = null;

    private Menu menu;

    private static final String buildVersionName = BuildConfig.VERSION_NAME;

    private boolean scanSystem = false;
    private boolean scanApps = true;
    private boolean scanExternal = true;
    private boolean scanRemovable = false;

    private TextView logView;

    private static final int REQUEST_PERMISSION_EXTERNAL_STORAGE = 0;
    private static final int REQUEST_PERMISSION_POST_NOTIFICATIONS = 0;

    @Override
    protected final void onCreate(Bundle savedInstanceState) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            getWindow().clearFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
        }
        super.onCreate(savedInstanceState);
        Utils.setContext(Hypatia.getAppContext());
        setContentView(R.layout.content_main);

        Toolbar toolbar = findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        logView = findViewById(R.id.txtLogOutput);
        logView.setMovementMethod(new ScrollingMovementMethod());
        logView.setTextIsSelectable(true);

        HypatiaLogger.getInstance().setLogView(logView);

        HypatiaLogger.Log(getString(R.string.app_disclaimer) + "\n\n\n");
        HypatiaLogger.Log(getString(R.string.app_copyright));
        HypatiaLogger.Log(getString(R.string.app_license));
        HypatiaLogger.Log(getString(R.string.app_version, buildVersionName));

        HypatiaLogger.Log(Utils.checkOldDatabase(this));

        malwareScanner = new MalwareScanner(this, true);

        prefs = getSharedPreferences(BuildConfig.APPLICATION_ID, Context.MODE_PRIVATE);

        requestPermissions();

        Utils.considerStartService(this);

        handleIntent(getIntent());
    }

    public TextView getLogView() {
        return logView;
    }

    @Override
    protected final void onNewIntent(Intent intent) {
        super.onNewIntent(intent);

        handleIntent(intent);
    }

    private void handleIntent(Intent intent) {
        if (intent != null && intent.hasExtra("SHARE_SCAN_RESULT")) {
            String result = intent.getStringExtra("SHARE_SCAN_RESULT");
            HypatiaLogger.Log(result, LogType.INFO);
        }
    }

    @Override
    protected void onDestroy() {
        Hypatia.getInstance().setMainActivity(null);
        super.onDestroy();
    }

    @Override
    public final boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu_main, menu);
        this.menu = menu;
        menu.findItem(R.id.toggleRealtime).setChecked(Utils.isServiceRunning(MalwareScannerService.class, this));
        menu.findItem(R.id.toggleOnionRouting).setChecked(prefs.getBoolean("ONION_ROUTING", false));
        menu.findItem(R.id.toggleExtended).setChecked(prefs.getBoolean("SIGNATURES_EXTENDED", false));
        menu.findItem(R.id.toggleLinkScanner).setChecked(prefs.getBoolean("DOMAINS", false));
        updateScanButton(false);
        return true;
    }

    private void requestPermissions() {
        if (SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            if (checkSelfPermission(Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
                requestPermissions(new String[] { Manifest.permission.POST_NOTIFICATIONS },
                        REQUEST_PERMISSION_POST_NOTIFICATIONS);
            }
        }
        if (SDK_INT >= Build.VERSION_CODES.M) {
            if (checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
                requestPermissions(new String[] { Manifest.permission.READ_EXTERNAL_STORAGE },
                        REQUEST_PERMISSION_EXTERNAL_STORAGE);
            }
            if (checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
                requestPermissions(new String[] { Manifest.permission.WRITE_EXTERNAL_STORAGE },
                        REQUEST_PERMISSION_EXTERNAL_STORAGE);
            }
        }
        if (SDK_INT >= Build.VERSION_CODES.R) {
            if (!Environment.isExternalStorageManager()) {
                Intent intent = new Intent(Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION);
                Uri uri = Uri.fromParts("package", getPackageName(), null);
                intent.setData(uri);
                startActivity(intent);
            }
        }
    }

    private void showCredits() {
        Dialog creditsDialog;
        AlertDialog.Builder creditsBuilder = new AlertDialog.Builder(this);
        creditsBuilder.setTitle(getString(R.string.lblFullCredits));
        creditsBuilder.setItems(R.array.fullCredits, (dialog, which) -> {
            // do nothing
        });
        creditsDialog = creditsBuilder.create();
        creditsDialog.show();
    }

    @Override
    public final boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.toggleOnionRouting:
                if (!item.isChecked()) {
                    if (Utils.isOrbotInstalled(this)) {
                        prefs.edit().putBoolean("ONION_ROUTING", !item.isChecked()).apply();
                        item.setChecked(true);
                    } else {
                        prefs.edit().putBoolean("ONION_ROUTING", false).apply();
                        item.setChecked(false);
                        Toast.makeText(this, R.string.lblOnionRoutingNotInstalled, Toast.LENGTH_SHORT).show();
                    }
                } else {
                    prefs.edit().putBoolean("ONION_ROUTING", false).apply();
                    item.setChecked(false);
                }
                break;
            case R.id.mnuUpdateDatabase:
                if (Database.hasDownloadsRunning()) {
                    HypatiaLogger.Log(getString(R.string.lblUpdateRunning));
                } else if (malwareScanner.running) {
                    HypatiaLogger.Log(getString(R.string.lblScanRunning));
                } else if (!Utils.isNetworkAvailable(this)) {
                    HypatiaLogger.Log(getString(R.string.lblNoNetwork));
                } else if (Database.isDatabaseLoading()) {
                    HypatiaLogger.Log(getString(R.string.lblDatabaseLoading));
                } else if (Utils.isConnectionMetered(this)) {
                    int amt = prefs.getBoolean("SIGNATURES_EXTENDED", false) ? 200 : 50;
                    new AlertDialog.Builder(this)
                            .setTitle(R.string.confirm_update_title)
                            .setMessage(getString(R.string.confirm_update_summary, String.valueOf(amt)))
                            .setIcon(android.R.drawable.ic_dialog_alert)
                            .setPositiveButton(getString(android.R.string.yes), (dialog, which) -> {
                                updateDatabase();
                            })
                            .setNegativeButton(getString(android.R.string.no), (dialog, which) -> {
                                dialog.cancel();
                            }).show();
                } else {
                    updateDatabase();
                }
                break;
            case R.id.mnuDatabaseServer:
                if (Database.hasDownloadsRunning()) {
                    HypatiaLogger.Log(getString(R.string.lblUpdateRunning) + "\n");
                } else if (Database.isDatabaseLoading()) {
                    HypatiaLogger.Log(getString(R.string.lblDatabaseLoading) + "\n");
                } else {
                    AlertDialog.Builder builderServerOverride = new AlertDialog.Builder(this);
                    builderServerOverride.setTitle(getString(R.string.lblDatabaseServer));
                    final EditText inputServerOverride = new EditText(this);
                    inputServerOverride.setInputType(InputType.TYPE_CLASS_TEXT);
                    inputServerOverride.setText(Utils.getDatabaseURL(this));
                    builderServerOverride.setView(inputServerOverride);
                    builderServerOverride.setPositiveButton(getString(R.string.lblOverride), (dialog, which) -> {
                        String newServer = inputServerOverride.getText().toString();
                        if (!newServer.endsWith("/")) {
                            newServer += "/";
                        }
                        Database.changedUri = true;
                        prefs.edit().putString("DATABASE_SERVER", newServer).apply();
                        HypatiaLogger.Log(Utils.checkOldDatabase(this) + "\n");
                    });
                    builderServerOverride.setNegativeButton(getString(R.string.lblResetPrimary), (dialog, which) -> {
                        Database.changedUri = true;
                        prefs.edit().putString("DATABASE_SERVER", Utils.DATABASE_URL_DEFAULT).apply();
                        dialog.cancel();
                    });
                    builderServerOverride.setNeutralButton(getString(R.string.lblResetGitHub), (dialog, which) -> {
                        Database.changedUri = true;
                        prefs.edit().putString("DATABASE_SERVER", Utils.DATABASE_URL_GITHUB).apply();
                        dialog.cancel();
                    });
                    builderServerOverride.show();
                }
                break;
            case R.id.mnuSigningKey:
                if (Database.hasDownloadsRunning()) {
                    HypatiaLogger.Log(getString(R.string.lblUpdateRunning) + "\n");
                } else if (Database.isDatabaseLoading()) {
                    HypatiaLogger.Log(getString(R.string.lblDatabaseLoading) + "\n");
                } else {
                    AlertDialog.Builder builderKey = new AlertDialog.Builder(this);
                    builderKey.setTitle(getString(R.string.lblSigningKey));
                    final EditText inputKey = new EditText(this);
                    inputKey.setInputType(InputType.TYPE_CLASS_TEXT);
                    inputKey.setText(Utils.getSigningKey(this));
                    builderKey.setView(inputKey);
                    builderKey.setPositiveButton(getString(R.string.lblOverride), (dialog, which) -> {
                        prefs.edit().putString("SIGNING_KEY", inputKey.getText().toString()).apply();
                        HypatiaLogger.Log(Utils.checkOldDatabase(this) + "\n");
                    });
                    builderKey.setNegativeButton(getString(R.string.lblReset), (dialog, which) -> {
                        prefs.edit().putString("SIGNING_KEY", Utils.SIGNING_KEY_DEFAULT).apply();
                        dialog.cancel();
                    });
                    builderKey.show();
                }
                break;
            case R.id.toggleExtended:
                if (Database.hasDownloadsRunning()) {
                    HypatiaLogger.Log(getString(R.string.lblUpdateRunning) + "\n");
                } else if (Database.isDatabaseLoading()) {
                    HypatiaLogger.Log(getString(R.string.lblDatabaseLoading) + "\n");
                } else {
                    boolean prevExtended = prefs.getBoolean("SIGNATURES_EXTENDED", false);
                    new AlertDialog.Builder(this)
                            .setTitle(R.string.confirm_extended_title)
                            .setMessage(getString(R.string.confirm_extended_summary))
                            .setIcon(android.R.drawable.ic_menu_compass)
                            .setPositiveButton(getString(android.R.string.yes), (dialog, which) -> {
                                prefs.edit().putBoolean("SIGNATURES_EXTENDED", true).apply();
                                item.setChecked(true);
                                if (!prevExtended) {
                                    Database.changedConfig = true;
                                }
                            })
                            .setNegativeButton(getString(android.R.string.no), (dialog, which) -> {
                                prefs.edit().putBoolean("SIGNATURES_EXTENDED", false).apply();
                                item.setChecked(false);
                                if (prevExtended) {
                                    Database.changedConfig = true;
                                }
                                dialog.cancel();
                            }).show();
                }
                break;
            case R.id.toggleLinkScanner:
                if (Database.hasDownloadsRunning()) {
                    HypatiaLogger.Log(getString(R.string.lblUpdateRunning) + "\n");
                } else if (Database.isDatabaseLoading()) {
                    HypatiaLogger.Log(getString(R.string.lblDatabaseLoading) + "\n");
                } else {
                    boolean prevDomains = prefs.getBoolean("DOMAINS", false);
                    new AlertDialog.Builder(this)
                            .setTitle(R.string.confirm_link_scanner_title)
                            .setMessage(getString(R.string.confirm_link_scanner_summary))
                            .setIcon(android.R.drawable.ic_menu_compass)
                            .setPositiveButton(getString(android.R.string.yes), (dialog, which) -> {
                                prefs.edit().putBoolean("DOMAINS", true).apply();
                                item.setChecked(true);
                                if (!prevDomains) {
                                    Database.changedConfig = true;
                                }
                                startActivityForResult(
                                        new Intent(android.provider.Settings.ACTION_ACCESSIBILITY_SETTINGS), 0);
                            })
                            .setNegativeButton(getString(android.R.string.no), (dialog, which) -> {
                                prefs.edit().putBoolean("DOMAINS", false).apply();
                                item.setChecked(false);
                                if (prevDomains) {
                                    Database.changedConfig = true;
                                }
                                dialog.cancel();
                            }).show();
                }
                break;
            case R.id.toggleRealtime:
                if (malwareScanner.running) {
                    HypatiaLogger.Log(getString(R.string.lblScanRunning) + "\n");
                } else {
                    Intent realtimeScanner = new Intent(Hypatia.getAppContext(), MalwareScannerService.class);
                    if (!item.isChecked()) {
                        prefs.edit().putBoolean("autostart", true).apply();
                        Utils.considerStartService(this);
                    } else {
                        stopService(realtimeScanner);
                        prefs.edit().putBoolean("autostart", false).apply();
                    }
                    item.setChecked(!item.isChecked());
                }
                break;
            case R.id.mnuScanSystem:
                scanSystem = !item.isChecked();
                item.setChecked(scanSystem);
                break;
            case R.id.mnuScanApps:
                scanApps = !item.isChecked();
                item.setChecked(scanApps);
                break;
            case R.id.mnuScanExternal:
                scanExternal = !item.isChecked();
                item.setChecked(scanExternal);
                break;
            case R.id.mnuScanRemovable:
                scanRemovable = !item.isChecked();
                item.setChecked(scanRemovable);
                break;
            case R.id.mnuSelfTestReal:
                Utils.writeSelfTestFiles(this);
                break;
            case R.id.mnuFullCredits:
                showCredits();
                break;
            case R.id.btnStartScan:
                if (!malwareScanner.running) {
                    if (Database.hasDownloadsRunning()) {
                        HypatiaLogger.Log(getString(R.string.lblUpdateRunning) + "\n");
                    } else if (Database.isDatabaseLoading()) {
                        HypatiaLogger.Log(getString(R.string.lblDatabaseLoading) + "\n");
                    } else {
                        updateScanButton(true);
                        startScanner();
                    }
                } else {
                    HypatiaLogger.Log("\n" + getString(R.string.main_cancelling_scan) + "\n\n");
                    malwareScanner.cancel(true);
                    malwareScanner.running = false;
                }
        }
        return super.onOptionsItemSelected(item);
    }

    private void startScanner() {
        malwareScanner = new MalwareScanner(this, true);
        malwareScanner.running = true;
        HashSet<File> filesToScan = new HashSet<>();
        if (scanSystem) {
            filesToScan.add(Environment.getRootDirectory());
            filesToScan.add(new File("/"));
            filesToScan.add(new File("/apex"));
            filesToScan.add(new File("/cache"));
            filesToScan.add(new File("/data"));
            filesToScan.add(new File("/data/local/tmp"));
            filesToScan.add(new File("/firmware"));
            filesToScan.add(new File("/oem"));
            filesToScan.add(new File("/odm"));
            filesToScan.add(new File("/odm_dlkm"));
            filesToScan.add(new File("/product"));
            filesToScan.add(new File("/system"));
            filesToScan.add(new File("/system_dlkm"));
            filesToScan.add(new File("/vendor"));
            filesToScan.add(new File("/vendor_dlkm"));
        }
        if (scanApps) {
            for (ApplicationInfo packageInfo : getPackageManager()
                    .getInstalledApplications(PackageManager.GET_META_DATA)) {
                if (packageInfo != null) {
                    if (packageInfo.sourceDir != null) {
                        filesToScan.add(new File(packageInfo.sourceDir));
                    }
                    if (packageInfo.dataDir != null) {
                        filesToScan.add(new File(packageInfo.dataDir));
                    }
                    if (packageInfo.nativeLibraryDir != null) {
                        filesToScan.add(new File(packageInfo.nativeLibraryDir));
                    }
                    if (packageInfo.publicSourceDir != null) {
                        filesToScan.add(new File(packageInfo.publicSourceDir));
                    }
                }
            }
        }
        if (scanExternal) {
            if (Environment.getExternalStorageDirectory() != null) {
                filesToScan.add(Environment.getExternalStorageDirectory());
            }
        }
        if (scanRemovable) {
            File removableStorage = new File("/storage");
            if (removableStorage.exists()) {
                filesToScan.add(removableStorage);
            }
        }

        PowerManager powerManager = (PowerManager) getSystemService(POWER_SERVICE);
        PowerManager.WakeLock wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
                "Hypatia::ManualScanLock");
        wakeLock.acquire(10 * 60 * 1000L); /* 10 minutes */
        MalwareScanner.isCache = false;
        malwareScanner.executeOnExecutor(Utils.getThreadPoolExecutor(), filesToScan);
        new Thread(() -> {
            try {
                while (malwareScanner.running) {
                    Thread.sleep(500);
                }
                runOnUiThread(() -> updateScanButton(false));
                wakeLock.release();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }

    private void updateDatabase() {
        if (prefs.getBoolean("ONION_ROUTING", false)) {
            Utils.requestStartOrbot(this);
            HypatiaLogger.Log(getString(R.string.lblOnionRoutingEnabledHint) + "\n");
        }
        new Database(findViewById(R.id.txtLogOutput));
        if (!Database.isDatabaseLoading()) {
            PowerManager powerManager = (PowerManager) getSystemService(POWER_SERVICE);
            PowerManager.WakeLock wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
                    "Hypatia::UpdateLock");
            wakeLock.acquire(3 * 60 * 1000L); /* 3 minutes */
            Database.updateDatabase(this, Database.signatureDatabases);
            Utils.getThreadPoolExecutor().execute(() -> {
                try {
                    Thread.sleep(500);
                    HypatiaLogger.Log("Considering database reload!", LogType.DEBUG);
                    while (Database.hasDownloadsRunning()) {
                        Thread.sleep(500);
                        HypatiaLogger.Log("Download in progress, waiting!", LogType.VERYVERBOSE);
                    }
                    wakeLock.release();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                runOnUiThread(() -> {
                    HypatiaLogger.Log(getString(R.string.lblDatabasesUpdated) + "\n");
                    Database.changedUri = false;
                });
                if (Database.isDatabaseLoaded()) {
                    if (Database.changedDownload || Database.changedConfig || Database.changedUri) {
                        HypatiaLogger.Log("Really reloading database!", LogType.DEBUG);
                        Database.loadDatabase(Hypatia.getAppContext(), true, Database.signatureDatabases);
                    } else {
                        HypatiaLogger.Log("Database not changed, skipping reload!", LogType.DEBUG);
                    }
                } else {
                    HypatiaLogger.Log("Database not loaded, skipping reload!", LogType.DEBUG);
                }
            });
        } else {
            HypatiaLogger.Log(getString(R.string.lblDatabaseLoading) + "\n");
        }
    }

    private void updateScanButton(boolean running) {
        if (menu == null || menu.findItem(R.id.btnStartScan) == null) {
            return;
        }
        if (running) {
            if (SDK_INT >= Build.VERSION_CODES.O) {
                menu.findItem(R.id.btnStartScan).setIconTintList(getColorStateList(R.color.colorRed));
            }
            if (SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                menu.findItem(R.id.btnStartScan).setIcon(getDrawable(android.R.drawable.ic_menu_close_clear_cancel));
            }
        } else {
            if (SDK_INT >= Build.VERSION_CODES.O) {
                menu.findItem(R.id.btnStartScan).setIconTintList(getColorStateList(R.color.colorGreen));
            }
            if (SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                menu.findItem(R.id.btnStartScan).setIcon(getDrawable(android.R.drawable.ic_media_play));
            }
        }
    }

}