Android学习之路(21) 进程间通信-AIDL与Servce基本使用

最新推荐文章于 2024-05-02 17:52:03 发布
最新推荐文章于 2024-05-02 17:52:03 发布
阅读量813 收藏 3
点赞数
分类专栏： 安卓 文章标签： android 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32907491/article/details/133965150
版权

Service 与 Thread 和 进程 之间的关系

  • 进程：应用程序在内存中分配的空间。（正在运行中的程序）
  • 线程：负责程序执行的单元，也称为执行路径。（需要线程来执行代码）。一个进程至少包含一条线程，如果一个进程中出现了条线程，此程序就为多线程程序。
  • Service是一个组件：默认运行在Main线程（进程中）。和Thread没关系。如果Service在清单文件中用 android:process 属性另开进程运行此Service组件，就算Service被销毁进程也不会停止。

Service的生命周期图

!
|
【Android】跨进程通信——AIDL、之Service基本细节使用之：精通

Service 与 Thread 和 进程 之间的关系

  • 进程：应用程序在内存中分配的空间。（正在运行中的程序）
  • 线程：负责程序执行的单元，也称为执行路径。（需要线程来执行代码）。一个进程至少包含一条线程，如果一个进程中出现了条线程，此程序就为多线程程序。
  • Service是一个组件：默认运行在Main线程（进程中）。和Thread没关系。如果Service在清单文件中用 android:process 属性另开进程运行此Service组件，就算Service被销毁进程也不会停止。

Service的生命周期图

回调方法详解

  • onCreate()，创建Service时调用，整个生命周期中只执行一次。
  • onBind()，必须实现的方法，客户端调用bindService()时回调该方法，返回一个IBind对象，通过此对象与被绑定Service通信。此后如果再次使用bindService绑定Service，系统不会再调用onBind()方法，只会直接把IBinder对象传递给其他后来增加的客户端！
  • onStartCommand()，早期版本是onStart()。客户端通过startService()时调用。可多次调用startService()，但不会创建新的Service对象，继续复用已创建的Service，会继续回调onStartCommand()方法。
  • onUnbind()，当该Service上绑定的所有客户端都断开时会回调该方法！
  • onDestroy()，服务被关闭前调用此方法。如调用stopService()，或者调用unbindService()。

三种服务的启动方式

  1. startService()启动Service
  • 方法回调：onCreate() —> onStartCommand() —> 进入运行状态。
  • 联系绑定：与调用者无联系，就算调用者结束了生命，只要不调用stopService()方法，Service还会继续运行。
  • 结束方法：stopService()
  1. bindService()启动Service
  • 方法回调：onCreate() —> onBind() —> 进入运行状态。
  • 联系绑定：服务与调用者进行联系绑定。1. 如果调用者没有手动调用unbindService()关闭服务，当调用者销毁后，服务也会被销毁，并回调 onUnbind() —> onDestroy()。 2. 如果是多个客户端绑定同一个Service的话，当所有的客户端都和service解除绑定或销毁后，系统才会销毁service。
  • 结束方法：unbindService()
  • 注意：如果中途中通过startService() 方法启动服务，则服务不会和全部调用者进行联系绑定。
  1. startService()启动Service后，调用bindService()绑定Service
  • 方法回调：onCreate() —> onStartCommand() —> onBind() —> 进入运行状态。
  • 方法回调2：如果两条语句在一个方法内：onCreate() —> onBind() —> onStartCommand() —> 进入运行状态。
  • 联系绑定：与调用者无联系，因为服务是通过startService()启动的。
  • 结束方法：先unbindService()解绑，再调用stopService()关闭Service

不管哪种方法启动服务，都可以调用 stopService() 关闭服务。上面是按照规范关闭服务，当然你有需求的话。

清单文件声明 Service 组件及属性

android:exported表示是否允许除了当前程序之外的其他程序访问这个服务
android:enabled表示是否启用这个服务
android:permission是权限声明
android:process是否需要在单独的进程中运行,当设置为android:process=”:remote”时，代表Service在单独的进程中运行。注意“：”很重要，它的意思是指要在当前进程名称前面附加上当前的包名，所以“remote”和”:remote”不是同一个意思，前者的进程名称为：remote，而后者的进程名称为：App-packageName:remote。
android:isolatedProcess设置 true 意味着，服务会在一个特殊的进程下运行，这个进程与系统其他进程分开且没有自己的权限。与其通信的唯一途径是通过服务的API(bind and start)。
<service android:name=".myService"
    android:enabled="true"
    android:exported="true"
    android:icon="@drawable/ic_launcher"
    android:label="string"
    android:process=":string"
    android:permission="string">
</service>

Intent的显式与隐式启动

一、显示启动service

Intent intent = new Intent(this, MyService.class);
startService(intent);

二、隐式启动service

首先自定义意图过滤器：标签 intent-filter、Action

<service android:name=".MyService" 
    android:enabled="true" >
    <intent-filter android:priority="1000" >
 
        <action android:name="com.bin.action.MyService" />
 
    </intent-filter>
</service>
<!-- android:priority="1000" 服务优先级 -->

三、5.0后隐式启动 service

5.0 之前的隐式启动service

Intent intent = new Intent("com.bin.action.MyService");
startService(intent);

5.0 之后的隐式启动service

Intent intent = new Intent("com.bin.action.MyService");
intent.setPackage(getPackageName()); //如果是另一个程序的service则指定它的包名
startService(intent);

前台Service

原理：在服务里通过 startForeground() 方法启动一个通知 Notification，也可以使用兼容包里的 通知对象。

public void onCreate()
{
    super.onCreate();
    Notification.Builder localBuilder = new Notification.Builder(this);
    localBuilder.setSmallIcon(R.drawable.ic_launcher);
    localBuilder.setContentTitle("Service标题");
    localBuilder.setContentText("正在运行...");
    startForeground(1, localBuilder.getNotification());
}

系统8.0、8.1的后台 Service 必须切换成前台服务

