学习Android的第二十九天

Android Service 与 Activity 通讯

范例

Android Service Alarm 定时广播

Alarm

Android Service 与 Activity 通讯

Activity 与 Service 通信的媒介就是 Service 中的 onBind() 方法，onBind() 方法会返回一个自定义的 Binder 对象。

在自定义的 Service 类中，我们会创建一个继承自 Binder 的自定义 Binder 类，其中包含了我们想要暴露给 Activity 的方法。这个 Binder 类负责实现跨进程通信所需的接口。
在 Service 类中，我们需要实例化这个自定义的 Binder 类，并且在 onBind() 方法中返回这个 Binder 对象。
在 Activity 类中，我们需要实例化一个 ServiceConnection 对象，并且重写 onServiceConnected() 方法。当连接到 Service 时，系统会调用 onServiceConnected() 方法，并提供一个 Binder 对象，通过它可以调用 Service 中暴露的方法。

范例

package com.example.myapplication2;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;

public class MyService extends Service {

    public void doSomething() {
    }

    // 自定义的 Binder 类
    public class MyBinder extends Binder {
        MyService getService() {
            return MyService.this;
        }

        // 暴露给 Activity 的方法
        public void doSomething() {
            // 在这里执行具体的操作
        }
    }

    private final IBinder mBinder = new MyBinder();

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

package com.example.myapplication2;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

    private MyService mService;
    private boolean mBound = false;

    // ServiceConnection 对象
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName className, IBinder service) {
            MyService.MyBinder binder = (MyService.MyBinder) service;
            mService = binder.getService();
            mBound = true;

            // 在这里可以调用 Service 中暴露的方法
            mService.doSomething();
        }

        @Override
        public void onServiceDisconnected(ComponentName arg0) {
            mBound = false;
        }
    };

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

        // 启动 Service
        Intent intent = new Intent(this, MyService.class);
        startService(intent);
    }

    @Override
    protected void onStart() {
        super.onStart();
        // 绑定到 Service
        Intent intent = new Intent(this, MyService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // 解绑 Service
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }
}

Android Service Alarm 定时广播

对于在 Android 应用中执行定时任务，特别是需要长期在后台运行的定时任务，使用 Alarm 机制是更为可靠和适合的选择。相比之下，Timer 类存在一些局限性，如在设备休眠时无法保证准确执行定时任务。

Alarm 机制通过设置系统级别的闹钟来触发某个操作，即使应用处于后台或设备休眠状态，也能够唤醒 CPU 并执行相应的任务。这种方式适合于需要长期在后台持续执行的定时任务，比如轮询服务器进行数据更新或状态确认等。

同时，在使用 Alarm 机制时，需要注意区分 CPU 唤醒与屏幕唤醒。CPU 唤醒是指在设备休眠状态下唤醒 CPU 执行任务，而屏幕唤醒则是指设备从休眠状态恢复到亮屏状态。通常情况下，我们希望定时任务能够唤醒 CPU 执行而不会唤醒屏幕，以节省设备电量并保持用户体验。

总的来说，针对需要长期在后台执行的定时任务，推荐使用 Alarm 机制，它可以可靠地唤醒 CPU 执行任务，且能够有效管理定时任务的触发和执行。

Alarm

对于 Android 中 AlarmManager 的 set() 方法，参数包括类型（type）、开始时间（startTime）和 PendingIntent 对象（pi），这些参数决定了闹钟的执行方式和动作。

1. 类型（type）：

AlarmManager.ELAPSED_REALTIME：相对于系统启动时间的相对时间，手机睡眠时不可用。
AlarmManager.ELAPSED_REALTIME_WAKEUP：相对于系统启动时间的相对时间，手机睡眠时会唤醒系统。
AlarmManager.RTC_WAKEUP：绝对时间，手机睡眠时会唤醒系统。
AlarmManager.POWER_OFF_WAKEUP：在手机关机状态下也能正常提示功能，但受SDK版本影响，可能并不是所有版本都支持。

2. 开始时间（startTime）：

决定了闹钟的第一次执行时间，以毫秒为单位。可以使用 SystemClock.elapsedRealtime() 或 System.currentTimeMillis() 根据类型来获取合适的时间。

3. PendingIntent 对象（pi）：

用于绑定闹钟的执行动作，比如发送广播、给出提示等等。

如果通过启动服务来实现闹钟提示，应该使用 `Pending.getService()` 方法获取 PendingIntent 对象。
如果通过广播来实现闹钟提示，应该使用 `PendingIntent.getBroadcast()` 方法获取 PendingIntent 对象。
如果通过 Activity 来实现闹钟提示，应该使用 `PendingIntent.getActivity()` 方法获取 PendingIntent 对象。

正确选择 PendingIntent 获取方法很重要，否则虽然不会报错，但可能无法看到闹钟提示效果。根据实际情况选择合适的 PendingIntent 获取方法，确保闹钟的执行动作能够按预期进行。

Alarm 使用流程

使用 Alarm 的一般流程如下：

1、获取 AlarmManager 对象：

AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);

2、使用 set() 方法设置定时任务：

int durtime = 2 * 1000; // 单位毫秒
long triggerAtTime = SystemClock.elapsedRealtime() + durtime;
manager.set(AlarmManager.RTC_WAKEUP, triggerAtTime, pendingIntent);

3、定义一个 Service，在其 onStartCommand() 方法中开辟一条事务线程，用于处理定时逻辑。

4、定义一个广播（Broadcast），用于启动 Service。

