Taskmanager in flutter

Question

So i have this app that main purpouse is to act as a task manager like windows one in android. the 2 principal issue are: 1:the data of the apps opened in the phone and the usage of the memory are not real. 2:i can't close the app like windows task manager. I will prompt some screenshot in order to be more visual

The code of the app is:

import 'package:flutter/material.dart';
import 'package:syncfusion_flutter_charts/charts.dart';
import 'package:system_info2/system_info2.dart';
import 'package:process_run/shell.dart';
import 'package:flutter/services.dart';
import 'dart:async';
import 'package:device_apps/device_apps.dart';

class TaskManagerScreen extends StatefulWidget {
  const TaskManagerScreen({super.key});

  @override
  TaskManagerScreenState createState() => TaskManagerScreenState();
}

class TaskManagerScreenState extends State<TaskManagerScreen> {
  List<TaskData> _cpuData = [];
  List<ApplicationWithUsage> _runningApps = [];
  double _usedMemory = 0.0;
  double _totalMemory = 0.0;

  static const platform = MethodChannel('com.example.monitoreo/permissions');
  Timer? _timer;

  @override
  void initState() {
    super.initState();
    _startFetchingData();
  }

  @override
  void dispose() {
    _timer?.cancel();
    super.dispose();
  }

  void _startFetchingData() {
    _fetchData();
    _timer = Timer.periodic(Duration(seconds: 5), (timer) {
      _fetchData();
    });
  }

  Future<void> _fetchData() async {
    try {
      if (!await _requestUsageStatsPermission()) {
        return;
      }

      double usedMemory = SysInfo.getFreePhysicalMemory() / (1024 * 1024);
      double totalMemory = SysInfo.getTotalPhysicalMemory() / (1024 * 1024);

      double cpuUsage = await _getCpuUsage();

      List<String> runningAppsPackageNames = await _getRunningApps();
      List<ApplicationWithUsage> runningApps = [];

      for (var packageName in runningAppsPackageNames) {
        var app = await DeviceApps.getApp(packageName);
        if (app != null) {
          double appCpuUsage = await _getAppCpuUsage(packageName);
          double appMemoryUsage = await _getAppMemoryUsage(packageName);
          runningApps.add(ApplicationWithUsage(app, appCpuUsage, appMemoryUsage));
        }
      }

      setState(() {
        _cpuData = [
          TaskData('Uso', cpuUsage),
          TaskData('Libre', 100 - cpuUsage),
        ];
        _runningApps = runningApps;
        _usedMemory = totalMemory - usedMemory;
        _totalMemory = totalMemory;
      });
    } catch (e) {
      debugPrint('Error fetching data: $e');
    }
  }

  Future<bool> _requestUsageStatsPermission() async {
    try {
      final bool result = await platform.invokeMethod('requestUsageStatsPermission');
      return result;
    } catch (e) {
      print("Error solicitando permiso de uso de estadísticas: $e");
      return false;
    }
  }

  Future<List<String>> _getRunningApps() async {
    try {
      final List<dynamic> result = await platform.invokeMethod('getRunningApps');
      return result.cast<String>();
    } catch (e) {
      print("Error obteniendo aplicaciones en ejecución: $e");
      return [];
    }
  }

  Future<double> _getCpuUsage() async {
    try {
      var shell = Shell();
      var result = await shell.run('sh -c "top -bn1 | grep \'%Cpu(s)\'"');

      if (result.isNotEmpty) {
        var output = result[0].stdout as String;
        var usageString = output.split(',')[0].split(':')[1].trim().split(' ')[0];
        return double.tryParse(usageString) ?? 0.0;
      }
    } catch (e) {
      debugPrint('Error getting CPU usage: $e');
    }
    return 0.0;
  }

  Future<double> _getAppCpuUsage(String packageName) async {
    // Implementa la lógica para obtener el uso de CPU de la aplicación
    return 0.0;
  }