注意：调用startForegroundService()后5秒内没有调用startForeground(），会有ANR(Application Not Responding)

public class MyService extends Service {
 
    @Override
    public void onCreate()
    {
        super.onCreate();
        // 调用startForegroundService()后5秒内没有调用startForeground(），会有ANR
		if (Build.VERSION.SDK_INT >= Build.VERSION_CODE.O) {
            Notification.Builder localBuilder = new Notification.Builder(this);
            localBuilder.setSmallIcon(R.drawable.ic_launcher);
            localBuilder.setContentTitle("Service标题");
            localBuilder.setContentText("正在运行...");
            startForeground(1, localBuilder.getNotification());
        }
    }
 
	@Override
	public void onDestroy() {
		stopForeground(true);
		super.onDestroy();
	}
}

版本兼容判断 启动Service（8.0、8.1启动Service方法用startForegroundService()）

if (Build.VERSION.SDK_INT >= Build.VERSION_CODE.O) {
	startForegroundService(intent); 
} else {
	startService(intent);
}

使用 startForegroundService() 方法启动service，还需要添加权限：

 <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>

跨进程通信

跨进程通信的场景有两种：

  • 本地service跨进程通信：是和当前程序内的service进行通信
  • 远程Service跨进程通信：是和其它程序内的service进行通信，已知方式：
  1. AIDL 接口描述文件方式
  2. 不用AIDL方式，使用 Binder 的 onTransact 方法
  3. 使用Messenger：Handler的方式

先来了解一下 ：bindService()、ServiceConnection、Binder

1.1 bindService(Intent service, ServiceConnection conn, int flags)

  • service : 通过该intent指定要启动的Service
  • conn : ServiceConnection对象，用户监听访问者与Service间的连接情况，连接成功回调该对象中的onServiceConnected(ComponentName,IBinder)方法；如果Service所在的宿主由于异常终止或者其他原因终止，导致Service与访问者间断开，连接时调用onServiceDisconnected(CompanentName)方法，主动通过unbindService() 方法断开并不会调用上述方法！
  • flags : 指定绑定时是否自动创建Service(如果Service还未创建)，参数可以是 0 (不自动创建)，BIND_AUTO_CREATE(自动创建)

1.2 ServiceConnection

private IBinder myService;
 
private ServiceConnection con = new ServiceConnection(){
 
		@Override
		public void onServiceConnected(ComponentName package, IBinder service)
		{
            myService = service;
			Toast.makeText(MyService.this, "连接成功", Toast.LENGTH_LONG).show();
		}
 
		@Override
		public void onServiceDisconnected(ComponentName package)
		{
            myService = null;
			Toast.makeText(MyService.this, "连接断开", Toast.LENGTH_LONG).show();
		}
};

1.3 返回的 Binder 对象

返回的对象不能为null，否则连接不成立。

2. 本地 Service 跨进程通信

服务端：

服务端需要写一个继承自 Binder 的类与服务通信。而这个类是你自定义的。

public class MyService extends Service
{
    private MyBinder binder;
 
    @Override
    public IBinder onBinder(Intent intent)
    {
        if (binder == null) {
            binder = new MyBinder();
        }
        return binder;
    }
 
    private class MyBinder extends Binder
    {
        // ...code
        // 返回此对象与Service进行通信
        public void toast(Context context, String str)
        {
            Toast.mackText(context, str, Toast.LENGTH_LONG).show();
        }
    }
 
}

然后在清单文件声明服务组件，并用 android:process 属性另开进程

<service android:name=".MyService" 
android:enabled="true"
android:process=":MyService" />

客户端：

public class MainActivity extends Activity 
{
 
    private IBinder myService;
 
    private ServiceConnection con = new ServiceConnection() {
 
		@Override
		public void onServiceConnected(ComponentName package, IBinder service)
		{
            myService = service;
			Toast.makeText(MainActivity.this, "连接成功", Toast.LENGTH_LONG).show();
            try
			{
                if (myService != null) {
                    Toast.makeText(MainActivity.this, myService.toast(this, "myService 弹出我吧！"), Toast.LENGTH_LONG).show();
                } else {
                    Toast.makeText(MainActivity.this, "服务端未启动，或异常关闭", Toast.LENGTH_LONG).show();
                }
			}
			catch (RemoteException e)
			{}
 
		}
 
		@Override
		public void onServiceDisconnected(ComponentName package)
		{
            myService = null;
			Toast.makeText(MainActivity.this, "连接断开", Toast.LENGTH_LONG).show();
		}
    };
	
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
	    bindService(new Intent(this, MyService.class), con, BIND_AUTO_CREATE);
    }
	
}

3. 远程 Service 跨进程通信

1. AIDL跨进程通信

编写 AIDL 的注意事项：

  • 接口名词需要与aidl文件名相同。
  • 接口和方法前面不要加访问权限修饰符：public ,private,protected等，也不能用static final。
  • AIDL默认支持的类型包括Java基本类型，String，List，Map，CharSequence，除此之外的其他类型都 需要import声明，对于使用自定义类型作为参数或者返回值，自定义类型需要实现Parcelable接口。
  • 自定义类型和AIDL生成的其它接口类型在aidl描述文件中，应该显式import，即便在该类和定义 的包在同一个包中。
  • 常见坑：两个应用程序的AIDL描述文件所在的包，必须一样。

服务端：创建 AIDL 文件接口 ：IPerson.aidl

package com.bin.aidl;
 
interface IPerson {
    String getContent(int postion);
}

保存后会在 gen目录的包路径下 自动生成 IPerson.java （图片来源网络）

自定义Service类：

注意：这时候我们返回的 Binder 对象是继承自 AIDL接口的 内部类Stub，IPerson.java下的 Stub类

public static abstract class Stub extends android.os.Binder implements com.bin.aidl.IPerson
public class AIDLService extends Service {
 
    private IBinder binder;
 
    @Override
    public IBinder onBind(Intent intent) {
        if (binder == null) {
            binder = new AIDLBinder();
        }
        return binder;
    }
 
    private final class AIDLBinder extends Stub {
        @Override
        public String getContent(int postion) throws RemoteException {
            String result = null;
            switch (postion) {
                case 0:
                    result = "我是0";
                    break;
                case 1:
                    result = "我是1";
                    break;
                case 2:
                    result = "我是2";
                    break;
                default:
                    result = "我是默认";
                    break;
            }
            return result;
        }
    }
}

在AndroidManifest.xml文件中注册Service

