AIDL

最新推荐文章于 2020-03-10 14:09:44 发布
最新推荐文章于 2020-03-10 14:09:44 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wojiaohuangyu/article/details/50420089
版权
 AIDL介绍
    AIDL表示“Android接口定义语言”：Android Interface Definition Language.
    使用AIDL定义的接口，会被开发工具生成为可实现远程访问的接口。
    进程间通信模式是组件间通信的“高级”应用方式，与一般组件间通信的区别在于：接口需要使用AIDL定义。
    由于存在2个应用程序进行通信，因此，提供服务的应用程序通常被称之为“服务端”，而调用它的
    接口的方法的应用程序则被称之为“客户端”。
    AIDL接口：
        使用java中创建接口的方式即可创建AIDL的接口，区别在于：
     AIDL的接口的原文件扩展名为.aidl,一般的接口的源文件的扩展名为java。
     AIDL的接口不允许使用public或任何访问权限修饰符去修饰该接口，它
     默认即被修饰为public。
在创建了AIDL接口后，开发工具会在gen下生成匹配的JAVA源文件。
使用AIDL绑定远程Service
     在开发工具生成的AIDL接口的JAVA源文件中，定义了名为stub的内部类，
     继承了android.os.Binder，并实现了AIDL的接口，因此，开发人员在创建Service中的IBinder
     的实现类时，仅需继承该Stub类即可。
     由开发人员定义的AIDL接口中的抽象方法，都被定义为抛出远程异常(android.os.RemoteException),
     在实现这些抽象方法时需要处理。
     在AIDL接口的Stub内部类中，存在asInterface(IBinder obj)方法，用于将IBinder对象
     转换为AIDL接口的实现类对象，因此，在绑定Service的组件中，可通过该方法得到AIDL接口的实现类对象。
 使用AIDL与一般绑定服务的区别
       使用AIDL与一般绑定服务的区别：
    【服务端】使用AIDL接口
    【服务端】创建AIDL接口的内部类Stub的子类对象，并将其作为Service中
    onBind()的返回值；
    【服务端】必须配置Service是可以隐式激活的
    【客户端】将服务端的AIDL文件复制到客户端
    【客户端】在ServiceConnection的onServiceConnected()中，使用AIDL接口的
       Stub的asinterface()方法，将参数IBinder转换为AIDL接口的对象。
    服务端开发步骤：
         开发AIDL接口源文件，并确保扩展名是.aidl（如果先创建的*.java源文件后改名，则需刷新）
 在Service中开发AIDL接口的实现类，并实现AIDL接口中定义的抽象方法；
 实现Service类中的onBind()方法，并将AIDL的实现类的对象作为该方法的返回值
 注册Service类，并配置<intent-filter>
 部署服务端应用程序到设备上
   客户端开发步骤
         1、将服务端的AIDL相关文件复制到客户端中，注意：相关文件的包名、类名是不允许修改的
2、开发ServiceConnection接口中的实现类
3、使用隐式意图绑定服务端的Service
         4、在ServiceConnection接口中的实现类的onServiceConnected()方法中，通过AIDL的内部类Stub的asInterface()方法

，将IBinder对象转换为AIDL接口的对象。

一个简单的小案例：

         服务端：  

             MainActivity：

       

package com.edu.hpu.service;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;

public class MainActivity extends Activity {

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

package com.edu.hpu.service;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;

public class PlayerService extends Service{

	@Override
	public void onCreate() {
		// TODO Auto-generated method stub
		Log.d("AIDL","服务端：PlayerService onCreate");
		super.onCreate();
	}
	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		Log.d("AIDL","服务端：PlayerService onBind");
		return new InnerBinder();
	}

	 private class InnerBinder extends PlayerAIDL.Stub{

		@Override
		public void playMusic() throws RemoteException {
			// TODO Auto-generated method stub
			Log.d("AIDL","服务端：PlayerService playMusic");
		}

		@Override
		public void pauseMusic() throws RemoteException {
			// TODO Auto-generated method stub
			Log.d("AIDL","服务端：PlayerService pauseMusic");
		}
		 
	 }
}

PlayerAIDL.aidl 

package com.edu.hpu.service;

interface PlayerAIDL {
     void playMusic();
     void pauseMusic();
}

布局没有任何改变，初始的即可，

需要在AndroidMainfest.xml中配置信息：

  

