Android Service生命周期管理与数据传递最佳实践

public class ForegroundService extends Service {
    // 成员变量，在Service实例创建时初始化一次
    double x1 = MainActivity.x1; 
    double y1 = MainActivity.y1;
    double radius_ = MainActivity.radius_;
    int k = MainActivity.k;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        while (true) {
                            // 此处的x1是Service的成员变量，其值在Service创建时就已固定
                            Log.e("Service", "Running " + String.valueOf(x1)); 
                            try {
                                Thread.sleep(1000);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
        ).start();
        return super.onStartCommand(intent, flags, startId);
    }

    // ... 其他Service生命周期方法
}

// MainActivity.java
public class MainActivity extends AppCompatActivity {
    public static double x1_static = 10.0; // 示例静态变量

    private void startOrUpdateService(double newXValue) {
        // 更新静态变量 (不推荐，但为演示Intent传递做对比)
        x1_static = newXValue; 

        // 创建Intent并添加数据
        Intent serviceIntent = new Intent(this, ForegroundService.class);
        serviceIntent.putExtra("KEY_X_VALUE", newXValue); // 使用putExtra传递动态数据
        serviceIntent.putExtra("KEY_Y_VALUE", 20.0); // 传递其他数据

        // 启动或更新Service
        startService(serviceIntent);
    }

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

        // 首次启动Service
        startOrUpdateService(35.6761919);

        // 模拟一段时间后更新数据并再次启动Service
        new Handler().postDelayed(() -> {
            startOrUpdateService(35.4436739); // 传递新的X值
        }, 5000);
    }
}

// ForegroundService.java
public class ForegroundService extends Service {
    private double currentX1; // 使用非静态成员变量保存当前值
    private Thread currentWorkerThread; // 用于管理工作线程

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d("Service", "Service created.");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (intent != null) {
            // 从Intent中获取最新数据
            currentX1 = intent.getDoubleExtra("KEY_X_VALUE", 0.0); 
            double y1 = intent.getDoubleExtra("KEY_Y_VALUE", 0.0);
            Log.d("Service", "Received new X value: " + currentX1);

            // 在这里可以根据新数据更新Service的内部状态或逻辑
            // 例如，如果Service需要执行一个基于新参数的任务：
            startNewTask(currentX1, y1); 
        }

        // START_STICKY 表示如果Service被系统杀死，系统会尝试重新创建它，并传递一个null的Intent。
        // START_NOT_STICKY 表示Service被杀死后不会自动重启。
        // START_REDELIVER_INTENT 表示Service被杀死后会重启，并重新传递最后一个非null的Intent。
        return START_STICKY; 
    }

    private void startNewTask(double x, double y) {
        // 示例：确保只有一个工作线程在运行
        if (currentWorkerThread != null && currentWorkerThread.isAlive()) {
            // 如果线程正在运行，可以考虑中断它或向其发送更新信号
            // 为了简单起见，这里直接中断旧线程
            currentWorkerThread.interrupt(); 
            Log.d("Service", "Interrupting previous worker thread.");
        }

        // 启动新的工作线程，使用最新的数据
        currentWorkerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (!Thread.currentThread().isInterrupted()) { // 检查中断状态
                    Log.e("Service", "Running with X: " + String.valueOf(x));
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        Log.e("Service", "Worker thread interrupted.");
                        Thread.currentThread().interrupt(); // 重新设置中断状态
                        break; // 退出循环
                    }
                }
                Log.d("Service", "Worker thread finished.");
            }
        });
        currentWorkerThread.start();
    }

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

    @Override
    public void onDestroy() {
        super.onDestroy();
        // 确保Service销毁时停止所有工作线程
        if (currentWorkerThread != null) {
            currentWorkerThread.interrupt();
        }
        Log.d("Service", "Service destroyed.");
    }
}