注意：从一个进程启动另一个进程的 Service 要定义 意图过滤器

<service android:name=".AIDLService">
    <intent-filter>
        <action android:name="android.intent.action.AIDLService" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</service>

是 Intent默认添加的附加属性，所以加上。

服务端编写完毕

客户端：

首先把 服务端的AIDL文件复制过来，不能修改AIDL文件里的任何东西，包括 所在 package …

注意：AIDL存放的包路径必须与服务端一致

与服务端连接成功后，返回的Binder对象要强转为 AIDL 接口对象才能使用自定义方法：

// public static com.bin.aidl.IPerson asInterface(android.os.IBinder obj)
 
IPerson.Stub.asInterface(service); 
public class MainActivity extends Activity 
{
	private IPerson iPerson;
	private ServiceConnection con = new ServiceConnection(){
 
		@Override
		public void onServiceConnected(ComponentName package, IBinder service)
		{
                        Toast.makeText(MainActivity.this, "连接成功", Toast.LENGTH_LONG).show();
			iPerson = IPC.Stub.asInterface(service);
			try
			{
				Toast.makeText(MainActivity.this, iPerson.getContent(0), Toast.LENGTH_LONG).show();
			}
			catch (RemoteException e)
			{}
		}
 
		@Override
		public void onServiceDisconnected(ComponentName package)
		{
			Toast.makeText(MainActivity.this, "断开连接", Toast.LENGTH_LONG).show();
			iPerson = null;
		}
	};
	
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
	
        Intent service = new Intent("android.intent.action.AIDLService");
        service.setPackage("com.bin.aidl");
        bindService(service, con, BIND_AUTO_CREATE);
    }
	
}

2. 不用AIDL方式，使用 Binder 的 onTransact 方法

服务端：

public class IPCService extends Service {
 
    private static final String DESCRIPTOR = "IPCService";
    private IBinder binder;
 
    @Override
    public IBinder onBind(Intent intent) {
        if (binder == null) {
            binder = new IPCBinder();
        }
        return binder;
    }
 
    private final class IPCBinder extends Binder {
 
        @Override
        protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
            switch (code){
                case 0x001: {
                    //读取发送来的消息
                    data.enforceInterface(DESCRIPTOR);
                    int postion = data.readInt();
                    //处理
                    String result = null;
                    switch (postion) {
                        case 0:
                            result = "我是0";
                            break;
                        case 1:
                            result = "我是1";
                            break;
                        case 2:
                            result = "我是2";
                            break;
                        default:
                            result = "我是默认";
                            break;
                    }
                    //返回数据
                    reply.writeNoException();
                    reply.writeString(result);
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }
 
    }
}

客户端：

public class MainActivity extends Activity 
{
	private IBinder iBinder;
	private ServiceConnection con = new ServiceConnection(){
 
		@Override
		public void onServiceConnected(ComponentName package, IBinder service)
		{
                        Toast.makeText(MainActivity.this, "连接成功", Toast.LENGTH_LONG).show();
			iBinder = service;
 
			android.os.Parcel data = android.os.Parcel.obtain();
                        android.os.Parcel reply = android.os.Parcel.obtain();
                        String result = null;
                        int postion = 1;
                        try {
                            //写入信息
                            data.writeInterfaceToken("IPCService");
                            data.writeInt(postion);
                            //发送消息
                            mIBinder.transact(0x001, data, reply, 0);
                            //读取返回信息
                            reply.readException();
                            result = reply.readString();
                        }catch (RemoteException e) {
                            e.printStackTrace();
                        } finally { 
                            //释放资源
                            reply.recycle();
                            data.recycle();
                        }
                        Toast.makeText(MainActivity.this, result, Toast.LENGTH_LONG).show();
		}
 
		@Override
		public void onServiceDisconnected(ComponentName package)
		{
			Toast.makeText(MainActivity.this, "断开连接", Toast.LENGTH_LONG).show();
			iBinder = null;
		}
	};
	
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
	
        Intent service = new Intent("android.intent.action.IPCService");
        service.setPackage("com.bin.ipcservice");
        bindService(service, con, BIND_AUTO_CREATE);
    }
	
}

3. 使用Messenger跨进程通信

  • 服务端实现一个Handler，由其接受来自客户端的每个调用的回调
  • 使用实现的Handler创建Messenger对象
  • 通过Messenger得到一个IBinder对象，并将其通过onBind()返回给客户端
  • 客户端使用 IBinder 将 Messenger（引用服务的 Handler）实例化，然后使用后者将 Message 对象发送给服务
  • 服务端在其 Handler 中（具体地讲，是在 handleMessage() 方法中）接收每个 Message

服务端：

public class MessengerService extends Service {
 
    private final Messenger mMessenger = new Messenger(new ServiceHandler());
 
    class ServiceHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            String result = null;
            switch (msg.what) {
                case 0:
                    result = "我是0";
                    break;
                case 1:
                    result = "我是1";
                    break;
                case 2:
                    result = "我是2";
                    break;
                default:
                    result = "我是默认";
                    break;
            }
            Toast.makeText(MessengerService.this, result, Toast.LENGTH_LONG).show();
            super.handleMessage(msg);
        }
    }
 
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        //返回给客户端一个IBinder实例
        return mMessenger.getBinder();
    }
}

客户端：

public class MainActivity extends Activity 
{
	private Messenger mService;
	private ServiceConnection con = new ServiceConnection(){
 
		@Override
		public void onServiceConnected(ComponentName package, IBinder service)
		{
                        Toast.makeText(MainActivity.this, "连接成功", Toast.LENGTH_LONG).show();
			//接收onBind()传回来的IBinder，并用它构造Messenger
                        mService = new Messenger(service);
 
                        //构造一个消息对象
                        Message msg = Message.obtain(null, 2, 0, 0);
                        try {
                            //把这个信息发送给服务端
                            mService.send(msg);
                        } catch (RemoteException e) {
                            e.printStackTrace();
                        }
		}
 
		@Override
		public void onServiceDisconnected(ComponentName package)
		{
			Toast.makeText(MainActivity.this, "断开连接", Toast.LENGTH_LONG).show();
			mService = null;
		}
	};
	
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
	
