AIDL示例

已于 2022-07-16 13:05:40 修改
阅读量489 收藏 1
点赞数
分类专栏： Android开发 文章标签： android java
于 2022-07-16 12:53:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangadping/article/details/125818592
版权

AIDL示例

官方文档

  • 服务端
    • aidl

      IPlayerService.aidl

      package com.example.aidl;
import com.example.aidl.MusicInfo;
import com.example.aidl.IMetadataUpdateCallback;

interface IPlayerService {
    MusicInfo getMusicInfo();
    void startPlay();
    void endPlay();
    void registerMetadataUpdateCallback(IMetadataUpdateCallback callback);
    void unregisterMetadataUpdateCallback(IMetadataUpdateCallback callback);
}

      MusicInfo.aidl

      package com.example.aidl;

parcelable MusicInfo;

      IMetadataUpdateCallback.aidl

      package com.example.aidl;
import com.example.aidl.MusicInfo;

interface IMetadataUpdateCallback {
    void onMetadataUpdate(in MusicInfo musicInfo);
}
    • service

      PlayerService.java

      package com.example.aidl;

import android.annotation.TargetApi;
import android.app.Service;
import android.content.Intent;
import android.os.Build;
import android.os.IBinder;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.util.Log;

/**
 * @author Dongping Wang
 * date 2022/7/14 0:12
 */
public class PlayerService extends Service {

    private static final String TAG = "PlayerService";