<service
         android:name="com.edu.hpu.service.PlayerService">
        <intent-filter>
            <action android:name="com.edu.hpu.service.intent.action.REMOTE_PLAYER_SERVICE"/>
            <category android:name="android.intent.category.DEFAULT"/>
        </intent-filter>
    </service>
应用端：

     需要将相对应的aidl包跟文件都复制到应用端，

MainActivity：

package com.example.receiveservice;

import com.edu.hpu.service.PlayerAIDL;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;

public class MainActivity extends Activity {

	private ServiceConnection conn = null;
	PlayerAIDL player;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		
		Log.i("AIDL","客户端：MainActivity.onCreate");
		conn = new InnerServiceConnection();
		Intent service = new Intent("com.edu.hpu.service.intent.action.REMOTE_PLAYER_SERVICE");
		bindService(service,conn,BIND_AUTO_CREATE);
	}
	private class InnerServiceConnection implements ServiceConnection{

		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			// TODO Auto-generated method stub
			Log.i("AIDL","客户端：MainActivity.onServiceConnected");
			
			player = PlayerAIDL.Stub.asInterface(service);
			try {
				player.playMusic();
			} catch (RemoteException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			try {
				player.pauseMusic();
			} catch (RemoteException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		@Override
		public void onServiceDisconnected(ComponentName name) {
			// TODO Auto-generated method stub
			
		}
		
	}
	@Override
	protected void onDestroy() {
		// TODO Auto-generated method stub
		unbindService(conn);
		super.onDestroy();
	}
}

以上的就是这个简单的小项目，先将服务端配置到虚拟器上，然后将客户端配置到虚拟器上，运行成功，就会在客户端打印出服务端的信息。

注意：
         绑定远程Service时，组件的相关方法执行顺序：
   1、【客户端】绑定远程Service，即调用bindService()方法；
   2、【服务端】Service的生命周期开始，即onCreate()->onBind();
   3、【客户端】ServiceConnection中onServiceConnected()方法被回调。
  在客户端执行bindService()时，由于服务端的Service尚未启动，更没有返回IBinder
  对象，则客户端中onServiceConnected()方法还没有被回调，因此，直接在客户端bindService()后马上
  调用远程服务可能导致NullPointerException.

使用AIDL远程播放音乐

服务端：

   MainActivity：

package com.example.service1;

import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;

public class MainActivity extends Activity {

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

Service： 

package com.example.service1;

import java.io.IOException;

import android.app.Service;
import android.content.Intent;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnCompletionListener;
import android.os.Environment;
import android.os.IBinder;
import android.os.RemoteException;

public class PlayerService extends Service {
	private MediaPlayer player;
	private int Current;
	private String[] musics = new String[] {
			Environment.getExternalStorageDirectory().getAbsolutePath()
					+ "/Music/number1.mp3",
			Environment.getExternalStorageDirectory().getAbsolutePath()
					+ "/Music/number2.mp3",
			Environment.getExternalStorageDirectory().getAbsolutePath()
					+ "/Music/number3.mp3" };
	private int currentMusicIndex = 0;

	@Override
	public void onCreate() {

		// TODO Auto-generated method stub
		player = new MediaPlayer();
		player.setOnCompletionListener(new OnCompletionListener() {
			
			@Override
			public void onCompletion(MediaPlayer mp) {
				// TODO Auto-generated method stub
				doNext();
			}
		});
		super.onCreate();
	}

	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		return new InnerBinder();
	}

	private void doPlay() {
		player.reset();
		try {
			player.setDataSource(musics[currentMusicIndex]);
			player.prepare();
			player.seekTo(Current);
			player.start();
			Current = 0;
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalStateException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private void doPause() {
		if (player.isPlaying()) {
			Current = player.getCurrentPosition();
			player.pause();
		}
	}

	private void doPrevious() {
		currentMusicIndex--;
		if (currentMusicIndex < 0) {
			currentMusicIndex = musics.length - 1;
		}
		Current = 0;
		doPlay();
	}

	private void doNext() {
		currentMusicIndex++;
		if (currentMusicIndex >= musics.length) {
			currentMusicIndex = 0;
		}
		Current = 0;
		doPlay();
	}

	private class InnerBinder extends PlayerAIDL.Stub {

		@Override
		public void play() throws RemoteException {
			// TODO Auto-generated method stub
               doPlay();
		}

		@Override
		public void pause() throws RemoteException {
			// TODO Auto-generated method stub
              doPause();
		}

		@Override
		public void previous() throws RemoteException {
			// TODO Auto-generated method stub
              doPrevious();
		}

		@Override
		public void next() throws RemoteException {
			// TODO Auto-generated method stub
             doNext();
		}

	}
	@Override
	public void onDestroy() {
		// TODO Auto-generated method stub
		player.release();
		player = null;
		super.onDestroy();
	}

}

需要提前将音乐添加到虚拟机中，我在这里边添加了三首歌曲，

PlayerAIDL.aidl

package com.example.service1;

interface PlayerAIDL {
      void play();
      void pause();
      void previous();
      void next();
}

布局里边不用修改，就按照默认的就可以，

重要的一步，在AndroidMainfest.xml中配置Service：

<service android:name="com.example.service1.PlayerService">
            <intent-filter>
                <action android:name="com.example.service1.REMOTE_PLAYER_SERVICE_1"/>
                 <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </service>


应用端：


相应的，需要将服务端的相对应的.aidl所在的包名以及文件都拷贝到应用端，这里不再做介绍，

MainActivity：

package com.example.service2;

import com.example.service1.PlayerAIDL;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;

public class MainActivity extends Activity {

	private InnerServiceConnection conn;
	private PlayerAIDL player;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		conn = new InnerServiceConnection();
		Intent service = new Intent(
				"com.example.service1.REMOTE_PLAYER_SERVICE_1");
		bindService(service, conn, BIND_AUTO_CREATE);
	}

	public void doPlay(View view) {
            try {
				player.play();
			} catch (RemoteException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}

	public void doPause(View view) {
       try {
		player.pause();
	} catch (RemoteException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	}

	public void doPrevious(View view) {
                try {
					player.previous();
				} catch (RemoteException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
	}

	public void doNext(View view) {
           try {
			player.next();
		} catch (RemoteException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private class InnerServiceConnection implements ServiceConnection {

		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			// TODO Auto-generated method stub
			player = PlayerAIDL.Stub.asInterface(service);

		}

		@Override
		public void onServiceDisconnected(ComponentName name) {
			// TODO Auto-generated method stub

		}

	}

	@Override
	protected void onDestroy() {
		// TODO Auto-generated method stub
		unbindService(conn);
		super.onDestroy();
	}
}

布局： 

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
     >

    <ImageButton
        android:id="@+id/pause"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignTop="@+id/play"
        android:layout_marginLeft="58dp"
        android:onClick="doPause"
        android:layout_toRightOf="@+id/play"
        android:src="@android:drawable/ic_media_pause" />

    <ImageButton
        android:id="@+id/play"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:onClick="doPlay"
        android:layout_alignParentTop="true"
        android:layout_marginLeft="87dp"
        android:layout_marginTop="36dp"
        android:src="@android:drawable/ic_media_play" />

    <ImageButton
        android:id="@+id/previous"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/play"
        android:onClick="doPrevious"
        android:layout_below="@+id/play"
        android:layout_marginTop="49dp"
        android:src="@android:drawable/ic_media_previous" />

    <ImageButton
        android:id="@+id/next"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/pause"
        android:onClick="doNext"
        android:layout_alignTop="@+id/previous"
        android:src="@android:drawable/ic_media_next" />

</RelativeLayout>
AndroidMainfest.xml中的相关信息无需配置，直接将服务端的应用部署到虚拟机上边，然后将应用端的应用部署到虚拟机上边，运行应用端的应用，就会实现一个跨应用程序获取Service的一个能够进行歌曲播放、暂停、上一曲、下一曲的功能。

AIDL中的数据类型
 在AIDL接口中，如需使用以下数据类型，无需导包语句即可直接使用：
    JAVA的基本数据类型，包括：byte,short,int,long,float,double,char,boolean.
    String与CharSequence。
    List与Map。
如需使用自定义的数据类型，或List，Map中封装自定义数据类型的数据，则要求：
   1、自定义的数据类型实现Parcelable接口i；
   2、编写自定义数据类型的*.aidl文件；
   3、无论自定义数据类型与AIDL接口文件是否在同一个包中，在使用自定义数据类型时，都需在AIDL接口文件中
   显式的使用import语句导入；
   4、将自定义数据类型的*.java源文件与*.aidl源文件复制到客户端。
   自定义数据类型的*.aidl文件：
       需存在与*.java源文件相同的package语句；
       添加parcelable类名；语句。
      Parcelable接口：基于任何复合数据类型都是基本数据类型封装后的集合，因此，各种复合数据类型都可以被拆分为
      基本数据类型进行传输。
      parcelable接口约定了数据被序列化传输的方式。
      在parcelable接口中，定义了一下抽象方法：
              public int describeContents()(用于内容接口的描述)
     public void writeToParcel(Parcel dest,int flags)（writeToParcel()方法用于将当前类的成员写入到Parcel
     容器中，重写该方法时，调用Parcel类的write系列方法即可，例如writeInt(),writeString()等。）
  通常开发人员仍自定义readFromParcel(Parcel parcel)方法，以对应必须重写的writeToParcel()方法，用于从Parcel容器中
  读取数据。
  读取数据时，顺序必须与写入数据完全相同！

 public void writeToParcel(Parcel parcel,int flags){
	       parcel.writeInt(age);
	       parcel.writeString(name);
	       parcel.writeString(from);

	   }
	   public void readFromParcel(Parcel parcel){
	       this.age = parcel.readInt();
	       this.name = parcel.readString();
	       this.from = parcel.readString();
	   }

必须创建静态常量CREATOR，实现Parcelable.Creator<T>接口：
      该常量必须被修饰为public static final ,且常量名必须为
      CREATOR;
      重写接口中的抽象方法。
使用AIDL访问自定义类型数据
     功能：服务端提供getStudentList()方法，返回List<Student>类型数据。
                    Student类型中至少封装3个属性，且至少其中2个属性的数据类型是相同的，
   例如2个String类型和1个int类型。
 客户端可获取服务端提供的数据

下面的是相对应的案例：

服务端：

        MainActivity：

package com.example.servicemen;

import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;

public class MainActivity extends Activity {

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

Student.java 

package com.example.servicemen;

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

public class Student implements Parcelable{
    private String name;
    private String from;
    private int age;
    
    
    public Student(String name, String from, int age) {
		this.name = name;
		this.from = from;
		this.age = age;
	}
    
    

	@Override
	public String toString() {
		return "Student [name=" + name + ", from=" + from + ", age=" + age
				+ "]";
	}



	public Student(Parcel source) {
    	// TODO Auto-generated constructor stub
    	readFromParcel(source);
    }
	
	
    public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getFrom() {
		return from;
	}

	public void setFrom(String from) {
		this.from = from;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}


	public static final Parcelable.Creator<Student> CREATOR = new Parcelable.Creator<Student>(){

		@Override
		public Student createFromParcel(Parcel source) {
			// TODO Auto-generated method stub
			return new Student(source);
		}

		@Override
		public Student[] newArray(int size) {
			// TODO Auto-generated method stub
			return new Student[size];
		}
    	
	};

	@Override
	public int describeContents() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public void writeToParcel(Parcel dest, int flags) {
		// TODO Auto-generated method stub
		dest.writeString(name);
		dest.writeString(from);dest.writeInt(age);
		
	}
	
	private void readFromParcel(Parcel from){
		this.name = from.readString();
		this.from = from.readString();
		this.age = from.readInt();
	}

}

Service: 

package com.example.servicemen;

import java.util.ArrayList;
import java.util.List;

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

public class StudentService extends Service{

	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		return new InnerBinder();
	}
	
	private class InnerBinder extends StudentAIDL.Stub{

		@Override
		public List<Student> getStudentList() throws RemoteException {
			// TODO Auto-generated method stub
			List<Student> students = new ArrayList<Student>();
			students.add(new Student("asjdasd","fdghfg",30));
			students.add(new Student("ssasd","saafg",60));
			students.add(new Student("sliuliud","ililfg",90));
			return students;
		}
		
	}

}

Student.aidl: 

package com.example.servicemen;

parcelable Student;

StudentAIDL.aidl: 

package com.example.servicemen;

import com.example.servicemen.Student;
interface StudentAIDL {
     List<Student> getStudentList();
     
}
相应的需要在AndroidMainfest.xml中配置相关的信息： 

<service 
            android:name="com.example.servicemen.StudentService">
            <intent-filter>
                <action android:name="com.example.servicemen.intent.action.STUDENT_ACTION"/>
                <category android:name="android.intent.category.DEFAULT"/>
            </intent-filter>
        </service>

服务端的布局使用默认的即可，不用做更改，

应用端：相应的需要将Student.sidl,StudentAIDL.aidl,Student.java及他们所在的包名都复制到客户端，

MainActivity：

package com.example.service4;

import java.util.List;

import com.example.servicemen.Student;
import com.example.servicemen.StudentAIDL;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.view.Menu;
import android.view.MenuItem;

public class MainActivity extends Activity {
  
	private ServiceConnection conn;
    private StudentAIDL service;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		
		setContentView(R.layout.activity_main);
		conn = new InnerServiceConnection();
		Intent service = new Intent("com.example.servicemen.intent.action.STUDENT_ACTION");
		bindService(service, conn, BIND_AUTO_CREATE);
		
	}
	
	private class InnerServiceConnection implements ServiceConnection{

		@Override
		public void onServiceConnected(ComponentName name, IBinder arg0) {
			// TODO Auto-generated method stub
			service = StudentAIDL.Stub.asInterface(arg0);
			try {
				List<Student> students = service.getStudentList();
			    for (Student student : students) {
					System.out.println("student" + student);
				}
			} catch (RemoteException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}

		@Override
		public void onServiceDisconnected(ComponentName name) {
			// TODO Auto-generated method stub
			
		}
		
	}
	@Override
	protected void onDestroy() {
		// TODO Auto-generated method stub
	    unbindService(conn);
		super.onDestroy();
	}
}

布局不用做任何的修改，先将服务端部署到虚拟机上，然后运行应用端，查看logcat，就会看到服务端的打印的信息。


黄小鱼ZZZ
关注
专栏目录
Android进阶笔记：AIDL内部实现详解 （一）
jelly_fang的博客
01-16 2415
AIDL内部实现详解 （一）AIDL的作用是实现跨进程通讯使用方法也非常的简单，他的设计模式是典型的C/S架构。使用AIDL只要在Client端和Server端的项目根目录下面创建一个aidl的文件夹，在aidl文件夹的下面用java代码编写一个后缀名为.aidl的接口文件然后重新编译一下就会在gen目录下生成相对应的java文件。这里主要研究aidl的运作流程以及原理。 aidl结构首先我在Se
Android中aidl如何import文件
houchangxi的专栏
03-29 1048
如果你做Android开发，那就应该会知道aidl工具的，但是会使用aidl命令行工具的人有吗有吗有吗，如果有的话你们为神马不出来写写怎么用！！！！ 用aidl命令行的如果不出意外肯定会遇见类似这样的错误 $ aidl IRemoteServiceCallback.aidl IRemoteServiceCallback.aidl:19: couldn' t find import for...
AIDL传递基础数据类型
08-17
AIDL远程调用，传递基础数据类型
aidl文件import 报错; couldn't find import for class
狂发飘飘
07-17 1329
aidl文件import 报错; couldn't find import for class
AIDL双向绑定kotlin版本
06-18
首先，在`app/src/main/aidl`目录下创建两个AIDL文件，例如`IAidlService.aidl`（服务端接口）和`IClientCallback.aidl`（客户端回调接口）。在`IAidlService.aidl`中声明服务端提供的方法，而在`IClientCallback....
aidl 电话文件 ITelephony.aidl NeighboringCellInfo.aidl
07-13
在Android系统中，`aidl`（Android Interface Definition Language）是一种接口定义语言，用于创建跨进程通信（IPC，Inter-Process Communication）的接口。当一个应用程序需要与其他应用程序或系统服务进行通信时，...
AIDL for HALs测试客户端
01-10
**Android Interface Definition Language (AIDL) 用于 Hardware Abstraction Layers (HALs) 的测试客户端** 在Android系统中，硬件抽象层(HAL, Hardware Abstraction Layer)是操作系统与硬件设备之间的接口，它...
Android camera用到的aidl文件和aidl编译出来.h 和cpp文件
最新发布
03-12
Android camera用到的aidl文件和aidl编译出来的BnCameraService.h，BpCameraService.h，ICameraService.cpp，ICameraService.h， 单独编译方法见： https://blog.csdn.net/kk3087961/article/details/136051743 ...
Android Aidl
12-19
在Android系统中，AIDL（Android Interface Definition Language）是一种接口定义语言，用于实现不同进程间的通信，即远程进程通讯。AIDL使得服务（Service）和活动（Activity）这两个独立的APK之间能够相互通信，...
AOSP新增AIDL调用
SpHinner的专栏
12-11 1516
    在做AOSP开发的时候可能会遇到这种情况,上层的APP需要调用Api做一些操作,但是这些操作App是没有权限去做的,只有系统进程才有权限去做. 该怎么样实现呢, 其实很简单,仿照其它的Manager去做即可.     1. 写一个AIDL接口文件. 放在framewrok /base/core 包下任意目录, 建议放在android.os包下面.  可以参照里面其它的aidl文件来写就是...
Android studio 使用AIDL 无法import class问题解决
木聿的专栏
06-16 6708
在用android studio 用AIDL的过程中，如果使用
AIDL的阐述
Cattle_Wei的博客
12-20 238
AIDL的英文名称全称是Android Interface Define Language。 当A进程要去调用B进程中的service时，并实现通信，我们通常都是通过AIDL来操作的。 A工程： 首先我们在net.blogjava.mobile.aidlservice包中创建一个RemoteService.aidl文件，在里面我们自定义一个接口， 含有方法get。ADT查见会在gen目录下
Android AIDL import 错误
frj463806056的专栏
03-10 1590
如果你在使用aidl接口过程中，生成aidl接口文件失败时（具体表现为：build目录下aidl的目录里，对应的aidl的接口文件打开是空白的），使用时可能是导致无法引用或找不到包时。你可以试试是否由于aidl的接口中有中文注释，可以去除或者修改为英语注释，然后clean 之后再make，此时很有可能就可以用了。 如果你的aidl 接口中，参数或返回结果包含自定义的类结构，该自定义的类结构需...
Android之——AIDL小结
冰河的专栏
07-26 3388
AIDL （Android Interface Definition Language ）AIDL 适用于 进程间通信，并且与Service端多个线程并发的情况，如果只是单个线程 可以使用 Messenger ，如果不需要IPC 可以使用BinderAIDL语法：基础数据类型都可以适用，List Map等有限适用。static field 不适用。AIDL基本用法 1、实现.aidl文件 接口
aidl 传递对象
Gassion永刚
08-13 718
第一：实现Parcelable接口  第二：定义一个Parcelable.Creator类型的CREATOR对象  第三：要提供一个Booka.aidl文件，其中内容为parcelable Booka，定义了之后，在其他aidl文件中引用Booka时便不会提示出错了。  Booka.java public class Booka implements Parcelable {
AIDL完全学习手册
eyelike的专栏
05-07 1974
1.引言打开Android源码，会发现在有些包的里面，在各个java类下面总是会有若干白色图标的文件，后缀为aidl。双击打开，也是一篇黑白，没有java代码的关键字变色突示，写法似java又总有些不同。这个文件好生怪异！ 它到底是什么？有什么作用？怎么使用？2.释义AIDL（Android Interface Definition Language，Android接口定义语言）。 很多文章在引
Android中AIDL的基本用法
kentlee114的专栏
05-25 439
早些时候就听说过AIDL，也常在各种Android面试题、教程甚至大牛采访中看到过它的身影。可见AIDL在Android开发中的地位十分的重要。 于是决定先从AIDL的一些基本概念和基本用法开始着手学习它，下面是一些整理的笔记。 AIDL的全称为Android Interface Definition Language, 顾名思义，它主要就是用来定义接口的一种语言: AIDL
android中使用AIDL
karizhang的专栏
11-28 615
android中可以使用AIDL定义接口，实现进程间通信。 这个和COM等组件技术原理是一样的。 需要注意的有： 1. AIDL中定义的接口和方法名是不需要权限修饰符的. 2. AIDL中方法的返回类型如果是java基本基本类型则不需要import其他包和接口。 3. AIDL中一般只能import AIDL接口。不能import java的接口，但是List等java接口可以使用。 3
Android AIDL 进程通信详解
"aidl在Android中的应用主要涉及到进程间通信（IPC，Interprocess Communication），它是一种接口定义语言，用于描述客户端和服务端之间的通信接口。通过aidl，开发者可以定义服务暴露给其他应用程序调用的方法和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值