        Intent service = new Intent("android.intent.action.MessengerService");
        service.setPackage("com.bin.messengerservice");
        bindService(service, con, BIND_AUTO_CREATE);
    }
	
}

双进程守护
原理：两个服务之间互相绑定，监听服务之间的 ServiceConnection 对象，重写 onServiceDisconnected() 方法 在对方异常断开连接时重启对方。

服务1：

public class MyService1 extends Service
{
    private MyBinder binder;
    private IBinder mService;
    private Intent intent;
 
    private ServiceConnection con = new ServiceConnection(){
 
		@Override
		public void onServiceConnected(ComponentName package, IBinder service)
		{
			Toast.makeText(MyService1.this, "连接成功", Toast.LENGTH_LONG).show();
                        mService = service;
		}
 
		@Override
		public void onServiceDisconnected(ComponentName package)
		{
			Toast.makeText(MyService1.this, "连接断开", Toast.LENGTH_LONG).show();
                        mService = null;
                        startService(intent);
                        bindService(intent, con, 0);
		}
    };
    
 
    @Override
    public void onCreate()
    {
        intent = new Intent(this, MyService2.class);
        startService(intent);
        bindService(intent, con, 0);
        super.onCreate();
    }
 
    @Override
    public IBinder onBinder(Intent intent)
    {
        if (binder == null) {
            binder = new MyBinder();
        }
        return binder;
    }
 
    private class MyBinder extends Binder
    {
        // TODO
    }
 
}

服务2：

public class MyService2 extends Service
{
    private MyBinder binder;
    private IBinder mService;
    private Intent intent;
 
    private ServiceConnection con = new ServiceConnection(){
 
		@Override
		public void onServiceConnected(ComponentName package, IBinder service)
		{
			Toast.makeText(MyService2.this, "连接成功", Toast.LENGTH_LONG).show();
                        mService = service;
		}
 
		@Override
		public void onServiceDisconnected(ComponentName package)
		{
			Toast.makeText(MyService2.this, "连接断开", Toast.LENGTH_LONG).show();
                        mService = null;
                        startService(intent);
                        bindService(intent, con, 0);
		}
    };
    
 
    @Override
    public void onCreate()
    {
        intent = new Intent(this, MyService1.class);
        startService(intent);
        bindService(intent, con, 0);
        super.onCreate();
    }
 
    @Override
    public IBinder onBinder(Intent intent)
    {
        if (binder == null) {
            binder = new MyBinder();
        }
        return binder;
    }
 
    private class MyBinder extends Binder
    {
        // TODO
    }
 
}

启动服务的方式可以在 Activity 中，也可以用广播接收器，我这里就用活动来启动服务

public class MainActivity extends Activity 
{
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
	
        Intent service = new Intent(this, MyService1.class);
        startService(service);
    }
	
}

记得在清单文件声明Service组件

<service android:name=".MyService1" />
<service android:name=".MyService2"
    android:process=":MyService2"/>

注意：双进程守护只能防止第三方应用kill，并不能防止用户手动停止掉

| |
|–|–|
| | |

回调方法详解
onCreate()，创建Service时调用，整个生命周期中只执行一次。
onBind()，必须实现的方法，客户端调用bindService()时回调该方法，返回一个IBind对象，通过此对象与被绑定Service通信。此后如果再次使用bindService绑定Service，系统不会再调用onBind()方法，只会直接把IBinder对象传递给其他后来增加的客户端！
onStartCommand()，早期版本是onStart()。客户端通过startService()时调用。可多次调用startService()，但不会创建新的Service对象，继续复用已创建的Service，会继续回调onStartCommand()方法。
onUnbind()，当该Service上绑定的所有客户端都断开时会回调该方法！
onDestroy()，服务被关闭前调用此方法。如调用stopService()，或者调用unbindService()。
三种服务的启动方式

  1. startService()启动Service
    方法回调：onCreate() —> onStartCommand() —> 进入运行状态。
    联系绑定：与调用者无联系，就算调用者结束了生命，只要不调用stopService()方法，Service还会继续运行。
    结束方法：stopService()
  2. bindService()启动Service
    方法回调：onCreate() —> onBind() —> 进入运行状态。
    联系绑定：服务与调用者进行联系绑定。1. 如果调用者没有手动调用unbindService()关闭服务，当调用者销毁后，服务也会被销毁，并回调 onUnbind() —> onDestroy()。 2. 如果是多个客户端绑定同一个Service的话，当所有的客户端都和service解除绑定或销毁后，系统才会销毁service。
    结束方法：unbindService()
    注意：如果中途中通过startService() 方法启动服务，则服务不会和全部调用者进行联系绑定。
  3. startService()启动Service后，调用bindService()绑定Service
    方法回调：onCreate() —> onStartCommand() —> onBind() —> 进入运行状态。
    方法回调2：如果两条语句在一个方法内：onCreate() —> onBind() —> onStartCommand() —> 进入运行状态。
    联系绑定：与调用者无联系，因为服务是通过startService()启动的。
    结束方法：先unbindService()解绑，再调用stopService()关闭Service
    不管哪种方法启动服务，都可以调用 stopService() 关闭服务。上面是按照规范关闭服务，当然你有需求的话。

清单文件声明 Service 组件及属性
android:exported 表示是否允许除了当前程序之外的其他程序访问这个服务
android:enabled 表示是否启用这个服务
android:permission 是权限声明
android:process 是否需要在单独的进程中运行,当设置为android:process=”:remote”时，代表Service在单独的进程中运行。注意“：”很重要，它的意思是指要在当前进程名称前面附加上当前的包名，所以“remote”和”:remote”不是同一个意思，前者的进程名称为：remote，而后者的进程名称为：App-packageName:remote。
android:isolatedProcess 设置 true 意味着，服务会在一个特殊的进程下运行，这个进程与系统其他进程分开且没有自己的权限。与其通信的唯一途径是通过服务的API(bind and start)。


Intent的显式与隐式启动
一、显示启动service
Intent intent = new Intent(this, MyService.class);
startService(intent);
二、隐式启动service
首先自定义意图过滤器：标签 intent-filter、Action


    <action android:name="com.bin.action.MyService" />

</intent-filter>

三、5.0后隐式启动 service
5.0 之前的隐式启动service