  Future<double> _getAppMemoryUsage(String packageName) async {
    // Implementa la lógica para obtener el uso de memoria de la aplicación
    return 0.0;
  }

  Future<void> _killApp(String packageName) async {
    try {
      await platform.invokeMethod('killApp', {'packageName': packageName});
    } catch (e) {
      print("Error al cerrar la aplicación: $e");
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Administrador de Tareas'),
        leading: IconButton(
          icon: const Icon(Icons.arrow_back),
          onPressed: () {
            Navigator.pop(context);
          },
        ),
      ),
      body: Padding(
        padding: const EdgeInsets.all(8.0),
        child: Column(
          children: <Widget>[
            const Text(
              'Uso de CPU',
              style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
            ),
            Expanded(
              child: SfCircularChart(
                series: <CircularSeries>[
                  PieSeries<TaskData, String>(
                    dataSource: _cpuData,
                    xValueMapper: (TaskData data, _) => data.name,
                    yValueMapper: (TaskData data, _) => data.usage,
                    dataLabelMapper: (TaskData data, _) => '${data.usage}%',
                    dataLabelSettings: const DataLabelSettings(isVisible: true),
                  ),
                ],
              ),
            ),
            const SizedBox(height: 20),
            const Text(
              'Aplicaciones en Ejecución',
              style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
            ),
            Expanded(
              child: ListView.builder(
                itemCount: _runningApps.length,
                itemBuilder: (context, index) {
                  ApplicationWithUsage appWithUsage = _runningApps[index];
                  return ListTile(
                    title: Text(appWithUsage.app.appName),
                    subtitle: Text(
                        'CPU: ${appWithUsage.cpuUsage.toStringAsFixed(2)}%, Memoria: ${appWithUsage.memoryUsage.toStringAsFixed(2)}MB'),
                    trailing: IconButton(
                      icon: Icon(Icons.close),
                      onPressed: () => _killApp(appWithUsage.app.packageName),
                    ),
                  );
                },
              ),
            ),
            const SizedBox(height: 20),
            const Text(
              'Uso de Memoria RAM',
              style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
            ),
            Expanded(
              child: SfCartesianChart(
                primaryXAxis: CategoryAxis(),
                series: <ChartSeries>[
                  ColumnSeries<TaskData, String>(
                    dataSource: [
                      TaskData('Usada', _usedMemory),
                      TaskData('Libre', _totalMemory - _usedMemory),
                    ],
                    xValueMapper: (TaskData data, _) => data.name,
                    yValueMapper: (TaskData data, _) => data.usage,
                    dataLabelSettings: const DataLabelSettings(isVisible: true),
                  ),
                ],
              ),
            ),
          ],
        ),
      ),
    );
  }
}

class TaskData {
  TaskData(this.name, this.usage);

  final String name;
  final double usage;
}

class ApplicationWithUsage {
  ApplicationWithUsage(this.app, this.cpuUsage, this.memoryUsage);

  final Application app;
  final double cpuUsage;
  final double memoryUsage;
}

package com.example.monitoreo

import android.app.AppOpsManager
import android.app.ActivityManager
import android.app.usage.UsageStats
import android.app.usage.UsageStatsManager
import android.content.Context
import android.content.Intent
import android.os.Binder
import android.os.Build
import android.provider.Settings
import android.widget.Toast
import androidx.annotation.RequiresApi
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodChannel
import java.util.concurrent.TimeUnit