    private MusicInfo mMusicInfo = new MusicInfo("稻香", "周杰伦");

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

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy");
    }

    @Override
    public IBinder onBind(Intent intent) {
        Log.d(TAG, "onBind");
        return mBinder;
    }

    @Override
    public boolean onUnbind(Intent intent) {
        boolean b = super.onUnbind(intent);
        Log.d(TAG, "onUnbind");
        return b;
    }

    @Override
    public void onRebind(Intent intent) {
        super.onRebind(intent);
        Log.d(TAG, "onRebind");
    }

    private IBinder mBinder = new IPlayerService.Stub() {

        private RemoteCallbackList<IMetadataUpdateCallback> callbacks = new RemoteCallbackList<IMetadataUpdateCallback>() {
            @Override
            public void onCallbackDied(IMetadataUpdateCallback callback) {
                super.onCallbackDied(callback);
                Log.d(TAG, "onCallbackDied:" + callback);
            }
        };

        @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
        private void notifyMetadataUpdated() {
            callbacks.beginBroadcast();
            for (int i = 0; i < callbacks.getRegisteredCallbackCount(); i++) {
                try {
                    callbacks.getBroadcastItem(i).onMetadataUpdate(mMusicInfo);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
            callbacks.finishBroadcast();
        }

        @Override
        public MusicInfo getMusicInfo() throws RemoteException {
            Log.d(TAG, "getMusicInfo: " + mMusicInfo.toString());
            return mMusicInfo;
        }

        @Override
        public void startPlay() throws RemoteException {
            Log.d(TAG, "startPlay");
            // fixme:模拟当前歌曲变化，测试用
            notifyMetadataUpdated();
        }

        @Override
        public void endPlay() throws RemoteException {
            Log.d(TAG, "endPlay");
        }

        @Override
        public void registerMetadataUpdateCallback(IMetadataUpdateCallback callback) throws RemoteException {
            Log.d(TAG, "registerMetadataUpdateCallback:" + callback);
            callbacks.register(callback);
        }

        @Override
        public void unregisterMetadataUpdateCallback(IMetadataUpdateCallback callback) throws RemoteException {
            Log.d(TAG, "unregisterMetadataUpdateCallback:" + callback);
            callbacks.unregister(callback);
        }
    };
}

      服务在AndroidManifest中配置，指定:Remote进程

      <service
            android:name=".PlayerService"
            android:enabled="true"
            android:exported="true"
            android:process=":Remote">
            <intent-filter>
                <action android:name="example.intent.action.TEST_AIDL" />
            </intent-filter>
</service>

      MusicInfo.java

      package com.example.aidl;

import android.os.Parcel;
import android.os.Parcelable;

/**
 * @author Dongping Wang
 * date 2022/7/14 0:18
 */
public class MusicInfo implements Parcelable {

    private String title;
    private String singer;

    public MusicInfo() {
    }

    public MusicInfo(String title, String singer) {
        this.title = title;
        this.singer = singer;
    }

    protected MusicInfo(Parcel in) {
        title = in.readString();
        singer = in.readString();
    }

    public static final Creator<MusicInfo> CREATOR = new Creator<MusicInfo>() {
        @Override
        public MusicInfo createFromParcel(Parcel in) {
            return new MusicInfo(in);
        }

        @Override
        public MusicInfo[] newArray(int size) {
            return new MusicInfo[size];
        }
    };

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getSinger() {
        return singer;
    }

    public void setSinger(String singer) {
        this.singer = singer;
    }

    @Override
    public String toString() {
        return "MusicInfo{" +
                "title='" + title + '\'' +
                ", singer='" + singer + '\'' +
                '}';
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(title);
        dest.writeString(singer);
    }
}
  • 客户端

    通过PlayerServiceManager 进行调用服务端代码

    package com.example.aidl;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @author Dongping Wang
 * date 2022/7/14 22:04
 */
public final class PlayerServiceManager {

    private static final String ACTION_PLAYER_SERVICE = "example.intent.action.TEST_AIDL";
    private static final String PACKAGE_PLAYER_SERVICE = "com.example.aidl";

    private static final String TAG = "PlayerServiceManager";

    private Context mContext;
    private ServiceConnection mServiceConn;
    private volatile boolean mServiceRegistered;
    private IPlayerService playerService;
    private List<PlayerServiceConnectionListener> listeners = new CopyOnWriteArrayList<>();

    public static PlayerServiceManager newInstance(Context context) {
        return new PlayerServiceManager(context);
    }

    private PlayerServiceManager(Context context) {
        this.mContext = context;
    }

    public boolean bindService() {
        if (mServiceRegistered) {
            return true;
        }
        mServiceConn = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, final IBinder service) {
                Log.d(TAG, "onServiceConnected");
                playerService = IPlayerService.Stub.asInterface(service);
                for (PlayerServiceConnectionListener listener : listeners) {
                    listener.onServiceConnected();
                }
                try {
                    service.linkToDeath(new IBinder.DeathRecipient() {
                        @Override
                        public void binderDied() {
                            Log.d(TAG, "binderDied");
                            service.unlinkToDeath(this, 0);
                            bindService();
                        }
                    }, 0);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {
                Log.d(TAG, "onServiceDisconnected");
                for (PlayerServiceConnectionListener listener : listeners) {
                    listener.onServiceDisconnected();
                }
                playerService = null;
            }
        };
        Intent intent = new Intent().setAction(ACTION_PLAYER_SERVICE).setPackage(PACKAGE_PLAYER_SERVICE);
        mServiceRegistered = mContext.bindService(intent, mServiceConn, Context.BIND_AUTO_CREATE);
        return mServiceRegistered;
    }

    public boolean unbindService() {
        if (!mServiceRegistered) {
            return false;
        }
        if (mServiceConn != null) {
            mContext.unbindService(mServiceConn);
            mServiceRegistered = false;
            return true;
        }
        return false;
    }

    public void startPlay() {
        if (playerService != null) {
            try {
                playerService.startPlay();
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    }

    public void endPlay() {
        if (playerService != null) {
            try {
                playerService.endPlay();
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    }

    public MusicInfo getMusicInfo() {
        if (playerService != null) {
            try {
                return playerService.getMusicInfo();
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    public void registerMetadataUpdateCallback(IMetadataUpdateCallback callback) {
        if (playerService != null) {
            try {
                playerService.registerMetadataUpdateCallback(callback);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    }

    public void unregisterMetadataUpdateCallback(IMetadataUpdateCallback callback) {
        if (playerService != null) {
            try {
                playerService.unregisterMetadataUpdateCallback(callback);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    }

    public void registerPlayerServiceConnectionListener(PlayerServiceConnectionListener listener) {
        if (!listeners.contains(listener)) {
            listeners.add(listener);
        }
    }

    public void unregisterPlayerServiceConnectionListener(PlayerServiceConnectionListener listener) {
        if (listeners.contains(listener)) {
            listeners.remove(listener);
        }
    }

    public interface PlayerServiceConnectionListener {
        void onServiceConnected();

        void onServiceDisconnected();
    }
}

    MainActivity中四个按按钮来绑定、解绑、调用

    package com.example.aidl;

import android.os.Bundle;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;

import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";
    private PlayerServiceManager playerService = PlayerServiceManager.newInstance(this);

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

    public void bindService(View view) {
        playerService.bindService();
        playerService.registerPlayerServiceConnectionListener(listener);
    }

    public void unbindService(View view) {
        playerService.unregisterMetadataUpdateCallback(callback);
        playerService.unbindService();
    }

    public void startPlay(View view) {
        playerService.startPlay();
    }

    public void endPlay(View view) {
        playerService.endPlay();
    }

    private final IMetadataUpdateCallback callback = new IMetadataUpdateCallback.Stub() {
        @Override
        public void onMetadataUpdate(MusicInfo musicInfo) throws RemoteException {
            Log.d(TAG, "onMetadataUpdate:" + musicInfo.toString());
        }
    };

    private final PlayerServiceManager.PlayerServiceConnectionListener listener = new PlayerServiceManager.PlayerServiceConnectionListener() {
        @Override
        public void onServiceConnected() {
            playerService.registerMetadataUpdateCallback(callback);
        }

        @Override
        public void onServiceDisconnected() { }
    };
}

    输出结果：

    2022-07-16 12:44:42.100 1874-1903/system_process I/ActivityManager: Start proc 9341:com.example.aidl:Remote/u0a133 for service {com.example.aidl/com.example.aidl.PlayerService}
2022-07-16 12:44:42.266 9341-9341/? D/PlayerService: onCreate
2022-07-16 12:44:42.266 9341-9341/? D/PlayerService: onBind
2022-07-16 12:44:42.267 9307-9307/com.example.aidl D/PlayerServiceManager: onServiceConnected
2022-07-16 12:44:42.269 9341-9361/? D/PlayerService: registerMetadataUpdateCallback:com.example.aidl.IMetadataUpdateCallback$Stub$Proxy@4a38442
2022-07-16 12:44:44.959 9341-9361/? D/PlayerService: startPlay
2022-07-16 12:44:44.961 9307-9307/com.example.aidl D/MainActivity: onMetadataUpdate:MusicInfo{title='稻香', singer='周杰伦'}
2022-07-16 12:44:47.278 9341-9361/? D/PlayerService: unregisterMetadataUpdateCallback:com.example.aidl.IMetadataUpdateCallback$Stub$Proxy@e410990
2022-07-16 12:44:47.281 9341-9341/? D/PlayerService: onUnbind
2022-07-16 12:44:47.281 9341-9341/? D/PlayerService: onDestroy
dongpingwang
关注
专栏目录
AidlDemo(简单aidl的例子)
03-04
一个简单的android aidl范例，用于理解使用aidl的流程。
【Android】AIDL介绍和实例讲解
weixin_34245082的博客
12-03 157
前言为使应用程序之间能够彼此通信，Android提供了IPC （Inter Process Communication，进程间通信）的一种独特实现： AIDL （Android Interface Definition Language， Android接口定义语言）。网上看了几篇关于AIDL的文章，写得都很不错，不过例子构造大多略微复杂： 建立两个Android项目，一个是...
AIDL简单示例
qq_39257624的博客
10-18 1378
为了实现不同间进程通信，我们会使用到AIDL。由服务端提供服务，客户端通过AIDL链接服务端，以调用服务端对应的功能。
AIDL例子
zbo1301的专栏
05-08 472
1、aidl接口文件（包名）服务端和客户端必须保持一致。2、客户端调用服务端的接口时，有二种方法。这里需要说明的是。setaction中内容是在服务端manifest中service标签的&lt;action&gt;字段。 setpackage字段是服务端的包名即manifest.xml中填写的包名。// 第一种方式 第一个参数是服务端package名， 第二个参数是服务端service类路径 ...
一个简单的AIDL例子
11-13
一个简单的aidl例子。非常简单的例子适合新手。写了个文章记录遇到的问题，顺便把代码传上来。
AIDLService:AIDL 示例
06-14
**AIDLService:AIDL 示例** 在Android开发中，AIDL（Android Interface Definition Language）是一种用于实现进程间通信（IPC，Inter-Process Communication）的技术。它允许一个应用组件在不同的进程中调用另一个...
androidAIDL示例
11-25
在AIDL示例中，可能包含了一个使用Message传递数据的例子，演示了如何在不同线程或进程之间安全地传递信息。而ContentProvider部分可能会展示如何创建自定义的ContentProvider，以及如何通过Uri查询、插入、更新和...
Android AIDL示例代码.zip
06-02
这个“Android AIDL示例代码.zip”压缩包中包含了丰富的示例和解释，旨在帮助开发者更好地理解和运用AIDL。 AIDL的基本概念： 1. **接口定义**：AIDL用于定义接口，这些接口描述了服务提供的方法。接口定义文件以`....
AIDL示例超赞的demo
01-18
**标题"AIDL示例超赞的demo"**表明这是一个展示AIDL实际应用的优秀实例，它将帮助开发者理解如何通过AIDL来构建client和server之间的通信桥梁。 **描述中提到，该demo包含两个module，即"server"和"client"。** 在...
AIDL示例代码
03-07
在"AIDL示例代码"中，我们可以看到两个主要的组成部分：`My_Chapter_2_aidl_client_mine` 和 `My_Chapter_2_aidl_service_mine`，分别代表客户端和服务端的实现。** **AIDL的基本概念：** 1. **接口定义**：AIDL...
AIDL的简单例子
05-04
AIDL的简单例子,一看就懂！
Android项目之AidlDemo(简单aidl的例子)
03-06
Android项目之AidlDemo(简单的aidl的例子)。AIDL是Android中IPC（Inter-Process Communication）方式中的一种，AIDL是Android Interface definition language的缩写。需要的小伙伴自请下载。
AIDL的示例以及自己简单实现一个AIDL
08-27
AIDL的示例以及自己简单实现一个AIDL ,code具有一定的参考意义，让人理解AIDL是怎么完成远程调用的
aidl简单实例
03-19
一个aidl的简单实例源码，具体使用参见
AIDL使用示例
卧龙跃马的博客
08-14 551
AIDL使用示例 项目结构 AIDL支持的数据类型 基本数据类型(除short类型外) String Char List （集合中的元素必须是支持的类型或者是其它声明的AIDL对象） 集合中的元素需要使用in、out、inout修饰；其中 in 表示数据只能由客户端流向服务端（即传入的参数）， out 表示数据只能由服务端流向客户端（即输出的参数），而 inout 则表示数据可在服务端与客户端之间双向流通 Map （集合中的元素必须是支持的类型或者是其它声明的AIDL对象） 集
AIDL实例
weixin_30319097的博客
09-12 278
服务端： 1. 创建要传递的实体类 Person，并实现 Parcelable 接口。 package cn.zzw.aidl; import android.os.Parcel;import android.os.Parcelable; public class PersonInfo implements Parcelable{ private String name; ...
Android AIDL代码实例
weixin_30292843的博客
11-18 172
两个应用的aidl文件夹中的内容相同，包名为服务器的包名。 IMyAidlInterface.aidl // IMyAidlInterface.aidl package com.zhang.aidldemo; import com.zhang.aidldemo.TimerCallback; interface IMyAidlInterface ...
简单AIDL示例Android源码分析
而“AidlDemo(简单aidl的例子)”项目是一个具体的示例，开发者可以通过这个项目了解如何在Android中应用AIDL来实现进程间通信。 通过研究这些文件，开发者可以加深对Android中AIDL实现机制的理解，并能够应用这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值