Intent intent = new Intent(“com.bin.action.MyService”);
startService(intent);
5.0 之后的隐式启动service

Intent intent = new Intent(“com.bin.action.MyService”);
intent.setPackage(getPackageName()); //如果是另一个程序的service则指定它的包名
startService(intent);
前台Service
原理：在服务里通过 startForeground() 方法启动一个通知 Notification，也可以使用兼容包里的 通知对象。

public void onCreate()
{
super.onCreate();
Notification.Builder localBuilder = new Notification.Builder(this);
localBuilder.setSmallIcon(R.drawable.ic_launcher);
localBuilder.setContentTitle(“Service标题”);
localBuilder.setContentText(“正在运行…”);
startForeground(1, localBuilder.getNotification());
}
系统8.0、8.1的后台 Service 必须切换成前台服务
注意：调用startForegroundService()后5秒内没有调用startForeground(），会有ANR

public class MyService extends Service {

@Override
public void onCreate()
{
    super.onCreate();
    // 调用startForegroundService()后5秒内没有调用startForeground(），会有ANR
	if (Build.VERSION.SDK_INT >= Build.VERSION_CODE.O) {
        Notification.Builder localBuilder = new Notification.Builder(this);
        localBuilder.setSmallIcon(R.drawable.ic_launcher);
        localBuilder.setContentTitle("Service标题");
        localBuilder.setContentText("正在运行...");
        startForeground(1, localBuilder.getNotification());
    }
}

@Override
public void onDestroy() {
	stopForeground(true);
	super.onDestroy();
}

}

版本兼容判断 启动Service（8.0、8.1启动Service方法用startForegroundService()）

if (Build.VERSION.SDK_INT >= Build.VERSION_CODE.O) {
startForegroundService(intent);
} else {
startService(intent);
}
使用 startForegroundService() 方法启动service，还需要添加权限：

跨进程通信 跨进程通信的场景有两种：

本地service跨进程通信：是和当前程序内的service进行通信
远程Service跨进程通信：是和其它程序内的service进行通信，已知方式：
1. AIDL 接口描述文件方式

             2. 不用AIDL方式，使用 Binder 的 onTransact 方法

             3. 使用Messenger：Handler的方式

先来了解一下 ：bindService()、ServiceConnection、Binder

1.1 bindService(Intent service, ServiceConnection conn, int flags)
service : 通过该intent指定要启动的Service
conn : ServiceConnection对象，用户监听访问者与Service间的连接情况，连接成功回调该对象中的onServiceConnected(ComponentName,IBinder)方法；如果Service所在的宿主由于异常终止或者其他原因终止，导致Service与访问者间断开，连接时调用onServiceDisconnected(CompanentName)方法，主动通过unbindService() 方法断开并不会调用上述方法！
flags : 指定绑定时是否自动创建Service(如果Service还未创建)，参数可以是 0 (不自动创建)，BIND_AUTO_CREATE(自动创建)
1.2 ServiceConnection
private IBinder myService;

private ServiceConnection con = new ServiceConnection(){

	@Override
	public void onServiceConnected(ComponentName package, IBinder service)
	{
                    myService = service;
		Toast.makeText(MyService.this, "连接成功", Toast.LENGTH_LONG).show();
	}

	@Override
	public void onServiceDisconnected(ComponentName package)
	{
                    myService = null;
		Toast.makeText(MyService.this, "连接断开", Toast.LENGTH_LONG).show();
	}

};

1.3 返回的 Binder 对象注意
返回的对象不能为null，否则连接不成立。

  1. 本地 Service 跨进程通信
    服务端：

服务端需要写一个继承自 Binder 的类与服务通信。而这个类是你自定义的。

public class MyService extends Service
{
private MyBinder binder;

@Override
public IBinder onBinder(Intent intent)
{
    if (binder == null) {
        binder = new MyBinder();
    }
    return binder;
}

private class MyBinder extends Binder
{
    // ...code
    // 返回此对象与Service进行通信
    public void toast(Context context, String str)
    {
        Toast.mackText(context, str, Toast.LENGTH_LONG).show();
    }
}

}

然后在清单文件声明服务组件，并用 android:process 属性另开进程


客户端：

public class MainActivity extends Activity
{

private IBinder myService;

private ServiceConnection con = new ServiceConnection() {

	@Override
	public void onServiceConnected(ComponentName package, IBinder service)
	{
                    myService = service;
		Toast.makeText(MainActivity.this, "连接成功", Toast.LENGTH_LONG).show();
                    try
		{
                        if (myService != null) {
                            Toast.makeText(MainActivity.this, myService.toast(this, "myService 弹出我吧！"), Toast.LENGTH_LONG).show();
                        } else {
                            Toast.makeText(MainActivity.this, "服务端未启动，或异常关闭", Toast.LENGTH_LONG).show();
                        }
		}
		catch (RemoteException e)
		{}

	}

	@Override
	public void onServiceDisconnected(ComponentName package)
	{
                    myService = null;
		Toast.makeText(MainActivity.this, "连接断开", Toast.LENGTH_LONG).show();
	}
};

@Override
protected void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
	
bindService(new Intent(this, MyService.class), con, BIND_AUTO_CREATE);
}

}

  1. 远程 Service 跨进程通信
  2. AIDL跨进程通信
    编写 AIDL 的注意事项：

接口名词需要与aidl文件名相同。
接口和方法前面不要加访问权限修饰符：public ,private,protected等，也不能用static final。
AIDL默认支持的类型包括Java基本类型，String，List，Map，CharSequence，除此之外的其他类型都 需要import声明，对于使用自定义类型作为参数或者返回值，自定义类型需要实现Parcelable接口。
自定义类型和AIDL生成的其它接口类型在aidl描述文件中，应该显式import，即便在该类和定义 的包在同一个包中。
常见坑：两个应用程序的AIDL描述文件所在的包，必须一样。
服务端：创建 AIDL 文件接口 ：IPerson.aidl

package com.bin.aidl;

interface IPerson {
String getContent(int postion);
}
保存后会在 gen目录的包路径下 自动生成 IPerson.java （图片来源网络）

自定义Service类：