class MainActivity: FlutterActivity() {
    private val CHANNEL = "com.example.monitoreo/permissions"

    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)
        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler {
                call, result ->
            when (call.method) {
                "requestUsageStatsPermission" -> {
                    val permissionGranted = requestUsageStatsPermission()
                    result.success(permissionGranted)
                }
                "getRunningApps" -> {
                    val runningApps = getRunningApps()
                    result.success(runningApps)
                }
                "killApp" -> {
                    val packageName = call.argument<String>("packageName")
                    if (packageName != null) {
                        killApp(packageName)
                    }
                }
                else -> result.notImplemented()
            }
        }
    }

    private fun requestUsageStatsPermission(): Boolean {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            val appOps = getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
            val mode = appOps.checkOpNoThrow(AppOpsManager.OPSTR_GET_USAGE_STATS, Binder.getCallingUid(), packageName)
            return if (mode == AppOpsManager.MODE_ALLOWED) {
                true
            } else {
                val intent = Intent(Settings.ACTION_USAGE_ACCESS_SETTINGS)
                startActivity(intent)
                Toast.makeText(this, "Por favor, habilite el acceso a estadísticas de uso", Toast.LENGTH_LONG).show()
                false
            }
        }
        return false
    }

    @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
    private fun getRunningApps(): List<String> {
        val usageStatsManager = getSystemService(Context.USAGE_STATS_SERVICE) as UsageStatsManager
        val endTime = System.currentTimeMillis()
        val startTime = endTime - TimeUnit.MINUTES.toMillis(10) // Últimos 10 minutos
        val usageStatsList = usageStatsManager.queryUsageStats(
            UsageStatsManager.INTERVAL_DAILY, startTime, endTime
        )
        val runningApps = usageStatsList
            .filter { it.lastTimeUsed > startTime }
            .map { it.packageName }
        return runningApps
    }

    private fun killApp(packageName: String) {
        val activityManager = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
        activityManager.killBackgroundProcesses(packageName)
    }
}

name: monitoreo
description: A new Flutter project.

publish_to: 'none' # Remove this line if you wish to publish to pub.dev

version: 1.0.0+1

environment:
  sdk: '>=3.4.3 <4.0.0'

dependencies:
  flutter:
    sdk: flutter
  permission_handler: ^10.2.0
  path_provider: ^2.0.11
  cupertino_icons: ^1.0.6
  syncfusion_flutter_charts: ^21.1.41
  device_info_plus: ^10.1.0
  process_run: ^0.12.0
  system_info2: ^2.0.0
  device_apps: ^2.2.0

dev_dependencies:
  flutter_test:
    sdk: flutter

flutter:
  uses-material-design: true
  assets:
    - assets/images/fondoflutter.jpg

import 'package:flutter/material.dart';
import 'package:path_provider/path_provider.dart';
import 'package:flutter/services.dart'; // Importar servicios para MethodChannel
import 'task_manager_screen.dart'; // Importar la pantalla del administrador de tareas

const platform = MethodChannel('com.example.monitoreo/permissions');

Future<bool> requestUsageStatsPermission() async {
  try {
    final bool result = await platform.invokeMethod('requestUsageStatsPermission');
    return result;
  } catch (e) {
    print("Error solicitando permiso de uso de estadísticas: $e");
    return false;
  }
}

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: TaskManagerScreen(),
    );
  }
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.monitoreo">

    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
    <uses-permission android:name="android.permission.GET_TASKS"/>
    <uses-permission android:name="android.permission.PACKAGE_USAGE_STATS"/>
    <uses-permission android:name="android.permission.KILL_BACKGROUND_PROCESSES"/>
    <uses-permission android:name="android.permission.REAL_GET_TASKS"/>

    <application
        android:label="monitoreo"
        android:name="${applicationName}"
        android:icon="@mipmap/ic_launcher">
        <activity
            android:name=".MainActivity"
            android:exported="true"
            android:launchMode="singleTop"
            android:taskAffinity=""
            android:theme="@style/LaunchTheme"
            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
            android:hardwareAccelerated="true"
            android:windowSoftInputMode="adjustResize">
            <meta-data
                android:name="io.flutter.embedding.android.NormalTheme"
                android:resource="@style/NormalTheme"
                />
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
        <meta-data
            android:name="flutterEmbedding"
            android:value="2" />
    </application>
    <queries>
        <intent>
            <action android:name="android.intent.action.PROCESS_TEXT"/>
            <data android:mimeType="text/plain"/>
        </intent>
    </queries>
</manifest>```