欢迎加入我的知识星球Android系统开发指南
欢迎关注微信公众号 无限无羡
欢迎关注知乎账号 无限无羡
在平时的业务开发中,我们往往需要开发自定义的系统服务来处理自己特殊的需求,我们这里提供两种方式来实现。第一种是按照已有的系统服务的方法,运行在system_server进程中,由于这样添加服务的话万一因为自定义的服务发生崩溃,将会导致system_server崩溃,从而引起系统重启。所以我们这里还会介绍第二种方法,就是将自定义的服务放到一个独立的进程中,与system_server进程隔离,这样即便自定义服务发生崩溃,也不会影响到系统稳定性。
本节先介绍第一种方法,下一节介绍第二种方法。
我们将自定义的服务取名为BeanManagerService。
定义aidl
Binder默认可以传输基本类型的数据,如果要传递类对象,则这个类需要实现序列化。我们先定义一个序列化的自定义类型,用于binder间参数传递。主要分为两步:
- 创建自定义类型,实现Parcelable接口
// frameworks/base/core/java/android/bean/Person.java
package android.bean;
import android.annotation.NonNull;
import android.os.Parcel;
import android.os.Parcelable;
public final class Person implements Parcelable {
// 注意定义成员变量的顺序,后面读取和写入都必须按这个顺序
private String mName;
private int mAge;
public Person() {
}
public Person(@NonNull String name, int age) {
this.mName = name;
this.mAge = age;
}
private Person(@NonNull Parcel in) {
// 注意定义成员变量的顺序
this.mName = in.readString();
this.mAge = in.readInt();
}
@NonNull
public String getName() {
return mName;
}
public int getAge() {
return mAge;
}
public void setName(@NonNull String name) {
mName = name;
}
public void setAge(int age) {
mAge = age;
}
@Override
public int describeContents() {
return 0;
}
//
@Override
public void writeToParcel(@NonNull Parcel dest, int flags) {
// 注意定义成员变量的顺序
dest.writeString(this.mName);
dest.writeInt(this.mAge);
}
public void readFromParcel(@NonNull Parcel source) {
// 注意定义成员变量的顺序
this.mName = source.readString();
this.mAge = source.readInt();
}
@NonNull
public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() {
@Override
public Person createFromParcel(@NonNull Parcel source) {
return new Person(source);
}
@Override
public Person[] newArray(int size) {
return new Person[size];
}
};
}
- 创建aidl文件,如下:
// frameworks/base/core/java/android/bean/Person.aidl
package android.bean;
parcelable Person;
这样就定义好了一个自定义对象类型,该类型可以通过binder传递,下面我们会有例子说明。
接下来我们定义自定义服务,首先要定义一个aidl文件来定义我们的接口,这个aidl文件编译后会生成binder的客户端服务端接口,我们需要实现客户端和服务端。
// bean为新建的文件夹,用于存放自定义服务
// frameworks/base/core/java/android/bean/IBeanManager.aidl
package android.bean;
import android.bean.Person;
/**
* {@hide}
*/
interface IBeanManager {
void sayHello(String words);
// 自定义类型前面必须加上in或者out或者inout标识符
// in: 表示参数只能由客户端传递到服务端,基本类型默认只支持in修饰符
// out: 表示参数只能由服务端传递到客户端,服务端如果修改了参数对象的值
// 那么客户端的值也会改变,但是服务端无法读取客户端对象的值
// inout: 表示参数可以双向传递
void sayHelloTo(in Person person, String words);
}
由于下面的Android.bp已经包含了该目录下几乎所有aidl文件和java文件的编译,所以我们不需要再将自定义的BeanManager.aidl添加到编译环境。
// frameworks/base/core/java/Android.bp
filegroup {
name: "framework-core-sources",
srcs: [
"**/*.java",
"**/*.aidl",
],
exclude_srcs: [
// Remove election toolbar code from build time
"android/service/selectiontoolbar/*.aidl",
"android/service/selectiontoolbar/*.java",
"android/view/selectiontoolbar/*.aidl",
"android/view/selectiontoolbar/*.java",
"com/android/internal/widget/floatingtoolbar/RemoteFloatingToolbarPopup.java",
],
visibility: ["//frameworks/base"],
}
用以下命令编译aidl
source build/envsetup.sh
lunch sdk_car_x86_64-userdebug// 这里选择自己的项目
make update-api
make framework -j16
编译完成后,可以看到out下已经生成了binder相关的文件
Server端实现
cd frameworks/base
mkdir -p services/core/java/com/android/server/bean/
新建BeanManagerService.java
编译配置同上,不需要再单独加到编译配置中。
// frameworks/base/services/core/java/com/android/server/bean/BeanManagerService.java
package com.android.server.bean;
import android.bean.IBeanManager;
import android.bean.Person;
import android.content.Context;
import android.util.Log;
import com.android.server.SystemService;
import com.android.server.Watchdog;
public class BeanManagerService extends IBeanManager.Stub
implements Watchdog.Monitor {
static final String TAG = "BeanManagerService";
final Context mContext;
public BeanManagerService(Context systemContext) {
Log.d(TAG, "BeanManagerService");
mContext = systemContext;
Watchdog.getInstance().addMonitor(this);
}
@Override
public void sayHello(String words) {
Log.d(TAG, " sayHello : " + words);
}
@Override
public void sayHelloTo(Person person, String words) {
Log.d(TAG, " sayHello " + person.getName() + ": " + words);
}
public void systemReady() {
Log.d(TAG, " systemReady ");
}
/** In this method we try to acquire our lock to make sure that we have not deadlocked */
public void monitor() {
synchronized (this) { }
}
// 这里我们定义了一个内部类继承SystemService,这样便于方便system_server统一管理启动服务
// 系统启动时会回调所有继承了SystemService的类的函数,比如onStart,onBootPhase等等。
public static final class Lifecycle extends SystemService {
static final String TAG = "BeanManagerService.Lifecycle";
private BeanManagerService mService;
public Lifecycle(Context context) {
super(context);
// 在这里构造我们的BeanManagerService对象
mService = new BeanManagerService(context);
}
@Override
public void onStart() {
Log.d(TAG, "onStart");
// 这里最终调用ServiceManager.addService
publishBinderService(Context.BEAN_SERVICE, mService);
}
@Override
public void onBootPhase(int phase) {
Log.d(TAG, "onBootPhase");
if (phase == SystemService.PHASE_ACTIVITY_MANAGER_READY) {
mService.systemReady();
}
}
}
}
添加服务名称
// frameworks/base/core/java/android/content/Context.java
diff --git a/core/java/android/content/Context.java b/core/java/android/content/Context.java
index 77ca48a8ed1d..6ad91d26daf7 100644
--- a/core/java/android/content/Context.java
+++ b/core/java/android/content/Context.java
@@ -3809,6 +3809,7 @@ public abstract class Context {
ACCOUNT_SERVICE,
ACTIVITY_SERVICE,
ALARM_SERVICE,
+ BEAN_SERVICE,
NOTIFICATION_SERVICE,
ACCESSIBILITY_SERVICE,
CAPTIONING_SERVICE,
@@ -4248,6 +4249,16 @@ public abstract class Context {
*/
public static final String ACTIVITY_SERVICE = "activity";
+ /**
+ * Use with {@link #getSystemService(String)} to retrieve a
+ * {@link android.bean.BeanManager} for interacting with the global
+ * system state.
+ *
+ * @see #getSystemService(String)
+ * @see android.bean.BeanManager
+ */
+ public static final String BEAN_SERVICE = "bean";
+
开机启动服务:
// frameworks/base/services/java/com/android/server/SystemServer.java
// 系统启动时将服务分为几个类型,如下,我们可以根据自己的具体业务添加到对应的函数里面
try {
t.traceBegin("StartServices");
// 引导服务,必须
startBootstrapServices(t);
// 核心服务,必须
startCoreServices(t);
// 其他服务,一般放在这里面
startOtherServices(t);
// 定义在apexes中的服务apexes,有兴趣的可以看下源码
startApexServices(t);
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
} finally {
t.traceEnd(); // StartServices
}
--- a/services/java/com/android/server/SystemServer.java
+++ b/services/java/com/android/server/SystemServer.java
@@ -110,6 +110,7 @@ import com.android.server.appbinding.AppBindingService;
import com.android.server.art.ArtManagerLocal;
import com.android.server.attention.AttentionManagerService;
import com.android.server.audio.AudioService;
+import com.android.server.bean.BeanManagerService;
import com.android.server.biometrics.AuthService;
import com.android.server.biometrics.BiometricService;
import com.android.server.biometrics.sensors.face.FaceService;
@@ -1466,6 +1467,10 @@ public final class SystemServer implements Dumpable {
}
}, SECONDARY_ZYGOTE_PRELOAD);
+ t.traceBegin("BeanManagerService");
// 这里最终会通过反射的方法调用BeanManagerService.Lifecycle的构造函数
+ mSystemServiceManager.startService(BeanManagerService.Lifecycle.class);
+ t.traceEnd();
+
t.traceBegin("StartKeyAttestationApplicationIdProviderService");
ServiceManager.addService("sec_key_att_app_id_provider",
new KeyAttestationApplicationIdProviderService(context));
mSystemServiceManager.startService的实现:
// frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
public <T extends SystemService> T startService(Class<T> serviceClass) {
try {
final String name = serviceClass.getName();
Slog.i(TAG, "Starting " + name);
Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartService " + name);
// Create the service.
if (!SystemService.class.isAssignableFrom(serviceClass)) {
throw new RuntimeException("Failed to create " + name
+ ": service must extend " + SystemService.class.getName());
}
final T service;
try {
// 调用构造函数,对于我们的自定义服务就是BeanManagerService.Lifecycle
Constructor<T> constructor = serviceClass.getConstructor(Context.class);
service = constructor.newInstance(mContext);
} catch (InstantiationException ex) {
throw new RuntimeException("Failed to create service " + name
+ ": service could not be instantiated", ex);
} catch (IllegalAccessException ex) {
throw new RuntimeException("Failed to create service " + name
+ ": service must have a public constructor with a Context argument", ex);
} catch (NoSuchMethodException ex) {
throw new RuntimeException("Failed to create service " + name
+ ": service must have a public constructor with a Context argument", ex);
} catch (InvocationTargetException ex) {
throw new RuntimeException("Failed to create service " + name
+ ": service constructor threw an exception", ex);
}
startService(service);
return service;
} finally {
Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
}
}
public void startService(@NonNull final SystemService service) {
// Check if already started
String className = service.getClass().getName();
if (mServiceClassnames.contains(className)) {
Slog.i(TAG, "Not starting an already started service " + className);
return;
}
mServiceClassnames.add(className);
// 将BeanManagerService.Lifecycle加入mServices列表
// 系统的启动过程会遍历mServices列表,回调每个服务的对应函数
// Register it.
mServices.add(service);
// Start it.
long time = SystemClock.elapsedRealtime();
try {
// 这里就是调用每个服务的onStart函数
service.onStart();
} catch (RuntimeException ex) {
throw new RuntimeException("Failed to start service " + service.getClass().getName()
+ ": onStart threw an exception", ex);
}
warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStart");
}
到此,服务的添加代码已经完成,我们编译验证一下:
// 因为Context.java中新增了BEAN_SERVICE的API,所以要先make update-api
source build/envsetup.sh
lunch sdk_car_x86_64-userdebug
make update-api -j16
make -j16
启动模拟器
emulator
这时发现服务无法启动,看日志有如下报错:
Selinux权限问题,我们根据日志按规则添加:
adb pull /sys/fs/selinux/policy
adb logcat -b events -d | audit2allow -p policy
输出信息如下:
#============= system_server ==============
allow system_server default_android_service:service_manager add;
大家如果看过我的另一篇文章Android 13添加自定义native服务,就能立马明白这里该如何添加。
如果按照上面的提示应该是在system_server.te里添加allow system_server default_android_service:service_manager add;
但是这样会触发neverallow,正确的方法是为自定义的服务添加一个新的标签:
// vendor/zzh/sepolicy/private/service_contexts
bean u:object_r:bean_service:s0
// vendor/zzh/sepolicy/public/service.te
type bean_service, service_manager_type;
// vendor/zzh/sepolicy/public/system_server.te
allow system_server bean_service:service_manager add;
上述修改的文件大家根据自己项目添加到具体的文件中,也可以参考Android 13添加自定义native服务。
修改后重新编译启动验证
可以看到服务已经正常启动。
如果遇到修改selinux后开机还是报错的情况,手动kill掉模拟器进程再启动模拟器。
Client端调用
Client调用实际上就是获取binder的代理对象,然后通过代理对象调用服务端的方法。在Android系统中,为了方便App使用系统服务的功能,一般都会给每个服务定义一个XXXManager,App可以通过Context.getSystemService(serviceName)来获取到经过包装的服务端的代理XXXManager。Context.getSystemService最终会调用到SystemServiceRegistry中的getSystemService。
// frameworks/base/core/java/android/app/SystemServiceRegistry.java
/**
* Gets a system service from a given context.
* @hide
*/
public static Object getSystemService(ContextImpl ctx, String name) {
if (name == null) {
return null;
}
// SYSTEM_SERVICE_FETCHERS是一个map,保存了每个服务的名称和Manager的映射关系
// ServiceFetcher是一个接口,有一个抽象方法T getService(ContextImpl ctx);
// 这个getService返回的便是服务的代理包装类XXXManager
final ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
if (fetcher == null) {
if (sEnableServiceNotFoundWtf) {
Slog.wtf(TAG, "Unknown manager requested: " + name);
}
return null;
}
final Object ret = fetcher.getService(ctx);
if (sEnableServiceNotFoundWtf && ret == null) {
// Some services do return null in certain situations, so don't do WTF for them.
switch (name) {
case Context.CONTENT_CAPTURE_MANAGER_SERVICE:
case Context.APP_PREDICTION_SERVICE:
case Context.INCREMENTAL_SERVICE:
case Context.ETHERNET_SERVICE:
return null;
}
Slog.wtf(TAG, "Manager wrapper not available: " + name);
return null;
}
return ret;
}
ServiceFetcher接口的定义
// frameworks/base/core/java/android/app/SystemServiceRegistry.java
/**
* Base interface for classes that fetch services.
* These objects must only be created during static initialization.
*/
static abstract interface ServiceFetcher<T> {
T getService(ContextImpl ctx);
}
ServiceFetcher接口的实现有两个,CachedServiceFetcher和StaticServiceFetcher,这两个其实是两个抽象类,都有一个抽象方法createService,而这个createService正式获取服务端代理的真正实现。CachedServiceFetcher顾名思义就是将每个服务的代理对象都进行缓存,下一次获取的时候直接使用缓存的对象就可以了。
// frameworks/base/core/java/android/app/SystemServiceRegistry.java
/**
* Override this class when the system service constructor needs a
* ContextImpl and should be cached and retained by that context.
*/
static abstract class CachedServiceFetcher<T> implements ServiceFetcher<T> {
private final int mCacheIndex;
CachedServiceFetcher() {
// Note this class must be instantiated only by the static initializer of the
// outer class (SystemServiceRegistry), which already does the synchronization,
// so bare access to sServiceCacheSize is okay here.
// 每一个Context对象包含了一个保存服务代理的数组,每添加一个代理,也就是每创建一个CachedServiceFetcher,
// sServiceCacheSize便会递增,而每个CachedServiceFetcher中的mCacheIndex则是自己在整个数组中的index。
// 后续获取服务代理时,如果cache中有数据,则直接根据mCacheIndex获取即可。
mCacheIndex = sServiceCacheSize++;
}
@Override
@SuppressWarnings("unchecked")
public final T getService(ContextImpl ctx) {
//获取Context中的保存服务代理的数组mServiceCache
final Object[] cache = ctx.mServiceCache;
// final int[] mServiceInitializationStateArray = new int[mServiceCache.length];
// mServiceInitializationStateArray是一个以mServiceCache.length为size的int数组,用于
// 保存每个服务代理的状态,目前有四种状态:
// static final int STATE_UNINITIALIZED = 0;
// static final int STATE_INITIALIZING = 1;
// static final int STATE_READY = 2;
// static final int STATE_NOT_FOUND = 3;
final int[] gates = ctx.mServiceInitializationStateArray;
boolean interrupted = false;
T ret = null;
for (;;) {
boolean doInitialize = false;
synchronized (cache) {
// Return it if we already have a cached instance.
// 先根据mCacheIndex获取,如果不为null,说明之前已经保存过,直接返回。
T service = (T) cache[mCacheIndex];
if (service != null) {
ret = service;
break; // exit the for (;;)
}
// If we get here, there's no cached instance.
// Grr... if gate is STATE_READY, then this means we initialized the service
// once but someone cleared it.
// We start over from STATE_UNINITIALIZED.
// Similarly, if the previous attempt returned null, we'll retry again.
// 走到这里说明缓存中没有保存代理对象
// 但是状态却是(STATE_READY),说明之前是添加过的,但是现在找不到了,说明被谁从数组中移除了
// 或者状态是找不到(STATE_NOT_FOUND)
// 那么就将状态重置为STATE_UNINITIALIZED,重新再往cache数组添加一次
if (gates[mCacheIndex] == ContextImpl.STATE_READY
|| gates[mCacheIndex] == ContextImpl.STATE_NOT_FOUND) {
gates[mCacheIndex] = ContextImpl.STATE_UNINITIALIZED;
}
// It's possible for multiple threads to get here at the same time, so
// use the "gate" to make sure only the first thread will call createService().
// At this point, the gate must be either UNINITIALIZED or INITIALIZING.
// 这里在往代理服务数组中添加新数据之前,先把状态设置为STATE_INITIALIZING
if (gates[mCacheIndex] == ContextImpl.STATE_UNINITIALIZED) {
doInitialize = true;
gates[mCacheIndex] = ContextImpl.STATE_INITIALIZING;
}
}
if (doInitialize) {
// Only the first thread gets here.
// 接下来就要真正的保存服务代理到数组中了
T service = null;
@ServiceInitializationState int newState = ContextImpl.STATE_NOT_FOUND;
try {
// This thread is the first one to get here. Instantiate the service
// *without* the cache lock held.
// 这里通过createService获取到服务代理对象,前面说过createService是一个抽象方法,
// 说明有子类实现的地方,后面会讲到
service = createService(ctx);
newState = ContextImpl.STATE_READY;
} catch (ServiceNotFoundException e) {
onServiceNotFound(e);
} finally {
synchronized (cache) {
//如果createService没有异常的话,将代理服务保存到cache数组
// 将状态设置为newState, newState在前面设置为了STATE_READY
cache[mCacheIndex] = service;
gates[mCacheIndex] = newState;
cache.notifyAll();
}
}
ret = service;
break; // exit the for (;;)
}
// The other threads will wait for the first thread to call notifyAll(),
// and go back to the top and retry.
synchronized (cache) {
// Repeat until the state becomes STATE_READY or STATE_NOT_FOUND.
// We can't respond to interrupts here; just like we can't in the "doInitialize"
// path, so we remember the interrupt state here and re-interrupt later.
// 如果服务代理正在添加过程中,还没有添加完成时,又有一个新的线程来getSystemService,则会
// 进去wait状态,等待服务代理对象添加完成后执行notifyAll来唤醒当前线程
while (gates[mCacheIndex] < ContextImpl.STATE_READY) {
try {
// Clear the interrupt state.
interrupted |= Thread.interrupted();
cache.wait();
} catch (InterruptedException e) {
// This shouldn't normally happen, but if someone interrupts the
// thread, it will.
Slog.w(TAG, "getService() interrupted");
interrupted = true;
}
}
}
}
if (interrupted) {
Thread.currentThread().interrupt();
}
return ret;
}
// 抽象方法createService
public abstract T createService(ContextImpl ctx) throws ServiceNotFoundException;
}
// StaticServiceFetcher则是服务代理中不需要Context对象的一种实现,也就是创建XXXManager对象时不需要
// 传入Context参数
/**
* Override this class when the system service does not need a ContextImpl
* and should be cached and retained process-wide.
*/
static abstract class StaticServiceFetcher<T> implements ServiceFetcher<T> {
private T mCachedInstance;
@Override
public final T getService(ContextImpl ctx) {
synchronized (StaticServiceFetcher.this) {
if (mCachedInstance == null) {
try {
mCachedInstance = createService();
} catch (ServiceNotFoundException e) {
onServiceNotFound(e);
}
}
return mCachedInstance;
}
}
public abstract T createService() throws ServiceNotFoundException;
}
通过上面可以看到,CachedServiceFetcher和StaticServiceFetcher都需要实现createService的抽象方法,我们的自定义服务代理对象BeanManager假设需要传入Context对象,则需要使用CachedServiceFetcher。
// frameworks/base/core/java/android/app/SystemServiceRegistry.java
registerService(Context.BEAN_SERVICE, BeanManager.class,
// 这里是CachedServiceFetcher抽象类的实现
new CachedServiceFetcher<BeanManager>() {
// 抽象方法createService的实现,我们看到其实很简单,就是通过ServiceManager获取服务的binder代理对象
@Override
public BeanManager createService(ContextImpl ctx) throws ServiceNotFoundException {
IBinder b = ServiceManager.getServiceOrThrow(Context.BEAN_SERVICE);
IBeanManager service = IBeanManager.Stub.asInterface(b);
// 以IBeanManager和Context为参数构造BeanManager,这样我们通过Context.getSysetemService(Context.BEAN_SERVICE)
// 返回的对象就是BeanManager
return new BeanManager(service, ctx);
}});
/**
* Statically registers a system service with the context.
* This method must be called during static initialization only.
*/
// registerService只是保存为全局的对象
private static <T> void registerService(@NonNull String serviceName,
@NonNull Class<T> serviceClass, @NonNull ServiceFetcher<T> serviceFetcher) {
SYSTEM_SERVICE_NAMES.put(serviceClass, serviceName);
SYSTEM_SERVICE_FETCHERS.put(serviceName, serviceFetcher);
SYSTEM_SERVICE_CLASS_NAMES.put(serviceName, serviceClass.getSimpleName());
}
接下来就是该定义BeanManager了
// frameworks/base/core/java/android/bean/BeanManager.java
package android.bean;
import android.annotation.NonNull;
import android.content.Context;
import android.os.RemoteException;
import android.util.Log;
/**
* {@hide}
*/
public class BeanManager {
private static final String TAG = "BeanManager";
private Context mContext;
private IBeanManager mService;
public BeanManager(IBeanManager service, Context ctx) {
Log.d(TAG, "new BeanManager");
mService = service;
mContext = ctx;
}
public void sayHello(@NonNull String words) {
Log.d(TAG, "sayHello words: " + words);
if (mService == null) {
Log.d(TAG, "sayHello mService is null!!!");
return;
}
try {
mService.sayHello(words);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
public void sayHelloTo(@NonNull Person person, @NonNull String words) {
Log.d(TAG, "sayHelloTo " + person.getName() + ": " + words);
if (mService == null) {
Log.d(TAG, "sayHelloTo mService is null!!!");
return;
}
try {
mService.sayHelloTo(person, words);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
}
到此,我们的服务代理就添加完成了。我们调用BeanManager测试一下,我们添加到Launcher里,开机加载
Launcher时就会调用。文章来源:https://www.toymoban.com/news/detail-691083.html
// packages/apps/Car/Launcher/src/com/android/car/carlauncher/CarLauncher.java
--- a/src/com/android/car/carlauncher/CarLauncher.java
+++ b/src/com/android/car/carlauncher/CarLauncher.java
@@ -21,7 +21,10 @@ import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_TRUSTED_OVERL
import android.app.ActivityManager;
import android.app.TaskStackListener;
+import android.bean.BeanManager;
+import android.bean.Person;
import android.car.user.CarUserManager;
+import android.content.Context;
import android.content.Intent;
import android.content.res.Configuration;
import android.os.Bundle;
@@ -108,6 +111,13 @@ public class CarLauncher extends FragmentActivity {
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
+ BeanManager beanManager = (BeanManager) getSystemService(Context.BEAN_SERVICE);
+ beanManager.sayHello("Hello world !");
+ Person person = new Person();
+ person.setName("Rick");
+ person.setAge(32);
+ beanManager.sayHelloTo(person, " Good Night!!!");
+
if (CarLauncherUtils.isCustomDisplayPolicyDefined(this)) {
Intent controlBarIntent = new Intent(this, ControlBarActivity.class);
controlBarIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
编译后重启服务器,看到如下日志说明调用成功:文章来源地址https://www.toymoban.com/news/detail-691083.html
04-05 21:08:24.623 638 638 I SystemServiceManager: Starting com.android.server.bean.BeanManagerService$Lifecycle
04-05 21:08:24.624 638 638 D BeanManagerService: BeanManagerService
04-05 21:08:24.624 638 638 D BeanManagerService.Lifecycle: onStart
04-05 21:08:25.592 638 638 D BeanManagerService.Lifecycle: onBootPhase
04-05 21:08:25.650 638 638 D BeanManagerService.Lifecycle: onBootPhase
04-05 21:08:25.650 638 638 D BeanManagerService: systemReady
04-05 21:08:26.020 638 638 D BeanManagerService.Lifecycle: onBootPhase
04-05 21:08:36.513 1933 1933 D BeanManager: new BeanManager
04-05 21:08:36.513 1933 1933 D BeanManager: sayHello words: Hello world !
04-05 21:08:36.515 638 805 D BeanManagerService: sayHello : Hello world !
04-05 21:08:36.517 1933 1933 D BeanManager: sayHello to Rick: Good Night !
04-05 21:08:36.519 638 805 D BeanManagerService: sayHello to Rick: Good Night!
到了这里,关于Android 13添加自定义Java系统服务(一)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!