注意：这时候我们返回的 Binder 对象是继承自 AIDL接口的 内部类Stub，IPerson.java下的 Stub类

public static abstract class Stub extends android.os.Binder implements com.bin.aidl.IPerson
public class AIDLService extends Service {

private IBinder binder;

@Override
public IBinder onBind(Intent intent) {
    if (binder == null) {
        binder = new AIDLBinder();
    }
    return binder;
}

private final class AIDLBinder extends Stub {
    @Override
    public String getContent(int postion) throws RemoteException {
        String result = null;
        switch (postion) {
            case 0:
                result = "我是0";
                break;
            case 1:
                result = "我是1";
                break;
            case 2:
                result = "我是2";
                break;
            default:
                result = "我是默认";
                break;
        }
        return result;
    }
}

}

在AndroidManifest.xml文件中注册Service

注意：从一个进程启动另一个进程的 Service 要定义 意图过滤器

是 Intent默认添加的附加属性，所以加上。

服务端编写完毕

客户端：

首先把 服务端的AIDL文件复制过来，不能修改AIDL文件里的任何东西，包括 所在 package …

注意：AIDL存放的包路径必须与服务端一致

与服务端连接成功后，返回的Binder对象要强转为 AIDL 接口对象才能使用自定义方法：

// public static com.bin.aidl.IPerson asInterface(android.os.IBinder obj)

IPerson.Stub.asInterface(service);
public class MainActivity extends Activity
{
private IPerson iPerson;
private ServiceConnection con = new ServiceConnection(){

	@Override
	public void onServiceConnected(ComponentName package, IBinder service)
	{
                    Toast.makeText(MainActivity.this, "连接成功", Toast.LENGTH_LONG).show();
		iPerson = IPC.Stub.asInterface(service);
		try
		{
			Toast.makeText(MainActivity.this, iPerson.getContent(0), Toast.LENGTH_LONG).show();
		}
		catch (RemoteException e)
		{}
	}

	@Override
	public void onServiceDisconnected(ComponentName package)
	{
		Toast.makeText(MainActivity.this, "断开连接", Toast.LENGTH_LONG).show();
		iPerson = null;
	}
};

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

    Intent service = new Intent("android.intent.action.AIDLService");
    service.setPackage("com.bin.aidl");
    bindService(service, con, BIND_AUTO_CREATE);
}

}

  1. 不用AIDL方式，使用 Binder 的 onTransact 方法
    服务端：

public class IPCService extends Service {

private static final String DESCRIPTOR = "IPCService";
private IBinder binder;

@Override
public IBinder onBind(Intent intent) {
    if (binder == null) {
        binder = new IPCBinder();
    }
    return binder;
}

private final class IPCBinder extends Binder {

    @Override
    protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
        switch (code){
            case 0x001: {
                //读取发送来的消息
                data.enforceInterface(DESCRIPTOR);
                int postion = data.readInt();
                //处理
                String result = null;
                switch (postion) {
                    case 0:
                        result = "我是0";
                        break;
                    case 1:
                        result = "我是1";
                        break;
                    case 2:
                        result = "我是2";
                        break;
                    default:
                        result = "我是默认";
                        break;
                }
                //返回数据
                reply.writeNoException();
                reply.writeString(result);
                return true;
            }
        }
        return super.onTransact(code, data, reply, flags);
    }

}

}

客户端：

public class MainActivity extends Activity
{
private IBinder iBinder;
private ServiceConnection con = new ServiceConnection(){

	@Override
	public void onServiceConnected(ComponentName package, IBinder service)
	{
                    Toast.makeText(MainActivity.this, "连接成功", Toast.LENGTH_LONG).show();
		iBinder = service;

		android.os.Parcel data = android.os.Parcel.obtain();
                    android.os.Parcel reply = android.os.Parcel.obtain();
                    String result = null;
                    int postion = 1;
                    try {
                        //写入信息
                        data.writeInterfaceToken("IPCService");
                        data.writeInt(postion);
                        //发送消息
                        mIBinder.transact(0x001, data, reply, 0);
                        //读取返回信息
                        reply.readException();
                        result = reply.readString();
                    }catch (RemoteException e) {
                        e.printStackTrace();
                    } finally { 
                        //释放资源
                        reply.recycle();
                        data.recycle();
                    }
                    Toast.makeText(MainActivity.this, result, Toast.LENGTH_LONG).show();
	}

	@Override
	public void onServiceDisconnected(ComponentName package)
	{
		Toast.makeText(MainActivity.this, "断开连接", Toast.LENGTH_LONG).show();
		iBinder = null;
	}
};

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

    Intent service = new Intent("android.intent.action.IPCService");
    service.setPackage("com.bin.ipcservice");
    bindService(service, con, BIND_AUTO_CREATE);
}

}

  1. 使用Messenger跨进程通信
    服务端实现一个Handler，由其接受来自客户端的每个调用的回调
    使用实现的Handler创建Messenger对象
    通过Messenger得到一个IBinder对象，并将其通过onBind()返回给客户端
    客户端使用 IBinder 将 Messenger（引用服务的 Handler）实例化，然后使用后者将 Message 对象发送给服务
    服务端在其 Handler 中（具体地讲，是在 handleMessage() 方法中）接收每个 Message
    服务端：

public class MessengerService extends Service {

private final Messenger mMessenger = new Messenger(new ServiceHandler());

class ServiceHandler extends Handler {
    @Override
    public void handleMessage(Message msg) {
        String result = null;
        switch (msg.what) {
            case 0:
                result = "我是0";
                break;
            case 1:
                result = "我是1";
                break;
            case 2:
                result = "我是2";
                break;
            default:
                result = "我是默认";
                break;
        }
        Toast.makeText(MessengerService.this, result, Toast.LENGTH_LONG).show();
        super.handleMessage(msg);
    }
}

@Nullable
@Override
public IBinder onBind(Intent intent) {
    //返回给客户端一个IBinder实例
    return mMessenger.getBinder();
}

}

客户端：

