安卓AIDL跨进程调用技术实例(踩坑讲解)(两种方案)(max函数服务|音乐播放服务)

方法一：aidl接口+Service类

main文件下创建aidl接口：

创建之后：

代码：

interface GetMaxAidlService {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
//    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
//            double aDouble, String aString);

    int max(int num1,int num2);
}

创建Service类：

代码如下：

import com.example.emptydemo.GetMaxAidlService;

public class GetMaxService extends Service {

    GetMaxAidlService.Stub mBinder = new GetMaxAidlService.Stub(){

        @Override
        public int max(int num1, int num2) {
            return Math.max(num1,num2);
        }
    };

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

    @Override
    public void onCreate() {
        super.onCreate();
    }

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

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
}

这个 mBinder 是GetMaxAidlService.Stub 实例，而Stub继承了android.os.Binder，Binder又实现了android.os.IBinder接口。其实他们就是实现绑定用的。

Activity类中添加属性：

    private GetMaxAidlService getMaxAidlService;//服务类，可以调用相应方法
    private GetMaxConnection getMaxConnection;//连接类

他们后面要被拿来连起来，之后的getMaxAidlService就可以用来调用跨进程方法

Activity定义连接类GetMaxConnection ：

    private class GetMaxConnection implements ServiceConnection {

        public void onServiceConnected(ComponentName name, IBinder service) {
            getMaxAidlService = (GetMaxAidlService) GetMaxAidlService.Stub.asInterface(service);
            // 将连接得到的IBinder服务传给引用变量
        }

        public void onServiceDisconnected(ComponentName name) {
        }
    }

在AndroidManifest.xml中注册服务：

        <service android:name=".service.GetMaxService">
            <intent-filter>
                        <!--别名-->
                <action android:name="getMax"/>
            </intent-filter>
        </service>

在Activity的onCreate方法中添加：

        Intent intent = new Intent();
        intent.setAction("getMax");//用别名
        intent.setPackage("com.example.emptydemo");
        getMaxConnection = new GetMaxConnection();
        bindService(intent, getMaxConnection, BIND_AUTO_CREATE);

bindService方法将所有绑定好

现在我们就可以使用跨进程的max函数了：

getMaxAidlService.max(0,1);

上我的demo图：

方法二：一个Service类搞定

因为我们mBinder这个变量是GetMaxAidlService.Stub实例，也就是Binder的子类，那我们可以直接定义一个Binder子类在Service类中。

一个服务类搞定：

public class MusicService extends Service {
    private static final String TAG = "MusicService";
    public MediaPlayer mediaPlayer;

    public class MyBinder extends Binder {
        // 播放音乐
        public void plays(String path) {
            play(path);
        }

        // 暂停播放
        public void pauses() {
            pause();
        }

        // 重新播放
        public void replays(String path) {
            replay(path);
        }

        // 停止播放
        public void stops() {
            stop();
        }

        // 获取当前播放进度
        public int getCurrentPosition() {
            return getCurrentProgress();
        }

        // 获取音乐文件的长度
        public int getMusicWidth() {
            return getMusicLength();
        }
    }

    public void onCreate() {
        super.onCreate();
    }

    // 播放音乐
    @SuppressLint("NewApi")
    public void play(String path) {
        try {
            if (mediaPlayer == null) {
                Log.i(TAG, "开始播放音乐");
                // 创建一个MediaPlayer播放器
                mediaPlayer = new MediaPlayer();
                // 指定参数为音频文件
                mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
                // 指定播放的路径
                mediaPlayer.setDataSource(path);
                // 准备播放
                mediaPlayer.prepare();
                mediaPlayer.setOnPreparedListener(new OnPreparedListener() {
                    @Override
                    public void onPrepared(MediaPlayer mp) {
                        // TODO Auto-generated method stub
                        // 开始播放
                        mediaPlayer.start();
                    }
                });
            } else {
                int position = getCurrentProgress();
                mediaPlayer.seekTo(position);
                try {
                    mediaPlayer.prepare();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                mediaPlayer.start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 暂停音乐
    public void pause() {
        if (mediaPlayer != null && mediaPlayer.isPlaying()) {
            Log.i(TAG, "播放暂停");
            mediaPlayer.pause(); // 暂停播放
        } else if (mediaPlayer != null && (!mediaPlayer.isPlaying())) {
            mediaPlayer.start();
        }
    }

    // 重新播放音乐
    public void replay(String path) {
        if (mediaPlayer != null) {
            Log.i(TAG, "重新开始播放");
            mediaPlayer.seekTo(0);
            try {
                mediaPlayer.prepare();
            } catch (IllegalStateException e) {
                e.printStackTrace();
            } catch (IOException e) {

                e.printStackTrace();
            }
            mediaPlayer.start();
        }
    }

    // 停止音乐
    @SuppressLint("WrongConstant")
    public void stop() {
        if (mediaPlayer != null) {
            Log.i(TAG, "停止播放");
            mediaPlayer.stop();
            mediaPlayer.release();
            mediaPlayer = null;
        } else {
            Toast.makeText(getApplicationContext(), "已停止", 0).show();
        }
    }

    // 获取资源文件的长度
    public int getMusicLength() {
        if (mediaPlayer != null) {
            return mediaPlayer.getDuration();
        }
        return 0;
    }

    // 获取当前进度
    public int getCurrentProgress() {
        if (mediaPlayer != null & mediaPlayer.isPlaying()) {
            Log.i(TAG, "获取当前进度");
            return mediaPlayer.getCurrentPosition();
        } else if (mediaPlayer != null & (!mediaPlayer.isPlaying())) {
            return mediaPlayer.getCurrentPosition();
        }
        return 0;
    }

    public void onDestroy() {
        if (mediaPlayer != null) {
            mediaPlayer.stop();
            mediaPlayer.release();
            mediaPlayer = null;
        }
        super.onDestroy();
    }

    public IBinder onBind(Intent intent) {
        // 第一步执行onBind方法
        return new MyBinder();
    }
}

老样子注册服务：

        <service android:name=".service.MusicService"/>

Activity属性：

private Intent intent;
private myConn conn;
private MusicService.MyBinder binder;

onCreate

conn = new myConn();
intent = new Intent(this, MusicService.class);
bindService(intent, conn, BIND_AUTO_CREATE);

连接类：

    private class myConn implements ServiceConnection {

        public void onServiceConnected(ComponentName name, IBinder service) {
            binder = (MusicService.MyBinder) service;
        }

        public void onServiceDisconnected(ComponentName name) {
        }
    }

调用：

binder.plays(path);