5、在 AndroidManifest.xml 文件中注册 Service 和 Broadcast。

请注意，对于 Android 4.4+（API 19）的设备，Alarm 任务的触发时间可能会变得不准确，有可能会有延时。这是系统为了进行耗电性的优化所做的调整。如果需要准确无误的触发时间，可以考虑使用 setExact() 方法。

范例

1、创建一个新的 Java 类，命名为 AlarmReceiver，继承自 BroadcastReceiver：

package com.example.myapplication2;

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

public class AlarmReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        Toast.makeText(context, "定时任务触发", Toast.LENGTH_SHORT).show();
    }
}

2、在 AndroidManifest.xml 文件中注册 AlarmReceiver 广播：

<receiver android:name=".AlarmReceiver" />

3、修改MainActivity.java：

package com.example.myapplication2;

import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.Intent;
import android.os.Bundle;
import android.os.SystemClock;

import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

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


        AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
        Intent intent = new Intent(this, AlarmReceiver.class);
        PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);

        long triggerAtTime = SystemClock.elapsedRealtime() + 5000; // 5秒后触发
        alarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pendingIntent);


    }
}

Android IBinder

IBinder是Android系统中用于远程对象通信的关键接口之一。以下是您提供的内容的总结：

IBinder的作用：

IBinder是远程对象的基本接口，用于高性能的轻量级远程调用机制。

IBinder的使用：

不仅用于远程调用，也可用于进程内调用。
一般情况下，我们通过继承Binder类来实现IBinder接口，而不是直接实现该接口。

主要方法：

transact()：向远程IBinder对象发送调用。
onTransact()：响应接收到的调用。
这些方法是同步执行的，比如transact()在对方的onTransact()方法调用完成之前不会返回。

数据传输：

transact()发送的数据是通过Parcel进行传输的。
Parcel是一种通用的缓冲区，除了数据外，还包含描述其内容的元数据。
元数据用于管理IBinder对象的引用，以便在进程间移动Parcel时保存这些引用。

进程间通信：

1、IBinder和Binder之间的管理类似于唯一标识符。
2、在操作远程对象时，可能需要确保它们是有效的。可以使用以下方法：

当目标进程不存在时，使用transact()方法会抛出RemoteException异常。
调用pingBinder()时，如果目标进程不存在，则返回false。
可以使用linkToDeath()方法向IBinder注册一个IBinder.DeathRecipient，在代表的进程退出时调用。

Binder

在 Binder 机制中，通常存在以下组件和调用流程：

Client（客户端）：

客户端是使用 Binder 机制进行远程调用的应用程序或组件。
客户端通过获取服务的代理对象（Proxy）来调用远程服务的方法。
客户端通过 Binder 机制将请求发送到服务端。

Server（服务端）：

服务端是提供远程服务的应用程序或组件。
服务端通过实现具体的业务逻辑来响应客户端的请求。
服务端通过 Binder 机制接收来自客户端的请求，并执行相应的操作。

Service Manager（服务管理器）：

服务管理器是 Android 系统中的一个系统服务，负责维护 Binder 对象的注册表。
它允许客户端通过 Binder 对象的名称来查找远程服务，并获取其代理对象。

Binder 驱动程序：

Binder 驱动程序是 Android 系统中的内核模块，负责处理 Binder 通信的底层细节。
它负责跟踪 Binder 对象的生命周期、实现进程间通信和线程间通信的机制。

Binder 机制的调用流程如下：

客户端通过 Service Manager 获取远程服务的代理对象（Proxy）。
客户端调用代理对象的方法，传递参数和回调接口（如果需要）。
代理对象将调用请求封装成 Binder 消息，并通过 Binder 驱动程序发送给服务端。
服务端接收到 Binder 消息后，解析消息内容，并执行相应的操作。
服务端执行完操作后，将结果返回给客户端，同样通过 Binder 消息传递。
客户端接收到结果后，执行相应的逻辑处理。

为什么是 Binder ?

Binder 机制之所以成为 Android 进程间通信的基础，带来了很多便利和好处，

主要归功于以下几个原因：

高效的进程间通信机制：Binder 机制在底层实现了高效的进程间通信机制，包括线程间通信和进程间通信。这使得在 Android 系统中，不同应用程序或者同一个应用程序的不同进程之间能够进行快速、可靠的通信。
抽象了底层细节：使用 Binder 机制时，开发者不需要关心底层通信的实现细节，如进程间通信的具体实现、数据传输方式等。通过 AIDL（Android Interface Definition Language）定义接口后，Binder 机制会自动处理数据的传输和远程方法的调用，使得开发者只需专注于业务逻辑的实现。
提供了灵活的接口定义方式：通过 AIDL 定义接口，开发者可以自由地描述远程服务的接口，包括方法的签名、参数以及返回值。这种灵活的接口定义方式使得不同进程之间的通信更加灵活和方便。
内置了安全机制：Binder 机制内置了安全机制，确保了进程间通信的安全性。例如，Binder 会对传输的数据进行序列化和反序列化，同时通过权限验证等方式确保通信的安全性，防止恶意程序对进程间通信进行攻击。
统一的通信接口：在 Android 系统中，大部分的跨进程通信都是通过 Binder 机制进行的。这种统一的通信接口使得不同应用程序之间的通信更加一致，提高了系统的稳定性和可维护性。

综上所述，Binder 机制作为 Android 系统中进程间通信的基础，通过其高效、抽象、安全、灵活的特性，极大地简化了开发者进行进程间通信的复杂度，提高了系统的性能和稳定性。