public class MainActivity extends Activity
{
private Messenger mService;
private ServiceConnection con = new ServiceConnection(){

	@Override
	public void onServiceConnected(ComponentName package, IBinder service)
	{
                    Toast.makeText(MainActivity.this, "连接成功", Toast.LENGTH_LONG).show();
		//接收onBind()传回来的IBinder，并用它构造Messenger
                    mService = new Messenger(service);

                    //构造一个消息对象
                    Message msg = Message.obtain(null, 2, 0, 0);
                    try {
                        //把这个信息发送给服务端
                        mService.send(msg);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
	}

	@Override
	public void onServiceDisconnected(ComponentName package)
	{
		Toast.makeText(MainActivity.this, "断开连接", Toast.LENGTH_LONG).show();
		mService = null;
	}
};

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

    Intent service = new Intent("android.intent.action.MessengerService");
    service.setPackage("com.bin.messengerservice");
    bindService(service, con, BIND_AUTO_CREATE);
}

}

双进程守护
原理：两个服务之间互相绑定，监听服务之间的 ServiceConnection 对象，重写 onServiceDisconnected() 方法 在对方异常断开连接时重启对方。

服务1：

public class MyService1 extends Service
{
private MyBinder binder;
private IBinder mService;
private Intent intent;

private ServiceConnection con = new ServiceConnection(){

	@Override
	public void onServiceConnected(ComponentName package, IBinder service)
	{
		Toast.makeText(MyService1.this, "连接成功", Toast.LENGTH_LONG).show();
                    mService = service;
	}

	@Override
	public void onServiceDisconnected(ComponentName package)
	{
		Toast.makeText(MyService1.this, "连接断开", Toast.LENGTH_LONG).show();
                    mService = null;
                    startService(intent);
                    bindService(intent, con, 0);
	}
};


@Override
public void onCreate()
{
    intent = new Intent(this, MyService2.class);
    startService(intent);
    bindService(intent, con, 0);
    super.onCreate();
}

@Override
public IBinder onBinder(Intent intent)
{
    if (binder == null) {
        binder = new MyBinder();
    }
    return binder;
}

private class MyBinder extends Binder
{
    // TODO
}

}

服务2：

public class MyService2 extends Service
{
private MyBinder binder;
private IBinder mService;
private Intent intent;

private ServiceConnection con = new ServiceConnection(){

	@Override
	public void onServiceConnected(ComponentName package, IBinder service)
	{
		Toast.makeText(MyService2.this, "连接成功", Toast.LENGTH_LONG).show();
                    mService = service;
	}

	@Override
	public void onServiceDisconnected(ComponentName package)
	{
		Toast.makeText(MyService2.this, "连接断开", Toast.LENGTH_LONG).show();
                    mService = null;
                    startService(intent);
                    bindService(intent, con, 0);
	}
};


@Override
public void onCreate()
{
    intent = new Intent(this, MyService1.class);
    startService(intent);
    bindService(intent, con, 0);
    super.onCreate();
}

@Override
public IBinder onBinder(Intent intent)
{
    if (binder == null) {
        binder = new MyBinder();
    }
    return binder;
}

private class MyBinder extends Binder
{
    // TODO
}

}

启动服务的方式可以在 Activity 中，也可以用广播接收器，我这里就用活动来启动服务

public class MainActivity extends Activity
{
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

    Intent service = new Intent(this, MyService1.class);
    startService(service);
}

}
记得在清单文件声明Service组件

注意：双进程守护只能防止第三方应用kill，并不能防止用户手动停止掉
星如雨ｸﾞｯ!(๑•̀ㅂ•́)و✧
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android的AIDL机制
世上只有一种英雄主义
11-23 3837
Android 接口定义语言 (AIDL)AIDL（Android 接口定义语言）与您可能使用过的其他 IDL 类似。 您可以利用它定义客户端与服务使用进程间通信 (IPC) 进行相互通信时都认可的编程接口。 在 Android 上，一个进程通常无法访问另一个进程的内存。 尽管如此，进程需要将其对象分解成操作系统能够识别的原语，并将对象编组成跨越边界的对象。 编写执行这一编组操作的代码是一项繁琐的工
Android——使用Service服务实现通信
Liwo4418的博客
06-09 1755
其中这个服务有addTimer()、play()、pausePlay()、continuePlay()和seekTo()方法实现每隔500ms更新播放进度条、播放音乐、暂停播放、继续播放和设置音乐播放进度条功能，具体代码如下。MainActivity实现了音乐文件的播放、暂停播放、继续播放、播放进度的设置以及音乐播放器界面的退出功能。运行上述程序，分别对点击“播放”、“暂停”、“继续”按钮可分别实现音乐播放、暂停、继续播放的功能。设计一个服务的具体应用，实现服务的通信。把相应的音频和图片导入到项目中。
Android Service 与 AIDL 详解
个人笔记
03-12 1704
服务的基本用法 Service 是安卓四大组件之一，Activity 一般有具体的用户界面，而 Service 则是 Android 实现程序后台运行的解决方案。那些不需要与用户交互，或者需要长期运行的任务，就适合使用服务。服务的特性如下 服务并不能独立运行，而是依靠某个进程创建，该进程被杀死，服务也就不复存在 服务不会自动开启线程，默认是在主线程中运行。如果不手动在服务的内部创建子线程，很可能...
Android进程间通信 深入浅出AIDL(一)
最新发布
2401_84408814的博客
05-02 772
官方推荐我们用Messenger来进行跨进程通信,但是Messenger是以串行的方式来处理客户端发来的消息,如果大量的消息同时发送到服务端,服务端仍然只能一个个处理,如果有大量的并发请求,那么用Messenger就不太合适了.这种情况就得用AIDL了.其实Messenger的底层也是AIDL,只不过系统做了层封装,简化使用.2. AIDL使用创建 .aidl 文件:此文件定义带有方法签名的编程接口.实现接口: Android SDK 工具会基于你的 .aidl 文件,使用 Java 编程语言生成接口.此接
Android AIDL跨进程通信
Ikulm的博客
06-12 2038
AIDL的文件编写相对来说不是很难，都是定义的一些接口方法，供外部调用。其中，我们通过自定义的远程服务ChatService作为中间组件，在两个应用间都绑定过一次，并且在DemoA中我们的远程服务与Activity的通信是通过Messenger来实现的，Messenger内部也是通过Binder机制将Message从一个进程传递到另一个进程。
AIDL 应用间简单通信demo及基本问题
JiaoJunfeng
01-17 1012
AIDL入门
Android 进程间通信AIDL使用详解
08-29
"Android 进程间通信AIDL使用详解" Android 进程间通信（IPC）是一种复杂的技术，AIDL（Android Interface Definition Language）是 Android 系统中的一种进程间通信机制。AIDL 是一种描述语言，用于定义服务器和...
Android-Android进程间通信之AIDL
08-13
**Android进程间通信之AIDL详解** Android系统作为一个多任务操作系统，多个应用程序之间可能存在需要相互交互的需求，这就涉及到了进程间通信（IPC, Inter-Process Communication）。在Android中，AIDL（Android ...
android根据不同任务创建不同进程，并通过AIDL进行进程间通信
04-13
进程间通信的效率比在同一进程中通信要低，因为涉及到数据序列化和跨进程通信的开销。因此，合理使用AIDL并控制IPC的数量对于保持应用性能至关重要。 总结，Android系统允许开发者创建多个进程来执行不同的任务，...
android中的AIDL进程间通信示例
01-04
因此不能共享内存，就出现了问题，于是，需要提供一些机制在不同进程之间进行数据通信，这个机制就是AIDL了。 一、一个android中AIDL的简单例子 假如是这样，现在有一个项目中提供了比较成熟的计算的方法，而现在我...
关于Android Service真正的完全详解，你需要知道的一切
kim5659的博客
07-22 1666
关于Android Service真正的完全详解，你需要知道的一切
进程间的通信-AIDL-IPC Binder的原理和源码阅读
qq_40032848的博客
05-06 134
1、首先客户端调用context.bindService方法，在intent里面设置action隐式意图绑定服务---->使指定action的Service调用onBind方法，onBind方法执行完，返回IBinder实例–>把返回的IBinder实例，同时调用客户端的onServiceConnected方法，把IBinder实例作为参数传递到客户端。拿到服务对象，调用服务端的onBind方法。然后再进行跨进程通信，拿到AMS的IBinder驱动，调用AMS的publishService方法，发布服务。
Android之AIDL（进程间通信），2024Android春招面试经历
m0_61549953的博客
03-15 716
我见过很多技术leader在面试的时候，遇到处于迷茫期的大龄程序员，比面试官年龄都大。这些人有一些共同特征：可能工作了7、8年，还是每天重复给业务部门写代码，工作内容的重复性比较高，没有什么技术含量的工作。问到这些人的职业规划时，他们也没有太多想法。其实30岁到40岁是一个人职业发展的黄金阶段，一定要在业务范围内的扩张，技术广度和深度提升上有自己的计划，才有助于在职业发展上有持续的发展路径，而不至于停滞不前。不断奔跑，你就知道学习的意义所在！
Aidl进程间通信详细介绍
weixin_34051201的博客
07-21 151
目录介绍 1.问题答疑 2.Aidl相关属性介绍 2.1 AIDL所支持的数据类型 2.2 服务端和客户端 2.3 AIDL的基本概念 3.实际开发中案例操作 3.1 aidl通信业务需求 3.2 操作步骤伪代码 3.3 服务端操作步骤 3.4 客户端操作步骤 3.5 测试 4.可能出现的问题 4.1 客户端在子线程中发起通信访问问题 4.2 什么情况下会导致远程调用失败 4.3 ...
AIDL的工作原理与使用示例 跨进程通信 远程方法调用RPC
chenhao0568的专栏
02-22 1002
AIDL（Android Interface Definition Language）是Android中用于定义客户端和服务端之间通信接口的一种接口定义语言。它允许你定义客户端和服务的通信协议，用于在不同的进程间或同一进程的不同组件间进行数据传递。AIDL通过定义接口和数据类型，让Android应用中的组件能够跨进程通信（IPC），即所谓的远程方法调用（Remote Procedure Call, RPC）。类似于应用调用其它应用的函数。 在Android中，不同的应用和组件通常运行在各自的进程中。为了让这
两个APP进行AIDL通信
N_Y_S的博客
07-30 631
二、将服务器的,aidl文件复制到客户端app中,Rebuid,让项目生成同名的接口文件。在资源管理器显示文件,然后将文件复制到客户端的src文件夹下,然后Rebuid。三、在Activity中绑定接口，使用接收到的Binder通信。这个时候通信并不能成功，因为版本原因，需要在注册表添加服务器的路径。添加逻辑接口以后Rebuild让项目生成同名的接口文件。包名com.nys.power。包名com.nys.login。在aidl文件中添加逻辑接口。会自动创建相应的包名。一、创建客户端App。........
android 服务通信,Android service通信
weixin_35252979的博客
05-25 1110
概要：介绍绑定服务端的三种方式：同一进程绑定服务、跨进程绑定服务(Messenger)、跨进程绑定服务(aidl)。 重点说一下通过Messenger、Service实现的进程间通信。基础：AIDL(Android Interface Definition Language)——进程间通信的一种机制。它允许您定义客户端和服务端通过使用进程间通信(IPC)进行通信的编程接口。在Android上，一个...
Android中的Service的通信
进击中的Park哥
09-09 6749
1.这段时间，基本上把android的所有知识点遍历过一次，开始写点东西记录了，不然我发现我记忆力谁退的厉害，总是会忘记。 现在在写个音乐播放器的Demo,所以我又看了一遍Service的API,我决定把重点的东西写下来。      首先来看API中对Service的介绍.      1.服务是当不影响用户或者提供给其他应用程序功能的组件。每个服务都应该在配置文件中配置,可以有两种方式启动一
Android Service与Activity之间通信的几种方式
www.v5qq.com的技术博客
08-05 2010
转载请注明地址http://blog.csdn.net/xiaanming/article/details/9750689 在Android中，Activity主要负责前台页面的展示，Service主要负责需要长期运行的任务，所以在我们实际开发中，就会常常遇到Activity与Service之间的通信，我们一般在Activity中启动后台Service，通过Intent来启动，Intent中...
Android Binder进程间通信与AIDL详解
在Android系统中，进程间通信（IPC，Inter-Process Communication）是一项重要的技术，它允许不同进程间的组件协同工作。Binder是Android系统中实现IPC的主要机制，而AIDL（Android Interface Definition Language）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值